{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# Incremental Matrix Profiles for Streaming Time Series Data\n", "\n", "[![Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/TDAmeritrade/stumpy/main?filepath=notebooks/Tutorial_Matrix_Profiles_For_Streaming_Data.ipynb)\n", "\n", "Now that you have a basic understanding of how to compute a matrix profile, in this short tutorial, we will demonstrate how to incrementally update your matrix profile when you have streaming (on-line) data using the `stumpy.stumpi` (\"STUMP Incremental\") function. You can learn more about the details of this approach by reading Section G of the [Matrix Profile I](https://www.cs.ucr.edu/~eamonn/PID4481997_extend_Matrix%20Profile_I.pdf) paper and Section 4.6 and Table 5 [this paper](https://www.cs.ucr.edu/~eamonn/ten_quadrillion.pdf)." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Getting Started\n", "\n", "Let's import the packages that we'll need to create and analyze a randomly generated time series data set." ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "import numpy as np\n", "import stumpy\n", "import numpy.testing as npt\n", "import time" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Generating Some Random Time Series Data\n", "\n", "Imagine that we have an [IoT](https://en.wikipedia.org/wiki/Internet_of_things) sensor that has been collecting data once an hour for the last 14 days. That would mean that we've amassed `14 * 24 = 336` data points up until this point and our data set might look like this:" ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [], "source": [ "T = np.random.rand(336)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "And, perhaps, we know from experience that an interesting motif or anomaly might be detectable within a 12 hour (sliding) time window:" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [], "source": [ "m = 12" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Typical Batch Analysis" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "To compute the matrix profile using a batch process is straightforward using `stumpy.stump`:" ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [], "source": [ "mp = stumpy.stump(T, m)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "But as the length of `T` grows with each passing hour, it will take increasingly more time to compute the matrix profile since `stumpy.stump` will actually re-compute all of the pairwise distances between all subsequences within the time series. This is super time consuming! Instead, for streaming data, we want to find a way to take the new incoming (single) data point and compare the subsequence that it resides in with the rest of the time series (i.e., compute the distance profile) and update the existing matrix profile. Luckily, this can be easily accomplished with `stumpy.stumpi` or \"STUMP Incremental\".\n", "\n", "## Streaming (On-line) Analysis with STUMPI\n", "\n", "As we wait for the next data point, `t`, to arrive, we can take our existing data initialize our streaming object:" ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [], "source": [ "stream = stumpy.stumpi(T, m, egress=False) # Don't egress/remove the oldest data point when streaming" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "And when a new data point, `t`, arrives:" ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [], "source": [ "t = np.random.rand()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We can append `t` to our `stream` and easily update the matrix profile, `P`, and matrix profile indices, `I` behind the scenes:" ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [], "source": [ "stream.update(t)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "In the background, `t` has been appended to the existing time series and it automatically compares the new subsequence with all of the existing ones and updates the historical values. It also determines which one of the existing subsequences is the nearest neighbor to the new subsequence and appends this information to the matrix profile. And this can continue on, say, for another 1,000 iterations (or indefinitely) as additional data is streamed in:" ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [], "source": [ "for i in range(1000):\n", " t = np.random.rand()\n", " stream.update(t)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "It is important to reiterate that incremental `stumpy.stumpi` is different from batch `stumpy.stump` in that it does not waste any time re-computing any of the past pairwise distances. `stumpy.stumpi` only spends time computing new distances and then updates the appropriate arrays where necessary and, thus, it is really fast!" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Validation\n", "\n", "### The Matrix Profile\n", "\n", "Now, this claim of \"fast updating\" with streaming (on-line) data may feel strange or seem magical so, first, let's validate that the output from incremental `stumpy.stumpi` is the same as performing batch `stumpy.stump`. Let's start with the full time series with `64` data points and compute the full matrix profile:" ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [], "source": [ "T_full = np.random.rand(64)\n", "m = 8\n", "\n", "mp = stumpy.stump(T_full, m)\n", "P_full = mp[:, 0]\n", "I_full = mp[:, 1]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Next, for `stumpy.stumpi`, we'll only start with the first `10` elements from the full length time series and then incrementally stream in the additional data points one at a time:" ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [], "source": [ "# Start with half of the full length time series and initialize inputs\n", "T_stream = T_full[:10].copy()\n", "stream = stumpy.stumpi(T_stream, m, egress=False) # Don't remove/egress the oldest data point when streaming\n", "\n", "# Incrementally add one new data point at a time and update the matrix profile\n", "for i in range(len(T_stream), len(T_full)):\n", " t = T_full[i]\n", " stream.update(t)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Now that we're done, let's check and validate that:\n", "\n", "1. `stream.T == T_full`\n", "2. `stream.P == P_full`\n", "3. `stream.I == I_full`" ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [], "source": [ "npt.assert_almost_equal(stream.T_, T_full)\n", "npt.assert_almost_equal(stream.P_, P_full)\n", "npt.assert_almost_equal(stream.I_, I_full)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "There are no errors! So, this means that `stump.stumpi` indeed produces the correct matrix profile results that we'd expect.\n", "\n", "### The Performance\n", "\n", "We've basically claimed that incrementally updating our matrix profile with `stumpy.stumpi` is much faster (in total computational time) than performing a full pairwise distance calculation with `stumpy.stump` as each new data point arrives. Let's actually compare the timings by taking a full time series that is 10,000 data points in length and we initialize both approaches with the first 2% of the time series (i.e., the first 200 points) and append a single new data point at each iteration before re-computing the matrix profile:" ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "stumpy.stump: 257.4s\n", "stumpy.stumpi: 3.1s\n" ] } ], "source": [ "T_full = np.random.rand(10_000)\n", "T_stream = T_full[:200].copy()\n", "m = 100\n", "\n", "# `stumpy.stump` timing\n", "start = time.time()\n", "mp = stumpy.stump(T_stream, m)\n", "for i in range(200, len(T_full)):\n", " T_stream = np.append(T_stream, T_full[i])\n", " mp = stumpy.stump(T_stream, m)\n", "stump_time = time.time() - start\n", "\n", "# `stumpy.stumpi` timing\n", "stream = stumpy.stumpi(T_stream, m, egress=False) # Don't egress/remove the oldest data point when streaming\n", "start = time.time()\n", "for i in range(200, len(T_full)):\n", " t = T_full[i]\n", " stream.update(t)\n", "stumpi_time = time.time() - start\n", "\n", "print(f\"stumpy.stump: {np.round(stump_time,1)}s\")\n", "print(f\"stumpy.stumpi: {np.round(stumpi_time, 1)}s\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Setting aside the fact that having more CPUs will speed up both approaches, we clearly see that incremental `stumpy.stumpi` is one to two orders of magnitude faster than batch `stumpy.stump` for processing streaming data. In fact for the current hardware, on average, it is taking roughly 0.1 seconds for `stumpy.stump` to analyze each new matrix profile. So, if you have more than 10 new data point arriving every second, then you wouldn't be able to keep up. In contrast, `stumpy.stumpi` should be able to comfortably handle and process ~450+ new data points per second using fairly modest hardware. Additionally, batch `stumpy.stump`, which has a computational complexity of `O(n^2)`, will get even slower as more and more data points get appended to the existing time series while `stumpy.stumpi`, which is essentially `O(1)`, will continue to be highly performant. \n", "\n", "In fact, if you don't care about maintaining the oldest data point and its relationships with the newest data point (i.e., you only care about maintaining a fixed sized sliding window), then you can get slightly improve the performance by telling `stumpy.stumpi` to remove/egress the oldest data point (along with its corresponding matrix profile information) by setting the parameter `egress=True` when we instantiate our streaming object (note that this is actually the default behavior):" ] }, { "cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [], "source": [ "stream = stumpy.stumpi(T_stream, m, egress=True) # Egressing/removing the oldest data point is the default behavior!" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "And now, when we process the same data above:" ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "stumpy.stumpi: 3.4s\n" ] } ], "source": [ "# `stumpy.stumpi` timing with egress\n", "stream = stumpy.stumpi(T_stream, m, egress=True)\n", "start = time.time()\n", "for i in range(200, len(T_full)):\n", " t = T_full[i]\n", " stream.update(t)\n", "stumpi_time = time.time() - start\n", "\n", "print(f\"stumpy.stumpi: {np.round(stumpi_time, 1)}s\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## A Visual Example\n", "\n", "Now that we understand how to compute and update our matrix profile with streaming data, let's explore this with a real example data set where there is a known pattern and see if `stumpy.stumpi` can correctly identify when the global pattern (motif) is encountered. " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Retrieving and Loading the Data\n", "\n", "First let's import some additional Python packages and then retrieve our standard \"Steamgen Dataset\":" ] }, { "cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
drum pressureexcess oxygenwater levelsteam flow
0320.082392.5067740.0327019.302970
1321.710992.5459080.2847999.662621
2320.913312.3605620.20365210.990955
3325.002520.0270540.32618712.430107
4326.652760.2856490.75377613.681666
\n", "
" ], "text/plain": [ " drum pressure excess oxygen water level steam flow\n", "0 320.08239 2.506774 0.032701 9.302970\n", "1 321.71099 2.545908 0.284799 9.662621\n", "2 320.91331 2.360562 0.203652 10.990955\n", "3 325.00252 0.027054 0.326187 12.430107\n", "4 326.65276 0.285649 0.753776 13.681666" ] }, "execution_count": 15, "metadata": {}, "output_type": "execute_result" } ], "source": [ "%matplotlib inline\n", "\n", "import pandas as pd\n", "import stumpy\n", "import numpy as np\n", "import matplotlib.pyplot as plt\n", "from matplotlib.patches import Rectangle\n", "from matplotlib import animation\n", "from IPython.display import HTML\n", "import os\n", "\n", "plt.style.use('https://raw.githubusercontent.com/TDAmeritrade/stumpy/main/docs/stumpy.mplstyle')\n", "\n", "steam_df = pd.read_csv(\"https://zenodo.org/record/4273921/files/STUMPY_Basics_steamgen.csv?download=1\")\n", "steam_df.head()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "This data was generated using fuzzy models applied to mimic a steam generator at the Abbott Power Plant in Champaign, IL. The data feature that we are interested in is the output steam flow telemetry that has units of kg/s and the data is \"sampled\" every three seconds with a total of 9,600 datapoints.\n", "\n", "The motif (pattern) that we are looking for is highlighted below and yet it is still very hard to be certain that the orange and green subsequences are a match, that is, until we zoom in on them and overlay the subsequences on top each other. Now, we can clearly see that the motif is very similar!" ] }, { "cell_type": "code", "execution_count": 16, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "m = 640\n", "fig, axs = plt.subplots(2)\n", "plt.suptitle('Steamgen Dataset', fontsize='30')\n", "axs[0].set_ylabel(\"Steam Flow\", fontsize='20')\n", "axs[0].plot(steam_df['steam flow'], alpha=0.5, linewidth=1)\n", "axs[0].plot(steam_df['steam flow'].iloc[643:643+m])\n", "axs[0].plot(steam_df['steam flow'].iloc[8724:8724+m])\n", "rect = Rectangle((643, 0), m, 40, facecolor='lightgrey')\n", "axs[0].add_patch(rect)\n", "rect = Rectangle((8724, 0), m, 40, facecolor='lightgrey')\n", "axs[0].add_patch(rect)\n", "axs[1].set_xlabel(\"Time\", fontsize='20')\n", "axs[1].set_ylabel(\"Steam Flow\", fontsize='20')\n", "axs[1].plot(steam_df['steam flow'].values[643:643+m], color='C1')\n", "axs[1].plot(steam_df['steam flow'].values[8724:8724+m], color='C2')\n", "plt.show()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Using STUMPI\n", "\n", "Now, let's take a look at what happens to the matrix profile when we initialize our `stumpy.stumpi` with the first 2,000 data points:" ] }, { "cell_type": "code", "execution_count": 17, "metadata": {}, "outputs": [], "source": [ "T_full = steam_df['steam flow'].values\n", "T_stream = T_full[:2000]\n", "stream = stumpy.stumpi(T_stream, m, egress=False) # Don't egress/remove the oldest data point when streaming" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "and then incrementally append a new data point and update our results:" ] }, { "cell_type": "code", "execution_count": 18, "metadata": {}, "outputs": [], "source": [ "windows = [(stream.P_, T_stream)]\n", "P_max = -1\n", "for i in range(2000, len(T_full)):\n", " t = T_full[i]\n", " stream.update(t)\n", " \n", " if i % 50 == 0:\n", " windows.append((stream.P_, T_full[:i+1]))\n", " if stream.P_.max() > P_max:\n", " P_max = stream.P_.max()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "When we plot the growing time series (upper panel), `T_stream`, along with the matrix profile (lower panel), `P`, we can watch how the matrix profile evolves as new data is appended:" ] }, { "cell_type": "code", "execution_count": 19, "metadata": {}, "outputs": [ { "data": { "text/html": [ "\n", "\n", "\n", "\n", "\n", "\n", "
\n", " \n", "
\n", " \n", "
\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
\n", "
\n", " \n", " \n", " \n", " \n", " \n", " \n", "
\n", "
\n", "
\n", "\n", "\n", "\n" ], "text/plain": [ "" ] }, "execution_count": 19, "metadata": {}, "output_type": "execute_result" } ], "source": [ "fig, axs = plt.subplots(2, sharex=True, gridspec_kw={'hspace': 0})\n", "\n", "rect = Rectangle((643, 0), m, 40, facecolor='lightgrey')\n", "axs[0].add_patch(rect)\n", "rect = Rectangle((8724, 0), m, 40, facecolor='lightgrey')\n", "axs[0].add_patch(rect)\n", "axs[0].set_xlim((0, T_full.shape[0]))\n", "axs[0].set_ylim((-0.1, T_full.max()+5))\n", "axs[1].set_xlim((0, T_full.shape[0]))\n", "axs[1].set_ylim((-0.1, P_max+5))\n", "axs[0].axvline(x=643, linestyle=\"dashed\")\n", "axs[0].axvline(x=8724, linestyle=\"dashed\")\n", "axs[1].axvline(x=643, linestyle=\"dashed\")\n", "axs[1].axvline(x=8724, linestyle=\"dashed\")\n", "axs[0].set_ylabel(\"Steam Flow\", fontsize='20')\n", "axs[1].set_ylabel(\"Matrix Profile\", fontsize='20')\n", "axs[1].set_xlabel(\"Time\", fontsize='20')\n", "\n", "\n", "lines = []\n", "for ax in axs:\n", " line, = ax.plot([], [], lw=2)\n", " lines.append(line)\n", "line, = axs[1].plot([], [], lw=2)\n", "lines.append(line)\n", " \n", "def init():\n", " for line in lines:\n", " line.set_data([], [])\n", " return lines\n", "\n", "def animate(window):\n", " P, T = window\n", " for line, data in zip(lines, [T, P]):\n", " line.set_data(np.arange(data.shape[0]), data)\n", " \n", " return lines\n", "\n", "anim = animation.FuncAnimation(fig, animate, init_func=init,\n", " frames=windows, interval=100, \n", " blit=True, repeat=False)\n", "\n", "anim_out = anim.to_jshtml()\n", "plt.close() # Prevents duplicate image from displaying\n", "if os.path.exists(\"None0000000.png\"):\n", " os.remove(\"None0000000.png\") # Delete rogue temp file \n", "\n", "HTML(anim_out)\n", "# anim.save('/tmp/stumpi.mp4')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Here, the vertical dotted lines mark the position of where the global motif pair is expected to be and the gray box emphasizes the corresponding motif subsequences. As you play through this animation you may notice that the matrix profile is constantly changing since past subsequences may find a new nearest neighbor. However, note that any change in the matrix profile can only move downward (toward zero). Throughout most of this animation, the subsequence highlighted on the left (grey box) has a relatively high matrix profile value. However, as the time series extends past the grey box on the right, the aforementioned matrix profile value drops significantly and stabilizes quickly as soon as its nearest neighbor has fully arrived in the stream. This is really cool! In fact, the authors of the original [Matrix Profile I](https://www.cs.ucr.edu/~eamonn/PID4481997_extend_Matrix%20Profile_I.pdf) paper point out that, on this dataset, it would be possible to continue monitoring the matrix profile with `stumpy.stumpi` for several decades before running out of time or memory!" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Bonus Section - Never Update History\n", "\n", "Above, we've gone with the typical definition of a matrix profile. That is, for any given subsequence, `T[i : i + m]`, find the distance to its nearest neighbor, `T[j : j + m]`, regardless of whether `j` is to the left of `i` (i.e., `j < i`) or to the right of `i` (i.e., `j > i`). This means that as new data comes in, even the matrix profiles for the past historical data points also get updated if a \"new\" nearest neighbor has revealed itself. Essentially, this is \"hindsight\". So, there may be a case where, the first time you see a unique subsequence, you may identify it as an anomaly due to its relatively high matrix profile value. However, as more and more new data arrive, this originally anomalous subsequence may no longer be unique anymore. Consider observing only the first period of a sine wave, all of these subsequence would be unique. But as the next period of the sine wave starts to stream in, we realize that the data points in the first period are no longer anomalous so we update their matrix profile values accordingly.\n", "\n", "Now, this may or may not be beneficial depending on how you choose to define an \"anomaly\". In fact, you may choose not to update the matrix profiles from the past and you may want to restrict the search for a nearest neighbor, `j`, to always be to the left of `i` (i.e., `j < i`). Luckily, in `stumpy.stumpi` this is already done for you and you can access the left matrix profile and the left matrix profile indices via the `.left_P` and the `.left_I` attributes, respectively, of your streaming object:" ] }, { "cell_type": "code", "execution_count": 20, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Full Matrix Profile: [1.78 1.53 1.49 1.19 2.13 1.66 2.5 2.35 1.94 2.29 2.35 2.33 1.97 1.66\n", " 2.14 2.77 1.99 1.94 2.59 2.53 2.56 2.7 2.27 2.23 2.13 1.4 1.97 1.92\n", " 2.35 1.88 1.81 2.12 2.19 2.3 1.78 1.75 1.39 2.5 2.14 1.94 2.29 2.35\n", " 2.15 1.85 1.95 1.16 1.39 2.21 2.35 1.88 1.81 1.99 2.4 2.15 1.53 1.49\n", " 1.16]\n", "Left Matrix Profile: [ inf inf inf 2.81 3.75 4.04 3.53 3.7 3.65 2.92 2.79 2.61 2.39 1.66\n", " 2.72 2.77 3.01 2.96 2.94 2.53 2.62 2.7 2.33 2.71 2.67 1.4 1.97 1.92\n", " 2.56 2.47 2.27 2.23 2.19 2.3 1.78 1.75 2.34 2.5 2.14 1.94 2.29 2.35\n", " 2.55 2.39 2.13 1.8 1.39 2.21 2.35 1.88 1.81 1.99 2.4 2.15 1.53 1.49\n", " 1.16]\n", "Full Matrix Profile Indices: [34 54 55 56 46 13 37 38 39 40 41 22 26 5 38 39 51 55 56 4 28 10 30 31\n", " 44 3 12 5 48 49 50 49 24 25 0 1 46 6 14 8 9 10 53 54 55 56 36 36\n", " 28 29 30 16 7 42 1 2 45]\n", "Left Matrix Profile Indices: [-1 -1 -1 0 1 2 3 4 5 1 2 3 4 5 10 11 9 2 3 4 9 10 11 9\n", " 10 3 12 5 20 7 22 23 24 25 0 1 4 6 14 8 9 10 11 34 24 3 36 36\n", " 28 29 30 16 7 42 1 2 45]\n" ] } ], "source": [ "T_full = np.random.rand(64)\n", "m = 8\n", "\n", "T_stream = T_full[:10].copy()\n", "stream = stumpy.stumpi(T_stream, m, egress=False) # Don't egress/remove the oldest data point when streaming. To egress, set `egress=True`\n", "\n", "for i in range(len(T_stream), len(T_full)):\n", " t = T_full[i]\n", " stream.update(t)\n", "\n", "print(f\"Full Matrix Profile: {np.round(stream.P_, 2)}\")\n", "print(f\"Left Matrix Profile: {np.round(stream.left_P_, 2)}\")\n", "print(f\"Full Matrix Profile Indices: {stream.I_}\")\n", "print(f\"Left Matrix Profile Indices: {stream.left_I_}\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Of course, it is important to point out that a `-1` value in the left matrix profile indices does not correspond to the last subsequence in the time series. Instead, it means that the subsequence in that position has no valid nearest neighbor to its left. Consequently, the corresponding left matrix profile value will be set to `np.inf`." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Summary\n", "\n", "And that's it! You've just learned how to incrementally update your matrix profile for streaming (on-line) data. \n", "\n", "## Resources\n", "\n", "[Matrix Profile I](https://www.cs.ucr.edu/~eamonn/PID4481997_extend_Matrix%20Profile_I.pdf)\n", "\n", "[Time Series Joins, Motifs, Discords and Shapelets:\n", "A Unifying View that Exploits the Matrix Profile](https://www.cs.ucr.edu/~eamonn/MP_journal.pdf) (see Section 4.6 and Table 5)\n", "\n", "\n", "[STUMPY Documentation](https://stumpy.readthedocs.io/en/latest/)\n", "\n", "[STUMPY Matrix Profile Github Code Repository](https://github.com/TDAmeritrade/stumpy)" ] } ], "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.9.6" } }, "nbformat": 4, "nbformat_minor": 4 }