tsadmetrics 0.1.4__py3-none-any.whl → 0.1.5__py3-none-any.whl

entorno/bin/activate_this.py

@@ -0,0 +1,32 @@
+# -*- coding: utf-8 -*-
+"""Activate virtualenv for current interpreter:
+
+Use exec(open(this_file).read(), {'__file__': this_file}).
+
+This can be used when you must use an existing Python interpreter, not the virtualenv bin/python.
+"""
+import os
+import site
+import sys
+
+try:
+    abs_file = os.path.abspath(__file__)
+except NameError:
+    raise AssertionError("You must use exec(open(this_file).read(), {'__file__': this_file}))")
+
+bin_dir = os.path.dirname(abs_file)
+base = bin_dir[: -len("bin") - 1]  # strip away the bin part from the __file__, plus the path separator
+
+# prepend bin to PATH (this file is inside the bin directory)
+os.environ["PATH"] = os.pathsep.join([bin_dir] + os.environ.get("PATH", "").split(os.pathsep))
+os.environ["VIRTUAL_ENV"] = base  # virtual env is right above bin directory
+
+# add the virtual environments libraries to the host python import mechanism
+prev_length = len(sys.path)
+for lib in "../lib/python3.8/site-packages".split(os.pathsep):
+    path = os.path.realpath(os.path.join(bin_dir, lib))
+    site.addsitedir(path.decode("utf-8") if "" else path)
+sys.path[:] = sys.path[prev_length:] + sys.path[0:prev_length]
+
+sys.real_prefix = sys.prefix
+sys.prefix = base

entorno/bin/rst2html.py

@@ -0,0 +1,23 @@
+#!/home/linux/Documentos/TSADmetrics/entorno/bin/python
+
+# $Id: rst2html.py 9115 2022-07-28 17:06:24Z milde $
+# Author: David Goodger <goodger@python.org>
+# Copyright: This module has been placed in the public domain.
+
+"""
+A minimal front end to the Docutils Publisher, producing HTML.
+"""
+
+try:
+    import locale
+    locale.setlocale(locale.LC_ALL, '')
+except Exception:
+    pass
+
+from docutils.core import publish_cmdline, default_description
+
+
+description = ('Generates (X)HTML documents from standalone reStructuredText '
+               'sources.  ' + default_description)
+
+publish_cmdline(writer_name='html', description=description)

entorno/bin/rst2html4.py

@@ -0,0 +1,26 @@
+#!/home/linux/Documentos/TSADmetrics/entorno/bin/python
+
+# $Id: rst2html4.py 9115 2022-07-28 17:06:24Z milde $
+# Author: David Goodger <goodger@python.org>
+# Copyright: This module has been placed in the public domain.
+
+"""
+A minimal front end to the Docutils Publisher, producing (X)HTML.
+
+The output conforms to XHTML 1.0 transitional
+and almost to HTML 4.01 transitional (except for closing empty tags).
+"""
+
+try:
+    import locale
+    locale.setlocale(locale.LC_ALL, '')
+except Exception:
+    pass
+
+from docutils.core import publish_cmdline, default_description
+
+
+description = ('Generates (X)HTML documents from standalone reStructuredText '
+               'sources.  ' + default_description)
+
+publish_cmdline(writer_name='html4', description=description)

entorno/bin/rst2html5.py

@@ -0,0 +1,33 @@
+#!/home/linux/Documentos/TSADmetrics/entorno/bin/python
+# :Copyright: © 2015 Günter Milde.
+# :License: Released under the terms of the `2-Clause BSD license`_, in short:
+#
+#    Copying and distribution of this file, with or without modification,
+#    are permitted in any medium without royalty provided the copyright
+#    notice and this notice are preserved.
+#    This file is offered as-is, without any warranty.
+#
+# .. _2-Clause BSD license: https://opensource.org/licenses/BSD-2-Clause
+#
+# Revision: $Revision: 9021 $
+# Date: $Date: 2022-03-04 16:54:22 +0100 (Fr, 04. Mär 2022) $
+
+"""
+A minimal front end to the Docutils Publisher, producing HTML 5 documents.
+
+The output is also valid XML.
+"""
+
+try:
+    import locale  # module missing in Jython
+    locale.setlocale(locale.LC_ALL, '')
+except locale.Error:
+    pass
+
+from docutils.core import publish_cmdline, default_description
+
+description = ('Generates HTML5 documents from standalone '
+               'reStructuredText sources.\n'
+               + default_description)
+
+publish_cmdline(writer_name='html5', description=description)

entorno/bin/rst2latex.py

@@ -0,0 +1,26 @@
+#!/home/linux/Documentos/TSADmetrics/entorno/bin/python
+
+# $Id: rst2latex.py 9115 2022-07-28 17:06:24Z milde $
+# Author: David Goodger <goodger@python.org>
+# Copyright: This module has been placed in the public domain.
+
+"""
+A minimal front end to the Docutils Publisher, producing LaTeX.
+"""
+
+try:
+    import locale
+    locale.setlocale(locale.LC_ALL, '')
+except Exception:
+    pass
+
+from docutils.core import publish_cmdline
+
+description = ('Generates LaTeX documents from standalone reStructuredText '
+               'sources. '
+               'Reads from <source> (default is stdin) and writes to '
+               '<destination> (default is stdout).  See '
+               '<https://docutils.sourceforge.io/docs/user/latex.html> for '
+               'the full reference.')
+
+publish_cmdline(writer_name='latex', description=description)

entorno/bin/rst2man.py

@@ -0,0 +1,27 @@
+#!/home/linux/Documentos/TSADmetrics/entorno/bin/python
+
+# Author:
+# Contact: grubert@users.sf.net
+# Copyright: This module has been placed in the public domain.
+
+"""
+man.py
+======
+
+This module provides a simple command line interface that uses the
+man page writer to output from ReStructuredText source.
+"""
+
+import locale
+try:
+    locale.setlocale(locale.LC_ALL, '')
+except Exception:
+    pass
+
+from docutils.core import publish_cmdline, default_description
+from docutils.writers import manpage
+
+description = ("Generates plain unix manual documents.  "
+               + default_description)
+
+publish_cmdline(writer=manpage.Writer(), description=description)

entorno/bin/rst2odt.py

@@ -0,0 +1,28 @@
+#!/home/linux/Documentos/TSADmetrics/entorno/bin/python
+
+# $Id: rst2odt.py 9115 2022-07-28 17:06:24Z milde $
+# Author: Dave Kuhlman <dkuhlman@rexx.com>
+# Copyright: This module has been placed in the public domain.
+
+"""
+A front end to the Docutils Publisher, producing OpenOffice documents.
+"""
+
+try:
+    import locale
+    locale.setlocale(locale.LC_ALL, '')
+except Exception:
+    pass
+
+from docutils.core import publish_cmdline_to_binary, default_description
+from docutils.writers.odf_odt import Writer, Reader
+
+
+description = ('Generates OpenDocument/OpenOffice/ODF documents from '
+               'standalone reStructuredText sources.  ' + default_description)
+
+
+writer = Writer()
+reader = Reader()
+output = publish_cmdline_to_binary(reader=reader, writer=writer,
+                                   description=description)

entorno/bin/rst2odt_prepstyles.py

@@ -0,0 +1,20 @@
+#!/home/linux/Documentos/TSADmetrics/entorno/bin/python
+
+# Copyright: This module has been placed in the public domain.
+
+"""
+Adapt a word-processor-generated styles.odt for odtwriter use:
+
+Drop page size specifications from styles.xml in STYLE_FILE.odt.
+See https://docutils.sourceforge.io/docs/user/odt.html#page-size
+
+Provisional backwards compatibility stub (to be removed in Docutils >= 0.21).
+
+The actual code moved to the "docutils" library package and can be started
+with ``python -m docutils.writers.odf_odt.prepstyles``.
+"""
+
+from docutils.writers.odf_odt import prepstyles
+
+if __name__ == '__main__':
+    prepstyles.main()

entorno/bin/rst2pseudoxml.py

@@ -0,0 +1,23 @@
+#!/home/linux/Documentos/TSADmetrics/entorno/bin/python
+
+# $Id: rst2pseudoxml.py 9115 2022-07-28 17:06:24Z milde $
+# Author: David Goodger <goodger@python.org>
+# Copyright: This module has been placed in the public domain.
+
+"""
+A minimal front end to the Docutils Publisher, producing pseudo-XML.
+"""
+
+try:
+    import locale
+    locale.setlocale(locale.LC_ALL, '')
+except Exception:
+    pass
+
+from docutils.core import publish_cmdline, default_description
+
+
+description = ('Generates pseudo-XML from standalone reStructuredText '
+               'sources (for testing purposes).  ' + default_description)
+
+publish_cmdline(description=description)

