diff --git a/docs/Tutorial_DAMP.ipynb b/docs/Tutorial_DAMP.ipynb new file mode 100644 index 000000000..0aede3b5d --- /dev/null +++ b/docs/Tutorial_DAMP.ipynb @@ -0,0 +1,900 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "a6cafbd0", + "metadata": {}, + "source": [ + "# DAMP: Discord-Aware Matrix Profile" + ] + }, + { + "cell_type": "markdown", + "id": "f3f7c6e8", + "metadata": {}, + "source": [ + "Authors in [DAMP](https://www.cs.ucr.edu/~eamonn/DAMP_long_version.pdf) presented a method for discord detection that is scalable and it can be used in offline and online mode.\n", + "\n", + "To better understand the mechanism behind this method, we should first understand the difference between the full matrix profile and the left matrix profile of a time series `T`. For a subsequence with length `m`, and the start index `i`, i.e. `S_i = T[i:i+m]`, there are two groups of neighbors, known as left and right neighbors. The left neighbors are the subsequences on the left side of `S_i`, i.e. the subsequences in `T[:i]`. And, the right neighbors are the subsequences on the right side of `S_i`, i.e. the subsequences in `T[i+1:]`. The `i`-th element of the full matrix profile is the minimum distance between `S_i` and all of its neighbors, considering both left and right ones. However, in the left matrix profile, the `i`-th element is the minimum distance between the subsequence `S_i` and its left neighbors.\n", + "\n", + "One can use either the full matrix profile or the left matrix profile to find the top discord, a subsequence whose distance to its nearest neighbor is larger than the distance of any other subsequences to their nearest neighbors. However, using full matrix profile for detecting discords might result in missing the case where there are two rare subsequences that happen to also be similar to each other (a case that is known as \"twin freak\"). On the other hand, the left matrix profile resolves this problem by capturing the discord at its first occurance. Hence, even if there are two or more of such discords, we can still capture the first occurance by using the left matrix profile." + ] + }, + { + "cell_type": "markdown", + "id": "627bba73", + "metadata": {}, + "source": [ + "For now, let us consider a time series `T` and let's say we are interested in finding the top discord in an offline/batch setting. Suppose the time series `T` is set as follows:" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "32a4d8e5", + "metadata": {}, + "outputs": [], + "source": [ + "T = [\n", + " 0, \n", + " 1, \n", + " 2, \n", + " \n", + " 1000, \n", + " 2000, \n", + " 3000, \n", + " \n", + " 100, \n", + " 101, \n", + " 102, \n", + " \n", + " 0.1, \n", + " 1.1, \n", + " 2.1, \n", + " \n", + " 1000.1, \n", + " 2000.1, \n", + " 3000.1, \n", + " \n", + " 100.1, \n", + " 101.1, \n", + " 102.1, \n", + " \n", + " 0, \n", + " 2000, \n", + " 0,\n", + "]" + ] + }, + { + "cell_type": "markdown", + "id": "dced316e", + "metadata": {}, + "source": [ + "Also suppose that we are interested in subsequences with length `m=3` and we use Euclidean distance to compute the distance between any two subsequences. Now, let's see what we can say about discord in this data.\n", + "\n", + "\n", + "We start with the very first subsequence, i.e. `[0, 1, 2]`. Can we say if it is a discord or not? To answer this question, we need to compare this subsequence with other subsequences. However, we have not collected any more information yet. Therefore, at this very first stage, a person with a domain knowledge, might be able to answer this question. Let's say the data was confirmed to be of normal behaviour. We continue to collect more and more data. Then, at some point, e.g. `T = [0, 1, 2, 1000, 2000, 3000, 100, 101, 102]`, the user might think that there will be no new behaviour and all normal behaviour have been captured. Therefore, detecting discord can start from this moment since, now, a new pattern can be compared with all normal, previously-observed behaviours." + ] + }, + { + "cell_type": "markdown", + "id": "7bdd08a6", + "metadata": {}, + "source": [ + "**To be more precise:**
\n", + "For a given `split_idx`, the train part is `T[:split_idx]` and the potential anomalies should be coming from `T[split_idx:]`. The value of `split_idx` is problem dependent. If `split_idx` is too small, then `T[:split_idx]` may not contain all different kinds of regular patterns. Hence, we may incorrectly select a subsequence as a discord. If `split_idx` is too large, we may miss a discord if that discord and its nearest neighbor are both in `T[:split_idx]`. \n", + "\n", + "Later in this notebook, an alternative approach will be provided that does not need the `split_idx`. However, the user still needs to provide the regular patterns of the system first. For now, we consider `split_idx` in the implementation so as to remain faithful to the paper's implementation regarding classic DAMP." + ] + }, + { + "cell_type": "markdown", + "id": "d949f005", + "metadata": {}, + "source": [ + "# Getting Started" + ] + }, + { + "cell_type": "markdown", + "id": "1bae2bcc", + "metadata": {}, + "source": [ + "## core idea" + ] + }, + { + "cell_type": "markdown", + "id": "708dbd4f", + "metadata": {}, + "source": [ + "**How to find the top discord of `T` in the offline/batch mode?**
\n", + "To find the top discord, one can compute the left matrix profile, `PL`, and locate the index `i` where `PL` has the maximum finite value. The discord is the subsequence located at index `i`, i.e. the subsequence `T[i:i+m]`. What `DAMP` does is that it computes an **approximate** left matrix profile **whose maximum is exact**! This means that it can still give us the correct discord.\n", + "\n", + "**How does DAMP work?**
\n", + "Let's say we have a time series `T` and we begin checking each subsequence starting from left to right and updating our best-so-far discord as a rarer, more unique subsequence is encountered. At the `i`-th subsequence, the distance for the best-so-far discord is simply the distance between the rarest/most unique subsequence, discovered somewhere amongst `T[:i]`, and its [exact] left nearest neighbor. Let's denote the best-so-far discord distance as `bsf`. Naively, one can compare `S_i` with all of its left neighbors, i.e. the subsequences in `T[:i]`, and find its one-nearest-neighbor. However, this is very time consuming and DAMP employs an early abandoning approach that helps to dramatically reduce this computational time. So, as soon as DAMP finds a left neighbor whose distance to `S_i` is less than the best-so-far distance `bsf`, `DAMP` stops exploring the remaining of the left neighbors. Because, in such case, the distance between `S_i` to its left nearest neighbor would also be less than `bsf`, which means `S_i` cannot take the top-discord place. This is called **BackwardProcessing**. To take advantage of rolling-based computation, the \"BackwardProcessing\" explores the left neighbors of `S_i` chunk by chunk, and use the MASS algorithm to compute the distance between `S_i` and the subsequences in each chunk. Of the subsequences in a chunk, if we cannot find one whose distance to `S_i` is less than `bsf`, we go to the next chunk, and we update the distance between `S_i` and its best-so-far-discovered 1NN, `S_nn_i`. If we exhaust the subsequences in all chunks and realize that the distance between `S_i` and `S_nn_i` is greater than `bsf`, then we update `bsf`. In such case, the subsequence `S_i` becomes the best-so-far discord and `bsf` is the distance between the best-so-far discord and its nearest neighbor.\n", + "\n", + "We can now go to the next index, i.e. `i+1`, and do the same process. That means, for the next subsequence, we need to run \"BackwardProcessing\" at least once, i.e. using MASS algorithm to compute the distance between the subsequence `T[i+1:i+1+m]` and the subsequences in [at least] one chunk. But... what if we can find a way to prune some of the forthcoming subsequences? Then, we only need to do \"BackwardProcessing\" for the ones that are not pruned! This can speed up the process in discovering the top discord. To prune the forthcoming subsequences, we can use MASS to compute the distance between `S_i` and its right neighbors. This is known as **ForwardProcessing**. Note that for those subsequences, `S_i` is considered as one of their left neighbors! So, if the distance between `S_i` and any one of those subsequences become less than `bsf`, those subsequences can be prunned. Therefore, when `DAMP`'s process reaches one of those pruned subsequences, there will be no need to perform \"BackwardProcessing\" and it can be skipped as the subsequence is already pruned and cannot be the top discord." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "62733a79", + "metadata": {}, + "outputs": [], + "source": [ + "import math\n", + "\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import stumpy\n", + "import time\n", + "\n", + "from stumpy import core\n", + "from scipy.io import loadmat" + ] + }, + { + "cell_type": "markdown", + "id": "894b60ea", + "metadata": {}, + "source": [ + "## Naive approach" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "b7d1081c", + "metadata": {}, + "outputs": [], + "source": [ + "def naive_DAMP(T, m, split_idx):\n", + " \"\"\"\n", + " Compute the top discord in `T`, where the subsequence discord resides in T[split_index:]\n", + " \n", + " Parameters\n", + " ----------\n", + " T : numpy.ndarray\n", + " A time series for which the top discord will be computed.\n", + " \n", + " m : int\n", + " Window size\n", + " \n", + " split_idx : int\n", + " The split index between train and test. See note below for further details.\n", + " \n", + " Returns\n", + " -------\n", + " PL : numpy.ndarry\n", + " The [exact] left matrix profile. All infinite distances are ingored in computing\n", + " the discord.\n", + " \n", + " discord_dist : float\n", + " The discord's distance, which is the distance between the top discord and its\n", + " left nearest neighbor\n", + " \n", + " discord_idx : int\n", + " The start index of the top discord\n", + " \n", + " Note\n", + " ----\n", + " \n", + " \"\"\"\n", + " mp = stumpy.stump(T, m)\n", + " IL = mp[:, 2].astype(np.int64)\n", + " \n", + " k = len(T) - m + 1 # len(IL)\n", + " PL = np.full(k, np.inf, dtype=np.float64)\n", + " for i in range(split_idx, k):\n", + " nn_i = IL[i]\n", + " if nn_i >= 0:\n", + " PL[i] = np.linalg.norm(core.z_norm(T[i : i + m]) - core.z_norm(T[nn_i : nn_i + m]))\n", + " \n", + " PL_modified = np.where(PL==np.inf, np.NINF, PL)\n", + " discord_idx = np.argmax(PL_modified)\n", + " discord_dist = PL_modified[discord_idx]\n", + " if discord_dist == np.NINF:\n", + " discord_idx = -1\n", + " \n", + " return PL, discord_dist, discord_idx" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "f256aaee", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "discord_dist: 8.500883427933502\n", + "discord_index: 209\n", + "running time [sec]: 8.310516119003296\n" + ] + } + ], + "source": [ + "seed = 100\n", + "np.random.seed(seed)\n", + "\n", + "T = np.random.rand(100000)\n", + "m = 50\n", + "split_index = 200\n", + "\n", + "naive_DAMP(T, m, split_index) # dummy run\n", + "t_start = time.time()\n", + "excl_zone_denom = core.config.STUMPY_EXCL_ZONE_DENOM\n", + "core.config.STUMPY_EXCL_ZONE_DENOM = 1.0\n", + "PL, discord_dist, discord_index = naive_DAMP(T, m, split_index)\n", + "core.config.STUMPY_EXCL_ZONE_DENOM = excl_zone_denom\n", + "t_end = time.time()\n", + "\n", + "print('discord_dist: ', discord_dist)\n", + "print('discord_index: ', discord_index)\n", + "print('running time [sec]: ', t_end - t_start)" + ] + }, + { + "cell_type": "markdown", + "id": "b4e29653", + "metadata": {}, + "source": [ + "## DAMP approach" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "96d95529", + "metadata": {}, + "outputs": [], + "source": [ + "def next_pow2(v):\n", + " \"\"\"\n", + " Compute the smallest \"power of two\" number that is greater than/ equal to `v`\n", + " \n", + " Parameters\n", + " ----------\n", + " v : float\n", + " A real positive value\n", + " \n", + " Returns\n", + " -------\n", + " out : int\n", + " An integer value that is power of two, and satisfies `out >= v`\n", + " \"\"\"\n", + " return int(math.pow(2, math.ceil(math.log2(v))))" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "60ed404c", + "metadata": {}, + "outputs": [], + "source": [ + "def _backward_process(\n", + " T, \n", + " m, \n", + " query_idx, \n", + " M_T, \n", + " Σ_T, \n", + " T_subseq_isconstant, \n", + " bsf,\n", + "):\n", + " \"\"\"\n", + " Compute the (approximate) left matrix profile value that corresponds to the subsequence \n", + " `T[query_idx:query_idx+m]` and update the best-so-far discord distance.\n", + " \n", + " Parameters\n", + " ----------\n", + " T : numpy.ndarray\n", + " A time series\n", + " \n", + " m : int\n", + " Window size\n", + " \n", + " query_idx : int\n", + " The start index of the query with length `m`, i.e. `T[query_idx:query_idx+m]`\n", + " \n", + " M_T : np.ndarray\n", + " The sliding mean of `T`\n", + " \n", + " Σ_T : np.ndarray\n", + " The sliding standard deviation of `T`\n", + " \n", + " T_subseq_isconstant : numpy.ndarray\n", + " A numpy boolean array whose i-th element indicates whether the subsequence\n", + " `T[i : i+m]` is constant (True)\n", + " \n", + " bsf : float\n", + " The best-so-far discord distance\n", + " \n", + " Returns\n", + " -------\n", + " distance : float\n", + " The [approximate] left matrix profile value that corresponds to \n", + " the query, `T[query_idx : query_idx + m]`.\n", + " \n", + " bsf : float\n", + " The best-so-far discord distance \n", + " \"\"\"\n", + " # initializing the [best-so-far] first-nearest-neighbor\n", + " # distance of the query `Q = T[query_idx : query_idx + m]`\n", + " nn_distance = np.inf \n", + " \n", + " chunksize = next_pow2(m) \n", + " chunk_stop = query_idx \n", + " chunk_start = max(0, chunk_stop - chunksize)\n", + " \n", + " while nn_distance >= bsf:\n", + " QT = core.sliding_dot_product(\n", + " T[query_idx : query_idx + m], \n", + " T[chunk_start : chunk_stop],\n", + " )\n", + " D = core._mass(\n", + " T[query_idx : query_idx + m],\n", + " T[chunk_start : chunk_stop],\n", + " QT=QT,\n", + " μ_Q=M_T[query_idx],\n", + " σ_Q=Σ_T[query_idx],\n", + " M_T=M_T[chunk_start : chunk_stop - m + 1],\n", + " Σ_T=Σ_T[chunk_start : chunk_stop - m + 1],\n", + " Q_subseq_isconstant=T_subseq_isconstant[query_idx],\n", + " T_subseq_isconstant=T_subseq_isconstant[chunk_start : chunk_stop - m + 1],\n", + " )\n", + " \n", + " nn_distance = min(nn_distance, np.min(D)) \n", + " \n", + " if chunk_start == 0: # all chunks are visited.\n", + " bsf = max(bsf, nn_distance)\n", + " break\n", + " \n", + " chunksize = 2 * chunksize\n", + " chunk_stop = chunk_start + m\n", + " chunk_start = max(0, chunk_stop - chunksize)\n", + " \n", + " return nn_distance, bsf\n", + "\n", + "\n", + "def _foreward_process(\n", + " T, \n", + " m, \n", + " M_T, \n", + " Σ_T, \n", + " T_subseq_isconstant, \n", + " query_idx, \n", + " bsf, \n", + " pruned,\n", + "):\n", + " \"\"\"\n", + " Update the boolean array `pruned`, in place, by pruning subsequences that appear\n", + " after `query_idx` in the data `T`, and their distance to `T[query_idx : query_idx + m]`\n", + " is less than `bsf`.\n", + " \n", + " Paramaters\n", + " ----------\n", + " T : numpy.ndarray\n", + " The time series or sequence for which the top discord will be computed.\n", + " \n", + " m : int\n", + " Window size\n", + " \n", + " M_T : numpy.ndarray\n", + " The sliding mean\n", + " \n", + " Σ_T : numpy.ndarray\n", + " The sliding standard deviation\n", + " \n", + " T_subseq_isconstant : numpy.ndarray\n", + " A numpy boolean array whose i-th element indicates whether the subsequence\n", + " `T[i : i+m]` is constant (True)\n", + " \n", + " query_idx : int\n", + " The start index of the query with length `m`, i.e. `T[query_idx:query_idx+m]`\n", + " \n", + " bsf : float\n", + " The best-so-far discord distance\n", + " \n", + " pruned : np.ndarray\n", + " A boolean numpy array that indicate whether a subsequence is pruned for\n", + " being considered as discord\n", + " \n", + " Returns\n", + " -------\n", + " None\n", + " \"\"\" \n", + " chunksize = next_pow2(m) \n", + " chunk_start = query_idx + m\n", + " chunk_stop = min(chunk_start + chunksize, len(T))\n", + " if chunk_stop - chunk_start >= m:\n", + " QT = core.sliding_dot_product(T[query_idx : query_idx + m], T[chunk_start : chunk_stop])\n", + " D = core._mass(\n", + " T[query_idx : query_idx + m],\n", + " T[chunk_start : chunk_stop],\n", + " QT=QT,\n", + " μ_Q=M_T[query_idx],\n", + " σ_Q=Σ_T[query_idx],\n", + " M_T=M_T[chunk_start : chunk_stop - m + 1],\n", + " Σ_T=Σ_T[chunk_start : chunk_stop - m + 1],\n", + " Q_subseq_isconstant=T_subseq_isconstant[query_idx],\n", + " T_subseq_isconstant=T_subseq_isconstant[chunk_start : chunk_stop - m + 1],\n", + " )\n", + " \n", + " mask = np.argwhere(D < bsf) + chunk_start\n", + " pruned[mask] = True\n", + "\n", + " return\n", + "\n", + " \n", + " \n", + "def DAMP(T, m, split_idx): # Add param `T_subseq_isconstant` \n", + " \"\"\"\n", + " Compute the approximate left matrix profile for `T`. The global maximum\n", + " of this approximate profile is exact.\n", + " \n", + " Parameters\n", + " ----------\n", + " T : numpy.ndarray\n", + " A time series\n", + " \n", + " m : int\n", + " Window size\n", + " \n", + " split_idx : int\n", + " location of split point between train and test. The data `T[:split_idx]`\n", + " is considered as train and the remaining, i.e. `T[split_idx:]` is test.\n", + " \n", + " Returns\n", + " -------\n", + " PL : numpy.ndarry\n", + " The approximate left matrix profile. The finite global maximum of `PL` is exact,\n", + " and its corresponding index indicates the location of discord.\n", + " \n", + " discord_dist : float\n", + " The distance between the discord and its nearest neighbor\n", + " \n", + " discord_idx : int\n", + " The start index of discord.\n", + " \"\"\"\n", + " T, M_T, Σ_T, T_subseq_isconstant = core.preprocess(T, m)\n", + " excl_zone = int(np.ceil(m / stumpy.config.STUMPY_EXCL_ZONE_DENOM))\n", + " \n", + " l = len(T) - m + 1\n", + " PL = np.full(l, np.inf, dtype=np.float64) \n", + " pruned = np.full(l, 0, dtype=bool)\n", + " \n", + " bsf = np.NINF # the best-so-far discord distance\n", + " for i in range(split_idx, l):\n", + " if pruned[i]:\n", + " PL[i] = PL[i-1]\n", + " else:\n", + " PL[i], bsf = _backward_process(T, m, i, M_T, Σ_T, T_subseq_isconstant, bsf)\n", + " _foreward_process(T, m, M_T, Σ_T, T_subseq_isconstant, i, bsf, pruned)\n", + "\n", + " P = np.where(PL==np.inf, np.NINF, PL)\n", + " discord_idx = np.argmax(P)\n", + " discord_dist = P[discord_idx]\n", + " if discord_dist == np.NINF:\n", + " discord_idx = -1\n", + " \n", + " return PL, discord_dist, discord_idx" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "b05e1823", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "discord value: 8.500883427933504\n", + "discord at index: 209\n", + "running time [sec]: 2.594411849975586\n" + ] + } + ], + "source": [ + "DAMP(T, m, split_index) # dummpy run\n", + "t_start = time.time()\n", + "excl_zone_denom = core.config.STUMPY_EXCL_ZONE_DENOM\n", + "core.config.STUMPY_EXCL_ZONE_DENOM = 1\n", + "PL, discord_score, discord_idx = DAMP(T, m, split_index)\n", + "core.config.STUMPY_EXCL_ZONE_DENOM = excl_zone_denom\n", + "t_end = time.time()\n", + "\n", + "print('discord value: ', discord_score)\n", + "print('discord at index: ', discord_idx)\n", + "print('running time [sec]: ', t_end - t_start)" + ] + }, + { + "cell_type": "markdown", + "id": "18dc22e4", + "metadata": {}, + "source": [ + "# Reproducing Fig. 3 of paper (Anomaly in ECG data)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "735ad339", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "T has length: 30000\n" + ] + } + ], + "source": [ + "data = loadmat(\"DAMP_data/A_60-second snippet of an ECG.mat\") \n", + "T = data['val'].flatten().astype(np.float64)\n", + "\n", + "print(f\"T has length: {len(T)}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "bae8340c", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "T = T[:15000] # similar to the length considered in the paper\n", + "plt.figure(figsize=(30, 5))\n", + "plt.plot(T)\n", + "plt.xticks(fontsize=13)\n", + "plt.yticks(fontsize=13)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "8df3d115", + "metadata": {}, + "source": [ + "As observed, it is hard to locate the anomaly. Let's find it." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "6464b0d3", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "discord_dist: 7.774100500490462\n", + "discord_index: 9262\n", + "running time: [sec]: 0.7328600883483887\n" + ] + } + ], + "source": [ + "# `m` is provided in the supporting webpage. \n", + "# see: https://sites.google.com/view/discord-aware-matrix-profile/reproducibility?authuser=0\n", + "m = 150 \n", + "split_idx = 500 # rough value based on visual inspection of figure in the paper\n", + "\n", + "t_start = time.time()\n", + "excl_zone_denom = core.config.STUMPY_EXCL_ZONE_DENOM\n", + "core.config.STUMPY_EXCL_ZONE_DENOM = 1.0\n", + "PL_ref, discord_dist_ref, discord_idx_ref = naive_DAMP(T, m, split_idx)\n", + "core.config.STUMPY_EXCL_ZONE_DENOM = excl_zone_denom\n", + "t_end = time.time()\n", + "\n", + "print('discord_dist: ', discord_dist_ref)\n", + "print('discord_index: ', discord_idx_ref)\n", + "print('running time: [sec]: ', t_end - t_start)" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "6c9396ba", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "discord_dist: 7.7741005004904595\n", + "discord_index: 9262\n", + "running time: [sec]: 0.38638782501220703\n" + ] + } + ], + "source": [ + "t_start = time.time()\n", + "excl_zone_denom = core.config.STUMPY_EXCL_ZONE_DENOM\n", + "core.config.STUMPY_EXCL_ZONE_DENOM = 1.0\n", + "PL_comp, discord_dist_comp, discord_idx_comp = DAMP(T, m, split_idx)\n", + "core.config.STUMPY_EXCL_ZONE_DENOM = excl_zone_denom\n", + "t_end = time.time()\n", + "\n", + "print('discord_dist: ', discord_dist_comp)\n", + "print('discord_index: ', discord_idx_comp)\n", + "print('running time: [sec]: ', t_end - t_start)" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "ecc956a5", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "fig, axs = plt.subplots(nrows=3, figsize=(30, 15))\n", + "\n", + "axs[0].plot(T, color='k')\n", + "axs[0].set_xlim(0, 15000)\n", + "\n", + "axs[1].plot(PL_ref, color='r')\n", + "axs[1].set_xlim(0, 15000)\n", + "\n", + "axs[2].plot(PL_comp, color='b')\n", + "axs[2].set_xlim(0, 15000)\n", + "\n", + "axs[0].axvline(x=discord_idx_comp,ymin=-1,ymax=1,c=\"g\",linewidth=2, linestyle='--', zorder=0, clip_on=False)\n", + "axs[1].axvline(x=discord_idx_comp,ymin=-1,ymax=1,c=\"g\",linewidth=2, linestyle='--', zorder=0, clip_on=False)\n", + "axs[2].axvline(x=discord_idx_comp,ymin=0,ymax=1,c=\"g\",linewidth=2, linestyle='--', zorder=0, clip_on=False)\n", + "\n", + "axs[0].set_ylabel('data', fontsize=13)\n", + "axs[1].set_ylabel('Left MP', fontsize=13)\n", + "axs[2].set_ylabel('DAMP profile', fontsize=13)\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "132254db", + "metadata": {}, + "source": [ + "As observed, the global maximum of `DAMP profile` is exact and that is enough to get the top-1 discord." + ] + }, + { + "cell_type": "markdown", + "id": "a222d454", + "metadata": {}, + "source": [ + "## Reproducing Fig. 2 of paper (Anomaly in electrical motor data)" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "0c1ac65c", + "metadata": {}, + "outputs": [], + "source": [ + "data = loadmat(\"DAMP_data/bearing_time_series.mat\") \n", + "T = data['testdata'].flatten().astype(np.float64)" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "e2c5e932", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(30, 5))\n", + "plt.plot(T)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "00823dbd", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "length of `T`: 244189\n" + ] + } + ], + "source": [ + "print(f'length of `T`: {len(T)}')" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "3e5891d1", + "metadata": {}, + "outputs": [], + "source": [ + "# setting the parameters\n", + "m = 300 # according to supporting page\n", + "split_idx = 5000 # rough value based on visual inspection of figure in the paper" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "1cc66385", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "discord_dist: 16.925815600199474\n", + "discord_index: 49881\n", + "running time: [sec]: 44.49898862838745\n" + ] + } + ], + "source": [ + "# naive\n", + "t_start = time.time()\n", + "excl_zone_denom = core.config.STUMPY_EXCL_ZONE_DENOM\n", + "core.config.STUMPY_EXCL_ZONE_DENOM = 1.0\n", + "PL_ref, discord_dist_ref, discord_idx_ref = naive_DAMP(T, m, split_idx)\n", + "core.config.STUMPY_EXCL_ZONE_DENOM = excl_zone_denom\n", + "t_end = time.time()\n", + "\n", + "print('discord_dist: ', discord_dist_ref)\n", + "print('discord_index: ', discord_idx_ref)\n", + "print('running time: [sec]: ', t_end - t_start)" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "f77cd5fd", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "discord_dist: 16.92581560019947\n", + "discord_index: 49881\n", + "running time [sec]: 30.73443579673767\n" + ] + } + ], + "source": [ + "# performant \n", + "t_start = time.time()\n", + "excl_zone_denom = core.config.STUMPY_EXCL_ZONE_DENOM\n", + "core.config.STUMPY_EXCL_ZONE_DENOM = 1.0\n", + "PL, discord_dist, discord_idx = DAMP(T, m, split_idx)\n", + "core.config.STUMPY_EXCL_ZONE_DENOM = excl_zone_denom\n", + "t_end = time.time()\n", + "\n", + "print('discord_dist: ', discord_dist)\n", + "print('discord_index: ', discord_idx)\n", + "print('running time [sec]: ', t_end - t_start)" + ] + }, + { + "cell_type": "markdown", + "id": "c2319228", + "metadata": {}, + "source": [ + "The computed index `49881` matches the index provided in the supporting webpage.
\n", + "see [this slide of powerpoint](https://docs.google.com/presentation/d/1tQQfKuKrOa3j5-WJ9peoYfZGOnJbBcl9/edit#slide=id.p35)" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "7b0b2f63", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "fig, axs = plt.subplots(nrows=2, figsize=(30, 15))\n", + "\n", + "axs[0].plot(T, color='k')\n", + "axs[0].set_xlim(0, len(T))\n", + "\n", + "axs[1].plot(PL, color='r')\n", + "axs[1].set_xlim(0, len(T))\n", + "\n", + "axs[0].axvline(x=discord_idx,ymin=-1,ymax=1,c=\"g\",linewidth=2, linestyle='--', zorder=0, clip_on=False)\n", + "axs[1].axvline(x=discord_idx,ymin=0,ymax=1,c=\"g\",linewidth=2, linestyle='--', zorder=0, clip_on=False)\n", + "\n", + "axs[0].set_ylabel('data', fontsize=13)\n", + "axs[1].set_ylabel('DAMP profile', fontsize=13)\n", + "\n", + "axs[0].set_title(f'discord at index: {discord_idx}', fontsize=13)\n", + "plt.show()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.12" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +}