sarapy 1.0.1__tar.gz → 1.1.1__tar.gz

{sarapy-1.0.1/sarapy.egg-info → sarapy-1.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: sarapy
-Version: 1.0.1
+Version: 1.1.1
 Home-page: https://github.com/lucasbaldezzari/sarapy
 Author: Lucas Baldezzari
 Author-email: Lucas Baldezzari <lmbaldezzari@gmail.com>
@@ -19,6 +19,17 @@ Requires-Dist: geopy
 
 Library for processing SARAPICO project metadata of _AMG_.
 
+#### Version 1.1.1
+
+- Se modifica TimeSeriesProcessor.compute_ratio_dCdP() dado que la versión de vectorize al parecer no funcionaba correctamente en ciertos casos.
+
+#### Version 1.1.0
+
+Versión 1.1 estable para trabajarse en servidor.
+
+- Se implementa nueva estrategia para la clasificación de plantines.
+
+
 #### Version 1.0.1
 
 - Se agrega *__init.py__* dentro del mpdulo _utils_.

{sarapy-1.0.1 → sarapy-1.1.1}/README.md

@@ -2,6 +2,17 @@
 
 Library for processing SARAPICO project metadata of _AMG_.
 
+#### Version 1.1.1
+
+- Se modifica TimeSeriesProcessor.compute_ratio_dCdP() dado que la versión de vectorize al parecer no funcionaba correctamente en ciertos casos.
+
+#### Version 1.1.0
+
+Versión 1.1 estable para trabajarse en servidor.
+
+- Se implementa nueva estrategia para la clasificación de plantines.
+
+
 #### Version 1.0.1
 
 - Se agrega *__init.py__* dentro del mpdulo _utils_.

{sarapy-1.0.1 → sarapy-1.1.1}/pyproject.toml

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

{sarapy-1.0.1 → sarapy-1.1.1}/sarapy/dataProcessing/OpsProcessor.py

@@ -4,7 +4,7 @@ import datetime
 from dateutil.tz import tzutc
 import numpy as np
 import pandas as pd
-# from sarapy.mlProcessors import PlantinFMCreator
+from sarapy.mlProcessors import PlantinFMCreator
 from sarapy.mlProcessors import PlantinClassifier
 from sarapy.preprocessing import TransformInputData, TransformToOutputData
 
@@ -22,20 +22,27 @@ class OpsProcessor():
         """Constructor de la clase OpsProcessor.
         
         Args:
-            - distanciaMedia: Distancia media entre operaciones.
+            - kwargs: Diccionario con los argumentos necesarios instanciar algunas clases.
         """
 
-        plclass_map = {"classifier_file","imputeDistances", "distanciaMedia",
-                       "umbral_precision"," dist_mismo_lugar", "max_dist",
-                       "umbral_ratio_dCdP", "deltaO_medio"}
+        plclass_map = {"classifier_file"}
 
         kwargs_plclass = {}
         ##recorro kwargs y usando plclass_map creo un nuevo diccionario con los valores que se pasaron
         for key, value in kwargs.items():
             if key in plclass_map:
                 kwargs_plclass[key] = value
+
+        fmcreator_map = {"imputeDistances", "distanciaMedia", "umbral_precision",
+                         "dist_mismo_lugar", "max_dist", "umbral_ratio_dCdP", "deltaO_medio"}
+        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._fertilizerFMCreator = FertilizerFMCreator() ## PARA IMPLEMENTAR
         
         self._operationsDict = {} ##diccionario de operarios con sus operaciones
@@ -45,7 +52,7 @@ class OpsProcessor():
         self.transformInputData = TransformInputData.TransformInputData()
         self.transformToOutputData = TransformToOutputData.TransformToOutputData()
         
-    def processOperations(self, data):
+    def processOperations(self, data, **kwargs):
         """Método para procesar las operaciones de los operarios.
 
         Se toma una nueva muestra y se procesa la información para clasificar las operaciones considerando el
@@ -68,6 +75,8 @@ class OpsProcessor():
                 "Precision": 1000,
                 "id_db_dw": 1 #int
             }
+
+            - kwargs: Diccionario con los argumentos necesarios para la clasificación. Se utiliza para pasar argumentos a los métodos de clasificación.
             
         Returns:
             Lista de diccionarios con las clasificaciones. Cada diccionario tiene la forma
@@ -79,7 +88,7 @@ class OpsProcessor():
             newSample = self.transformInputData.fit_transform(data)
             #Si tenemos nuevas operaciones, actualizamos el diccionario de operaciones
             self.updateOperationsDict(newSample) #actualizamos diccionario interno de la clase
-            pl_clas = self.classifyForPlantin() #clasificamos las operaciones para plantín
+            pl_clas = self.classifyForPlantin(**kwargs) #clasificamos las operaciones para plantín
             ft_clas = newSample[:,7].astype(int) #clasificamos las operaciones para fertilizante
             id_db_h_nums, id_db_dw_nums = self.getActualOperationsNumbers() #obtenemos los números de operaciones desde el diccionario de operaciones
             date_oprc = newSample[:,3]
@@ -148,14 +157,27 @@ class OpsProcessor():
         self.updateNewSamplesValues(ID_NPDPs_newOperations) #actualizo el estado de 'new_sample' en el diccionario de operaciones
         self.updateLastOperations(ID_NPDPs_newOperations) #actualizo la última operación de una muestra de operaciones en el diccionario de operaciones
 
-    def classifyForPlantin(self):
+    def classifyForPlantin(self, **kwargs):
         """Método para clasificar las operaciones para plantín.
         Se recorre el diccionario de operaciones y se clasifican las operaciones para plantín.
 
+        Args:
+            - kwargs: Diccionario con los argumentos necesarios para la clasificación. Se utiliza para pasar argumentos a los métodos de clasificación.
+
         Returns:
             - plantinClassifications: np.array con las clasificaciones de las operaciones para plantín.
         """
 
+        key_classify_map = {"feature_matrix", "update_samePlace",
+                            "useRatioStats", "std_weight", "useDistancesStats",
+                            "ratio_dcdp_umbral", "dist_umbral"}
+        
+        ##recorro kwargs y usando key_classify_map creo un nuevo diccionario con los valores que se pasaron
+        classify_kwargs = {}
+        for key, value in kwargs.items():
+            if key in key_classify_map:
+                classify_kwargs[key] = value
+
         ##creamos/reiniciamos el array con las clasificaciones de las operaciones para plantín
         plantinClassifications = None
         
@@ -165,7 +187,8 @@ class OpsProcessor():
         for ID_NPDP in ops_with_new_sample:#self.operationsDict.keys():
             ##clasificamos las operaciones para plantín
             operations = self.operationsDict[ID_NPDP]["sample_ops"]
-            classified_ops = self._plantin_classifier.classify(operations)
+            features, dst_pt, inest_pt = self.plantinFMCreator.fit_transform(operations)
+            classified_ops = self._plantin_classifier.classify(features, **classify_kwargs)
             
             ##chequeo si first_day_op_classified es True, si es así, no se considera la primera fila de las classified_ops
             if self.operationsDict[ID_NPDP]["first_day_op_classified"]:
@@ -270,17 +293,26 @@ if __name__ == "__main__":
     import pandas as pd
     import numpy as np
     import os
-    from sarapy.utils.getRawOperations import getRawOperations
+    import sarapy.utils.getRawOperations as getRawOperations
+    from sarapy.dataProcessing import OpsProcessor
+
+    data_path = os.path.join(os.getcwd(), "examples\\2024-09-04\\UPM012N\\data.json")
+    historical_data_path = os.path.join(os.getcwd(), "examples\\2024-09-04\\UPM012N\\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")
 
-    data_df_raw = getRawOperations("examples\\2024-05-30\\UPM007N\\data.json", "examples\\2024-05-30\\UPM007N\\historical-data.json")
+    raw_ops = getRawOperations.getRawOperations(raw_data, raw_data2)
 
     import time
     start_time = time.time()
-    op = OpsProcessor(classifier_file="examples\\pip_lda_imp.pkl", imputeDistances = False)
-    classifcations = op.processOperations(data_df_raw)
+    op = OpsProcessor.OpsProcessor(classifier_file='modelos\\pipeline_rf.pkl', imputeDistances = False)
+    classifications = op.processOperations(raw_ops, update_samePlace=True, useRatioStats=True)
     end_time = time.time()
     execution_time = end_time - start_time
     print("Execution time:", execution_time, "seconds")
     
-    print(len(classifcations))
-    classifcations[:10]
+    ##
+    df = pd.DataFrame(classifications)
+    tag_seedling = df["tag_seedling"].values
+    print(tag_seedling.mean())

{sarapy-1.0.1 → sarapy-1.1.1}/sarapy/dataProcessing/TimeSeriesProcessor.py

@@ -2,7 +2,6 @@
 
 import numpy as np
 from sklearn.base import BaseEstimator, TransformerMixin
-import warnings
 
 class TimeSeriesProcessor(BaseEstimator, TransformerMixin):
     """"
@@ -36,7 +35,7 @@ class TimeSeriesProcessor(BaseEstimator, TransformerMixin):
             self._deltaO = np.diff(X[:,0])
             self._deltaP = X[:,1]
             self._deltaC = self._deltaO - self._deltaP[1:]
-            ##agregamos un 0 al principio de deltaO y deltaC - versión 0.2.6
+            ##agregamos un 0 al principio de deltaO y deltaC
             self._deltaO = np.insert(self._deltaO, 0, 0)
             self._deltaC = np.insert(self._deltaC, 0, 0)
             ##computamos el ratio entre deltaC y deltaP. Usamos np.vectorize para que compute el ratio para cada elemento del array
@@ -44,10 +43,6 @@ class TimeSeriesProcessor(BaseEstimator, TransformerMixin):
             ##cambiamos primer valor de ratio_dCdP por 1
             self._ratio_dCdP[0] = 1
             
-            ##versión 0.2.5
-            # self._deltaO = np.hstack((self._deltaO, 0))
-            # self._deltaC = np.hstack((self._deltaC, 0))
-            
         elif X.shape[0] == 1:
             self._deltaO = np.array([0])
             self._deltaC = np.array([0])
@@ -73,12 +68,15 @@ class TimeSeriesProcessor(BaseEstimator, TransformerMixin):
     def fit_transform(self, X: np.array, y=None):
         self.fit(X)
         return self.transform(X)
-    
+           
     def compute_ratio_dCdP(self, deltaC, deltaP):
         """Devuelve el ratio entre el tiempo de caminata y el tiempo de pico abierto."""
-        
-        return (deltaC - deltaP)/(deltaC + deltaP) if deltaC + deltaP != 0 else 1
-        
+
+        numerator = deltaC - deltaP
+        denominator = deltaC + deltaP
+        ##reemplazo valores 0 del denominador por 1
+        denominator[denominator == 0] = 1
+        return numerator/denominator
     
     @property
     def deltaO(self):

sarapy-1.1.1/sarapy/mlProcessors/PlantinClassifier.py

@@ -0,0 +1,145 @@
+###Documentación en https://github.com/lucasbaldezzari/sarapy/blob/main/docs/Docs.md
+import numpy as np
+from sklearn.base import BaseEstimator, TransformerMixin
+from sklearn.pipeline import Pipeline
+from sarapy.mlProcessors import PlantinFMCreator
+import pickle
+
+class PlantinClassifier(BaseEstimator, TransformerMixin):
+    """Clase para implementar el pipeline de procesamiento de datos para la clasificación del tipo de operación para plantines."""
+    
+    def __init__(self, classifier_file = ""):
+        """Constructor de la clase PlantinClassifier.
+        
+        Args:
+            - classifier_file: String con el nombre del archivo que contiene el clasificador entrenado. El archivo a cargar es un archivo .pkl.
+        """
+
+        #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.")
+        except FileNotFoundError:
+            print("El archivo no se encuentra en el directorio actual.")
+        
+    def classify(self, feature_matrix, update_samePlace:bool = True, **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.
+        La forma de newData debe ser (n,3). Las columnas de newData deben ser,
+                - 1: deltaO
+                - 2: ratio_dCdP
+                - 3: distancias
+
+        kwargs: Diccionario con los argumentos necesarios para la clasificación.
+
+        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)
+
+        if update_samePlace:
+            self.grouped_ops = self.groupOpsSamePlace(feature_matrix, **kwargs)
+            self.clasificaiones = self.updateLabelsSamePlace(self.clasificaiones, self.grouped_ops)
+
+        return self.clasificaiones
+    
+    def groupOpsSamePlace(self, X, useRatioStats = True, std_weight=1, useDistancesStats = True,
+                          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.
+        Se entiende por operación en el mismo lugar aquellas operaciones que tengan distancias entre sí menores a 0.5.
+        La función tomará las operaciones que tengan distancias menores a 0.5 y la operación anterior, dado que se supone que la 
+        operación anterior se corresponde a un nuevo sitio de plantado.
+
+        Las operaciones de limpieza son aquellas que tienen un ratio_dCdP menor a 0.3
+
+        Args:
+        - X: Array con las features de operaciones. Las columnas son deltaO, ratio_dCdP y distances.
+        - useRatioStats: Booleano para usar o no las estadísticas. Por defecto es True.
+        - std_weight: Peso para la desviación estándar. Por defecto es 1.
+        - ratio_dcdp_umbral: Umbral para el ratio_dCdP. Por defecto es 0.1.
+        - dist_umbral: Umbral para la distancia (en metros). Por defecto es 0.5.
+        
+        Retorna:
+        - Una lista con los índices de las operaciones agrupadas.
+        """
+
+        if useRatioStats:
+            median_ratio_dcdp = np.median(X[:,1])
+            std_ratio_dcdp = np.std(X[:,1])
+            ratio_dcdp_umbral = median_ratio_dcdp - std_weight*std_ratio_dcdp
+
+        if useDistancesStats:
+            median_dist = np.median(X[:,2])
+            # std_dist = np.std(X[:,2])
+            dist_umbral = median_dist #- std_weight*std_dist
+
+        ##recorro las operaciones y comparo la actual con la siguiente. Si la distancia es menor a 0.5, la agrupo.
+        ##Si el ratio_dCdP es menor a 0.3, la agrupo.
+        grouped_ops = []
+        distancias = X[:,2]
+        ratio_dcdp = X[:,1]
+        flag_cleaning = True
+        for i in range(1,X.shape[0]):
+            if flag_cleaning:
+                sub_group = []
+            if distancias[i] < dist_umbral and ratio_dcdp[i] < ratio_dcdp_umbral:
+                flag_cleaning = False
+                sub_group.append(i-1)
+                sub_group.append(i)
+            else:
+                flag_cleaning = True
+                if len(sub_group) > 0:
+                    grouped_ops.append(sub_group)
+
+        ##recorro grouped_ops y elimino los elementos que se repiten dentro de cada subgrupo y ordeno los indices dentro de cada subgrupo
+        for i in range(len(grouped_ops)):
+            grouped_ops[i] = list(set(grouped_ops[i]))
+            grouped_ops[i].sort()
+
+        return grouped_ops
+
+    def updateLabelsSamePlace(self, labels, ops_grouped):
+        """
+        Función para actualizar las etiquetas de las operaciones agrupadas en el mismo lugar.
+
+        Args:
+        - labels: Array con las etiquetas de las operaciones.
+        - indexes: Array con los índices correspondientes a operaciones repetidas
+        """
+        new_labels = labels.copy()
+        for indexes in ops_grouped:
+            new_labels[indexes[0]] = 1
+            new_labels[indexes[1:]] = 0
+
+        return new_labels
+    
+if __name__ == "__main__":
+    import os
+    import pandas as pd
+    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
+
+    fmcreator = PlantinFMCreator.PlantinFMCreator(imputeDistances=False)
+    tindata = TransformInputData.TransformInputData()
+
+    data_path = os.path.join(os.getcwd(), "examples\\2024-09-04\\UPM011N\\data.json")
+    historical_data_path = os.path.join(os.getcwd(), "examples\\2024-09-04\\UPM011N\\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")
+
+    raw_ops = np.array(getRawOperations.getRawOperations(raw_data, raw_data2))
+    raw_X = tindata.fit_transform(raw_ops)[:,2:]
+
+    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
+
+    print(rf_clf_nu.classify(X, update_samePlace = False).mean())
+    print(rf_clf_wu.classify(X, update_samePlace=True, useRatioStats=True, useDistancesStats=True).mean())

{sarapy-1.0.1 → sarapy-1.1.1}/sarapy/mlProcessors/PlantinFMCreator.py

@@ -4,7 +4,6 @@ import warnings
 import numpy as np
 from sklearn.base import BaseEstimator, TransformerMixin
 from sarapy.dataProcessing import TLMSensorDataProcessor, TimeSeriesProcessor, GeoProcessor
-from sarapy.preprocessing import DistancesImputer
 
 class PlantinFMCreator(BaseEstimator, TransformerMixin):
     """La clase FMCreator se encarga de crear la Feature Matrix (FM) a partir de los datos de telemetría. Se utilizan las clases TLMSensorDataExtractor, TimeSeriesProcessor y GeoProcessor para realizar las transformaciones necesarias.
@@ -69,11 +68,9 @@ class PlantinFMCreator(BaseEstimator, TransformerMixin):
                 - 4: precision del GPS
                 
         Returns:
-            - featureMatrix: Es un array con la matriz de características. La forma de featureMatrix es (n,5). Las columnas de featureMatrix son,
-                - 0: DST_PT: Distorsión de plantín
-                - 1: deltaO: delta operación
-                - 2: ratio_dCdP: Ratio entre el delta de caminata y delta de pico abierto
-                - 3: distances: Distancias entre operaciones
+                - 0: feature_matrix: (deltaO, ratio_dCdP, distances)
+                - 1: dst_pt
+                - 2: inest_pt
         """
         
         if not self.is_fitted:
@@ -88,7 +85,7 @@ class PlantinFMCreator(BaseEstimator, TransformerMixin):
         date_oprc = X[:,1].astype(int) #datos de fecha y hora de operación
         lats = X[:,2].astype(float) #latitudes de las operaciones
         longs = X[:,3].astype(float) #longitudes de las operaciones  
-        precitions = X[:,4].astype(float) #precision del GPS   
+        # precitions = X[:,4].astype(float) #precision del GPS   
         
 ##***** OBTENEMOS LOS DATOS PARA FITEAR LOS OBJETOS Y ASÍ PROCESAR LA FM *****
         ##obtengo las posiciones de los datos de tlmDataExtractor y timeProcessor
@@ -106,32 +103,16 @@ class PlantinFMCreator(BaseEstimator, TransformerMixin):
         ##genero un array de puntos de la forma (n,2)
         points = np.hstack((lats.reshape(-1,1),longs.reshape(-1,1)))
         self._distances = geoprocessor.fit_transform(points)
-        
-        ####***** IMPUTAMOS DATOS SI ES LO REQUERIDO*****
-        if self.imputeDistances:
-            distanceimputer = DistancesImputer.DistancesImputer(distanciaMedia = self.distanciaMedia,
-                                                                umbral_precision = self.umbral_precision,
-                                                                dist_mismo_lugar = self.dist_mismo_lugar,
-                                                                max_dist = self.max_dist,
-                                                                umbral_ratio_dCdP = self.umbral_ratio_dCdP,
-                                                                deltaO_medio = self.deltaO_medio, keepDims = False, columnToImpute = 0)
-            
-            X_distance_imputation = np.hstack((self._distances.reshape(-1, 1),
-                                            precitions.reshape(-1, 1),
-                                            self._tlmExtracted[:,self._tlmdeDP["GNSSFlag"]].reshape(-1, 1),
-                                            self._tlmExtracted[:,self._tlmdeDP["FIX"]].reshape(-1, 1),
-                                            self._timeDeltas[:,self._tpDP["deltaO"]].reshape(-1, 1),
-                                            self._timeDeltas[:,self._tpDP["ratio_dCdP"]].reshape(-1, 1)))
-            
-            self._distances = distanceimputer.fit_transform(X_distance_imputation)   
+
+        self.dst_pt = self._tlmExtracted[:,self._tlmdeDP["DSTRPT"]]
+        self.inest_pt = self._tlmExtracted[:,self._tlmdeDP["INESTPT"]]
         
         ##armamos la feature matrix
-        featureMatrix = np.vstack((self._tlmExtracted[:,self._tlmdeDP["DSTRPT"]],
-                                   self._timeDeltas[:,self._tpDP["deltaO"]],
-                                   self._timeDeltas[:,self._tpDP["ratio_dCdP"]],
-                                   self._distances)).T
+        self.featureMatrix = np.vstack((self._timeDeltas[:,self._tpDP["deltaO"]],
+                                        self._timeDeltas[:,self._tpDP["ratio_dCdP"]],
+                                        self._distances)).T
         
-        return featureMatrix
+        return self.featureMatrix, self.dst_pt, self.inest_pt
 
     def fit_transform(self, X: np.array, y=None):
         """Fittea y transforma los datos de X en la matriz de características.
@@ -145,11 +126,9 @@ class PlantinFMCreator(BaseEstimator, TransformerMixin):
                 - 4: precision del GPS
                 
         Returns:
-            - featureMatrix: Es un array con la matriz de características. La forma de featureMatrix es (n,5). Las columnas de featureMatrix son,
-                - 0: DST_PT: Distorsión de plantín
-                - 1: deltaO: delta operación
-                - 2: ratio_dCdP: Ratio entre el delta de caminata y delta de pico abierto
-                - 3: distances: Distancias entre operaciones
+                - 0: feature_matrix: (deltaO, ratio_dCdP, distances)
+                - 1: dst_pt
+                - 2: inest_pt
         """
         self.fit(X)
         return self.transform(X)
@@ -176,18 +155,23 @@ class PlantinFMCreator(BaseEstimator, TransformerMixin):
     
         
 if __name__ == "__main__":
-    ##genero objeto FMCreator
-    fmcreator = PlantinFMCreator(imputeDistances=False)
-    import pandas as pd
     import os
-    path = os.path.join(os.getcwd(), "examples\\volcado_17112023_NODE_processed.csv")
-    raw_data = pd.read_csv(path, sep=";", ).to_numpy()
+    import pandas as pd
+    import numpy as np
+    from sarapy.preprocessing import TransformInputData
+    from sarapy.mlProcessors import PlantinFMCreator
+    import sarapy.utils.getRawOperations as getRawOperations
 
-    X = raw_data[50:60,2:]
-    fmcreator.fit(X)
-    fm = fmcreator.fit_transform(X)
-    print(fm)
-    print(fm.shape)
-    
-    X2 = raw_data[60:81,2:]
-    fmcreator.transform(X2).shape
+    fmcreator = PlantinFMCreator.PlantinFMCreator(imputeDistances=False)
+    tindata = TransformInputData.TransformInputData()
+
+    ##cargo los archivos examples\2024-09-04\UPM001N\data.json y examples\2024-09-04\UPM001N\historical-data.json
+    data_path = os.path.join(os.getcwd(), "examples\\2024-09-04\\UPM001N\\data.json")
+    historical_data_path = os.path.join(os.getcwd(), "examples\\2024-09-04\\UPM001N\\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")
+
+    raw_ops = np.array(getRawOperations.getRawOperations(raw_data, raw_data2))
+    X = tindata.fit_transform(raw_ops)
+
+    fm, dst_pt, inest_pt = fmcreator.fit_transform(X[:,2:])  

{sarapy-1.0.1 → sarapy-1.1.1}/sarapy/preprocessing/TransformInputData.py

@@ -100,7 +100,11 @@ if __name__ == "__main__":
     
     transform_input_data = TransformInputData()
 
-    ppk_results = getRawOperations("examples\\2024-05-30\\UPM007N\\data.json", "examples\\2024-05-30\\UPM007N\\historical-data.json")
+    #cargo "examples\\2024-05-30\\UPM007N\\data.json"
+    data = pd.read_json("examples\\2024-05-30\\UPM007N\\data.json").to_dict(orient="records")
+    historical_data = pd.read_json("examples\\2024-05-30\\UPM007N\\historical-data.json").to_dict(orient="records")
+
+    ppk_results = getRawOperations(data,historical_data)
 
     X = np.array(ppk_results)
     print(transform_input_data.fit_transform(X))

{sarapy-1.0.1 → sarapy-1.1.1}/sarapy/preprocessing/TransformToOutputData.py

@@ -8,7 +8,7 @@ class TransformToOutputData(BaseEstimator, TransformerMixin):
         
         Args:
             - dataToTransform: array con los datos de las operaciones clasificadas.
-            Actualmente el array de dataToTransform es de (n,4) con las columnas siguientes
+            Actualmente el array de dataToTransform es de (n,5) con las columnas siguientes
             
                 - 0: id_db_h
                 - 1: id_db_dw
@@ -36,6 +36,15 @@ class TransformToOutputData(BaseEstimator, TransformerMixin):
         
     def fit(self, X:np.array, y = None):
         """
+        Args:
+            - X: array con los datos de las operaciones clasificadas.
+            Actualmente el array de dataToTransform es de (n,5) con las columnas siguientes
+            
+                - 0: id_db_h
+                - 1: id_db_dw
+                - 2: tag_seedling
+                - 3: tag_fertilizer      
+                - 4: date_oprc          
         """
         self.is_fitted = True
         keys = ["id_db_h", "id_db_dw", "tag_seedling", "tag_fertilizer", "date_oprc"]        
@@ -45,19 +54,41 @@ class TransformToOutputData(BaseEstimator, TransformerMixin):
         date_oprc = np.array([datetime.datetime.fromtimestamp(date, datetime.timezone.utc) for date in date_data])
         self.temp_df.loc[:,"date_oprc"] = date_oprc.flatten()
         ##convierto las columnas "id_db_h", "id_db_dw", "tag_seedling", "tag_fertilizer" a int
-        self.temp_df.loc[:,["id_db_h", "id_db_dw", "tag_seedling", "tag_fertilizer"]] = self.temp_df.loc[:,["id_db_h", "id_db_dw", "tag_seedling", "tag_fertilizer"]].astype(int)
-        
+        for col in ["id_db_h", "id_db_dw", "tag_seedling", "tag_fertilizer"]:
+            self.temp_df[col] = self.temp_df[col].astype(float).astype(int)
+
         return self
     
     def transform(self, X:np.array):
         """
-        Retorna los datos de entrada a un formato utilizable para procesar las operaciones.
+        Args:
+            - X: array con los datos de las operaciones clasificadas.
+            Actualmente el array de dataToTransform es de (n,5) con las columnas siguientes
+            
+                - 0: id_db_h
+                - 1: id_db_dw
+                - 2: tag_seedling
+                - 3: tag_fertilizer      
+                - 4: date_oprc          
+        Returns:
+            Retorna una lista de diccionarios donde cada diccionario contiene los datos de una operación para los campos mencionados anteriormente.
         """
 
         return self.temp_df.to_dict(orient = "records")
     
     def fit_transform(self, X:np.array, y = None):
         """
+        Args:
+            - X: array con los datos de las operaciones clasificadas.
+            Actualmente el array de dataToTransform es de (n,5) con las columnas siguientes
+            
+                - 0: id_db_h
+                - 1: id_db_dw
+                - 2: tag_seedling
+                - 3: tag_fertilizer      
+                - 4: date_oprc          
+        Returns:
+            Retorna una lista de diccionarios donde cada diccionario contiene los datos de una operación para los campos mencionados anteriormente.
         """
         self.fit(X)
         return self.transform(X)

sarapy-1.1.1/sarapy/utils/getRawOperations.py

@@ -0,0 +1,20 @@
+import pandas as pd
+from sarapy.utils import amg_ppk
+import os
+def getRawOperations(data, historical_data):
+    """
+    Args:
+        data_file: Lista de diccionarios con la data
+        historical_data_file: Lista de diccionarios con historical_data
+
+    Returns the raw operations from the database.
+    """
+    hash_table = {}
+    for datum in data:
+        hash_table[datum["timestamp"]] = {"id_db_dw": datum["id"], "id_db_h": 0, "serialized_datum": ""}
+    for historical_datum in historical_data:
+        if historical_datum["timestamp"] in hash_table:
+            hash_table[historical_datum["timestamp"]].update({"id_db_h": historical_datum["id"], "serialized_datum": historical_datum["datum"]})
+    ppk_results = amg_ppk.main(hash_table, [])  # ToDo: PPK (Fernando)
+
+    return ppk_results

{sarapy-1.0.1 → sarapy-1.1.1}/sarapy/version.py

@@ -1,2 +1,2 @@
 ## Version of the package   
-__version__ = "1.0.1"
+__version__ = "1.1.1"

{sarapy-1.0.1 → sarapy-1.1.1/sarapy.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: sarapy
-Version: 1.0.1
+Version: 1.1.1
 Home-page: https://github.com/lucasbaldezzari/sarapy
 Author: Lucas Baldezzari
 Author-email: Lucas Baldezzari <lmbaldezzari@gmail.com>
@@ -19,6 +19,17 @@ Requires-Dist: geopy
 
 Library for processing SARAPICO project metadata of _AMG_.
 
+#### Version 1.1.1
+
+- Se modifica TimeSeriesProcessor.compute_ratio_dCdP() dado que la versión de vectorize al parecer no funcionaba correctamente en ciertos casos.
+
+#### Version 1.1.0
+
+Versión 1.1 estable para trabajarse en servidor.
+
+- Se implementa nueva estrategia para la clasificación de plantines.
+
+
 #### Version 1.0.1
 
 - Se agrega *__init.py__* dentro del mpdulo _utils_.

sarapy-1.0.1/sarapy/mlProcessors/PlantinClassifier.py

@@ -1,71 +0,0 @@
-###Documentación en https://github.com/lucasbaldezzari/sarapy/blob/main/docs/Docs.md
-import numpy as np
-from sklearn.base import BaseEstimator, TransformerMixin
-from sklearn.pipeline import Pipeline
-from sarapy.mlProcessors import PlantinFMCreator
-import pickle
-
-class PlantinClassifier(BaseEstimator, TransformerMixin):
-    """Clase para implementar el pipeline de procesamiento de datos para la clasificación del tipo de operación para plantines."""
-    
-    def __init__(self, classifier_file = "", **kwargs):
-        """Constructor de la clase PlantinClassifier.
-        
-        Args:
-            - classifier_file: String con el nombre del archivo que contiene el clasificador entrenado. El archivo a cargar es un archivo .pkl.
-        """
-        
-        plclass_map = {"imputeDistances", "distanciaMedia", "umbral_precision"," dist_mismo_lugar", "max_dist",
-                       "umbral_ratio_dCdP", "deltaO_medio"}
-        
-        kwargs_plfmc = {}
-        
-        ##recorro kwargs y usando plclass_map creo un nuevo diccionario con los valores que se pasaron
-        for key, value in kwargs.items():
-            if key in plclass_map:
-                kwargs_plfmc[key] = value
-        
-        self._plantinFMCreator = PlantinFMCreator.PlantinFMCreator(**kwargs_plfmc)
-        #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)
-        except FileNotFoundError:
-            print("El archivo no se encuentra en el directorio actual.")
-        
-    def classify(self, newData):
-        """Genera la clasificación de las operaciones para plantines.
-        
-        newData: Es un array con los datos (strings) provenientes de la base de datos histórica. La forma de newData debe ser (n,4). Las columnas de newData deben ser,
-                - 0: tlm_spbb son los datos de telemetría.
-                - 1: date_oprc son los datos de fecha y hora de operación.
-                - 2: latitud de la operación
-                - 3: longitud de la operación
-                - 4: precision del GPS
-        """
-        feature_matrix = self._plantinFMCreator.fit_transform(newData)
-        return self._pipeline.predict(feature_matrix)
-    
-if __name__ == "__main__":
-    from sarapy.dataProcessing import OpsProcessor
-
-    #cargo archivo examples\volcado_17112023_NODE_processed.csv
-    import pandas as pd
-    import os
-    path = os.path.join(os.getcwd(), "examples\\volcado_17112023_NODE_processed.csv")
-    data_df = pd.read_csv(path, sep=";", )
-    raw_data = data_df.to_numpy().astype(str)
-
-    ##tomo raw_data y obtengo muestras de entre 7 a 15 filas una detrás de la otra. El valor de entre 7 y 15 es aleatorio.
-    sample = []
-    index = 0
-    while True:
-        random_value = np.random.randint(8, 15)
-        if index + random_value < len(raw_data):
-            sample.append(raw_data[index:index+random_value])
-        else:
-            break
-        index += random_value
-
-    plantin_classifier = PlantinClassifier(classifier_file="examples\\pip_lda_imp.pkl",imputeDistances = False)
-    plantin_classifier.classify(sample[50][:,2:])

sarapy-1.0.1/sarapy/utils/getRawOperations.py

@@ -1,25 +0,0 @@
-import pandas as pd
-from sarapy.utils import amg_ppk
-import os
-def getRawOperations(data_file, historical_data_file):
-    """
-    Args:
-        data_file: Path to the file with the data.
-        historical_data_file: Path to the file with the historical data.
-    Returns the raw operations from the database.
-    """
-    #cargo examples\2024-05-30\UPM007N\data.json
-    data = pd.read_json(os.path.join("examples","2024-05-30","UPM007N","data.json"))
-    historical_data = pd.read_json(os.path.join("examples","2024-05-30","UPM007N","historical-data.json"))
-    #convierto a lista de diccionarios
-    data=data.to_dict(orient="records")
-    historical_data=historical_data.to_dict(orient="records")
-    hash_table = {}
-    for datum in data:
-        hash_table[datum["timestamp"]] = {"id_db_dw": datum["id"], "id_db_h": 0, "serialized_datum": ""}
-    for historical_datum in historical_data:
-        if historical_datum["timestamp"] in hash_table:
-            hash_table[historical_datum["timestamp"]].update({"id_db_h": historical_datum["id"], "serialized_datum": historical_datum["datum"]})
-    ppk_results = amg_ppk.main(hash_table, [])  # ToDo: PPK (Fernando)
-
-    return ppk_results