entorno/bin/rst2s5.py

@@ -0,0 +1,24 @@
+#!/home/linux/Documentos/TSADmetrics/entorno/bin/python
+
+# $Id: rst2s5.py 9115 2022-07-28 17:06:24Z milde $
+# Author: Chris Liechti <cliechti@gmx.net>
+# Copyright: This module has been placed in the public domain.
+
+"""
+A minimal front end to the Docutils Publisher, producing HTML slides using
+the S5 template system.
+"""
+
+try:
+    import locale
+    locale.setlocale(locale.LC_ALL, '')
+except Exception:
+    pass
+
+from docutils.core import publish_cmdline, default_description
+
+
+description = ('Generates S5 (X)HTML slideshow documents from standalone '
+               'reStructuredText sources.  ' + default_description)
+
+publish_cmdline(writer_name='s5', description=description)

entorno/bin/rst2xetex.py

@@ -0,0 +1,27 @@
+#!/home/linux/Documentos/TSADmetrics/entorno/bin/python
+
+# $Id: rst2xetex.py 9115 2022-07-28 17:06:24Z milde $
+# Author: Guenter Milde
+# Copyright: This module has been placed in the public domain.
+
+"""
+A minimal front end to the Docutils Publisher, producing Lua/XeLaTeX code.
+"""
+
+try:
+    import locale
+    locale.setlocale(locale.LC_ALL, '')
+except Exception:
+    pass
+
+from docutils.core import publish_cmdline
+
+description = ('Generates LaTeX documents from standalone reStructuredText '
+               'sources for compilation with the Unicode-aware TeX variants '
+               'XeLaTeX or LuaLaTeX. '
+               'Reads from <source> (default is stdin) and writes to '
+               '<destination> (default is stdout).  See '
+               '<https://docutils.sourceforge.io/docs/user/latex.html> for '
+               'the full reference.')
+
+publish_cmdline(writer_name='xetex', description=description)

entorno/bin/rst2xml.py

@@ -0,0 +1,23 @@
+#!/home/linux/Documentos/TSADmetrics/entorno/bin/python
+
+# $Id: rst2xml.py 9115 2022-07-28 17:06:24Z milde $
+# Author: David Goodger <goodger@python.org>
+# Copyright: This module has been placed in the public domain.
+
+"""
+A minimal front end to the Docutils Publisher, producing Docutils XML.
+"""
+
+try:
+    import locale
+    locale.setlocale(locale.LC_ALL, '')
+except Exception:
+    pass
+
+from docutils.core import publish_cmdline, default_description
+
+
+description = ('Generates Docutils-native XML from standalone '
+               'reStructuredText sources.  ' + default_description)
+
+publish_cmdline(writer_name='xml', description=description)

entorno/bin/rstpep2html.py

@@ -0,0 +1,25 @@
+#!/home/linux/Documentos/TSADmetrics/entorno/bin/python
+
+# $Id: rstpep2html.py 9115 2022-07-28 17:06:24Z milde $
+# Author: David Goodger <goodger@python.org>
+# Copyright: This module has been placed in the public domain.
+
+"""
+A minimal front end to the Docutils Publisher, producing HTML from PEP
+(Python Enhancement Proposal) documents.
+"""
+
+try:
+    import locale
+    locale.setlocale(locale.LC_ALL, '')
+except Exception:
+    pass
+
+from docutils.core import publish_cmdline, default_description
+
+
+description = ('Generates (X)HTML from reStructuredText-format PEP files.  '
+               + default_description)
+
+publish_cmdline(reader_name='pep', writer_name='pep_html',
+                description=description)

experiments/scripts/compute_metrics.py

