mtsa 0.0.0__tar.gz

mtsa-0.0.0/PKG-INFO

@@ -0,0 +1,78 @@
+Metadata-Version: 2.4
+Name: mtsa
+Version: 0.0.0
+Summary: Multiple Time Series Analysis
+Home-page: https://github.com/diegompin/mtsa
+Author: Diego Pinheiro
+Author-email: diegompin@gmail.com
+License: BSD 3-Clause License
+Keywords: mtsa,setuptools
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Programming Language :: Python :: 3
+Description-Content-Type: text/markdown
+Requires-Dist: pandas==2.2.2
+Requires-Dist: pytest==7.2.0
+Requires-Dist: numpy==1.24.4
+Requires-Dist: matplotlib==3.8.0
+Requires-Dist: scipy==1.11.2
+Requires-Dist: ipykernel==5.5.6
+Requires-Dist: librosa==0.9.2
+Requires-Dist: tensorflow==2.17.0
+Requires-Dist: spectrum==0.6.8
+Requires-Dist: torch==2.5.1
+
+<p align="center">
+<img width="805" height="310" alt="image" src="https://github.com/user-attachments/assets/6f0ff77f-c83e-45eb-bdf6-b6f2fcbd31ed" />
+</p>
+
+MTSA is a research toolkit designed to aggregate machine learning models for anomaly detection, with a strong focus on enhancing reproducibility and explainability in model implementation. It offers a structured environment for developing, testing, and comparing various anomaly detection approaches, prioritizing replicability and ease of use. The toolkit is continuously updated to include both classical and state-of-the-art algorithms for anomaly detection in multivariate time series.
+
+## 🔧 Installation
+
+To get started, clone the repository and install the required dependencies:
+
+```bash
+git clone https://github.com/your-username/MTSA.git
+cd MTSA
+pip install -r requirements.txt
+```
+
+## 🚀 Usage
+
+MTSA allows you to run anomaly detection models on acoustic data collected from complex systems like industrial machines.
+
+A complete example is available in the following Jupyter notebook:  
+👉 [examples/MTSA.ipynb](examples/MTSA.ipynb)
+
+> **Note:** If you encounter issues while running on Google Colab, try upgrading the Colab package:
+
+```bash
+pip install --upgrade google-colab
+```
+
+## 🧠 Implemented Machine Learning Approaches
+
+MTSA currently integrates the following anomaly detection models:
+
+- **Hitachi**  
+  A robust autoencoder model specifically designed for industrial anomaly detection tasks.
+
+- **RANSynCoders**  
+  Ensemble of autoencoders with FFT, leveraging bootstrapping to perform robust anomaly inference.
+  
+- **GANF**  
+  A model that combines graph structures, recurrent neural networks (RNNs), and normalizing flows to perform anomaly inference.
+
+- **Isolation Forest**  
+  A tree-based ensemble method that isolates anomalies.
+
+- **OSVM (One-Class SVM)**  
+  A support vector-based approach for detecting outliers by modeling the distribution of normal data.
+
+And more!
+
+
+## 🌐 Learn More
+
+For full documentation, examples, and additional resources, visit our [official website](https://iotdataatelier.github.io/mtsa-docs/).
+

mtsa-0.0.0/README.md

@@ -0,0 +1,55 @@
+<p align="center">
+<img width="805" height="310" alt="image" src="https://github.com/user-attachments/assets/6f0ff77f-c83e-45eb-bdf6-b6f2fcbd31ed" />
+</p>
+
+MTSA is a research toolkit designed to aggregate machine learning models for anomaly detection, with a strong focus on enhancing reproducibility and explainability in model implementation. It offers a structured environment for developing, testing, and comparing various anomaly detection approaches, prioritizing replicability and ease of use. The toolkit is continuously updated to include both classical and state-of-the-art algorithms for anomaly detection in multivariate time series.
+
+## 🔧 Installation
+
+To get started, clone the repository and install the required dependencies:
+
+```bash
+git clone https://github.com/your-username/MTSA.git
+cd MTSA
+pip install -r requirements.txt
+```
+
+## 🚀 Usage
+
+MTSA allows you to run anomaly detection models on acoustic data collected from complex systems like industrial machines.
+
+A complete example is available in the following Jupyter notebook:  
+👉 [examples/MTSA.ipynb](examples/MTSA.ipynb)
+
+> **Note:** If you encounter issues while running on Google Colab, try upgrading the Colab package:
+
+```bash
+pip install --upgrade google-colab
+```
+
+## 🧠 Implemented Machine Learning Approaches
+
+MTSA currently integrates the following anomaly detection models:
+
+- **Hitachi**  
+  A robust autoencoder model specifically designed for industrial anomaly detection tasks.
+
+- **RANSynCoders**  
+  Ensemble of autoencoders with FFT, leveraging bootstrapping to perform robust anomaly inference.
+  
+- **GANF**  
+  A model that combines graph structures, recurrent neural networks (RNNs), and normalizing flows to perform anomaly inference.
+
+- **Isolation Forest**  
+  A tree-based ensemble method that isolates anomalies.
+
+- **OSVM (One-Class SVM)**  
+  A support vector-based approach for detecting outliers by modeling the distribution of normal data.
+
+And more!
+
+
+## 🌐 Learn More
+
+For full documentation, examples, and additional resources, visit our [official website](https://iotdataatelier.github.io/mtsa-docs/).
+

mtsa-0.0.0/mtsa/__init__.py

@@ -0,0 +1,8 @@
+from .models import *
+from .training import *
+from .metrics import *
+from .features import *
+from .model_selection import *
+from .plotters import *
+from .utils import *
+

mtsa-0.0.0/mtsa/common.py

@@ -0,0 +1,43 @@
+import time
+from functools import partial
+from functools import reduce
+from mtsa.experiments import *
+
+def elapsed_time(fun, *args) -> Result:
+    start = time.time()
+    fun_return = fun(*args)
+    end = time.time()
+    time_elapsed = end - start
+    result = Result(time_elapsed, fun_return) 
+    return result
+
+
+def multiple_runs(runs, fun, *args):
+    list_run_ids = range(runs)
+    multiple_results = map(
+        lambda run_id:
+        {
+            'run_id': run_id,
+            "run_details": elapsed_time(fun, *args)
+        },
+        list_run_ids
+        )
+
+    return list(multiple_results)
+
+
+import json
+import functools as ft
+def print(element):
+    #TODO this is ugly but leting keras to be serialized causes circular reference at json.dumps 
+    should_dump = lambda o: any(map(ft.partial(isinstance, o), [t for t in [int, float, str, ParamResult, Result, Params, ModelParam]]))
+    def default(o):
+        if should_dump(o):
+            if hasattr(o, "__dict__"):
+                return o.__dict__
+            else:
+                return str(o)
+        else:
+            return ""
+    json_data = json.dumps(element, indent=4, default=default)
+    return json

mtsa-0.0.0/mtsa/correlation_networks.py

@@ -0,0 +1,39 @@
+import numpy as np
+import abc
+
+class CorrelationNetwork(abc.ABC):
+    """
+    Base class for implementing correlation between mfccs
+    """
+
+    def get_correlation(self, X: np.ndarray):
+        """Implement correlation"""
+
+class PearsonCorrelationNetwork(CorrelationNetwork):
+
+    def get_correlation(self, X : np.ndarray):
+        C = np.corrcoef(X, rowvar=True)
+        return C
+
+class DynamicCorrelationNetwork(CorrelationNetwork):
+
+    def get_correlation(self, X : np.ndarray):
+        """
+        Calculate dynamic correlation <(i - <i>)(j - <j>)>
+        where <x> is the first moment (e.g, expected value)
+        """
+        X = X.T
+        x_min = np.min(X, axis=0)
+        x_max = np.max(X, axis=0)
+        X = (X - x_min) / (x_max - x_min)
+        X = 2*X - 1
+        m = np.mean(X, axis=0)
+        D = X - m
+        return 1/len(D) * D.T.dot(D)
+    
+import scipy.stats as st
+class SpearmanCorrelationNetwork(CorrelationNetwork):
+
+    def get_correlation(self, X : np.ndarray):
+        rho, pval = st.spearmanr(X)
+        return rho

mtsa-0.0.0/mtsa/experiments.py

@@ -0,0 +1,22 @@
+from dataclasses import dataclass
+
+
+@dataclass
+class ModelParam:
+    name: str
+    obj: object
+    
+@dataclass
+class Params:
+    path: str
+    model: ModelParam
+
+@dataclass
+class Result:
+    time_elapsed: float
+    fun_return: object
+
+@dataclass
+class ParamResult:
+    params: Params
+    result: Result

mtsa-0.0.0/mtsa/features/__init__.py

@@ -0,0 +1,7 @@
+from .mel import *
+from .stats import *
+
+ALL = [
+    Array2MelSpec,
+    Array2Mfcc
+]

mtsa-0.0.0/mtsa/features/mel.py

@@ -0,0 +1,96 @@
+"""Base classes for all mfcc estimators."""
+
+import numpy as np
+import sys
+from sklearn.base import BaseEstimator, TransformerMixin
+import scipy.stats as st
+import librosa as lib
+from functools import reduce
+
+class Array2MelSpec(BaseEstimator, TransformerMixin):
+    def __init__(self, 
+                 sampling_rate,
+                 n_fft,
+                 hop_length,
+                 n_mels,
+                 frames,
+                 power
+                 ):
+        self.sampling_rate = sampling_rate
+        self.n_fft = n_fft
+        self.hop_length = hop_length
+        self.n_mels = n_mels
+        self.frames = frames
+        self.power = power
+
+    def fit(self, X, y=None, **fit_params):
+        return self
+
+    def transform(self, X, y=None, **fit_params):
+        
+        def normalize_melspec(mel_spectrogram):
+
+            # 03 convert melspectrogram to log mel energy
+            log_mel_spectrogram = 20.0 / self.power * np.log10(mel_spectrogram + sys.float_info.epsilon)
+
+            # 04 calculate total vector size
+            vectorarray_size = len(log_mel_spectrogram[0, :]) - self.frames + 1
+
+            # 05 skip too short clips
+            if vectorarray_size < 1:
+                return np.empty((0, dims), float)
+
+            # 06 generate feature vectors by concatenating multi_frames
+            dims = self.n_mels * self.frames
+            vectorarray = np.zeros((vectorarray_size, dims), float)
+            for t in range(self.frames):
+                vectorarray[:, self.n_mels * t: self.n_mels * (t + 1)] = log_mel_spectrogram[:, t: t + vectorarray_size].T
+
+            return vectorarray
+            
+        def extract_melspec(y):
+            params = {
+                'y':y, 
+                'n_fft': self.n_fft,
+                'hop_length': self.hop_length,
+                "n_mels": self.n_mels,
+                "power": self.power
+            }
+            if self.sampling_rate:
+                params['sr']=self.sampling_rate
+            
+            mel_spectrogram = lib.feature.melspectrogram(**params)
+            
+            normalized_melspec = normalize_melspec(mel_spectrogram)
+
+            return normalized_melspec
+        Xt = np.array(
+            reduce(
+                lambda n1, n2: np.concatenate([n1,n2]), 
+                map(extract_melspec, X))
+        )
+        return Xt
+    
+    
+class Array2Mfcc(BaseEstimator, TransformerMixin):
+    """
+     Gets a numpy array containing audio signals and transforms it into a numpy array containing mfcc signals
+     
+    """
+    
+    def __init__(self, sampling_rate):
+        self.sampling_rate = sampling_rate
+        #self.n_mfcc = n_mfcc
+
+    def fit(self, X, y=None, **fit_params):
+        return self
+
+    def transform(self, X, y=None, **fit_params):
+        def extract_mfcc(y):
+            if self.sampling_rate: 
+                return lib.feature.mfcc(y=y, sr=self.sampling_rate)
+            else: 
+                return lib.feature.mfcc(y=y)
+        Xt = np.array(list(map(extract_mfcc, X)))
+        return Xt
+