tsadmetrics 0.1.1__py3-none-any.whl → 0.1.3__py3-none-any.whl

tsadmetrics/_tsadeval/threshold_plt.py

@@ -0,0 +1,30 @@
+# import numpy as np
+# from matplotlib import pyplot as plt
+
+
+# x = np.arange(48)
+
+# y = np.sin(0.7 + x / 12) + np.sin(x / 4 + 29) + 0.1 * np.sin(1.25 * x) * (np.cos(np.sqrt(1.25 * x) + 2)) + x / 32 + 0.12
+
+
+# figsize = (3.4, 2)
+# plt.figure(figsize=figsize)
+
+# plt.plot(x, y)
+
+# for t in [0.5, 1, 1.5, 2, 2.5]:
+#     plt.plot(x, x + t - x, ".", color="dimgray")
+#     for i in range(len(x)):
+#         if t < y[i]:
+#             plt.plot([x[i]], [t], ".r")
+#             plt.plot([x[i]], [t], "xw", markersize=2)
+
+# fs = 7
+# plt.xlabel("Time", fontsize=fs)
+# plt.ylabel("Anomaly score / Threshold", fontsize=fs)
+# plt.xticks(fontsize=fs)
+# plt.yticks(fontsize=fs)
+
+# plt.tight_layout()
+# plt.savefig("thr2.pdf")
+# plt.show()

tsadmetrics/_tsadeval/time_tolerant.py

@@ -0,0 +1,33 @@
+# MIT License
+# 
+# Copyright (c) 2020 Erik Scharwächter
+# 
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+# 
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+# 
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+
+import numpy as np
+
+def time_tolerant_recall_(A, E, d):
+    N_E = float(E.sum())
+    T = len(E)
+    return len([t for t in range(d, T-d) if (E[t] == 1) and np.sum(A[(t-d):(t+d)+1]) >= 1])/N_E
+
+def time_tolerant_precision_(A, E, d):
+    N_A = float(A.sum())
+    T = len(E)
+    return len([t for t in range(d, T-d) if (A[t] == 1) and np.sum(E[(t-d):(t+d)+1]) >= 1])/N_A

tsadmetrics/_tsadeval/vus_utils.py

