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

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 = {}
@@ -343,7 +343,8 @@ if __name__ == "__main__":
             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\\regresor.pkl', poly_features_file='modelos\\poly_features.pkl',
+                        regresor_file='modelos\\regresor_v2.pkl', poly_features_file='modelos\\poly_features_v2.pkl',
                         **kwargs_fmcreator)
 
         ops_clasificadas = op.processOperations(samples, **kwargs_classifier)

sarapy/mlProcessors/FertilizerTransformer.py

@@ -48,23 +48,151 @@ class FertilizerTransformer:
         X_poly = self._poly_features.fit_transform(X.reshape(-1, 1))
         self.fertilizer_grams = self._regresor.predict(X_poly)
 
+        ##para valores de distorsión de 13+-0.3 y 15+-0.3, pongo los valores en 8 y 9 gramos, respectivamente
+        ##uso máscara booleana para encontrar los índices
+        mask_13 = (X >= 12.7) & (X <= 13.3)
+        mask_15 = (X >= 14.7) & (X <= 15.3)
+        self.fertilizer_grams[mask_13] = 8
+        self.fertilizer_grams[mask_15] = 9
+
         ##retorno con shape (n,)
         return self.fertilizer_grams.reshape(-1,)
     
 if __name__ == "__main__":
     import pandas as pd
+    import numpy as np
     import json
     from sarapy.preprocessing import TransformInputData
+    import matplotlib.pyplot as plt
+    from collections import Counter
+
+    fecha = "2025-08-09"
+    nodo_interes = "UPM095N"
 
-    historical_data_path = "examples/2025-06-21/UPM000N/historical-data.json"
+    historical_data_path = f"examples//{fecha}//{nodo_interes}//historical-data.json"
     with open(historical_data_path, 'r') as file:
         historical_data = json.load(file)
 
     ##cargo en un diccionario sarapy\preprocessing\telemetriaDataPosition.json
     data_positions = json.load(open("sarapy/preprocessing/telemetriaDataPosition.json", 'r'))
-    transform_input_data = TransformInputData.TransformInputData()
+    transform_input_data = TransformInputData()
     transformed_data = transform_input_data.transform(historical_data)
 
-    fertransformer = FertilizerTransformer(regresor_file='modelos\\regresor.pkl', poly_features_file='modelos\\poly_features.pkl')
+    fertransformer = FertilizerTransformer(regresor_file='modelos\\regresor_v2.pkl', poly_features_file='modelos\\poly_features_v2.pkl')
     gramos = fertransformer.transform(transformed_data)