@@ -0,0 +1,187 @@
+import pandas as pd
+import numpy as np
+import time
+import os
+from tsadmetrics import *
+
+def cargar_prediccion(modelo_nombre):
+    """
+    Carga las predicciones guardadas previamente.
+    """
+    nombre_archivo = f'../results/predictions/{modelo_nombre}_pred.csv'
+    resultados = pd.read_csv(nombre_archivo)
+    
+    y_true = resultados['ground_truth'].values
+    y_pred_binary = resultados['prediction_binary'].values
+    y_pred_continuous = resultados['prediction_continuous'].values
+    return y_true, y_pred_binary, y_pred_continuous
+
+# Lista de modelos y métricas
+nombre_modelos = ['CBLOF', 'IForest', 'KNN', 'LOF','AE1SVM','AutoEncoder','LSTM']
+metrics = [
+    ('point_wise_f_score', point_wise_f_score),
+    ('point_adjusted_f_score', point_adjusted_f_score),
+    ('delay_th_point_adjusted_f_score', delay_th_point_adjusted_f_score),
+    ('point_adjusted_at_k_f_score', point_adjusted_at_k_f_score),
+    ('latency_sparsity_aw_f_score', latency_sparsity_aw_f_score),
+    ('segment_wise_f_score', segment_wise_f_score),
+    ('composite_f_score', composite_f_score),
+    ('time_tolerant_f_score', time_tolerant_f_score),
+    ('range_based_f_score',range_based_f_score),
+    ('ts_aware_f_score',ts_aware_f_score),
+    ('enhanced_ts_aware_f_score', enhanced_ts_aware_f_score),
+    ('affiliation_based_f_score', affiliation_based_f_score),
+    ('nab_score', nab_score),
+    ('temporal_distance', temporal_distance),
+    ('average_detection_count', average_detection_count),
+    ('absolute_detection_distance',absolute_detection_distance),
+    ('total_detected_in_range',total_detected_in_range),
+    ('detection_accuracy_in_range',detection_accuracy_in_range),
+    ('weighted_detection_difference',weighted_detection_difference),
+    ('binary_pate', binary_pate),
+    ('mean_time_to_detect', mean_time_to_detect),
+]
+
+metrics_params = {
+    'delay_th_point_adjusted_f_score': {'k': 10},
+    'point_adjusted_at_k_f_score': {'k': 0.7},
+    'latency_sparsity_aw_f_score': {'ni': 2},
+    'time_tolerant_f_score': {'t': 30},
+    'range_based_f_score': {'p_alpha': 0, 'r_alpha':0},
+    'ts_aware_f_score': {'theta': 0.5, 'alpha':0.5, 'delta': 0, 'beta':1},
+    'enhanced_ts_aware_f_score': {'beta':1,'theta_p': 0.5, 'theta_r':0.1},
+    'total_detected_in_range': {'k': 30},
+    'detection_accuracy_in_range': {'k': 30},
+    'weighted_detection_difference':{'k': 30},
+    'binary_pate': {'early': 20, 'delay': 20}
+}
+
+# Crear directorio si no existe
+os.makedirs('../results/computed_metrics', exist_ok=True)
+
+# Rutas de los archivos
+results_path = '../results/computed_metrics/resultados.csv'
+times_path = '../results/computed_metrics/tiempos.csv'
+
+# Intentar cargar resultados existentes o crear nuevos DataFrames
+try:
+    all_results_df = pd.read_csv(results_path)
+    all_times_df = pd.read_csv(times_path)
+    print("Cargados resultados previos encontrados.")
+except:
+    all_results_df = pd.DataFrame(columns=['modelo'] + [m[0] for m in metrics])
+    all_times_df = pd.DataFrame(columns=['modelo', 'metrica', 'tiempo'])
+    print("No se encontraron resultados previos, comenzando desde cero.")
+
+# Función para guardar el progreso
+def guardar_progreso():
+    all_results_df.to_csv(results_path, index=False)
+    all_times_df.to_csv(times_path, index=False)
+    print(f"\nProgreso guardado a las {time.strftime('%H:%M:%S')}")
+
+# Tiempo de inicio y última vez que se guardó
+start_time = time.time()
+last_save_time = start_time
+
+# Bucle principal de cálculo
+for modelo in nombre_modelos:
+    # Verificar si el modelo ya está completo en los resultados
+    if modelo in all_results_df['modelo'].values:
+        print(f"\nModelo {modelo} ya calculado, saltando...")
+        continue
+    
+    print(f"\nComenzando cálculo para modelo: {modelo}")
+    
+    try:
+        # Cargar predicciones
+        y_true, y_pred, _ = cargar_prediccion(modelo)
+        
+        # Diccionario para almacenar resultados del modelo actual
+        model_results = {'modelo': modelo}
+        model_times = []
+        
+        for metric_name, metric_func in metrics:
+            # Verificar si esta métrica ya está calculada para este modelo
+            if not all_results_df.empty and modelo in all_results_df['modelo'].values:
+                existing_row = all_results_df[all_results_df['modelo'] == modelo].iloc[0]
+                if not pd.isna(existing_row[metric_name]):
+                    print(f"Métrica {metric_name} ya calculada para {modelo}, saltando...")
+                    continue
+            
+            print(f"Calculando métrica: {metric_name}, modelo: {modelo}...")
+            
+            try:
+                # Calcular métrica y tiempo de ejecución
+                start_metric_time = time.time()
+                
+                if metric_name in metrics_params:
+                    params = metrics_params[metric_name]
+                    metric_value = metric_func(y_true, y_pred, **params)
+                else:
+                    metric_value = metric_func(y_true, y_pred)
+                
+                computation_time = time.time() - start_metric_time
+                
+                # Actualizar resultados
+                model_results[metric_name] = metric_value
+                model_times.append({
+                    'modelo': modelo,
+                    'metrica': metric_name,
+                    'tiempo': computation_time
+                })
+                
+                print(f"Valor: {metric_value:.4f}, tiempo: {computation_time:.4f}s")
+                
+                # Guardar progreso cada hora
+                current_time = time.time()
+                if current_time - last_save_time > 3600:  # 3600 segundos = 1 hora
+                    # Añadir resultados parciales
+                    if modelo not in all_results_df['modelo'].values:
+                        all_results_df = pd.concat([all_results_df, pd.DataFrame([model_results])], ignore_index=True)
+                    else:
+                        idx = all_results_df.index[all_results_df['modelo'] == modelo][0]
+                        all_results_df.loc[idx, metric_name] = metric_value
+                    
+                    all_times_df = pd.concat([all_times_df, pd.DataFrame(model_times)], ignore_index=True)
+                    model_times = []  # Resetear tiempos para no duplicar
+                    
+                    guardar_progreso()
+                    last_save_time = current_time
+                
+            except Exception as e:
+                print(f"Error calculando {metric_name} para {modelo}: {str(e)}")
+                model_results[metric_name] = np.nan
+                model_times.append({
+                    'modelo': modelo,
+                    'metrica': metric_name,
+                    'tiempo': np.nan
+                })
+        
+        # Añadir resultados completos del modelo a los DataFrames principales
+        if modelo not in all_results_df['modelo'].values:
+            all_results_df = pd.concat([all_results_df, pd.DataFrame([model_results])], ignore_index=True)
+        else:
+            # Actualizar fila existente
+            idx = all_results_df.index[all_results_df['modelo'] == modelo][0]
+            for metric_name in model_results:
+                if metric_name != 'modelo':
+                    all_results_df.loc[idx, metric_name] = model_results[metric_name]
+        
+        all_times_df = pd.concat([all_times_df, pd.DataFrame(model_times)], ignore_index=True)
+        
+        # Guardar después de completar cada modelo
+        guardar_progreso()
+        last_save_time = time.time()
+    
+    except Exception as e:
+        print(f"Error procesando modelo {modelo}: {str(e)}")
+        # Añadir filas con NaN para este modelo
+        model_results = {'modelo': modelo}
+        for m in metrics:
+            model_results[m[0]] = np.nan
+        all_results_df = pd.concat([all_results_df, pd.DataFrame([model_results])], ignore_index=True)
+        guardar_progreso()
+
+# Guardar resultados finales
+guardar_progreso()
+print("\nProceso completado. Resultados finales guardados.")

