sarapy 2.2.0__py3-none-any.whl → 3.0.0__py3-none-any.whl

sarapy/analysis/__init__.py

@@ -0,0 +1,3 @@
+from .FeaturesResume import FeaturesResume
+
+__all__ = ["FeaturesResume"]

sarapy/dataProcessing/OpsProcessor.py

@@ -29,7 +29,12 @@ class OpsProcessor():
             - kwargs: Diccionario con los argumentos necesarios instanciar algunas clases.
         """
 
+        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._last_row_db = 0 ##indicador de la última fila de los datos extraidos de la base de datos histórica
 
         kwargs_plclass = {}
         ##recorro kwargs y usando plclass_map creo un nuevo diccionario con los valores que se pasaron
@@ -38,15 +43,16 @@ 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():
             if key in fmcreator_map:
                 fmcreator_kargs[key] = value
         
-        self._plantin_classifier = PlantinClassifier.PlantinClassifier(**kwargs_plclass)
-        self.plantinFMCreator = PlantinFMCreator.PlantinFMCreator(**fmcreator_kargs)
+        self._plantin_classifier = PlantinClassifier(**kwargs_plclass)
+        self.plantinFMCreator = PlantinFMCreator(**fmcreator_kargs)
         
         ##mapa de argumentos para FertilizerTransformer
         ft_map = {"regresor_file", "poly_features_file"}
@@ -56,16 +62,11 @@ class OpsProcessor():
             if key in ft_map:
                 ft_kwargs[key] = value
 
-        self._ftfmcreator = FertilizerFMCreator.FertilizerFMCreator()
-        self._fertilizer_transformer = FertilizerTransformer.FertilizerTransformer(**ft_kwargs)
-        
-        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._last_row_db = 0 ##indicador de la última fila de los datos extraidos de la base de datos histórica
-        self.transformInputData = TransformInputData.TransformInputData()
-        self.transformToOutputData = TransformToOutputData.TransformToOutputData()
-        
+        self._ftfmcreator = FertilizerFMCreator()
+        self._fertilizer_transformer = FertilizerTransformer(**ft_kwargs)
+        self.transformInputData = TransformInputData()
+        self.transformToOutputData = TransformToOutputData()
+
     def processOperations(self, data, **kwargs):
         """Método para procesar las operaciones de los operarios.
 
@@ -94,14 +95,14 @@ class OpsProcessor():
 
             #Si tenemos nuevas operaciones, actualizamos el diccionario de operaciones
             self.updateOperationsDict(newSample) #actualizamos diccionario interno de la clase
-            pl_clas = self.classifyForPlantin(**kwargs) #clasificamos las operaciones para plantín
+            pl_clas, self.classifications_probas = self.classifyForPlantin(**kwargs) #clasificamos las operaciones para plantín
 
             #estimamos los gramos de fertilizante
             ft_grams = self._fertilizer_transformer.transform(newSample)
             logging.debug(f"Fertilizer grams shape: {ft_grams.shape}")
             id_db_h_nums, id_db_dw_nums = self.getActualOperationsNumbers() #obtenemos los números de operaciones desde el diccionario de operaciones
             logging.debug(f"ID_DB_H shape: {id_db_h_nums.shape}, ID_DB_DW shape: {id_db_dw_nums.shape}")
