sarapy 2.3.0__tar.gz → 3.1.0__tar.gz

{sarapy-2.3.0 → sarapy-3.1.0}/PKG-INFO

@@ -1,24 +1,76 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: sarapy
-Version: 2.3.0
-Home-page: https://github.com/lucasbaldezzari/sarapy
-Author: Lucas Baldezzari
+Version: 3.1.0
+Summary: Library for Sarapico Metadata processing
 Author-email: Lucas Baldezzari <lmbaldezzari@gmail.com>
-Maintainer-email: Lucas Baldezzari <lmbaldezzari@gmail.com>
-License: For private use only. Owner AMG Servicios profesionales (Mercedes, Uruguay)
+License: MIT
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: Microsoft :: Windows :: Windows 10
+Classifier: Operating System :: Microsoft :: Windows :: Windows 11
+Classifier: Operating System :: Unix
+Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENCE
-Requires-Dist: numpy
-Requires-Dist: matplotlib
-Requires-Dist: pandas
-Requires-Dist: scipy
-Requires-Dist: scikit-learn
-Requires-Dist: geopy
+Requires-Dist: numpy>=1.23
+Requires-Dist: pandas>=1.5
+Requires-Dist: scipy>=1.9
+Requires-Dist: scikit-learn>=1.2
+Requires-Dist: matplotlib>=3.6
+Requires-Dist: seaborn>=0.12
+Requires-Dist: requests>=2.28
+Requires-Dist: python-dotenv>=1.0
+Requires-Dist: geopy>=2.3
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: black; extra == "dev"
+Requires-Dist: ruff; extra == "dev"
+Requires-Dist: mypy; extra == "dev"
+Dynamic: license-file
 
 # SARAPY
 
 Library for processing SARAPICO project metadata of _AMG SA_.
 
+#### Version 3.1.0
+
+- Se actualiza regresor para estimar fertilizante.
+- Actualización de archivos para instalar la libería.
+
+
+#### 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.egg-info/PKG-INFO → sarapy-3.1.0/README.md

@@ -1,24 +1,46 @@
-Metadata-Version: 2.1
-Name: sarapy
-Version: 2.3.0
-Home-page: https://github.com/lucasbaldezzari/sarapy
-Author: Lucas Baldezzari
-Author-email: Lucas Baldezzari <lmbaldezzari@gmail.com>
-Maintainer-email: Lucas Baldezzari <lmbaldezzari@gmail.com>
-License: For private use only. Owner AMG Servicios profesionales (Mercedes, Uruguay)
-Description-Content-Type: text/markdown
-License-File: LICENCE
-Requires-Dist: numpy
-Requires-Dist: matplotlib
-Requires-Dist: pandas
-Requires-Dist: scipy
-Requires-Dist: scikit-learn
-Requires-Dist: geopy
-
 # SARAPY
 
 Library for processing SARAPICO project metadata of _AMG SA_.
 
+#### Version 3.1.0
+
+- Se actualiza regresor para estimar fertilizante.
+- Actualización de archivos para instalar la libería.
+
+
+#### 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-3.1.0/pyproject.toml

@@ -0,0 +1,47 @@
+[build-system]
+requires = ["setuptools>=64", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "sarapy"
+version = "3.1.0"
+description = "Library for Sarapico Metadata processing"
+readme = "README.md"
+requires-python = ">=3.9"
+
+authors = [
+  { name = "Lucas Baldezzari", email = "lmbaldezzari@gmail.com" }
+]
+
+license = { text = "MIT" }
+
+classifiers = [
+  "License :: OSI Approved :: MIT License",
+  "Programming Language :: Python :: 3",
+  "Operating System :: Microsoft :: Windows :: Windows 10",
+  "Operating System :: Microsoft :: Windows :: Windows 11",
+  "Operating System :: Unix",
+]
+
+dependencies = [
+"numpy>=1.23",
+  "pandas>=1.5",
+  "scipy>=1.9",
+  "scikit-learn>=1.2",
+  "matplotlib>=3.6",
+  "seaborn>=0.12",
+  "requests>=2.28",
+  "python-dotenv>=1.0",
+  "geopy>=2.3",
+  ]
+
+[project.optional-dependencies]
+dev = [
+  "pytest",
+  "black",
+  "ruff",
+  "mypy",
+]
+
+[tool.setuptools]
+packages = { find = {} }

{sarapy-2.3.0 → sarapy-3.1.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.1.0}/sarapy/dataProcessing/OpsProcessor.py

@@ -32,8 +32,8 @@ class OpsProcessor():
         self.classifications_probas = None
         plclass_map = {"classifier_file"}
         self._operationsDict = {} ##diccionario de operarios con sus operaciones
-        self._platin_classifiedOperations = np.array([]) ##array con las operaciones clasificadas para plantin
-        self._fertilizer_classifiedOperations = np.array([]) ##array con las operaciones clasificadas para plantin
+        # self._platin_classifiedOperations = np.array([]) ##array con las operaciones clasificadas para plantin
+        # self._fertilizer_classifiedOperations = np.array([]) ##array con las operaciones clasificadas para plantin
         self._last_row_db = 0 ##indicador de la última fila de los datos extraidos de la base de datos histórica
 
         kwargs_plclass = {}
@@ -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,51 @@ 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',
+                        regresor_file='modelos\\regfresor_v2.pkl', poly_features_file='modelos\\poly_features_v2.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"***************************************************************")