-    print(gramos[:10])
+    print(gramos[:10])
+
+    df = pd.DataFrame(transformed_data)
+    score_ft = df["SC_FT"].values
+
+    print(score_ft.mean(), gramos.mean())
+    print(score_ft.max(), gramos.max())
+    print(score_ft.min(), gramos.min())
+
+    puntos = list(zip(score_ft, gramos))
+    conteos  = Counter(puntos)
+    xs, ys, sizes = zip(*[(x, y, c) for (x, y), c in conteos.items()])
+
+    np.array([s*10 for s in sizes]).shape
+
+    points = np.column_stack((score_ft, gramos))
+    unique_points, counts = np.unique(points, axis=0, return_counts=True)
+
+    sizes = np.log1p(counts) * 50
+
+    plt.figure(figsize=(10, 6))
+    handles, labels = plt.gca().get_legend_handles_labels()
+    order = [2, 0, 1]
+    plt.scatter(unique_points[:,0], unique_points[:,1], color="#5612af", label="Regresor 1 - Orden 12",zorder=1,
+                s=sizes)
+    plt.scatter(score_ft.mean(), gramos.mean(), color="#af121f", label="Punto promedio", marker='X',s=400)
+    plt.title(f'Predicciones Regresor 2 de orden 12 para NODO: {nodo_interes}')
+    plt.xlabel('Score de Fertilizante (SC_FT)')
+    plt.ylabel('Predicciones de Gramos de Fertilizante')
+    plt.grid(True)
+    plt.legend()
+    plt.savefig(f'predicciones_regresor2_orden12_{nodo_interes}.png')
+    plt.show()
+
+    nodos = ["UPM075N", "UPM076N", "UPM077N", "UPM078N", "UPM079N", "UPM080N", "UPM081N", "UPM082N", "UPM083N", "UPM084N",
+             "UPM085N", "UPM086N", "UPM087N", "UPM088N", "UPM089N", "UPM090N", "UPM091N", "UPM092N", "UPM093N", "UPM094N", "UPM095N",
+             "UPM096N", "UPM097N", "UPM098N", "UPM099N"]
+    
+    ##cargo datos históricos de ejemplo
+    
+    scores_ft_maximos = {}
+    scores_ft_minimos = {}
+    gramos_maximos = {}
+    gramos_minimos = {}
+    for nodo in nodos:
+        historical_data_path = f"examples//{fecha}//{nodo}//historical-data.json"
+        try:
+            with open(historical_data_path, 'r') as file:
+                historical_data = json.load(file)
+        except FileNotFoundError:
+            print(f"El archivo {historical_data_path} no se encuentra en el directorio actual.")
+            continue
+        transform_input_data = TransformInputData()
+        transformed_data = transform_input_data.transform(historical_data)
+        fertransformer = FertilizerTransformer(regresor_file='modelos\\regresor_v2.pkl', poly_features_file='modelos\\poly_features_v2.pkl')
+        gramos = fertransformer.transform(transformed_data)
+        gramos_maximos[nodo] = gramos.max()
+        gramos_minimos[nodo] = gramos.min()
+
+        df = pd.DataFrame(transformed_data)
+        score_ft = df["SC_FT"].values
+        scores_ft_maximos[nodo] = score_ft.max()
+        scores_ft_minimos[nodo] = score_ft.min()
+        
+    data = np.array([[gramos_maximos[nodo] for nodo in nodos],
+                       [scores_ft_maximos[nodo] for nodo in nodos],
+                        [gramos_minimos[nodo] for nodo in nodos],
+                          [scores_ft_minimos[nodo] for nodo in nodos]])  
+
+    data_df = pd.DataFrame(data=data.T, index=nodos, columns=['Gramos_Fertilizante', 'Score_Fertilizante', 'Gramos_Fertilizante_Min', 'Score_Fertilizante_Min'])
+
+    data_df['Gramos_Fertilizante'].plot.bar(figsize=(12, 6), color="#34a853", legend=False)
+    #add text labels on top of each bar with the height value
+    for i, v in enumerate(data_df['Gramos_Fertilizante']):
+        plt.text(i, v + 0.1, f"{v:.1f}", ha='center', va='bottom',color="#34a853")
+    plt.title('Máximos de gramos de fertilizante por nodo') 
+    plt.xlabel('Nodos')
+    plt.ylabel('Gramos de Fertilizante')
+    plt.grid(axis='y')
+    plt.savefig('maximos_gramos_fertilizante_por_nodo.png')
+    plt.show()
+
+    data_df['Gramos_Fertilizante_Min'].plot.bar(figsize=(12, 6), color="#34a853", legend=False)
+    #add text labels on top of each bar with the height value
+    for i, v in enumerate(data_df['Gramos_Fertilizante_Min']):
+        plt.text(i, v + 0.1, f"{v:.1f}", ha='center', va='bottom',color="#34a853")
+    plt.title('Mínimos de gramos de fertilizante por nodo') 
+    plt.xlabel('Nodos')
+    plt.ylabel('Gramos de Fertilizante')
+    plt.grid(axis='y')
+    plt.savefig('minimos_gramos_fertilizante_por_nodo.png')
+    plt.show()
+
+    data_df['Score_Fertilizante'].plot.bar(figsize=(12, 6), color="#3434a8", legend=False)
+    #add text labels on top of each bar with the height value
+    for i, v in enumerate(data_df['Score_Fertilizante']):
+        plt.text(i, v + 0.1, f"{v:.1f}", ha='center', va='bottom',color="#3434a8")
+    plt.title('Máximos de score de fertilizante por nodo') 
+    plt.xlabel('Nodos')
+    plt.ylabel('Score de Fertilizante')
+    plt.grid(axis='y')
+    plt.savefig('maximos_score_fertilizante_por_nodo.png')
+    plt.show()
+
+    data_df['Score_Fertilizante_Min'].plot.bar(figsize=(12, 6), color="#3434a8", legend=False)
+    #add text labels on top of each bar with the height value
+    for i, v in enumerate(data_df['Score_Fertilizante_Min']):
+        plt.text(i, v + 0.1, f"{v:.1f}", ha='center', va='bottom',color="#3434a8")
+    plt.title('Mínimos de score de fertilizante por nodo') 
+    plt.xlabel('Nodos')
+    plt.ylabel('Score de Fertilizante')
+    plt.grid(axis='y')
+    plt.savefig('minimos_score_fertilizante_por_nodo.png')
+    plt.show()
+
+    