-            date_oprc = pd.DataFrame(newSample)["date_oprc"].values.reshape(-1, 1) ##extraigo las fechas de operación de la muestra
+            # date_oprc = pd.DataFrame(newSample)["date_oprc"].values.reshape(-1, 1) ##extraigo las fechas de operación de la muestra
             timestamps = pd.DataFrame(newSample)["timestamp"].values.reshape(-1, 1) ##extraigo los timestamps de la muestra
             
             return self.transformToOutputData.fit_transform(np.column_stack((timestamps,
@@ -167,7 +168,8 @@ class OpsProcessor():
 
         key_classify_map = {"feature_matrix", "update_samePlace",
                             "useRatioStats", "std_weight", "useDistancesStats",
-                            "ratio_dcdp_umbral", "dist_umbral"}
+                            "ratio_dcdp_umbral", "dist_umbral",
+                            "umbral_bajo_dstpt", "umbral_proba_dstpt"}
         
         ##recorro kwargs y usando key_classify_map creo un nuevo diccionario con los valores que se pasaron
         classify_kwargs = {}
@@ -187,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 = 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
@@ -201,7 +203,7 @@ class OpsProcessor():
             
             self._operationsDict[ID_NPDP]["first_day_op_classified"] = True
 
-        return plantinClassifications
+        return plantinClassifications, classifications_probas
             
     def updateLastOperations(self, ID_NPDPs_newOperations):
         """Método para actualizar la última operación de una muestra de operaciones en el diccionario de operaciones
@@ -303,19 +305,52 @@ if __name__ == "__main__":
     import pandas as pd
     import json
     import logging
-    
-
-    historical_data_path = "examples\\2025-08-04 copy\\UPM008N\\historical-data.json"
-    with open(historical_data_path, 'r') as file:
-        samples = json.load(file)
-
-    samples1 = samples
-
-    op = OpsProcessor(classifier_file='modelos\\pipeline_rf.pkl', imputeDistances = False,
-                      regresor_file='modelos\\regresor.pkl', poly_features_file='modelos\\poly_features.pkl')
-
-    ops_clasificadas = op.processOperations(samples)
-    df_ops_clasificadas = pd.DataFrame(ops_clasificadas)
-
-    print(df_ops_clasificadas.describe())
 
+    ## 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.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,
+                         }
+
+    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/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/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/mlProcessors/PlantinClassifier.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 sklearn.pipeline import Pipeline
@@ -15,17 +16,26 @@ class PlantinClassifier(BaseEstimator, TransformerMixin):
             - classifier_file: String con el nombre del archivo que contiene el clasificador entrenado. El archivo a cargar es un archivo .pkl.
         """
 
+        self.logger = logging.getLogger("PlantinClassifier")
+
+        self.classifications_probas = None
+        self.clasificaciones = None
+
         #cargo el clasificador con pickle. Usamos try para capturar el error FileNotFoundError
         try:
             with open(classifier_file, 'rb') as file:
                 self._pipeline = pickle.load(file)
-            print("Clasificador cargado con éxito.")
+            self.logger.info("Clasificador 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.")
+            raise
+
     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 = 0.85, **kwargs):
+                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.
         
         - feature_matrix: Es un array con los datos (strings) provenientes de la base de datos histórica.
@@ -41,19 +51,39 @@ class PlantinClassifier(BaseEstimator, TransformerMixin):
         NOTA: Estas características son necesarias en base a la última versión del modelo de clasificación.
         """
 
-        self.clasificaiones = self._pipeline.predict(feature_matrix)
-        self.probas = self._pipeline.predict_proba(feature_matrix)
+        if use_ma:
+            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)
+
+        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)
-            self.clasificaiones = self.updateLabelsSamePlace(self.clasificaiones, self.grouped_ops)
+            self.clasificaciones = self.updateLabelsSamePlace(self.clasificaciones, self.grouped_ops)
 
         if update_dstpt:
-            self.clasificaiones = self.updateLabelsFromDSTPT(self.clasificaiones, dst_pt, inest_pt, umbral_proba)
+            self.clasificaciones = self.updateLabelsFromDSTPT(self.clasificaciones, dst_pt, inest_pt,
+                                                             umbral_bajo_dstpt, umbral_proba_dstpt,
+                                                             use_min_dstpt, factor)
 
-        return self.clasificaiones
-    
-    def groupOpsSamePlace(self, X, useRatioStats = True, std_weight=1, useDistancesStats = True,
+        return self.clasificaciones, self.classifications_probas
+
+    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.
@@ -123,20 +153,50 @@ class PlantinClassifier(BaseEstimator, TransformerMixin):
             new_labels[indexes[1:]] = 0
 
         return new_labels
-    
-    def updateLabelsFromDSTPT(self, labels, dst_pt, inest_pt, umbral_proba = 0.85):
+
+    def updateLabelsFromDSTPT(self, labels, dst_pt, inest_pt,
+                              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.
         """
         new_labels = labels.copy()
+
+        umbral_bajo_dstpt = min(dst_pt)*(1+factor) if use_min_dstpt else umbral_bajo_dstpt
         
-        ##filtro si dst_pt es menor a 7 y si inest_pt es 0
-        new_labels[(dst_pt < 4) & (inest_pt == 0)] = 0
+        ##filtro
+        new_labels[(dst_pt < umbral_bajo_dstpt) & (inest_pt == 0)] = 0
 
-        ##si inest_pt 1 es y umbral_proba es menor a umbra_proba, entonces la operación es 0
-        new_labels[(inest_pt == 1) & (self.probas[:,1] < umbral_proba)] = 0
+        ##si inest_pt 1 es y las probs son menores a umbral_proba_dstpt, entonces la operación es 0
+        new_labels[(inest_pt == 1) & (self.classifications_probas[:,1] < umbral_proba_dstpt)] = 0
 
         return new_labels
+
+    def get_dstpt_MA(self, dst_pt, 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 = 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
@@ -144,25 +204,54 @@ if __name__ == "__main__":
     import numpy as np
     from sarapy.preprocessing import TransformInputData
     from sarapy.mlProcessors import PlantinFMCreator
-    import sarapy.utils.getRawOperations as getRawOperations
     from sarapy.mlProcessors import PlantinClassifier
+    import json
+
 
-    fmcreator = PlantinFMCreator.PlantinFMCreator(imputeDistances=False)
-    tindata = TransformInputData.TransformInputData()
+    ## 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.1,
+                         "dist_umbral":0.5,
+                         }
 
-    data_path = os.path.join(os.getcwd(), "examples\\2024-10-15\\UPM015N\\data.json")
-    historical_data_path = os.path.join(os.getcwd(), "examples\\2024-10-15\\UPM015N\\historical-data.json")
-    raw_data = pd.read_json(data_path, orient="records").to_dict(orient="records")
-    raw_data2 = pd.read_json(historical_data_path, orient="records").to_dict(orient="records")
+    historical_data_path = "examples\\2025-09-04\\UPM042N\\historical-data.json"
+    with open(historical_data_path, 'r') as file:
+        samples = json.load(file)
 
-    raw_ops = np.array(getRawOperations.getRawOperations(raw_data, raw_data2))
-    raw_X = tindata.fit_transform(raw_ops)[:,2:]
+    fmcreator = PlantinFMCreator(**kwargs_fmcreator)
+    tindata = TransformInputData()
+    raw_X = tindata.transform(samples)
 
     X, dst_pt, inest_pt = fmcreator.fit_transform(raw_X)
 
-    rf_clf_nu = PlantinClassifier.PlantinClassifier(classifier_file='modelos\\pipeline_rf.pkl') ##wu = no update
-    rf_clf_wu = PlantinClassifier.PlantinClassifier(classifier_file='modelos\\pipeline_rf.pkl') ##wu = with update
+    rf_clf_wu = PlantinClassifier(classifier_file='modelos\\pipeline_rf.pkl')
 
-    print(rf_clf_nu.classify(X, dst_pt, inest_pt, update_samePlace = False, update_dstpt=False).mean())
-    print(rf_clf_wu.classify(X, dst_pt, inest_pt, update_samePlace=True, update_dstpt=True,
-    useRatioStats=True, useDistancesStats=True,umbral_proba=0.8).mean()) 
+    clasificaciones, probas = rf_clf_wu.classify(X, dst_pt, inest_pt, **kwargs_classifier)
+    print("media de clasificaciones", clasificaciones.mean())
+    print("media de probabilidades", probas.mean(axis=0), probas.std(axis=0), np.median(probas, axis=0))
+    print("primeras clasificaciones", clasificaciones[100:105])
+    print("primeras probabilidades", probas[100:105])
+    print("primeras distorsiones", dst_pt[100:105])
+    print("primeras inestabilidades", inest_pt[100:105])

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/mlProcessors/__init__.py

@@ -0,0 +1,11 @@
+from .FertilizerFMCreator import FertilizerFMCreator
+from .FertilizerTransformer import FertilizerTransformer
+from .PlantinClassifier import PlantinClassifier
+from .PlantinFMCreator import PlantinFMCreator
+
+__all__ = [
+    "FertilizerFMCreator",
+    "FertilizerTransformer",
+    "PlantinClassifier",
+    "PlantinFMCreator",
+]

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/preprocessing/__init__.py

@@ -1,2 +1,11 @@
-# from .DistancesImputer import DistancesImputer
-# from .FertilizerImputer import FertilizerImputer
+from .DistancesImputer import DistancesImputer
+from .FertilizerImputer import FertilizerImputer
+from .TransformInputData import TransformInputData
+from .TransformToOutputData import TransformToOutputData
+
+__all__ = [
+    "DistancesImputer",
+    "FertilizerImputer",
+    "TransformInputData",
+    "TransformToOutputData"
+]

sarapy/stats/__init__.py

@@ -1 +1,13 @@
-# from stats.stats import *
+from .stats import *
+
+__all__ = [
+    "getMA",
+    "probabilidadEmpirica",
+    "penalizacion",
+    "probSaturacion",
+    "estimarKDE",
+    "saturationProbability",
+    "movingProbability",
+    "resumen_sensor",
+    "detectar_secuencia_saturada"
+]

sarapy/stats/stats.py

@@ -2,8 +2,7 @@ import numpy as np
 from scipy.stats import skew, kurtosis, gaussian_kde
 import pandas as pd
 import logging
-
-logging.basicConfig(level=logging.DEBUG)
+logger = logging.getLogger(__name__)  # ← "sarapy.stats"
 
 def getMA(data, window_size=104, mode='same'):
     """
@@ -63,7 +62,7 @@ def saturationProbability(distorsion_data, saturation_mode = "alto", umbrales =
     if distorsion_data.shape[0] == 0:
         raise ValueError("La distorsion_data no puede estar vacía.")
     if distorsion_data.shape[0] < 50:
-        logging.warning("La distorsion_data tiene menos de 50 elementos. Los resultados pueden no ser representativos.")
+        logger.warning("La distorsion_data tiene menos de 50 elementos. Los resultados pueden no ser representativos.")
     
     ventana_filtered = distorsion_data.copy()
     if saturation_mode == "bajo":
@@ -75,7 +74,7 @@ def saturationProbability(distorsion_data, saturation_mode = "alto", umbrales =
 
     ##chequeo si la ventana filtrada está vacía
     if ventana_filtered.shape[0] == 0:
-        logging.warning("Ventana filtrada vacía. Se retornará 0.0.")
+        logger.warning("Ventana filtrada vacía. Se retornará 0.0.")
         return 0.0
 
     skew_val = skew(ventana_filtered)
@@ -84,13 +83,13 @@ def saturationProbability(distorsion_data, saturation_mode = "alto", umbrales =
     pena = penalizacion(alpha, skew_val, beta, kurt_val)
     ##chequeo que pena no sea nan, sino reemplazo por 1
     if np.isnan(pena):
-        logging.warning("La penalización es NaN. Se reemplazará por 1.")
+        logger.warning("La penalización es NaN. Se reemplazará por 1.")
         pena = 1.0
     # Probabilidad
     proba_empirica = ventana_filtered.shape[0]/distorsion_data.shape[0]
     prob_saturacion = proba_empirica * pena
   
-    logging.debug(f"Ventana filtrada: {ventana_filtered.shape[0]}, {distorsion_data.shape[0]}, {proba_empirica}, {pena}")
+    logger.debug(f"Ventana filtrada: {ventana_filtered.shape[0]}, {distorsion_data.shape[0]}, {proba_empirica}, {pena}")
     return prob_saturacion
 
 def movingProbability(distorsion_data, window_size=104, **kwargs):

sarapy/utils/__init__.py

@@ -0,0 +1,3 @@
+from .utils import *   # <- importa la FUNCIÓN (o clase), no el módulo
+__all__ = ["dataMerging", "getOutliersThresholds", "countingZeros", "get_lat_long_from_indices","readingFolders",
+           "filter_raw_by_time_window", "to_time_obj", "time_to_td"]