experiments/scripts/metrics_complexity_analysis.py

@@ -0,0 +1,109 @@
+import pandas as pd
+import numpy as np
+import time
+import os
+from tsadmetrics import *
+
+# Lista de modelos y métricas
+binary_metrics = [
+    ('point_wise_f_score', point_wise_f_score),
+    ('point_adjusted_f_score', point_adjusted_f_score),
+    ('delay_th_point_adjusted_f_score', delay_th_point_adjusted_f_score),
+    ('point_adjusted_at_k_f_score', point_adjusted_at_k_f_score),
+    ('latency_sparsity_aw_f_score', latency_sparsity_aw_f_score),
+    ('segment_wise_f_score', segment_wise_f_score),
+    ('composite_f_score', composite_f_score),
+    ('time_tolerant_f_score', time_tolerant_f_score),
+    ('range_based_f_score',range_based_f_score),
+    ('ts_aware_f_score',ts_aware_f_score),
+    ('enhanced_ts_aware_f_score', enhanced_ts_aware_f_score),
+    ('affiliation_based_f_score', affiliation_based_f_score),
+    ('nab_score', nab_score),
+    ('temporal_distance', temporal_distance),
+    ('average_detection_count', average_detection_count),
+    ('absolute_detection_distance',absolute_detection_distance),
+    ('total_detected_in_range',total_detected_in_range),
+    ('detection_accuracy_in_range',detection_accuracy_in_range),
+    ('weighted_detection_difference',weighted_detection_difference),
+    ('binary_pate', binary_pate),
+    ('mean_time_to_detect', mean_time_to_detect),
+
+]
+binary_metrics_params ={
+    'delay_th_point_adjusted_f_score': {'k': 10},
+    'point_adjusted_at_k_f_score': {'k': 0.7},
+    'latency_sparsity_aw_f_score': {'ni': 2},
+    'time_tolerant_f_score': {'t': 30},
+    'range_based_f_score': {'p_alpha': 0, 'r_alpha':0}, #Valor por defecto
+    'ts_aware_f_score': {'theta': 0.5, 'alpha':0.5, 'delta': 0, 'beta':1}, #Valor por defecto
+    'enhanced_ts_aware_f_score': {'beta':1,'theta_p': 0.5, 'theta_r':0.1}, #Valor por defecto
+    'total_detected_in_range': {'k': 30},
+    'detection_accuracy_in_range': {'k': 30},
+    'weighted_detection_difference':{'k': 3},
+    'binary_pate': {'early': 20, 'delay': 20}
+
+}
+
+continuous_metrics = [
+    ('precision_at_k', precision_at_k),
+    ('auc_roc_pw', auc_roc_pw),
+    ('auc_pr_pw', auc_pr_pw),
+    ('auc_pr_pa', auc_pr_pa),
+    ('auc_pr_sw', auc_pr_sw),
+    ('vus_roc', vus_roc),
+    ('vus_pr', vus_pr),
+    ('real_pate', real_pate)]
+
+continuous_metrics_params ={
+    'vus_roc': {'window': 4},
+    'vus_pr': {'window': 4},
+    'real_pate': {'early': 3, 'delay': 3},
+
+}
+SIZE = 1000
+# Cargar predicciones
+y_true, y_pred = np.random.choice([0, 1], size=SIZE), np.random.choice([0, 1], size=SIZE)
+
+Binary_mode = 1
+
+if Binary_mode == 0:
+    for metric_name, metric_func in binary_metrics:
+        
+            # Calcular métrica y tiempo de ejecución
+            
+
+            start_time = time.time()
+            if metric_name in binary_metrics_params:
+                params = binary_metrics_params[metric_name]
+                metric_value = metric_func(y_true, y_pred, **params)
+            else:
+                metric_value = metric_func(y_true, y_pred)
+            computation_time = time.time() - start_time
+            
+
+            
+            print(f"Métrica: {metric_name} - Valor: {metric_value:.4f} - Tiempo: {computation_time:.4f}s")
+                
+else:                
+    y_true = np.random.choice([0, 1], size=SIZE)
+    y_pred = np.random.rand(SIZE)  # Predicciones continuas
+        
+            # Calcular métrica y tiempo de ejecución
+            
+    for metric_name, metric_func in continuous_metrics:
+
+        start_time = time.time()
+        if metric_name in continuous_metrics_params:
+            params = continuous_metrics_params[metric_name]
+            metric_value = metric_func(y_true, y_pred, **params)
+        else:
+            metric_value = metric_func(y_true, y_pred)
+        computation_time = time.time() - start_time
+        
+
+        
+        print(f"Métrica: {metric_name} - Valor: {metric_value:.4f} - Tiempo: {computation_time:.4f}s")
+                
+                
+            
+