sarapy/version.py

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

{sarapy-3.0.0.dist-info → sarapy-3.1.1.dist-info}/METADATA

@@ -1,24 +1,47 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: sarapy
-Version: 3.0.0
-Home-page: https://github.com/lucasbaldezzari/sarapy
-Author: Lucas Baldezzari
+Version: 3.1.1
+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.1
+
+- Se vuelve a generar archivos de regresor_v2 y poly_features_v2 porque quedó mal cargado.
+
+#### 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.

{sarapy-3.0.0.dist-info → sarapy-3.1.1.dist-info}/RECORD

@@ -1,14 +1,14 @@
 sarapy/__init__.py,sha256=aVoywqGSscYYDycLaYJnz08dlQabl9gH0h4Q5KtHM9o,74
-sarapy/version.py,sha256=FwfAbPJHI1L9iu0rJTFUu9Rw3s7BA7POU73XKvHfy0E,48
+sarapy/version.py,sha256=nu21TnYDRA1Ea8izdV-DvsKrdGiTFxIbDKxBSxFh5lo,48
 sarapy/analysis/FeaturesResume.py,sha256=fqKpDy7Py3QHUMtrS8r-KE25ah4HjkJxBKoZtHdORAQ,31946
 sarapy/analysis/__init__.py,sha256=i6QGXmnuA-k6Gh6639TinluogMhLGIiL-tiR_S2i2Ok,74
 sarapy/dataProcessing/GeoProcessor.py,sha256=ARjgKTXDVdf_cFCXyFmzlnmmmay3HG3q-yeJ9QrAcQU,5919
-sarapy/dataProcessing/OpsProcessor.py,sha256=LaWKdVzPfSmFuuQsqalW5cySJ0kQf9wnfEniXUBYyr8,19306
+sarapy/dataProcessing/OpsProcessor.py,sha256=bK-l5d82-ZTcv169VEM7T7KlFtun24flvcvwXZFe5jw,19431
 sarapy/dataProcessing/TLMSensorDataProcessor.py,sha256=NhRxMoA4SHwyhD61xn6m5UIp1ZrDhEnHaFfhveMJLRQ,3689
 sarapy/dataProcessing/TimeSeriesProcessor.py,sha256=aig3A3_SCa9FVSWxGWiapBUX7Lj9Wi1BVyZi-XXZZYQ,6414
 sarapy/dataProcessing/__init__.py,sha256=Kqs5sFtq6RMEa3KLJFbsGRoYsIxHL1UUGMuplyCyQFk,200
 sarapy/mlProcessors/FertilizerFMCreator.py,sha256=LNi86CI6eVuQ0_UBVJNd_-L79fcY2-zY2NCm9ypl6OM,2354
