pattern-detector 0.1.0__py3-none-any.whl

pattern_detection/__init__.py

@@ -0,0 +1,3 @@
+from .detector import PatternDetector
+
+__all__ = ["PatternDetector"]

pattern_detection/detector.py

@@ -0,0 +1,152 @@
+import numpy as np
+import pandas as pd
+from scipy.stats import skew, kurtosis
+from joblib import Parallel, delayed
+
+class PatternDetector:
+    def __init__(self, df, pattern, column_pattern):
+        self.df = df.copy()
+        self.pattern = pattern
+        self.column_pattern = column_pattern
+        self.similarity_dict = {}
+        self.pattern1 = None
+        self.window_size = None
+        self.bin_parser = None
+        self.len_iter = None
+        self.pattern_constraints = {}
+
+    def preprocess_pattern(self):
+        """Preprocess the pattern data."""
+        len_iter = 400 if len(self.pattern) >= 400 else 200
+        bin_parser = 3 if len_iter == 400 else 2
+
+        self.pattern['bin'] = self.pattern.index // bin_parser
+        self.pattern1 = self.pattern.groupby('bin')[self.column_pattern].mean().to_numpy()
+        self.len_iter = len_iter
+        self.bin_parser = bin_parser
+        self.window_size = len(self.pattern1)
+
+        # Compute constraints
+        self.pattern_constraints = {
+            "max_pos": np.max(self.pattern1) + 0.1 * np.ptp(self.pattern1),
+            "min_pos": np.min(self.pattern1) - 0.1 * np.ptp(self.pattern1),
+            "mean_pos_upper": np.mean(self.pattern1) + 0.1 * np.ptp(self.pattern1),
+            "mean_pos_lower": np.mean(self.pattern1) - 0.1 * np.ptp(self.pattern1),
+            "pattern_skewness": skew(self.pattern1),
+            "pattern_kurtosis": kurtosis(self.pattern1),
+            "pattern_std": np.std(self.pattern1),
+            "starting_point_lower": self.pattern1[0] - 0.2 * np.ptp(self.pattern1),
+            "starting_point_upper": self.pattern1[0] + 0.2 * np.ptp(self.pattern1),
+            "ending_point_lower": self.pattern1[-1] - 0.2 * np.ptp(self.pattern1),
+            "ending_point_upper": self.pattern1[-1] + 0.2 * np.ptp(self.pattern1),
+            "cross_correlation_threshold": 0.5,
+        }
+
+    def preprocess_data(self):
+        """Preprocess the main data."""
+        self.df['bin'] = self.df.index // self.bin_parser
+        return self.df.groupby('bin')[self.column_pattern].mean().to_numpy().reshape(-1, 1)
+
+    def apply_constraints(self, window):
+        """Apply constraints to filter valid windows."""
+        pc = self.pattern_constraints
+        corr_coef = np.corrcoef(window, self.pattern1)[0][1]
+
+        if (
+            np.max(window) <= pc["max_pos"]
+            and np.min(window) >= pc["min_pos"]
+            and pc["mean_pos_upper"] >= np.mean(window) >= pc["mean_pos_lower"]
+            and abs(skew(window) - pc["pattern_skewness"]) < 0.5
+            and abs(kurtosis(window) - pc["pattern_kurtosis"]) < 1.0
+            and pc["pattern_std"] * 0.9 <= np.std(window) <= pc["pattern_std"] * 1.1
+            and corr_coef >= pc["cross_correlation_threshold"]
+            and pc["starting_point_lower"] <= window[0] <= pc["starting_point_upper"]
+            and pc["ending_point_lower"] <= window[-1] <= pc["ending_point_upper"]
+        ):
+            return True
+        return False
+
+    def compute_cosine_sim(self, data1, i, j):
+        """Compute cosine similarity for a given sliding window."""
+        window = data1[i:i + self.window_size - (self.len_iter // 2) + j, :].reshape(-1,)
+
+        if len(window) != len(self.pattern1):  # Ensure dimensions match
+            return i, j, 0
+
+        # Apply constraints
+        if not self.apply_constraints(window):
+            return i, j, 0
+
+        fft_pattern = np.fft.fft(self.pattern1)
+        fft_window = np.fft.fft(window)
+
+        dot_product = np.dot(np.abs(fft_pattern), np.abs(fft_window))
+        norm_pattern = np.linalg.norm(np.abs(fft_pattern))
+        norm_window = np.linalg.norm(np.abs(fft_window))
+        similarity = dot_product / (norm_pattern * norm_window)
+
+        return i, j, similarity
+
+    def calculate_similarity(self):
+        """Calculate sliding window cosine similarity."""
+        data1 = self.preprocess_data()
+
+        results = Parallel(n_jobs=-1)(
+            delayed(self.compute_cosine_sim)(data1, i, j)
+            for i in range(0, len(data1) - self.window_size, 2)
+            for j in range(0, self.len_iter, self.len_iter // 40)
+        )
+
+        for i, j, similarity in results:
+            if similarity > 0:
+                self.similarity_dict.setdefault(i, {})[j] = similarity
+
+    def get_top_similarities(self):
+        """Extract top similarities from the similarity dictionary."""
+        results = [
+            {'key': key1, 'max_key': max(value, key=value.get), 'max_value': max(value.values())}
+            for key1, value in self.similarity_dict.items()
+        ]
+        return pd.DataFrame(results)
+
+    def find_area_of_interest(self):
+        """Find areas of interest in the data."""
+        self.preprocess_pattern()
+        self.calculate_similarity()
+        df_dist = self.get_top_similarities()
+
+        approx_cycle_length = len(self.pattern1) * 0.95
+        df_dist['app_cycle'] = (df_dist['key'] // approx_cycle_length).astype(int)
+        grouped = df_dist.groupby('app_cycle')
+
+        cyc_concat_df = pd.concat(
+            [
+                group.loc[group['max_value'].idxmax()].assign(cycle=idx_cyc)
+                for idx_cyc, (_, group) in enumerate(grouped)
+                if not group.empty and group['max_value'].max() != 0
+            ],
+            ignore_index=True
+        )
+
+        cyc_concat_df['start_index'] = cyc_concat_df['key']
+        cyc_concat_df['end_index'] = (
+            cyc_concat_df['start_index'] + self.window_size +
+            cyc_concat_df['max_key'] - (self.len_iter // 2)
+        )
+        cyc_concat_df['shift_start'] = cyc_concat_df['start_index'].shift(1, fill_value=len(self.pattern1))
+        cyc_concat_df['diff'] = cyc_concat_df['shift_start'] - cyc_concat_df['start_index']
+        limit = len(self.pattern1) * 0.7
+        cyc_concat_df = cyc_concat_df[cyc_concat_df['diff'] < -limit].reset_index(drop=True)
+        cyc_concat_df['cycle'] = cyc_concat_df.index
+
+        cyc_concat_df['shift_end'] = cyc_concat_df['end_index'].shift(1, fill_value=cyc_concat_df['diff'].iloc[0])
+        cyc_concat_df['diff_end'] = cyc_concat_df['shift_end'] - cyc_concat_df['start_index']
+        overlap = cyc_concat_df['diff_end'] > 0
+        cyc_concat_df.loc[overlap, 'start_index'] += cyc_concat_df.loc[overlap, 'diff_end'] + 1
+
+        self.df['cycle'] = np.nan
+        for _, row in cyc_concat_df.iterrows():
+            start, stop = int(row['start_index'] * self.bin_parser), int(row['end_index'] * self.bin_parser)
+            self.df.loc[start:stop, 'cycle'] = row['cycle']
+
+        return self.df

pattern_detection/utils.py

@@ -0,0 +1,87 @@
+import numpy as np
+from scipy.stats import skew, kurtosis
+
+def calculate_statistics(data):
+    """
+    Calculate various statistics for a given dataset.
+
+    Parameters:
+    - data (array-like): The input data.
+
+    Returns:
+    - dict: Dictionary containing max, min, mean, std, skewness, and kurtosis.
+    """
+    return {
+        "max": np.max(data),
+        "min": np.min(data),
+        "mean": np.mean(data),
+        "std": np.std(data),
+        "skewness": skew(data),
+        "kurtosis": kurtosis(data),
+    }
+
+def normalize_data(data):
+    """
+    Normalize the input data to range [0, 1].
+
+    Parameters:
+    - data (array-like): Input data to normalize.
+
+    Returns:
+    - np.ndarray: Normalized data.
+    """
+    min_val = np.min(data)
+    max_val = np.max(data)
+    return (data - min_val) / (max_val - min_val)
+
+def validate_window(window, constraints):
+    """
+    Validate a sliding window against constraints.
+
+    Parameters:
+    - window (array-like): The input window data.
+    - constraints (dict): A dictionary of constraints with keys like 'max_pos', 'min_pos', etc.
+
+    Returns:
+    - bool: True if all constraints are satisfied, False otherwise.
+    """
+    corr_coef = np.corrcoef(window, constraints['pattern'])[0, 1]
+
+    return (
+        np.max(window) <= constraints["max_pos"]
+        and np.min(window) >= constraints["min_pos"]
+        and constraints["mean_pos_upper"] >= np.mean(window) >= constraints["mean_pos_lower"]
+        and abs(skew(window) - constraints["pattern_skewness"]) < 0.5
+        and abs(kurtosis(window) - constraints["pattern_kurtosis"]) < 1.0
+        and constraints["pattern_std"] * 0.9 <= np.std(window) <= constraints["pattern_std"] * 1.1
+        and corr_coef >= constraints["cross_correlation_threshold"]
+        and constraints["starting_point_lower"] <= window[0] <= constraints["starting_point_upper"]
+        and constraints["ending_point_lower"] <= window[-1] <= constraints["ending_point_upper"]
+    )
+
+def calculate_correlation(data1, data2):
+    """
+    Calculate correlation coefficient between two datasets.
+
+    Parameters:
+    - data1 (array-like): First dataset.
+    - data2 (array-like): Second dataset.
+
+    Returns:
+    - float: Correlation coefficient.
+    """
+    return np.corrcoef(data1, data2)[0, 1]
+
+def bin_data(data, bin_size):
+    """
+    Bin the data into averages over fixed-size intervals.
+
+    Parameters:
+    - data (array-like): The input data.
+    - bin_size (int): The size of the bins.
+
+    Returns:
+    - np.ndarray: Binned data.
+    """
+    binned = data[:len(data) // bin_size * bin_size].reshape(-1, bin_size)
+    return np.mean(binned, axis=1)

pattern_detector-0.1.0.dist-info/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Yigit Utku Bulut and Ahmet Faruk Minareci
+
+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.

pattern_detector-0.1.0.dist-info/METADATA

@@ -0,0 +1,17 @@
+Metadata-Version: 2.1
+Name: pattern_detector
+Version: 0.1.0
+Summary: A library for detecting patterns in time-series data.
+Author: Yigit Utku Bulut and Ahmet Faruk Minareci
+Author-email: yigit.utku.bulut@gmail.com, ahmetfaruk.minareci@gmail.com
+License: MIT
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.7
+License-File: LICENSE
+Requires-Dist: numpy
+Requires-Dist: pandas
+Requires-Dist: joblib
+Requires-Dist: scipy
+

pattern_detector-0.1.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+pattern_detection/__init__.py,sha256=hzZhj16aof1dhcIOAI9Tfo5EoPJgexGChsnCLgXq-68,68
+pattern_detection/detector.py,sha256=XaYYRledSolgTPTYLRSWhjZhmnAAvZT2pD3h5g9kP9k,6585
+pattern_detection/utils.py,sha256=jqkfeTqWEnrnvzKBxr_UdKj9cj7zPF15UhHPr9sBSa0,2646
+tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tests/test_detector.py,sha256=biHGbqd6Uc8dFTtyK-BxYeqFYtJOO9lk_6rQMeQCbQs,972
+pattern_detector-0.1.0.dist-info/LICENSE,sha256=RslT26mCGxF9nQEyEQL8kFMFUgmYvCA0UivIWefxWmU,1098
+pattern_detector-0.1.0.dist-info/METADATA,sha256=9pgMSSHwImJHjA1AOAOJm-ou2MsYnNFwPa6AGvl-fow,536
+pattern_detector-0.1.0.dist-info/WHEEL,sha256=R0nc6qTxuoLk7ShA2_Y-UWkN8ZdfDBG2B6Eqpz2WXbs,91
+pattern_detector-0.1.0.dist-info/top_level.txt,sha256=W_tzR9Ah3_TgQsiGDs46ELePkuxfcPmFOosXSYw2hl0,24
+pattern_detector-0.1.0.dist-info/RECORD,,

pattern_detector-0.1.0.dist-info/WHEEL

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

pattern_detector-0.1.0.dist-info/top_level.txt

@@ -0,0 +1,2 @@
+pattern_detection
+tests

tests/test_detector.py

@@ -0,0 +1,27 @@
+import pytest
+import numpy as np
+import pandas as pd
+from pattern_detection.detector import PatternDetector
+
+def test_preprocess_pattern():
+    pattern = pd.DataFrame({"value": range(10)})
+    detector = PatternDetector(None, pattern, "value")
+    detector.preprocess_pattern()
+    assert detector.pattern1 is not None
+    assert len(detector.pattern1) > 0
+
+def test_calculate_similarity():
+    data = pd.DataFrame({"value": range(100)})
+    pattern = pd.DataFrame({"value": range(10)})
+    detector = PatternDetector(data, pattern, "value")
+    detector.preprocess_pattern()
+    detector.calculate_similarity()
+    assert len(detector.similarity_dict) > 0
+
+def test_find_area_of_interest():
+    data = pd.DataFrame({"value": range(100)})
+    pattern = pd.DataFrame({"value": range(10)})
+    detector = PatternDetector(data, pattern, "value")
+    result = detector.find_area_of_interest()
+    assert "cycle" in result.columns
+    assert not result["cycle"].isnull().all()