sarapy 2.3.0__tar.gz → 3.0.0__tar.gz

{sarapy-2.3.0/sarapy.egg-info → sarapy-3.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: sarapy
-Version: 2.3.0
+Version: 3.0.0
 Home-page: https://github.com/lucasbaldezzari/sarapy
 Author: Lucas Baldezzari
 Author-email: Lucas Baldezzari <lmbaldezzari@gmail.com>
@@ -19,6 +19,39 @@ Requires-Dist: geopy
 
 Library for processing SARAPICO project metadata of _AMG SA_.
 
+#### Version 3.0.0
+- Se mejora la forma de obtener valores de media movil para todas las variables en las que se usa.
+- Se corrigen bugs debido a nodos con pocas operaciones.
+- Se corrigen errores a la hora de pasar parámetros a los métodos de algunas clases.
+- Se configuran parámetros de fmcreator y plantin_classifier para el reetiquetado, los mismos son:
+
+kwargs_fmcreator = {"imputeDistances":True, "distanciaMedia":1.8, "umbral_precision":0.3,
+                        "dist_mismo_lugar":0.2, "max_dist":100,
+                        "umbral_ratio_dCdP":2, "deltaO_medio":4,
+                        "impute_ratiodcdp": True, "umbral_impute_ratiodcdp": -0.5,
+                        "deltaO_ma": True, "deltaO_ma_window": 26}
+            
+            
+    ##argumentos del método PlantinClassifier.clasiffy()
+    kwargs_classifier = {"proba_threshold":0.4,
+                         "use_proba_ma":False,
+                         "proba_ma_window":10,
+                         "update_samePlace":True,
+                         "update_dstpt":True,
+                         "umbral_proba_dstpt":0.5,
+                         "umbral_bajo_dstpt":1.5,
+                         "use_ma":True,
+                         "dstpt_ma_window":62,
+                         "use_min_dstpt":False,
+                         "factor":0.1,
+                         
+                         "useRatioStats":False,
+                         "std_weight":1.,
+                         "useDistancesStats":False,
+                         "ratio_dcdp_umbral":0.1,
+                         "dist_umbral":0.5,
+                         }
+
 #### Version 2.3.0
 
 - Se agregan funcionalidades.

{sarapy-2.3.0 → sarapy-3.0.0}/README.md

@@ -2,6 +2,39 @@
 
 Library for processing SARAPICO project metadata of _AMG SA_.
 
+#### Version 3.0.0
+- Se mejora la forma de obtener valores de media movil para todas las variables en las que se usa.
+- Se corrigen bugs debido a nodos con pocas operaciones.
+- Se corrigen errores a la hora de pasar parámetros a los métodos de algunas clases.
+- Se configuran parámetros de fmcreator y plantin_classifier para el reetiquetado, los mismos son:
+
+kwargs_fmcreator = {"imputeDistances":True, "distanciaMedia":1.8, "umbral_precision":0.3,
+                        "dist_mismo_lugar":0.2, "max_dist":100,
+                        "umbral_ratio_dCdP":2, "deltaO_medio":4,
+                        "impute_ratiodcdp": True, "umbral_impute_ratiodcdp": -0.5,
+                        "deltaO_ma": True, "deltaO_ma_window": 26}
+            
+            
+    ##argumentos del método PlantinClassifier.clasiffy()
+    kwargs_classifier = {"proba_threshold":0.4,
+                         "use_proba_ma":False,
+                         "proba_ma_window":10,
+                         "update_samePlace":True,
+                         "update_dstpt":True,
+                         "umbral_proba_dstpt":0.5,
+                         "umbral_bajo_dstpt":1.5,
+                         "use_ma":True,
+                         "dstpt_ma_window":62,
+                         "use_min_dstpt":False,
+                         "factor":0.1,
+                         
+                         "useRatioStats":False,
+                         "std_weight":1.,
+                         "useDistancesStats":False,
+                         "ratio_dcdp_umbral":0.1,
+                         "dist_umbral":0.5,
+                         }
+
 #### Version 2.3.0
 
 - Se agregan funcionalidades.

{sarapy-2.3.0 → sarapy-3.0.0}/pyproject.toml

@@ -1,7 +1,7 @@
 [project]
 name = "sarapy"
 
-version = "2.3.0"
+version = "3.0.0"
 authors = [
   {name = "Lucas Baldezzari", email = "lmbaldezzari@gmail.com"},]
 maintainers = [

{sarapy-2.3.0 → sarapy-3.0.0}/sarapy/analysis/FeaturesResume.py

@@ -17,8 +17,8 @@ import re
 from datetime import datetime, time
 
 class FeaturesResume():
-    def __init__(self, raw_data, info="", filtrar=None, updateTagSeedling=False,
-                 kwargs_fmcreator=None, kwargs_classifier=None, timeFilter=None):
+    def __init__(self, raw_data, info="", filtrar=None, updateTagSeedling=False, outliers=None,
+                 kwargs_fmcreator=None, kwargs_classifier=None, timeFilter=None, window_size_ma=104):
         """
         Constructor para inicializar la clase FeaturesResume.
         
@@ -29,42 +29,62 @@ class FeaturesResume():
         self.updateTagSeedling = updateTagSeedling
         self.filtrar = filtrar
         self.timeFilter = timeFilter
+        self.outliers = outliers
+        self.window_size_ma = window_size_ma
 
         self.info = info
         if not kwargs_fmcreator:
-            self.kwargs_fmcreator = {"imputeDistances":False, "distanciaMedia":1.8, "umbral_precision":0.3,
-                                     "dist_mismo_lugar":0.0, "max_dist":100,
-                                     "umbral_ratio_dCdP":2, "deltaO_medio":4,}
+            self.kwargs_fmcreator = {"imputeDistances":True, "distanciaMedia":1.8, "umbral_precision":0.3,
+                                     "dist_mismo_lugar":0.2, "max_dist":100,
+                                     "umbral_ratio_dCdP":2, "deltaO_medio":4,
+                                     "impute_ratiodcdp": True, "umbral_impute_ratiodcdp": -0.8,
+                                     "deltaO_ma": True, "deltaO_ma_window": 26}
         else:
             self.kwargs_fmcreator = kwargs_fmcreator
             
         if not kwargs_classifier:
-            self.kwargs_classifier = {"proba_threshold":0.85,
-                                      "update_samePlace":False,
-                                      "update_dstpt":False,
+            self.kwargs_classifier = {"proba_threshold":0.2,
+                                      "use_proba_ma":False,
+                                      "proba_ma_window":10,
+                                      "update_samePlace":True,
+                                      "update_dstpt":True,
                                       "useRatioStats":False,
                                       "std_weight":1.,
                                       "useDistancesStats":False,
-                                      "ratio_dcdp_umbral":0.3,
+                                      "ratio_dcdp_umbral":0.0,
                                       "dist_umbral":0.5,
                                       "umbral_bajo_dstpt":4,
-                                      "umbral_proba_dstpt":0.85}
+                                      "umbral_proba_dstpt":0.70,
+                                      "use_ma":True,
+                                      "dstpt_ma_window":104,
+                                      "use_min_dstpt":False,
+                                      "factor":0.1}
         else:
             self.kwargs_classifier = kwargs_classifier
 
         if timeFilter:
             self.raw_data = self.filter_raw_by_time_window(**timeFilter)
             
-        self.plantinFMCreator = PlantinFMCreator(self.kwargs_fmcreator)
+        self.plantinFMCreator = PlantinFMCreator(**self.kwargs_fmcreator)
         self.tid = TransformInputData()
         self.data = self.transformRawData(self.raw_data)
-        if filtrar == 1:
+        
+        if self.filtrar == 1:
             self.data = self.data[self.data["tag_seedling"] == 1]
-        elif filtrar == 0:
+        elif self.filtrar == 0:
             self.data = self.data[self.data["tag_seedling"] == 0]
 
         if "dst_pt" in self.data.columns:
-            self.data["dst_pt_ma"] = self.getSensorMA()
+            if len(self.data["dst_pt"]) < window_size_ma:
+                self.data["dst_pt_ma"] = self.getSensorMA(window_size=len(self.data["dst_pt"]))
+            else:
+                self.data["dst_pt_ma"] = self.getSensorMA(window_size=window_size_ma)
+
+        if "tag_seed_probas1" in self.data.columns:
+            if len(self.data["tag_seed_probas1"]) < window_size_ma:
+                self.data["tag_seed_probas1_ma"] = self.getProbasMA(window_size=len(self.data["tag_seed_probas1"]))
+            else:
+                self.data["tag_seed_probas1_ma"] = self.getProbasMA(window_size=window_size_ma)
 
     def transformRawData(self, raw_data):
         """
@@ -136,6 +156,9 @@ class FeaturesResume():
         data["latitud"] = temp_samplesdf["latitud"]
         data["longitud"] = temp_samplesdf["longitud"]
 
+        if self.outliers:
+            data = self.removeOutliers(data.copy(), self.outliers)
+
         return data
 
     def classifiedData(self, classifier_file = 'modelos\\pipeline_rf.pkl', **kwargs_classifier):
@@ -143,13 +166,18 @@ class FeaturesResume():
         raw_X = self.tid.transform(self.raw_data)
         X, dst_pt, inest_pt = self.plantinFMCreator.fit_transform(raw_X)
 
-        rf_clf_wu = PlantinClassifier(classifier_file=classifier_file)
+        # ratio_dcdp_median = np.median(X[:, 1])
+        ##reemplazo los datos de X[:, 1] por la mediana si están por debajo de -10
+        # X[:, 1] = np.where(X[:, 1] < -0.8, ratio_dcdp_median, X[:, 1])
+        # X[:, 0] = self.getMA(X[:, 0], window_size=26)
+
+        clasificador = PlantinClassifier(classifier_file=classifier_file)
 
-        clasificaciones, probas = rf_clf_wu.classify(X, dst_pt, inest_pt, **kwargs_classifier)
+        clasificaciones, probas = clasificador.classify(X, dst_pt, inest_pt, **kwargs_classifier)
 
         return clasificaciones, probas
 
-    def removeOutliers(self, limits:dict={"deltaO": (0, 3600),
+    def removeOutliers(self, data, limits:dict={"deltaO": (0, 3600),
                                           "precision": (0, 10000)}):
         """
         Función para eliminar outliers de las características procesadas.
@@ -158,14 +186,17 @@ class FeaturesResume():
         ##chqueo que columnas sí están dentro de self.data y limits.
         ##las que no están, se ignoran y se muestra un mensaje de warning
         ##actualizo las columnas dentro de limits eliminando las que no están en self.data
+
         for col in list(limits.keys()):
-            if col not in self.data.columns:
+            if col not in data.columns:
                 logger.warning(f"La columna {col} no está en los datos y será ignorada.")
                 del limits[col]
 
         ##elimino outliers
         for col, (lower, upper) in limits.items():
-            self.data = self.data[(self.data[col] >= lower) & (self.data[col] <= upper)]
+            data = data[(data[col] >= lower) & (data[col] <= upper)]
+
+        return data
 
     def getResume(self, to="all", pctbajo_value=1, pctalto_value=14, lista_funciones=None):
         """
@@ -226,10 +257,44 @@ class FeaturesResume():
         data: numpy array con los datos de la serie temporal
         window_size: tamaño de la ventana para calcular la media móvil
         """
-        return np.convolve(self.data["dst_pt"].values, np.ones(window_size)/window_size, mode=mode)
+        # return np.convolve(self.data["dst_pt"].values, np.ones(window_size)/window_size, mode=mode)
+        ##para evitar ceros al inicio y al final debido a la convolución, agrego padding
+        ##pongo los primeros window_size valores de la señal al inicio y los últimos window_size valores al final
+        padding_start = self.data["dst_pt"].values[0:window_size]
+        padding_end = self.data["dst_pt"].values[-window_size:]
+        padded_data = np.concatenate([padding_start, self.data["dst_pt"].values, padding_end])
+        ma_full = np.convolve(padded_data, np.ones(window_size)/window_size, mode='same')
+        return ma_full[window_size: -window_size]
     
-    def generateSensorMA(self):
-        self.data["sensor_ma"] = self.getSensorMA()
+    def getProbasMA(self, window_size=104, mode='same'):
+        """
+        Función para calcular la media móvil de una serie temporal.
+        data: numpy array con los datos de la serie temporal
+        window_size: tamaño de la ventana para calcular la media móvil
+        """
+        ##para evitar ceros al inicio y al final debido a la convolución, agrego padding
+        ##copio los primeros y últimos valores usando la misma cantidad que window_size
+        ##pongo los primeros window_size valores de la señal al inicio y los últimos window_size valores al final
+        padding_start = self.data["tag_seed_probas1"].values[0:window_size]
+        padding_end = self.data["tag_seed_probas1"].values[-window_size:]
+        padded_data = np.concatenate([padding_start, self.data["tag_seed_probas1"].values, padding_end])
+        ma_full = np.convolve(padded_data, np.ones(window_size)/window_size, mode='same')
+        return ma_full[window_size: -window_size]
+    
+    def getMA(self, data: np.array, window_size=104, mode='same'):
+        """
+        Función para calcular la media móvil de una serie temporal.
+        data: numpy array con los datos de la serie temporal
+        window_size: tamaño de la ventana para calcular la media móvil
+        """
+        ##para evitar ceros al inicio y al final debido a la convolución, agrego padding
+        ##copio los primeros y últimos valores usando la misma cantidad que window_size
+        ##pongo los primeros window_size valores de la señal al inicio y los últimos window_size valores al final
+        padding_start = data[0:window_size]
+        padding_end = data[-window_size:]
+        padded_data = np.concatenate([padding_start, data, padding_end])
+        ma_full = np.convolve(padded_data, np.ones(window_size)/window_size, mode='same')
+        return ma_full[window_size: -window_size]
 
     def to_time_obj(self,t):
         """
@@ -299,6 +364,13 @@ class FeaturesResume():
                 mask &= ~tod.eq(t1)
 
         filtered = df[mask]
+        #me quedo con los indices donde se cumpla df[mask] y aplico a self.raw_data de origen
+
+        ##chequeo que filtered no esté vacio, sino retorno None
+        if filtered.empty or len(filtered) < 10:
+            logger.warning("El filtro de tiempo resultó en un conjunto vacío.")
+            print("El filtro de tiempo resultó en un conjunto vacío.")
+            return None
 
         #si inplace, actualizo filtro raw_data y retorno un nuevo objeto FeaturesResume, sino retorno los datos filtrados
         if inplace:
@@ -312,7 +384,9 @@ class FeaturesResume():
                 updateTagSeedling = self.updateTagSeedling,
                 kwargs_fmcreator = self.kwargs_fmcreator,
                 kwargs_classifier = self.kwargs_classifier,
-                timeFilter = None  # ya apliqué el filtro
+                timeFilter = None,  # ya apliqué el filtro
+                outliers = self.outliers,
+                window_size_ma=self.window_size_ma,
             )
 
             return new_fr
@@ -374,7 +448,7 @@ class FeaturesResume():
     ):
         """
         Genera un gráfico de comparación entre dos características en ejes y diferentes.
-        Podés elegir si cada eje usa línea, solo marcadores, o ambos.
+        Se puede elegir si cada eje usa línea, solo marcadores, o ambos.
 
         Args:
             - feature1, feature2: nombres de columnas en self.data.
@@ -442,15 +516,16 @@ class FeaturesResume():
         lines2, labels2 = ax2.get_legend_handles_labels()
         ax1.legend(lines1 + lines2, labels1 + labels2, loc='best')
 
-        if show:
-            plt.show()
-
         if save:
             if filename is not None:
                 plt.savefig(filename)
             else:
                 plt.savefig(f"feature_comparison_{feature1}_{feature2}.png")
-        plt.close(fig)  # Cierra la figura para liberar memoria
+
+        if show:
+            plt.show()
+        else:
+            plt.close(fig)  # Cierra la figura para liberar memoria
 
     ##gráfico de dispersión para comparar la distribución de 0s y 1s
     def plot_geo_compare(
@@ -464,6 +539,9 @@ class FeaturesResume():
         s: float = 10.0,
         alpha: float = 0.8,
         equal_aspect: bool = True,
+        save = False,
+        show = True,
+        filename = None,
         # ---- NUEVO: control de colorbar y límites de color ----
         vmin: float | None = None,
         vmax: float | None = None,
@@ -541,7 +619,15 @@ class FeaturesResume():
             ax.set_xlim(xmin, xmax)
             ax.set_ylim(ymin, ymax)
 
-        plt.show()
+
+        if save:
+            if filename is not None:
+                plt.savefig(filename)
+            else:
+                plt.savefig(f"geo_compare_{feature_col}.png")
+        if show:
+            plt.show()
+        plt.close(fig)  # Cierra la figura para liberar memoria
 
 if __name__ == "__main__":
     import json
@@ -554,20 +640,33 @@ if __name__ == "__main__":
     pkg_logger = logging.getLogger("sarapy.stats")
     pkg_logger.setLevel(logging.ERROR)
 
-    kwargs_fmcreator = {"imputeDistances":False, "distanciaMedia":1.8, "umbral_precision":0.3,
-                          "dist_mismo_lugar":0.0, "max_dist":100,
-                          "umbral_ratio_dCdP":2, "deltaO_medio":4,}
-    
-    kwargs_classifier = {"proba_threshold":0.85,
-                         "update_samePlace":False,
-                         "update_dstpt":False,
+    ## argumentos de PlantinFMCreator
+    kwargs_fmcreator = {"imputeDistances":True, "distanciaMedia":1.8, "umbral_precision":0.3,
+                        "dist_mismo_lugar":0.2, "max_dist":100,
+                        "umbral_ratio_dCdP":2, "deltaO_medio":4,
+                        "impute_ratiodcdp": True, "umbral_impute_ratiodcdp": -0.5,
+                        "deltaO_ma": True, "deltaO_ma_window": 26}
+            
+            
+    ##argumentos del método PlantinClassifier.clasiffy()
+    kwargs_classifier = {"proba_threshold":0.45,
+                         "use_proba_ma":False,
+                         "proba_ma_window":10,
+                         "update_samePlace":True,
+                         "update_dstpt":True,
+                         "umbral_proba_dstpt":0.5,
+                         "umbral_bajo_dstpt":1.5,
+                         "use_ma":True,
+                         "dstpt_ma_window":62,
+                         "use_min_dstpt":False,
+                         "factor":0.1,
+                         
                          "useRatioStats":False,
                          "std_weight":1.,
                          "useDistancesStats":False,
-                         "ratio_dcdp_umbral":0.3,
+                         "ratio_dcdp_umbral":0.1,
                          "dist_umbral":0.5,
-                         "umbral_bajo_dstpt":4,
-                         "umbral_proba_dstpt":0.7}
+                         }
 
     
     time_filter=None
@@ -590,14 +689,19 @@ if __name__ == "__main__":
 
     merged_data = dataMerging(historical_data, post_data, raw_data, nodoName=nodo,newColumns=False, asDF=False)
 
-    fr = FeaturesResume(merged_data, info = nodo, filtrar=None,
-                        kwargs_classifier=kwargs_classifier, updateTagSeedling=True, timeFilter=time_filter)
-
-    fr.removeOutliers({"deltaO": (0, 3600),
-                       "time_ac": (0, 100),
-                       "ratio_dCdP": (-50, 2),
-                       "precision": (0, 10000),
-                       "distances": (0, 5000)})
+    outliers = {
+            "ratio_dCdP": (-5, 2),
+            "deltaO": (0, 3600),
+            "time_ac": (0, 100),
+            "precision": (0, 5000),
+            "distances": (0, 100)
+            }
+
+    fr = FeaturesResume(merged_data, info = nodo, filtrar=None, outliers=outliers,
+                             kwargs_classifier=kwargs_classifier,
+                             kwargs_fmcreator=kwargs_fmcreator,
+                             updateTagSeedling=True, timeFilter=None,
+                             window_size_ma=62)
     
     print(fr.data["tag_seedling"].value_counts(normalize=True))
     print(fr.getResume(to="all"))

{sarapy-2.3.0 → sarapy-3.0.0}/sarapy/dataProcessing/OpsProcessor.py

@@ -43,7 +43,8 @@ class OpsProcessor():
                 kwargs_plclass[key] = value
 
         fmcreator_map = {"imputeDistances", "distanciaMedia", "umbral_precision",
-                         "dist_mismo_lugar", "max_dist", "umbral_ratio_dCdP", "deltaO_medio"}
+                         "dist_mismo_lugar", "max_dist", "umbral_ratio_dCdP", "deltaO_medio",
+                         "impute_ratiodcdp", "umbral_impute_ratiodcdp", "deltaO_ma", "deltaO_ma_window"}
         fmcreator_kargs = {}
         ##recorro kwargs y usando fmcreator_map creo un nuevo diccionario con los valores que se pasaron
         for key, value in kwargs.items():
@@ -188,7 +189,7 @@ class OpsProcessor():
             logging.debug(f"Número de operaciones para el nodo {ID_NPDP}: {len(operations)}")
             features, dst_pt, inest_pt = self.plantinFMCreator.fit_transform(operations)
             logging.debug(f"Features shape for {ID_NPDP}: {features.shape}")
-            classified_ops, classifications_probas = self._plantin_classifier.classify(features, dst_pt, inest_pt, **classify_kwargs)
+            classified_ops, classifications_probas = self._plantin_classifier.classify(features, dst_pt, inest_pt, **kwargs)
             logging.debug(f"Classified operations shape for {ID_NPDP}: {classified_ops.shape}")
             
             ##chequeo si first_day_op_classified es True, si es así, no se considera la primera fila de las classified_ops
@@ -306,37 +307,50 @@ if __name__ == "__main__":
     import logging
 
     ## argumentos de PlantinFMCreator
-    kwargs_constructor = {"imputeDistances":False, "distanciaMedia":1.8, "umbral_precision":0.3,
-                          "dist_mismo_lugar":0.0, "max_dist":100,
-                          "umbral_ratio_dCdP":0.5, "deltaO_medio":4,}
+    kwargs_fmcreator = {"imputeDistances":True, "distanciaMedia":1.8, "umbral_precision":0.3,
+                        "dist_mismo_lugar":0.2, "max_dist":100,
+                        "umbral_ratio_dCdP":2, "deltaO_medio":4,
+                        "impute_ratiodcdp": True, "umbral_impute_ratiodcdp": -0.5,
+                        "deltaO_ma": True, "deltaO_ma_window": 26}
             
             
-            ##argumentos del método PlantinClassifier.clasiffy()
-    kwargs_classifier = {"proba_threshold":0.85,
-                         "update_samePlace":False,
-                         "update_dstpt":False,
+    ##argumentos del método PlantinClassifier.clasiffy()
+    kwargs_classifier = {"proba_threshold":0.4,
+                         "use_proba_ma":False,
+                         "proba_ma_window":10,
+                         "update_samePlace":True,
+                         "update_dstpt":True,
+                         "umbral_proba_dstpt":0.5,
+                         "umbral_bajo_dstpt":1.5,
+                         "use_ma":True,
+                         "dstpt_ma_window":62,
+                         "use_min_dstpt":False,
+                         "factor":0.1,
+                         
                          "useRatioStats":False,
                          "std_weight":1.,
                          "useDistancesStats":False,
-                         "ratio_dcdp_umbral":0.3,
+                         "ratio_dcdp_umbral":0.1,
                          "dist_umbral":0.5,
-                         "umbral_bajo_dstpt":4,
-                         "umbral_proba_dstpt":0.85}
-
-    
-    historical_data_path = "examples\\2025-09-04\\UPM039N\\historical-data.json"
-    with open(historical_data_path, 'r') as file:
-        samples = json.load(file)
-
-    op = OpsProcessor(classifier_file='modelos\\pipeline_rf.pkl',
-                      regresor_file='modelos\\regresor.pkl', poly_features_file='modelos\\poly_features.pkl',
-                      **kwargs_constructor)
-
-    ops_clasificadas = op.processOperations(samples, **kwargs_classifier)
-    probas = op.classifications_probas
-    print(probas[:3])
-    print(ops_clasificadas[:3])
-    df_ops_clasificadas = pd.DataFrame(ops_clasificadas)
-
-    print(df_ops_clasificadas.describe())
-
+                         }
+
+    nodos = ['UPM006N','UPM007N','UPM034N','UPM037N','UPM038N','UPM039N','UPM045N','UPM041N',
+             'UPM048N','UPM105N','UPM107N']
+    for nodo in nodos:
+        print(f"**************** Procesando nodo: {nodo} ***********************")
+        historical_data_path = f"examples\\2025-08-09\\{nodo}\\historical-data.json"
+        with open(historical_data_path, 'r') as file:
+            samples = json.load(file)
+
+        op = OpsProcessor(classifier_file='modelos\\pipeline_rf.pkl',
+                        regresor_file='modelos\\regresor.pkl', poly_features_file='modelos\\poly_features.pkl',
+                        **kwargs_fmcreator)
+
+        ops_clasificadas = op.processOperations(samples, **kwargs_classifier)
+        probas = op.classifications_probas
+        # print(probas[:3])
+        # print(ops_clasificadas[:3])
+        df_ops_clasificadas = pd.DataFrame(ops_clasificadas)
+
+        print(df_ops_clasificadas.describe())
+        print(f"***************************************************************")

{sarapy-2.3.0 → sarapy-3.0.0}/sarapy/dataProcessing/TLMSensorDataProcessor.py

@@ -39,6 +39,8 @@ class TLMSensorDataProcessor():
             obj[:]                         -> todo
             obj[["col1"], :50]             -> columna col1, primeras 50 filas
         """
+        ##chqueo que se tengan datos, sino retorno []
+
         if isinstance(key, tuple): ##reviso si es una tupla
             ##se supone que key es una tupla de la forma (cols, rows)
             if len(key) != 2:
@@ -73,11 +75,11 @@ if __name__ == "__main__":
     import json
     from sarapy.preprocessing import TransformInputData
 
-    historical_data_path = "examples/2025-06-21/UPM000N/historical-data.json"
+    historical_data_path = "examples\\2025-09-04\\UPM042N\\historical-data.json"
     with open(historical_data_path, 'r') as file:
         historical_data = json.load(file)
 
-    inputData_transformer = TransformInputData.TransformInputData()
+    inputData_transformer = TransformInputData()
     data = inputData_transformer.transform(historical_data)
     
     tlm_processor = TLMSensorDataProcessor(data=data)
@@ -87,4 +89,5 @@ if __name__ == "__main__":
     tlm_processor[["id_db_dw", "id_db_h"], :5]#.shape
     tlm_processor.keys
     tlm_processor["longitud",:]
+    print(tlm_processor["date_oprc",:][:5])
     

{sarapy-2.3.0 → sarapy-3.0.0}/sarapy/mlProcessors/FertilizerTransformer.py

@@ -1,4 +1,5 @@
 import pickle
+import logging
 from sarapy.dataProcessing import TLMSensorDataProcessor
 
 class FertilizerTransformer:
@@ -13,22 +14,23 @@ class FertilizerTransformer:
             - regresor: Regresor que transforma los valores de distorsión a gramos.
             - poly_features: Grado del polinomio a utilizar en la transformación de los datos.        
         """
+        self.logger = logging.getLogger("FertilizerTransformer")
         ##cargo el regresor con pickle. Usamos try para capturar el error FileNotFoundError
         try:
             with open(regresor_file, 'rb') as file:
                 self._regresor = pickle.load(file)
-            print("Regresor cargado con éxito.")
+            self.logger.info("Regresor cargado con éxito.")
         except FileNotFoundError:
-            print("El archivo no se encuentra en el directorio actual.")
+            self.logger.error("El archivo no se encuentra en el directorio actual.")
 
         ##cargo las características polinómicas con pickle. Usamos try para capturar el error FileNotFoundError
         try:
             with open(poly_features_file, 'rb') as file:
                 self._poly_features = pickle.load(file)
-            print("Características polinómicas cargadas con éxito.")
+            self.logger.info("Características polinómicas cargadas con éxito.")
         except FileNotFoundError:
-            print("El archivo no se encuentra en el directorio actual.")
-            
+            self.logger.error("El archivo no se encuentra en el directorio actual.")
+
         self.fertilizer_grams = None ##cuando no se ha transformado ningún dato, se inicializa en None
 
 

{sarapy-2.3.0 → sarapy-3.0.0}/sarapy/mlProcessors/PlantinClassifier.py

@@ -28,11 +28,13 @@ class PlantinClassifier(BaseEstimator, TransformerMixin):
             self.logger.info("Clasificador cargado con éxito.")
         except FileNotFoundError:
             self.logger.error("El archivo no se encuentra en el directorio actual.")
+            raise
 
-    def classify(self, feature_matrix, dst_pt, inest_pt, proba_threshold = 0.85,
+    def classify(self, feature_matrix, dst_pt, inest_pt,
+                 proba_threshold = 0.45, use_proba_ma = False, proba_ma_window = 10,
                 update_samePlace:bool = True, update_dstpt: bool = True,
-                umbral_proba_dstpt = 0.85, umbral_bajo_dstpt = 4,
-                use_ma = False, ma_window = 104,
+                umbral_proba_dstpt = 0.5, umbral_bajo_dstpt = 1.5,
+                use_ma = True, dstpt_ma_window = 62,
                 use_min_dstpt = False, factor = 0.1, **kwargs):
         """Genera la clasificación de las operaciones para plantines.
         
@@ -50,13 +52,25 @@ class PlantinClassifier(BaseEstimator, TransformerMixin):
         """
 
         if use_ma:
-            dst_pt = self.get_dstpt_MA(dst_pt, window_size=ma_window, mode='same')
+            if dst_pt.shape[0] < dstpt_ma_window:
+                self.logger.warning("El tamaño de la serie temporal es menor que la ventana de media móvil. No se aplicará media móvil.")
+                dst_pt = self.get_dstpt_MA(dst_pt, window_size=dst_pt.shape[0], mode='same')             
+            else:
+                dst_pt = self.get_dstpt_MA(dst_pt, window_size=dstpt_ma_window, mode='same')
 
         self.clasificaciones = self._pipeline.predict(feature_matrix)
         self.classifications_probas = self._pipeline.predict_proba(feature_matrix)
 
-        # Si la probabilidad de ser plantín es menor al umbral, entonces la clasificación es 0 (no plantín)
-        self.clasificaciones[self.classifications_probas[:,1] < proba_threshold] = 0
+        if use_proba_ma:
+            if proba_ma_window >= self.classifications_probas.shape[0]:
+                self.logger.warning("El tamaño de la serie temporal es menor que la ventana de media móvil. No se aplicará media móvil a las probabilidades.")
+                probas_ma = self.get_probas_MA(self.classifications_probas, window_size=self.classifications_probas.shape[0], mode='same')
+            else:
+                probas_ma = self.get_probas_MA(self.classifications_probas, window_size=proba_ma_window, mode='same')
+            self.clasificaciones[probas_ma[:,1] < proba_threshold] = 0
+        else:
+            # self.clasificaciones = self._pipeline.classes_[np.argmax(self.classifications_probas, axis=1)]
+            self.clasificaciones[self.classifications_probas[:,1] < proba_threshold] = 0
 
         if update_samePlace:
             self.grouped_ops = self.groupOpsSamePlace(feature_matrix, **kwargs)
@@ -69,7 +83,7 @@ class PlantinClassifier(BaseEstimator, TransformerMixin):
 
         return self.clasificaciones, self.classifications_probas
 
-    def groupOpsSamePlace(self, X, useRatioStats = True, std_weight=1, useDistancesStats = True,
+    def groupOpsSamePlace(self, X, useRatioStats = False, std_weight=1, useDistancesStats = False,
                           ratio_dcdp_umbral=0.1, dist_umbral=0.5):
         """
         Función que agrupa las operaciones que se realizaron en el mismo lugar o que sean de limpieza.
@@ -141,7 +155,7 @@ class PlantinClassifier(BaseEstimator, TransformerMixin):
         return new_labels
 
     def updateLabelsFromDSTPT(self, labels, dst_pt, inest_pt,
-                              umbral_bajo_dstpt = 4, umbral_proba_dstpt = 0.85,
+                              umbral_bajo_dstpt = 4, umbral_proba_dstpt = 0.5,
                               use_min_dstpt = False, factor = 0.1):
         """
         Función para actualizar las etiquetas de las operaciones que tengan distorsiones de plantín.
@@ -164,7 +178,25 @@ class PlantinClassifier(BaseEstimator, TransformerMixin):
         data: numpy array con los datos de la serie temporal
         window_size: tamaño de la ventana para calcular la media móvil
         """
-        return np.convolve(dst_pt, np.ones(window_size)/window_size, mode=mode)
+        # return np.convolve(dst_pt, np.ones(window_size)/window_size, mode=mode)
+        padding_start = dst_pt[0:window_size]
+        padding_end = dst_pt[-window_size:]
+        padded_data = np.concatenate([padding_start, dst_pt, padding_end])
+        ma_full = np.convolve(padded_data, np.ones(window_size)/window_size, mode='same')
+        return ma_full[window_size: -window_size]
+    
+    def get_probas_MA(self, probas, window_size=104, mode='same'):
+        """
+        Función para calcular la media móvil de una serie temporal.
+        data: numpy array con los datos de la serie temporal
+        window_size: tamaño de la ventana para calcular la media móvil
+        """
+        # return np.convolve(dst_pt, np.ones(window_size)/window_size, mode=mode)
+        padding_start = probas[0:window_size, :]
+        padding_end = probas[-window_size:, :]
+        padded_data = np.vstack([padding_start, probas, padding_end])
+        ma_full = np.apply_along_axis(lambda m: np.convolve(m, np.ones(window_size)/window_size, mode='same'), axis=0, arr=padded_data)
+        return ma_full[window_size: -window_size, :]
     
 if __name__ == "__main__":
     import os
@@ -176,22 +208,35 @@ if __name__ == "__main__":
     import json
 
 
-    kwargs_fmcreator = {"imputeDistances":False, "distanciaMedia":1.8, "umbral_precision":0.3,
-                          "dist_mismo_lugar":0.0, "max_dist":100,
-                          "umbral_ratio_dCdP":2, "deltaO_medio":4,}
-    
-    kwargs_classifier = {"proba_threshold":0.85,
-                         "update_samePlace":False,
-                         "update_dstpt":False,
+    ## argumentos de PlantinFMCreator
+    kwargs_fmcreator = {"imputeDistances":True, "distanciaMedia":1.8, "umbral_precision":0.3,
+                        "dist_mismo_lugar":0.2, "max_dist":100,
+                        "umbral_ratio_dCdP":2, "deltaO_medio":4,
+                        "impute_ratiodcdp": True, "umbral_impute_ratiodcdp": -0.5,
+                        "deltaO_ma": True, "deltaO_ma_window": 26}
+            
+            
+    ##argumentos del método PlantinClassifier.clasiffy()
+    kwargs_classifier = {"proba_threshold":0.45,
+                         "use_proba_ma":False,
+                         "proba_ma_window":10,
+                         "update_samePlace":True,
+                         "update_dstpt":True,
+                         "umbral_proba_dstpt":0.5,
+                         "umbral_bajo_dstpt":1.5,
+                         "use_ma":True,
+                         "dstpt_ma_window":62,
+                         "use_min_dstpt":False,
+                         "factor":0.1,
+                         
                          "useRatioStats":False,
                          "std_weight":1.,
                          "useDistancesStats":False,
-                         "ratio_dcdp_umbral":0.3,
+                         "ratio_dcdp_umbral":0.1,
                          "dist_umbral":0.5,
-                         "umbral_bajo_dstpt":4,
-                         "umbral_proba_dstpt":0.85}
+                         }
 
-    historical_data_path = "examples\\2025-09-04\\UPM039N\\historical-data.json"
+    historical_data_path = "examples\\2025-09-04\\UPM042N\\historical-data.json"
     with open(historical_data_path, 'r') as file:
         samples = json.load(file)
 
@@ -210,6 +255,3 @@ if __name__ == "__main__":
     print("primeras probabilidades", probas[100:105])
     print("primeras distorsiones", dst_pt[100:105])
     print("primeras inestabilidades", inest_pt[100:105])
-
-    # print(rf_clf_wu.classify(X, dst_pt, inest_pt, **kwargs_classifier))
-

{sarapy-2.3.0 → sarapy-3.0.0}/sarapy/mlProcessors/PlantinFMCreator.py

@@ -1,4 +1,5 @@
 ###Documentación en https://github.com/lucasbaldezzari/sarapy/blob/main/docs/Docs.md
+import logging
 import numpy as np
 from sklearn.base import BaseEstimator, TransformerMixin
 from sarapy.dataProcessing import TLMSensorDataProcessor, TimeSeriesProcessor, GeoProcessor
@@ -20,7 +21,9 @@ class PlantinFMCreator(BaseEstimator, TransformerMixin):
     
     def __init__(self, imputeDistances = True, distanciaMedia:float = 1.8,
                  umbral_precision:float = 0.3, dist_mismo_lugar = 0.0, max_dist = 100,
-                 umbral_ratio_dCdP:float = 0.5, deltaO_medio = 4, baseDeltaP = 10):
+                 umbral_ratio_dCdP:float = 0.5, deltaO_medio = 4, baseDeltaP = 10,
+                 impute_ratiodcdp = False, umbral_impute_ratiodcdp = -0.8,
+                 deltaO_ma = False, deltaO_ma_window = 26):
         """Inicializa la clase FMCreator.
         
         Args:
@@ -30,6 +33,7 @@ class PlantinFMCreator(BaseEstimator, TransformerMixin):
             - umbral_ratio_dCdP: Umbral para el ratio entre el delta de caminata y el delta de pico abierto.
             - deltaO_medio: delta de operación medio entre operaciones.
         """
+        self.logger = logging.getLogger("PlantinFMCreator")
         
         self.is_fitted = False
         self.imputeDistances = imputeDistances
@@ -40,9 +44,10 @@ class PlantinFMCreator(BaseEstimator, TransformerMixin):
         self.umbral_ratio_dCdP = umbral_ratio_dCdP
         self.deltaO_medio = deltaO_medio
         self.baseDeltaP = baseDeltaP
-        
-        ##creamos un diccionario para saber la posición de cada dato dentro del array devuelto por transform()
-        self._dataPositions = {"DST_PT": 0, "deltaO": 2, "ratio_dCdP": 3, "distances": 4}
+        self.impute_ratiodcdp = impute_ratiodcdp
+        self.umbral_impute_ratiodcdp = umbral_impute_ratiodcdp
+        self.deltaO_ma = deltaO_ma
+        self.deltaO_ma_window = deltaO_ma_window
         
     def fit(self, X: np.array, y=None)-> np.array:
         """Fittea el objeto
@@ -73,7 +78,6 @@ class PlantinFMCreator(BaseEstimator, TransformerMixin):
         tpDP = timeProcessor._dataPositions
         geoprocessor = GeoProcessor.GeoProcessor()
         
-
         date_oprc = self.tlmDataProcessor["date_oprc",:] #datos de fecha y hora de operación
         time_ac = self.tlmDataProcessor["TIME_AC",:]/self.baseDeltaP #datos de fecha y hora de operación en formato timestamp
         lats = self.tlmDataProcessor["latitud",:] #latitudes de las operaciones
@@ -88,7 +92,6 @@ class PlantinFMCreator(BaseEstimator, TransformerMixin):
         timeData = np.hstack((date_oprc.reshape(-1,1),time_ac.reshape(-1, 1)))
         
         self._timeDeltas = timeProcessor.fit_transform(timeData)
-        # print(np.median(self._timeDeltas[:,tpDP["ratio_dCdP"]]))
 
         ##fitteamos geoprocessor con las latitudes y longitudes
         points = np.hstack((lats.reshape(-1,1),longs.reshape(-1,1)))
@@ -98,6 +101,22 @@ class PlantinFMCreator(BaseEstimator, TransformerMixin):
         self.featureMatrix = np.vstack((self._timeDeltas[:,tpDP["deltaO"]],
                                         self._timeDeltas[:,tpDP["ratio_dCdP"]],
                                         self._distances)).T
+
+        if self.impute_ratiodcdp:
+            ratio_dcdp_median = np.median(self.featureMatrix[:, 1])
+            self.featureMatrix[:, 1] = np.where(self.featureMatrix[:, 1] < self.umbral_impute_ratiodcdp, ratio_dcdp_median, self.featureMatrix[:, 1])
+
+        if self.deltaO_ma:
+            data = self.featureMatrix[:, 0]
+            if self.deltaO_ma_window >= len(data):
+                self.logger.warning("El tamaño de la serie temporal es menor que la ventana de media móvil. No se aplicará media móvil a deltaO.")
+                self.deltaO_ma_window = len(data)
+            
+            padding_start = data[0:self.deltaO_ma_window]
+            padding_end = data[-self.deltaO_ma_window:]
+            padded_data = np.concatenate([padding_start, data, padding_end])
+            ma_full = np.convolve(padded_data, np.ones(self.deltaO_ma_window)/self.deltaO_ma_window, mode='same')
+            self.featureMatrix[:, 0] = ma_full[self.deltaO_ma_window: - self.deltaO_ma_window]
         
         return self.featureMatrix, self.dst_pt, self.inest_pt
 
@@ -130,12 +149,6 @@ class PlantinFMCreator(BaseEstimator, TransformerMixin):
         """Devuelve las distancias entre operaciones."""
         return self._distances
     
-    @property
-    def dataPositions(self):
-        """Devuelve el diccionario con la posición de los datos dentro del array devuelto por transform()."""
-        return self._dataPositions
-    
-        
 if __name__ == "__main__":
     import pandas as pd
     import json

{sarapy-2.3.0 → sarapy-3.0.0}/sarapy/preprocessing/TransformInputData.py

@@ -137,7 +137,7 @@ if __name__ == "__main__":
     import pandas as pd
     import json
 
-    historical_data_path = "examples\\2025-08-04\\UPM006N\\historical-data.json"
+    historical_data_path = "examples\\2025-09-04\\UPM042N\\historical-data.json"
     with open(historical_data_path, 'r') as file:
         historical_data = json.load(file)
     df = pd.DataFrame(historical_data)
@@ -146,4 +146,5 @@ if __name__ == "__main__":
     data_positions = json.load(open("sarapy/preprocessing/telemetriaDataPosition.json", 'r'))
     transform_input_data = TransformInputData()
     transformed_data = transform_input_data.transform(historical_data)
-    print(transformed_data[:2])
+    print(transformed_data[:2])
+    print(transformed_data[0]["date_oprc"])

{sarapy-2.3.0 → sarapy-3.0.0}/sarapy/version.py

@@ -1,2 +1,2 @@
 ## Version of the package
-__version__ = "2.3.0"
+__version__ = "3.0.0"

{sarapy-2.3.0 → sarapy-3.0.0/sarapy.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: sarapy
-Version: 2.3.0
+Version: 3.0.0
 Home-page: https://github.com/lucasbaldezzari/sarapy
 Author: Lucas Baldezzari
 Author-email: Lucas Baldezzari <lmbaldezzari@gmail.com>
@@ -19,6 +19,39 @@ Requires-Dist: geopy
 
 Library for processing SARAPICO project metadata of _AMG SA_.
 
+#### Version 3.0.0
+- Se mejora la forma de obtener valores de media movil para todas las variables en las que se usa.
+- Se corrigen bugs debido a nodos con pocas operaciones.
+- Se corrigen errores a la hora de pasar parámetros a los métodos de algunas clases.
+- Se configuran parámetros de fmcreator y plantin_classifier para el reetiquetado, los mismos son:
+
+kwargs_fmcreator = {"imputeDistances":True, "distanciaMedia":1.8, "umbral_precision":0.3,
+                        "dist_mismo_lugar":0.2, "max_dist":100,
+                        "umbral_ratio_dCdP":2, "deltaO_medio":4,
+                        "impute_ratiodcdp": True, "umbral_impute_ratiodcdp": -0.5,
+                        "deltaO_ma": True, "deltaO_ma_window": 26}
+            
+            
+    ##argumentos del método PlantinClassifier.clasiffy()
+    kwargs_classifier = {"proba_threshold":0.4,
+                         "use_proba_ma":False,
+                         "proba_ma_window":10,
+                         "update_samePlace":True,
+                         "update_dstpt":True,
+                         "umbral_proba_dstpt":0.5,
+                         "umbral_bajo_dstpt":1.5,
+                         "use_ma":True,
+                         "dstpt_ma_window":62,
+                         "use_min_dstpt":False,
+                         "factor":0.1,
+                         
+                         "useRatioStats":False,
+                         "std_weight":1.,
+                         "useDistancesStats":False,
+                         "ratio_dcdp_umbral":0.1,
+                         "dist_umbral":0.5,
+                         }
+
 #### Version 2.3.0
 
 - Se agregan funcionalidades.