-sarapy/mlProcessors/FertilizerTransformer.py,sha256=0VkW1Kqnc0LMS1HgaVJvnsyg4MwAG-9ocw047_u7-U8,3119
+sarapy/mlProcessors/FertilizerTransformer.py,sha256=MTsuplwuRdDMVzycRRYZa98ZOEgRhBcjaDWQg6kyph4,8933
 sarapy/mlProcessors/PlantinClassifier.py,sha256=yNck3R8wGfy6rjb8Q2mxVdu63NWJgJ6UmqUORa2qvbk,12491
 sarapy/mlProcessors/PlantinFMCreator.py,sha256=y8rdkUb-84-ONa4kJOY2R2zAfuOXtUJVBEhUPhDncyY,7852
 sarapy/mlProcessors/__init__.py,sha256=wHnqLn15KRCOYI9WWS8_ArraG_c4UEfDCi19muwjN14,335
@@ -22,8 +22,11 @@ sarapy/stats/stats.py,sha256=eVmi6w9QcwvwuDK3yOr1Z8wQV-1oT3QJujDqWZFYzGc,11424
 sarapy/utils/__init__.py,sha256=TD_-dGgPQBD13hyf2OqDUET0XZOXTduJD1ht8tjZF_0,257
 sarapy/utils/plotting.py,sha256=kX-eYw618urMcUBkNPviQZdBziDc_TR3GInTsO90kU4,4065
 sarapy/utils/utils.py,sha256=NSSeZHeLnQWcFa6vfJ2nVkptX2dIyiCMlZPBmsgEvjo,7106
-sarapy-3.0.0.dist-info/LICENCE,sha256=N00sU3vSQ6F5c2vML9_qP4IFTkCPFFj0YGDB2CZP-uQ,840
-sarapy-3.0.0.dist-info/METADATA,sha256=mNSvlvzBpAm4_9fXTa5EALLidW7rfi6P7tR4bwzRRWc,7684
-sarapy-3.0.0.dist-info/WHEEL,sha256=R0nc6qTxuoLk7ShA2_Y-UWkN8ZdfDBG2B6Eqpz2WXbs,91
-sarapy-3.0.0.dist-info/top_level.txt,sha256=4mUGZXfX2Fw47fpY6MQkaJeuOs_8tbjLkkNp34DJWiA,7
-sarapy-3.0.0.dist-info/RECORD,,
+sarapy-3.1.1.dist-info/licenses/LICENCE,sha256=N00sU3vSQ6F5c2vML9_qP4IFTkCPFFj0YGDB2CZP-uQ,840
+test/checking_regresor.py,sha256=H5GZRD2ccy4yqjv9vr9PELpmbZVGY59lc2IDkKs7vTg,5931
+test/probabilidades_test.py,sha256=4mGwuYNQGQd-LurL63pBpaaw5QHIN1PymBPhzRQB9Hc,3254
+test/test_import.py,sha256=qYBVkwb3ACzGyYj4cVBNmrPAWw-cuITHgWP4oJYdrto,56
+sarapy-3.1.1.dist-info/METADATA,sha256=ycUenXbdz48V6M64FL5Y92DS9KQ32qbNiuUqQYh_lIo,8395
+sarapy-3.1.1.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+sarapy-3.1.1.dist-info/top_level.txt,sha256=gsDJg1lRhlnLTvKqH039RW-fsHlHgX6ZTxaM6GheziQ,34
+sarapy-3.1.1.dist-info/RECORD,,