@@ -0,0 +1,263 @@
+import numpy as np
+
+# This file includes code derived from the VUS project:
+# https://github.com/TheDatumOrg/VUS
+#
+# No license was specified in the original repository at the time of inclusion (April 2025),
+# which may imply that all rights are reserved by the original author(s).
+#
+# This code has been copied and modified for internal use only within the tsadmetrics project.
+# If you are the author or copyright holder and would like us to remove or relicense
+# this code, please contact us.
+#
+# This file is NOT intended for redistribution as a standalone component or as a derivative
+# of the original VUS project unless proper licensing is clarified.
+
+
+def range_convers_new( label):
+		'''
+		input: arrays of binary values 
+		output: list of ordered pair [[a0,b0], [a1,b1]... ] of the inputs
+		'''
+		L = []
+		i = 0
+		j = 0 
+		while j < len(label):
+			# print(i)
+			while label[i] == 0:
+				i+=1
+				if i >= len(label):  #?
+					break			 #?
+			j = i+1
+			# print('j'+str(j))
+			if j >= len(label):
+				if j==len(label):
+					L.append((i,j-1))
+	
+				break
+			while label[j] != 0:
+				j+=1
+				if j >= len(label):
+					L.append((i,j-1))
+					break
+			if j >= len(label):
+				break
+			L.append((i, j-1))
+			i = j
+		return L
+
+def new_sequence(label, sequence_original, window):
+    a = max(sequence_original[0][0] - window // 2, 0)
+    sequence_new = []
+    for i in range(len(sequence_original) - 1):
+        if sequence_original[i][1] + window // 2 < sequence_original[i + 1][0] - window // 2:
+            sequence_new.append((a, sequence_original[i][1] + window // 2))
+            a = sequence_original[i + 1][0] - window // 2
+    sequence_new.append((a, min(sequence_original[len(sequence_original) - 1][1] + window // 2, len(label) - 1)))
+    return sequence_new
+
+
+def sequencing(x, L, window=5):
+		label = x.copy().astype(float)
+		length = len(label)
+
+		for k in range(len(L)):
+			s = L[k][0]
+			e = L[k][1]
+
+			x1 = np.arange(e + 1, min(e + window // 2 + 1, length))
+			label[x1] += np.sqrt(1 - (x1 - e) / (window))
+
+			x2 = np.arange(max(s - window // 2, 0), s)
+			label[x2] += np.sqrt(1 - (s - x2) / (window))
+
+		label = np.minimum(np.ones(length), label)
+		return label
+
+
+def RangeAUC_volume_opt_mem(labels_original, score, windowSize, thre=250):
+		window_3d = np.arange(0, windowSize + 1, 1)
+		P = np.sum(labels_original)
+		seq = range_convers_new(labels_original)
+		l = new_sequence(labels_original, seq, windowSize)
+
+		score_sorted = -np.sort(-score)
+
+		tpr_3d = np.zeros((windowSize + 1, thre + 2))
+		fpr_3d = np.zeros((windowSize + 1, thre + 2))
+		prec_3d = np.zeros((windowSize + 1, thre + 1))
+
+		auc_3d = np.zeros(windowSize + 1)
+		ap_3d = np.zeros(windowSize + 1)
+
+		tp = np.zeros(thre)
+		N_pred = np.zeros(thre)
+		p = np.zeros((thre, len(score)))
+
+		for k, i in enumerate(np.linspace(0, len(score) - 1, thre).astype(int)):
+			threshold = score_sorted[i]
+			pred = score >= threshold
+			p[k] = pred
+			N_pred[k] = np.sum(pred)
+
+		for window in window_3d:
+			labels_extended = sequencing(labels_original, seq, window)
+			L = new_sequence(labels_extended, seq, window)
+
+			TF_list = np.zeros((thre + 2, 2))
+			Precision_list = np.ones(thre + 1)
+			j = 0
+
+			for i in np.linspace(0, len(score) - 1, thre).astype(int):
+				labels = labels_extended.copy()
+				existence = 0
+
+				for seg in L:
+					labels[seg[0]:seg[1] + 1] = labels_extended[seg[0]:seg[1] + 1] * p[j][seg[0]:seg[1] + 1]
+					if (p[j][seg[0]:(seg[1] + 1)] > 0).any():
+						existence += 1
+				for seg in seq:
+					labels[seg[0]:seg[1] + 1] = 1
+
+				N_labels = 0
+				TP = 0
+				for seg in l:
+					TP += np.dot(labels[seg[0]:seg[1] + 1], p[j][seg[0]:seg[1] + 1])
+					N_labels += np.sum(labels[seg[0]:seg[1] + 1])
+
+				TP += tp[j]
+				FP = N_pred[j] - TP
+
+				existence_ratio = existence / len(L)
+
+				P_new = (P + N_labels) / 2
+				recall = min(TP / P_new, 1)
+
+				TPR = recall * existence_ratio
+
+				N_new = len(labels) - P_new
+				FPR = FP / N_new
+				Precision = TP / N_pred[j]
+				j += 1
+
+				TF_list[j] = [TPR, FPR]
+				Precision_list[j] = Precision
+
+			TF_list[j + 1] = [1, 1]
+			tpr_3d[window] = TF_list[:, 0]
+			fpr_3d[window] = TF_list[:, 1]
+			prec_3d[window] = Precision_list
+
+			width = TF_list[1:, 1] - TF_list[:-1, 1]
+			height = (TF_list[1:, 0] + TF_list[:-1, 0]) / 2
+			AUC_range = np.dot(width, height)
+			auc_3d[window] = (AUC_range)
+
+			width_PR = TF_list[1:-1, 0] - TF_list[:-2, 0]
+			height_PR = Precision_list[1:]
+			AP_range = np.dot(width_PR, height_PR)
+			ap_3d[window] = (AP_range)
+		return tpr_3d, fpr_3d, prec_3d, window_3d, sum(auc_3d) / len(window_3d), sum(ap_3d) / len(window_3d)    
+
+def RangeAUC_volume_opt( labels_original, score, windowSize, thre=250):
+		window_3d = np.arange(0, windowSize + 1, 1)
+		P = np.sum(labels_original)
+		seq = range_convers_new(labels_original)
+		l = new_sequence(labels_original, seq, windowSize)
+
+		score_sorted = -np.sort(-score)
+
+		tpr_3d = np.zeros((windowSize + 1, thre + 2))
+		fpr_3d = np.zeros((windowSize + 1, thre + 2))
+		prec_3d = np.zeros((windowSize + 1, thre + 1))
+
+		auc_3d = np.zeros(windowSize + 1)
+		ap_3d = np.zeros(windowSize + 1)
+
+		tp = np.zeros(thre)
+		N_pred = np.zeros(thre)
+
+		for k, i in enumerate(np.linspace(0, len(score) - 1, thre).astype(int)):
+			threshold = score_sorted[i]
+			pred = score >= threshold
+			N_pred[k] = np.sum(pred)
+
+		for window in window_3d:
+
+			labels_extended = sequencing(labels_original, seq, window)
+			L = new_sequence(labels_extended, seq, window)
+
+			TF_list = np.zeros((thre + 2, 2))
+			Precision_list = np.ones(thre + 1)
+			j = 0
+
+			for i in np.linspace(0, len(score) - 1, thre).astype(int):
+				threshold = score_sorted[i]
+				pred = score >= threshold
+				labels = labels_extended.copy()
+				existence = 0
+
+				for seg in L:
+					labels[seg[0]:seg[1] + 1] = labels_extended[seg[0]:seg[1] + 1] * pred[seg[0]:seg[1] + 1]
+					if (pred[seg[0]:(seg[1] + 1)] > 0).any():
+						existence += 1
+				for seg in seq:
+					labels[seg[0]:seg[1] + 1] = 1
+
+				TP = 0
+				N_labels = 0
+				for seg in l:
+					TP += np.dot(labels[seg[0]:seg[1] + 1], pred[seg[0]:seg[1] + 1])
+					N_labels += np.sum(labels[seg[0]:seg[1] + 1])
+
+				TP += tp[j]
+				FP = N_pred[j] - TP
+
+				existence_ratio = existence / len(L)
+
+				P_new = (P + N_labels) / 2
+				recall = min(TP / P_new, 1)
+
+				TPR = recall * existence_ratio
+				N_new = len(labels) - P_new
+				FPR = FP / N_new
+
+				Precision = TP / N_pred[j]
+
+				j += 1
+				TF_list[j] = [TPR, FPR]
+				Precision_list[j] = Precision
+
+			TF_list[j + 1] = [1, 1]  # otherwise, range-AUC will stop earlier than (1,1)
+
+			tpr_3d[window] = TF_list[:, 0]
+			fpr_3d[window] = TF_list[:, 1]
+			prec_3d[window] = Precision_list
+
+			width = TF_list[1:, 1] - TF_list[:-1, 1]
+			height = (TF_list[1:, 0] + TF_list[:-1, 0]) / 2
+			AUC_range = np.dot(width, height)
+			auc_3d[window] = (AUC_range)
+
+			width_PR = TF_list[1:-1, 0] - TF_list[:-2, 0]
+			height_PR = Precision_list[1:]
+
+			AP_range = np.dot(width_PR, height_PR)
+			ap_3d[window] = AP_range
+
+		return tpr_3d, fpr_3d, prec_3d, window_3d, sum(auc_3d) / len(window_3d), sum(ap_3d) / len(window_3d)
+
+def generate_curve(label,score,slidingWindow, version='opt', thre=250):
+    if version =='opt_mem':
+        tpr_3d, fpr_3d, prec_3d, window_3d, avg_auc_3d, avg_ap_3d = RangeAUC_volume_opt_mem(labels_original=label, score=score, windowSize=slidingWindow, thre=thre)
+    else:
+        tpr_3d, fpr_3d, prec_3d, window_3d, avg_auc_3d, avg_ap_3d = RangeAUC_volume_opt(labels_original=label, score=score, windowSize=slidingWindow, thre=thre)
+        
+    X = np.array(tpr_3d).reshape(1,-1).ravel()
+    X_ap = np.array(tpr_3d)[:,:-1].reshape(1,-1).ravel()
+    Y = np.array(fpr_3d).reshape(1,-1).ravel()
+    W = np.array(prec_3d).reshape(1,-1).ravel()
+    Z = np.repeat(window_3d, len(tpr_3d[0]))
+    Z_ap = np.repeat(window_3d, len(tpr_3d[0])-1)
+    
+    return Y, Z, X, X_ap, W, Z_ap,avg_auc_3d, avg_ap_3d

tsadmetrics/binary_metrics.py

@@ -3,8 +3,8 @@ from .metric_utils import *
 from .metric_utils import get_events, calculate_intersection
 
 
-from _tsadeval.metrics import *
-from _tsadeval.prts.basic_metrics_ts import ts_fscore
+from ._tsadeval.metrics import *
+from ._tsadeval.prts.basic_metrics_ts import ts_fscore
 from pate.PATE_metric import PATE
 def point_wise_recall(y_true: np.array, y_pred: np.array):
     """

tsadmetrics/metric_utils.py

@@ -1,5 +1,5 @@
 import numpy as np
-from _tsadeval.metrics import Binary_anomalies, pointwise_to_full_series, segmentwise_to_full_series, DelayThresholdedPointAdjust
+from ._tsadeval.metrics import Binary_anomalies, pointwise_to_full_series, segmentwise_to_full_series, DelayThresholdedPointAdjust
 def get_tp_tn_fp_fn_point_wise(y_true: np.array,y_pred: np.array):
     TP,TN,FP,FN=0,0,0,0
     for true,pred in zip(y_true,y_pred):

tsadmetrics/non_binary_metrics.py

@@ -1,5 +1,5 @@
 import numpy as np
-from _tsadeval.metrics import *
+from ._tsadeval.metrics import *
 from .metric_utils import transform_to_full_series
 from sklearn.metrics import auc
 from .binary_metrics import point_adjusted_precision, point_adjusted_recall, segment_wise_precision, segment_wise_recall

tsadmetrics-0.1.3.dist-info/METADATA

@@ -0,0 +1,23 @@
+Metadata-Version: 2.1
+Name: tsadmetrics
+Version: 0.1.3
+Summary: Librería para evaluación de detección de anomalías en series temporales
+Home-page: https://github.com/pathsko/TSADmetrics
+Author: Pedro Rafael Velasco Priego
+Author-email: Pedro Rafael Velasco Priego <i12veprp@uco.es>
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: joblib==1.4.2
+Requires-Dist: numpy==1.24.4
+Requires-Dist: pandas==2.0.3
+Requires-Dist: PATE==0.1.1
+Requires-Dist: patsy==0.5.6
+Requires-Dist: python-dateutil==2.9.0.post0
+Requires-Dist: pytz==2024.1
+Requires-Dist: scikit-learn==1.3.2
+Requires-Dist: scipy==1.10.1
+Requires-Dist: six==1.16.0
+Requires-Dist: statsmodels==0.14.1
+Requires-Dist: threadpoolctl==3.5.0
+Requires-Dist: tzdata==2024.1
+

tsadmetrics-0.1.3.dist-info/RECORD

@@ -0,0 +1,20 @@
+tsadmetrics/__init__.py,sha256=MTWOa43fgOdkMNo5NglCReRnB8hoF0ob2PIvDziCNHw,1575
+tsadmetrics/binary_metrics.py,sha256=nwfPdfHAc_4tJMNlyIwMwFQRLvCU-ik9lQLqlaWLqTs,37741
+tsadmetrics/metric_utils.py,sha256=Y_lOE01_uyC22wnw3_G-kKUEJdqevDIWMWvSDE8Cjms,10477
+tsadmetrics/non_binary_metrics.py,sha256=JIOvkigSjHBZLKbGJj7ESe0lPM7P1JPoIUnbiMZuuLg,2896
+tsadmetrics/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tsadmetrics/utils.py,sha256=G0yWxgTZ9MBzyB0XDLrO2TMwmtm4hssDp5Sr0CG9FqY,1834
+tsadmetrics/_tsadeval/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tsadmetrics/_tsadeval/auc_roc_pr_plot.py,sha256=PHqJUXq2qI248XV9o04D8SsUJgowetaKq0Cu5bYrIAE,12689
+tsadmetrics/_tsadeval/discontinuity_graph.py,sha256=Ci65l_DPi6HTtb8NvQJe1najgGrRuEpOMWvSyi2AeR0,4088
+tsadmetrics/_tsadeval/latency_sparsity_aware.py,sha256=92wt6ARSXL5Y-281joNaSu1E7hnkIbl3m6gyzODTYBE,12092
+tsadmetrics/_tsadeval/metrics.py,sha256=d-1VpJu_mp8gZjW2FeD7eqkFKEkGsYcsy6DcSGK4kSk,24100
+tsadmetrics/_tsadeval/nabscore.py,sha256=8H4cgzzjXrbQzpI-YKEJj31eSGSROrT7NNC86n9d2yY,11696
+tsadmetrics/_tsadeval/tests.py,sha256=KjFPlEHWYkxHXtaEs1_WiTgATEtr7kPKQbgsljSxJ8o,12697
+tsadmetrics/_tsadeval/threshold_plt.py,sha256=ExgxIcsDMmgLNveNug5fimEhEe6Km0g68npQj-7oWOE,726
+tsadmetrics/_tsadeval/time_tolerant.py,sha256=duq3B58ohjS6QkWdNUuCQFt2xmCJ0dMWTVzOr6E3H0A,1486
+tsadmetrics/_tsadeval/vus_utils.py,sha256=XL5tV9hxBW8aGkobT84cp2FdHNuNZ3PUgaplwHsDjNk,7868
+tsadmetrics-0.1.3.dist-info/METADATA,sha256=OhHUxt6YdnWC49fL3j-UP-HjfGrNudEJwwrA1Mju07s,756
+tsadmetrics-0.1.3.dist-info/WHEEL,sha256=iAkIy5fosb7FzIOwONchHf19Qu7_1wCWyFNR5gu9nU0,91
+tsadmetrics-0.1.3.dist-info/top_level.txt,sha256=rRMFvkwJRUuenl0__YY_3BNr-rkdhAdj28iICkpC5a4,12
+tsadmetrics-0.1.3.dist-info/RECORD,,

tsadmetrics/ts_aware_utils.py

@@ -1,2 +0,0 @@
-from .utils import get_events
-

tsadmetrics-0.1.1.dist-info/METADATA

@@ -1,10 +0,0 @@
-Metadata-Version: 2.1
-Name: tsadmetrics
-Version: 0.1.1
-Summary: Librería para evaluación de detección de anomalías en series temporales
-Home-page: https://github.com/pathsko/TSADmetrics
-Author: Pedro Rafael Velasco Priego
-Author-email: Pedro Rafael Velasco Priego <i12veprp@uco.es>
-Requires-Python: >=3.6
-Description-Content-Type: text/markdown
-

tsadmetrics-0.1.1.dist-info/RECORD

@@ -1,11 +0,0 @@
-tsadmetrics/__init__.py,sha256=z6NknOSgSmwBxsWO6FcxA3yWSVHsCGyqi_f_XaCfDqc,1682
-tsadmetrics/binary_metrics.py,sha256=6yp4Dqg0_M_bJvyoWVgjAr4rLnGIDzHd7CzCRKqJVso,37739
-tsadmetrics/metric_utils.py,sha256=HtcgQ3sqnfoOQ-QnDctNiaRGDXRuFvGzMGhoS2HWYIg,10476
-tsadmetrics/non_binary_metrics.py,sha256=2F_qsV7wf-IMAB158uA9U0DC5l2apTAyK6XPN2roI7k,2895
-tsadmetrics/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-tsadmetrics/ts_aware_utils.py,sha256=RbgSAVLWeMtA0ZrvBw-_lT0b0ygFn9a1TxSW5cQAwmg,31
-tsadmetrics/utils.py,sha256=G0yWxgTZ9MBzyB0XDLrO2TMwmtm4hssDp5Sr0CG9FqY,1834
-tsadmetrics-0.1.1.dist-info/METADATA,sha256=FA9RKtLnaQgRv9EQ4hRuS2yRU4vfkWxA0wL5rw6Z0a0,350
-tsadmetrics-0.1.1.dist-info/WHEEL,sha256=iAkIy5fosb7FzIOwONchHf19Qu7_1wCWyFNR5gu9nU0,91
-tsadmetrics-0.1.1.dist-info/top_level.txt,sha256=rRMFvkwJRUuenl0__YY_3BNr-rkdhAdj28iICkpC5a4,12
-tsadmetrics-0.1.1.dist-info/RECORD,,