sarapy 2.3.0__py3-none-any.whl → 3.1.0__py3-none-any.whl

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//regfresor_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-2.3.0.dist-info/top_level.txt

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