{sarapy-3.0.0.dist-info → sarapy-3.1.1.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (72.1.0)
+Generator: setuptools (80.10.2)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

sarapy-3.1.1.dist-info/top_level.txt

@@ -0,0 +1,5 @@
+docs
+examples
+modelos
+sarapy
+test

test/checking_regresor.py

@@ -0,0 +1,162 @@
+import pickle
+import pandas as pd
+import numpy as np
+import matplotlib.pyplot as plt
+from sklearn.preprocessing import PolynomialFeatures
+from sklearn.linear_model import LinearRegression
+from sklearn.preprocessing import StandardScaler
+
+regresor = "modelos//regresor.pkl"
+poly_features = "modelos//poly_features.pkl"
+
+with open(regresor, "rb") as file:
+    loaded_regresor = pickle.load(file)
+
+with open(poly_features, "rb") as file:
+    loaded_poly_features = pickle.load(file)
+
+coeficientes = loaded_regresor.coef_.flatten()
+intercept = loaded_regresor.intercept_
+index = np.arange(len(coeficientes)) + 1
+distorsiones = np.linspace(0, 15, 1000)
+X_poly = loaded_poly_features.transform(distorsiones.reshape(-1, 1))
+predicciones = loaded_regresor.predict(X_poly)
+
+##genero un dataframe con los coeficientes
+labels = [f"Exponente/Coeficiente {i}" for i in index]
+tabla = pd.DataFrame(coeficientes, labels).rename(columns={0:"Valores"})
+tabla.loc[len(tabla)+1] = intercept
+tabla = tabla.rename(index={len(tabla):"intercepción"})
+
+#grafico de líneas de los coeficientes vs su índice
+plt.figure(figsize=(10, 6))
+plt.plot(index, coeficientes, marker='o', linestyle='-', color='b')
+plt.title('Coeficientes del Regresor Polinómico')
+plt.xlabel('Índice del Coeficiente')
+plt.ylabel('Valor del Coeficiente')
+plt.grid(True)
+plt.axhline(0, color='black', linewidth=0.8, linestyle='--')
+plt.show()
+
+# gráfico de dispersión de distorsión vs predicciones
+plt.figure(figsize=(10, 6))
+plt.scatter(distorsiones, predicciones, color='r', alpha=0.6)
+plt.title('Score de Fertilizante vs Predicciones en Gramos')
+plt.xlabel('Score de Fertilizante (SC_FT)')
+plt.ylabel('Predicciones de Gramos de Fertilizante')
+plt.grid(True)
+plt.show()
+
+inf, sup = 7, 13
+distorsiones[int(inf/0.1):int(sup/0.1+1)].mean()
+predicciones[int(inf/0.1):int(sup/0.1+1)].mean()
+
+
+# Definición de tramos: (x1, x2, y1, y2)
+segmentos1 = [(0, 4, 0, 0.821),
+             (4, 7, 0.821, 5),
+             (7, 9.5, 5, 5.41),
+             (9.5, 13, 5.41, 8),
+             (13, 15, 8, 9)]
+segmentos2 = [(0, 4, 0, 0.821),
+             (4, 7, 0.821, 5),
+            #  (7, 9.5, 5, 5.41),
+             (7, 13, 5, 8),
+             (13, 15, 8, 9)]
+
+def get_line(x1, x2, y1, y2):
+    m = (y2 - y1) / (x2 - x1)
+    b = y1 - m * x1
+    return m, b
+
+def piecewise_linear(x, segmentos, lines):
+    for (x1, x2, _, _), (m, b) in zip(segmentos, lines):
+        if x1 <= x <= x2:
+            return m * x + b
+    raise ValueError("x fuera de rango")
+
+lines1 = [get_line(*seg) for seg in segmentos1]
+lines2 = [get_line(*seg) for seg in segmentos2]
+
+# Ejemplo
+ys1 = np.array([piecewise_linear(x, segmentos1, lines1) for x in distorsiones])
+ys2 = np.array([piecewise_linear(x, segmentos2, lines2) for x in distorsiones])
+
+# gráfico de dispersión de distorsión vs predicciones
+plt.figure(figsize=(10, 6))
+handles, labels = plt.gca().get_legend_handles_labels()
+order = [2, 0, 1]
+plt.scatter(distorsiones, predicciones, color='r', alpha=0.5, label="Predicciones actuales",zorder=2)
+plt.scatter(distorsiones, ys1, color='g', alpha=0.5, label="Propuesta 1",zorder=1)
+plt.scatter(distorsiones, ys2, color='b', alpha=0.5, label="Propuesta 2",zorder=0)
+plt.title('Score de Fertilizante vs Predicciones en Gramos')
+plt.xlabel('Score de Fertilizante (SC_FT)')
+plt.ylabel('Predicciones de Gramos de Fertilizante')
+plt.grid(True)
+plt.legend()
+plt.show()
+
+
+### ************* Obteniendo nuevos regresores a partir de ys1 y ys2 ************* ###
+X = distorsiones.reshape(-1, 1)
+
+poly = PolynomialFeatures(
+    degree=12,
+    include_bias=True  # incluye el término β0
+)
+
+X_poly = poly.fit_transform(X)
+
+modelo1 = LinearRegression(fit_intercept=False)
+modelo1.fit(X_poly, ys1)
+modelo2 = LinearRegression(fit_intercept=False)
+modelo2.fit(X_poly, ys2)
+
+ys1_pred = modelo1.predict(X_poly)
+ys2_pred = modelo2.predict(X_poly)
+
+# gráfico de dispersión de distorsión vs predicciones
+plt.figure(figsize=(10, 6))
+handles, labels = plt.gca().get_legend_handles_labels()
+order = [2, 0, 1]
+plt.scatter(distorsiones, ys1, color='g', alpha=0.1, label="Función 1 Hardcodeada ",zorder=1)
+plt.scatter(distorsiones, ys1_pred, color="#5612af", alpha=0.5, label="Regresor 1 - Orden 12",zorder=2)
+plt.title('Comparación Función de Propuesta vs Regresor 1 de orden 12')
+plt.xlabel('Score de Fertilizante (SC_FT)')
+plt.ylabel('Predicciones de Gramos de Fertilizante')
+plt.grid(True)
+plt.legend()
+plt.show()
+
+# gráfico de dispersión de distorsión vs predicciones
+plt.figure(figsize=(10, 6))
+handles, labels = plt.gca().get_legend_handles_labels()
+order = [2, 0, 1]
+plt.scatter(distorsiones, ys2, color='b', alpha=0.1, label="Función 2 Hardcodeada ",zorder=1)
+plt.scatter(distorsiones, ys2_pred, color="#12af12", alpha=0.5, label="Regresor 2 - Orden 12",zorder=2)
+plt.title('Comparación Función de Propuesta vs Regresor 2 de orden 12')
+plt.xlabel('Score de Fertilizante (SC_FT)')
+plt.ylabel('Predicciones de Gramos de Fertilizante')
+plt.grid(True)
+plt.legend()
+plt.show()
+
+# gráfico de dispersión de distorsión vs predicciones
+plt.figure(figsize=(10, 6))
+handles, labels = plt.gca().get_legend_handles_labels()
+order = [2, 0, 1]
+plt.scatter(distorsiones, ys1_pred, color="#5612af", alpha=0.1, label="Regresor 1 - Orden 12",zorder=1)
+plt.scatter(distorsiones, ys2_pred, color="#12af12", alpha=0.5, label="Regresor 2 - Orden 12",zorder=2)
+plt.title('Regresor 1 vs Regresor 2 de orden 12')
+plt.xlabel('Score de Fertilizante (SC_FT)')
+plt.ylabel('Predicciones de Gramos de Fertilizante')
+plt.grid(True)
+plt.legend()
+plt.show()
+
+## Guardo el modelo 2 y las características polinómicas
+with open("modelos//regresor_v2.pkl", "wb") as file:
+    pickle.dump(modelo2, file)
+
+with open("modelos//poly_features_v2.pkl", "wb") as file:
+    pickle.dump(poly, file)

test/probabilidades_test.py

@@ -0,0 +1,77 @@
+from sarapy.utils.plotting import plotTemporalData
+import pandas as pd
+import numpy as np
+import os
+import sarapy.utils.getRawOperations as getRawOperations
+from sarapy.dataProcessing import OpsProcessor
+from sarapy.preprocessing import TransformInputData
+from sarapy.dataProcessing import TLMSensorDataProcessor
+import sarapy.stats.stats as stats
+
+tlmsde = TLMSensorDataProcessor.TLMSensorDataProcessor()
+
+nodo = "UPM017N"
+
+data_path = os.path.join(os.getcwd(), f"examples\\2025-04-10\\{nodo}\\data.json")
+historical_data_path = os.path.join(os.getcwd(), f"examples\\2025-04-10\\{nodo}\\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")
+
+transform_input_data = TransformInputData.TransformInputData()
+
+raw_ops = getRawOperations.getRawOperations(raw_data, raw_data2)
+datum = transform_input_data.fit_transform(raw_ops)[:,2]
+telemetria = tlmsde.fit_transform(datum)
+mode = telemetria[:,tlmsde.dataPositions["MODEFlag"]]
+dstpt = telemetria[:,tlmsde.dataPositions["DSTRPT"]]
+
+op = OpsProcessor.OpsProcessor(classifier_file='modelos\\pipeline_rf.pkl', imputeDistances = False,
+                                regresor_file='modelos\\regresor.pkl', poly_features_file='modelos\\poly_features.pkl')
+op.operationsDict
+data_processed = op.processOperations(raw_ops)
+
+#paso la lista de operaciones a un dataframe
+df = pd.DataFrame(data_processed)
+df["mode"] = mode
+df["dstpt"] = dstpt
+df["nodo"] = nodo
+ma = stats.getMA(df["dstpt"].values, window_size=104, mode='same')
+df["dstpt_ma"] = ma
+##me quedo con los datos donde mode==0
+df = df[df["mode"] == 0]
+
+#calculo el resumen del sensor
+resumen = stats.resumen_sensor(df, values_col="dstpt_ma", pctbajo_value=1, pctalto_value=14)
+print(resumen)
+#calculo la probabilidad de saturación
+prob_saturacion = stats.calcular_prob_saturacion(ma[2000:], saturation_mode="alto", umbrales=(1, 14),
+                                                 alpha=0.2, beta=0.2)
+print(f"Probabilidad de saturación: {prob_saturacion}")
+
+# Definimos grilla de alpha y beta
+alpha_vals = np.linspace(0, 1, 20)
+beta_vals = np.linspace(0, 1, 20)
+
+# Creamos matriz de resultados
+Psat_matrix = np.zeros((len(alpha_vals), len(beta_vals)))
+
+for i, alpha in enumerate(alpha_vals):
+    for j, beta in enumerate(beta_vals):
+        Psat = prob_saturacion = stats.calcular_prob_saturacion(ma, saturation_mode="alto", umbrales=(1, 14),
+                                            alpha=alpha, beta=beta)
+        Psat_matrix[i, j] = Psat
+
+import matplotlib.pyplot as plt
+import seaborn as sns
+
+plt.figure(figsize=(10, 8))
+sns.heatmap(Psat_matrix, xticklabels=np.round(beta_vals, 2), yticklabels=np.round(alpha_vals, 2), cmap="coolwarm")
+plt.title("Evolución de Psat en función de α (vertical) y β (horizontal)")
+plt.xlabel("β (peso de kurtosis)")
+plt.ylabel("α (peso de skewness)")
+plt.show()
+
+colors = ["#0b3256","#fa0000"]
+plotTemporalData(df, nodos = [nodo], columnas = ["dstpt_ma"], title = "DSTPT",sameFig = False, show = True,
+                save = False, filename = "dstpt_plot.png", figsize=(15, 10), colors=colors)

test/test_import.py

@@ -0,0 +1,5 @@
+def test_import():
+    import sarapy
+
+
+test_import()

sarapy-3.0.0.dist-info/top_level.txt

@@ -1 +0,0 @@
-sarapy