├── Chart Pattern Recognition.ipynb ├── README.md └── images ├── chart.png └── table.png /Chart Pattern Recognition.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# Chart Pattern Recognition" 8 | ] 9 | }, 10 | { 11 | "cell_type": "markdown", 12 | "metadata": {}, 13 | "source": [ 14 | "This feature engineering example involves a method for chart pattern recognition. Stemming from the idea that voice recognition is basically looking for patterns in waveforms, it seemed plausible that this could apply to normalized stock returns. This example uses closing price data for Microsoft from January 2000 to April 2018 (data from Quandl)." 15 | ] 16 | }, 17 | { 18 | "cell_type": "markdown", 19 | "metadata": {}, 20 | "source": [ 21 | "The following approach takes a rolling one-month window of price data, normalizes the data by converting it to cumulative percent returns over the period, and then stores the pattern. Next, it steps the window forward by one day and repeats the process to collect all possible historical patterns." 22 | ] 23 | }, 24 | { 25 | "cell_type": "markdown", 26 | "metadata": {}, 27 | "source": [ 28 | "Then we can compare the current period’s pattern to historical patterns, extract those patterns similar to the current pattern, and use the mean outcome of those similar patterns as the basis for the buy or sell recommendation. This is shown by the dots on the right-hand side of the chart — the green and red dots are the outcomes of the historical patterns, the yellow dot is the mean of those outcomes, which is the recommendation, and the purple dot is the actual outcome of the current pattern being evaluated." 29 | ] 30 | }, 31 | { 32 | "cell_type": "markdown", 33 | "metadata": {}, 34 | "source": [ 35 | "![alt text](chart.png \"Title\")" 36 | ] 37 | }, 38 | { 39 | "cell_type": "markdown", 40 | "metadata": {}, 41 | "source": [ 42 | "Testing this across about 200 patterns to evaluate predictive strength generated a 64% accuracy rate which is encouraging." 43 | ] 44 | }, 45 | { 46 | "cell_type": "markdown", 47 | "metadata": {}, 48 | "source": [ 49 | "![alt text](table.png \"Title\")" 50 | ] 51 | }, 52 | { 53 | "cell_type": "markdown", 54 | "metadata": {}, 55 | "source": [ 56 | "### Import dependencies" 57 | ] 58 | }, 59 | { 60 | "cell_type": "code", 61 | "execution_count": 3, 62 | "metadata": {}, 63 | "outputs": [], 64 | "source": [ 65 | "import pandas as pd\n", 66 | "import seaborn as sns\n", 67 | "import matplotlib.pyplot as plt\n", 68 | "import numpy as np\n", 69 | "from matplotlib import style\n", 70 | "style.use(\"ggplot\")\n", 71 | "%matplotlib inline" 72 | ] 73 | }, 74 | { 75 | "cell_type": "markdown", 76 | "metadata": {}, 77 | "source": [ 78 | "### Import data" 79 | ] 80 | }, 81 | { 82 | "cell_type": "code", 83 | "execution_count": 5, 84 | "metadata": {}, 85 | "outputs": [], 86 | "source": [ 87 | "stock = pd.read_csv('msft_prices.csv', parse_dates=[0]).set_index('Date') # parse dates convert from str to date, [0] is col index\n", 88 | "price = stock.Close.values # convert closing prices to numpy array" 89 | ] 90 | }, 91 | { 92 | "cell_type": "markdown", 93 | "metadata": {}, 94 | "source": [ 95 | "### Set up the rolling window function" 96 | ] 97 | }, 98 | { 99 | "cell_type": "code", 100 | "execution_count": 8, 101 | "metadata": {}, 102 | "outputs": [], 103 | "source": [ 104 | "def strided_app(prices, window_len, stride_step=1):\n", 105 | " ''' Takes a winow length of data points, steps forward by the stride_step, and\n", 106 | " repeats to collect all the data points into an array. \n", 107 | " \n", 108 | " Parameters\n", 109 | " ----------\n", 110 | " prices = closing price data\n", 111 | " window_len = 21 for 20 trading days or a 1 month window \n", 112 | " stride_step = step the window forward by one day \n", 113 | " \n", 114 | " Output\n", 115 | " ------\n", 116 | " Strided window of determined length and step function ''' \n", 117 | " \n", 118 | " nrows = ((prices.size - window_len)//stride_step) + 1\n", 119 | " n = prices.strides[0]\n", 120 | " \n", 121 | " return np.lib.stride_tricks.as_strided(prices, shape=(nrows, window_len), \n", 122 | " strides=(stride_step * n, n))" 123 | ] 124 | }, 125 | { 126 | "cell_type": "markdown", 127 | "metadata": {}, 128 | "source": [ 129 | "### Collect historical patterns of cumulative percentage price return data" 130 | ] 131 | }, 132 | { 133 | "cell_type": "code", 134 | "execution_count": 22, 135 | "metadata": {}, 136 | "outputs": [], 137 | "source": [ 138 | "def stored_cumPatterns(prices, window_len, stride_step=1):\n", 139 | " ''' Collects cumulative pct-change patterns (which normalizes the data) over \n", 140 | " the window period for each step forward (stride) through the price series. ''' \n", 141 | "\n", 142 | " # Array where each row has window_len of closing prices, by calling the strided_app function\n", 143 | " pattern_window = strided_app(prices, window_len, stride_step)\n", 144 | " # Normalize closing prices to cumulative percentage returns\n", 145 | " stored_cum_patts = (pattern_window[:,1:] / pattern_window[:,0:1] - 1) * 100\n", 146 | " \n", 147 | " return stored_cum_patts" 148 | ] 149 | }, 150 | { 151 | "cell_type": "markdown", 152 | "metadata": {}, 153 | "source": [ 154 | "The first two rows of window percentage returns are shown below, each row with 20 days of cumulative return figures." 155 | ] 156 | }, 157 | { 158 | "cell_type": "code", 159 | "execution_count": 27, 160 | "metadata": {}, 161 | "outputs": [ 162 | { 163 | "data": { 164 | "text/plain": [ 165 | "array([[ -3.38023336, -2.35929993, -5.62800275, -4.39258751,\n", 166 | " -3.69766644, -6.16849691, -9.22271791, -7.50686342,\n", 167 | " -3.69766644, -1.07240906, -8.20178449, -9.05971174,\n", 168 | " -10.99004804, -13.13486616, -11.79649966, -14.74776939,\n", 169 | " -15.27968428, -15.70864791, -16.03466026, -11.68496911],\n", 170 | " [ 1.05665068, -2.32640739, -1.04777127, -0.32853845,\n", 171 | " -2.88581069, -6.04688332, -4.27099982, -0.32853845,\n", 172 | " 2.38856331, -4.99023264, -5.87817439, -7.87604333,\n", 173 | " -10.09589771, -8.71070858, -11.7652282 , -12.31575209,\n", 174 | " -12.75972296, -13.09714083, -8.59527615, -10.48659208]])" 175 | ] 176 | }, 177 | "execution_count": 27, 178 | "metadata": {}, 179 | "output_type": "execute_result" 180 | } 181 | ], 182 | "source": [ 183 | "stored_cumPatterns(prices=price, window_len=21, stride_step=1)[:2]" 184 | ] 185 | }, 186 | { 187 | "cell_type": "code", 188 | "execution_count": 28, 189 | "metadata": {}, 190 | "outputs": [], 191 | "source": [ 192 | "def stored_dailyPatterns(prices, window_len, stride_step=1):\n", 193 | " ''' Gets the daily percent change patterns for the period. ''' \n", 194 | " \n", 195 | " # Array where each row has window_len of closing prices, by calling the strided_app function\n", 196 | " pattern_window = strided_app(prices, window_len, stride_step)\n", 197 | " # Normalize closing prices to daily percentage returns\n", 198 | " stored_daily_patts = (pattern_window[:,1:] / pattern_window[:,:-1] - 1) * 100\n", 199 | "\n", 200 | " return stored_daily_patts" 201 | ] 202 | }, 203 | { 204 | "cell_type": "markdown", 205 | "metadata": {}, 206 | "source": [ 207 | "### Collect the current pattern of cumulative percentage price return for comparison" 208 | ] 209 | }, 210 | { 211 | "cell_type": "code", 212 | "execution_count": 18, 213 | "metadata": {}, 214 | "outputs": [], 215 | "source": [ 216 | "def curr_cumPattern(prices, curr_patt_start, window_len, stride_step=1):\n", 217 | " ''' Gets the specified cumulative pct-change pattern for the window period. '''\n", 218 | " \n", 219 | " stored_cum_patts = stored_cumPatterns(prices, window_len, stride_step)\n", 220 | " curr_cum_patt = stored_cum_patts[curr_patt_start].reshape(1,-1)\n", 221 | " \n", 222 | " return curr_cum_patt" 223 | ] 224 | }, 225 | { 226 | "cell_type": "markdown", 227 | "metadata": {}, 228 | "source": [ 229 | "A current 20-day pattern is shown below, taken from the 500th trading day within the price history as a starting point for the window period." 230 | ] 231 | }, 232 | { 233 | "cell_type": "code", 234 | "execution_count": 29, 235 | "metadata": {}, 236 | "outputs": [ 237 | { 238 | "data": { 239 | "text/plain": [ 240 | "array([[ 3.26670644, 2.77446301, 2.2673031 , 3.49045346, 2.49105012,\n", 241 | " 3.34128878, 2.34188544, 2.13305489, 3.74403341, 1.23806683,\n", 242 | " 4.20644391, -1.40214797, -3.84844869, -4.92243437, -3.63961814,\n", 243 | " -4.83293556, -4.80310263, -7.04057279, -6.25 , -4.96718377]])" 244 | ] 245 | }, 246 | "execution_count": 29, 247 | "metadata": {}, 248 | "output_type": "execute_result" 249 | } 250 | ], 251 | "source": [ 252 | "curr_cumPattern(prices=price, curr_patt_start=500, window_len=21, stride_step=1)" 253 | ] 254 | }, 255 | { 256 | "cell_type": "code", 257 | "execution_count": 19, 258 | "metadata": {}, 259 | "outputs": [], 260 | "source": [ 261 | "def curr_dailyPattern(prices, curr_patt_start, window_len, stride_step=1):\n", 262 | " ''' Gets the daily percent change patterns for the period. ''' \n", 263 | " \n", 264 | " stored_daily_patts = stored_dailyPatterns(prices, window_len, stride_step)\n", 265 | " curr_daily_patt = stored_daily_patts[curr_patt_start].reshape(1,-1)\n", 266 | " \n", 267 | " return curr_daily_patt" 268 | ] 269 | }, 270 | { 271 | "cell_type": "markdown", 272 | "metadata": {}, 273 | "source": [ 274 | "### Compare current pattern to historical patterns for recognition" 275 | ] 276 | }, 277 | { 278 | "cell_type": "markdown", 279 | "metadata": {}, 280 | "source": [ 281 | "A simple way to identify similar patterns is to compare the number of up/down days in the window period. This can be done by converting the pct-change patterns to positive/negative days using numpy.sign. Then count those days in the window period where the sign matches the stored pattern and divide by the number of elements in the window period to get a percentage of days matched. Once all stored patterns have been compared to the current pattern, a cut-off threshold for a minimum level of similarity can then be applied to extract only those deemed similar enough. Conceptually, this is akin to a right-tail significance interval of a distribution.\n", 282 | "\n", 283 | "This isn't ideal as matching daily returns can understate the match while cumulative returns can overstate the match. To overcome this, an average of the daily and cumulative comparisons has been used as a compromise." 284 | ] 285 | }, 286 | { 287 | "cell_type": "code", 288 | "execution_count": 20, 289 | "metadata": {}, 290 | "outputs": [], 291 | "source": [ 292 | "def pattComp(prices, curr_patt_start, window_len, stride_step=1):\n", 293 | " ''' Counts the number of same-sign returns where a cut-off threshold for \n", 294 | " similarity can be applied. This needs to be an average of cumulative\n", 295 | " daily comparisons for a more stable cut-off threshold level. ''' \n", 296 | " \n", 297 | " # Call the current cumulative return pattern and stored cumulative return patterns:\n", 298 | " curr_cum_patt = curr_cumPattern(prices, curr_patt_start, window_len, \n", 299 | " stride_step).reshape(1,-1)\n", 300 | " stored_cum_patts = stored_cumPatterns(prices, window_len, stride_step)\n", 301 | " \n", 302 | " \n", 303 | " # Call the current daily return pattern and stored daily return patterns:\n", 304 | " curr_daily_patt = curr_dailyPattern(prices, curr_patt_start, window_len, \n", 305 | " stride_step).reshape(1,-1)\n", 306 | " stored_daily_patts = stored_dailyPatterns(prices, window_len, stride_step)\n", 307 | " \n", 308 | " # Count the number of matching signs, divide by window elements to get matching percent\n", 309 | " cum_comp = np.sum( np.sign(curr_cum_patt) == \n", 310 | " np.sign(stored_cum_patts), axis=1 ) / curr_cum_patt.size \n", 311 | " daily_comp = np.sum( np.sign(curr_daily_patt) == \n", 312 | " np.sign(stored_daily_patts), axis=1 ) / curr_daily_patt.size\n", 313 | " \n", 314 | " # Take the blended average of the two comparison methods above\n", 315 | " both_comp = np.mean((daily_comp, cum_comp), axis=0)\n", 316 | " \n", 317 | " return cum_comp, daily_comp, both_comp" 318 | ] 319 | }, 320 | { 321 | "cell_type": "markdown", 322 | "metadata": {}, 323 | "source": [ 324 | "#### Plot a historgram of pattern similarities to get a sense of what is going on..." 325 | ] 326 | }, 327 | { 328 | "cell_type": "markdown", 329 | "metadata": {}, 330 | "source": [ 331 | "Overlaying the distribution of pattern comparisons for the cumulative returns, daily returns and the average of the two gives a clearer picture or sense of what things look like. Change the curr_patt_start to anything less than 4565 (which is the index start point for the most recent pattern for comparison) to see how the distributions vary. " 332 | ] 333 | }, 334 | { 335 | "cell_type": "code", 336 | "execution_count": 30, 337 | "metadata": {}, 338 | "outputs": [], 339 | "source": [ 340 | "def plotHistograms(prices, curr_patt_start, window_len, stride_step=1):\n", 341 | " \n", 342 | " cum_comp, daily_comp, both_comp = pattComp(prices, curr_patt_start, \n", 343 | " window_len, stride_step)\n", 344 | "\n", 345 | " plt.hist(both_comp, label='both_comp', alpha=0.7)\n", 346 | " names = ['cum_comp', 'daily_comp']\n", 347 | " plt.hist([cum_comp, daily_comp], label=names , alpha=0.8)\n", 348 | " \n", 349 | " plt.title('Both Pattern Comparison')\n", 350 | " plt.legend()" 351 | ] 352 | }, 353 | { 354 | "cell_type": "code", 355 | "execution_count": 46, 356 | "metadata": {}, 357 | "outputs": [ 358 | { 359 | "data": { 360 | "image/png": "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\n", 361 | "text/plain": [ 362 | "" 363 | ] 364 | }, 365 | "metadata": {}, 366 | "output_type": "display_data" 367 | } 368 | ], 369 | "source": [ 370 | "plotHistograms(prices=price, curr_patt_start=4560, window_len=21, stride_step=1)" 371 | ] 372 | }, 373 | { 374 | "cell_type": "markdown", 375 | "metadata": {}, 376 | "source": [ 377 | "### Retrieve the similar patterns" 378 | ] 379 | }, 380 | { 381 | "cell_type": "markdown", 382 | "metadata": {}, 383 | "source": [ 384 | "With the current pattern compared to all previous patterns, we can now extract only the similar ones by defining a minimum cut-off threshold for perecentage similarity." 385 | ] 386 | }, 387 | { 388 | "cell_type": "code", 389 | "execution_count": 49, 390 | "metadata": {}, 391 | "outputs": [], 392 | "source": [ 393 | "def retrieve_cumSimPatts(prices, curr_patt_start, window_len, sim_threshold, \n", 394 | " stride_step=1):\n", 395 | " ''' need to retrieve stored_cumPatts that correspond w the stored_dailyPatts.\n", 396 | " -- use patt_sim_index to lookup from stored_cumPatts '''\n", 397 | " \n", 398 | " patt_similarity = pattComp(prices, curr_patt_start, window_len, stride_step)[2] # 2=both_comp\n", 399 | " patt_sim_index = np.where(patt_similarity > sim_threshold)[0]\n", 400 | " sim_patts_cum = stored_cumPatterns(prices, window_len, stride_step)[patt_sim_index]\n", 401 | " \n", 402 | " return sim_patts_cum" 403 | ] 404 | }, 405 | { 406 | "cell_type": "markdown", 407 | "metadata": {}, 408 | "source": [ 409 | "As an example, below shows the current pattern (from index start 4560) has 60 historical patterns that match with an 80% degree of similarity." 410 | ] 411 | }, 412 | { 413 | "cell_type": "code", 414 | "execution_count": 55, 415 | "metadata": {}, 416 | "outputs": [ 417 | { 418 | "data": { 419 | "text/plain": [ 420 | "60" 421 | ] 422 | }, 423 | "execution_count": 55, 424 | "metadata": {}, 425 | "output_type": "execute_result" 426 | } 427 | ], 428 | "source": [ 429 | "retrieve_cumSimPatts(prices=price, curr_patt_start=4560, window_len=21, \n", 430 | " sim_threshold=0.8, stride_step=1).shape[0]" 431 | ] 432 | }, 433 | { 434 | "cell_type": "code", 435 | "execution_count": 48, 436 | "metadata": {}, 437 | "outputs": [], 438 | "source": [ 439 | "def retrieve_dailySimPatts(prices, curr_patt_start, window_len, sim_threshold, \n", 440 | " stride_step=1):\n", 441 | " \n", 442 | " patt_similarity = pattComp(prices, curr_patt_start, window_len, stride_step)[2] # 2=both_comp\n", 443 | " patt_sim_index = np.where(patt_similarity > sim_threshold)[0]\n", 444 | " sim_patts_daily = stored_dailyPatterns(prices, window_len, stride_step)[patt_sim_index]\n", 445 | " \n", 446 | " return sim_patts_daily" 447 | ] 448 | }, 449 | { 450 | "cell_type": "markdown", 451 | "metadata": {}, 452 | "source": [ 453 | "### Evaluate the pattern outcomes" 454 | ] 455 | }, 456 | { 457 | "cell_type": "markdown", 458 | "metadata": {}, 459 | "source": [ 460 | "These functions calculate the returns of the patterns that are similar to the current pattern and then uses the mean of those similar returns as the predicted return for current pattern we are trying to predict." 461 | ] 462 | }, 463 | { 464 | "cell_type": "code", 465 | "execution_count": 68, 466 | "metadata": {}, 467 | "outputs": [], 468 | "source": [ 469 | "def stored_patts_returnOutcome(prices, curr_patt_start, window_len, return_period, \n", 470 | " sim_threshold, stride_step=1):\n", 471 | " ''' Then need to get the start price of the corresponding matched pattern from \n", 472 | " stored_cumPatts to calculate the return. (use the start price because we\n", 473 | " are extending the cumulative return pattern. '''\n", 474 | " patt_similarity = pattComp(prices, curr_patt_start, window_len, stride_step)[2] # 2=both_comp\n", 475 | " \n", 476 | " startprice_index = np.where(patt_similarity > sim_threshold)[0]\n", 477 | " stored_patts_startprice = prices[startprice_index]\n", 478 | " \n", 479 | " outcome_prices_index = np.clip(np.where(patt_similarity > sim_threshold)[0] +\n", 480 | " return_period+window_len, a_min=0, \n", 481 | " a_max=len(prices)-window_len)\n", 482 | " stored_patts_outcome_prices = prices[outcome_prices_index]\n", 483 | " \n", 484 | " stored_patts_outcome_returns = (stored_patts_outcome_prices / \n", 485 | " stored_patts_startprice -1 ) * 100\n", 486 | " \n", 487 | " return stored_patts_outcome_returns" 488 | ] 489 | }, 490 | { 491 | "cell_type": "code", 492 | "execution_count": 69, 493 | "metadata": {}, 494 | "outputs": [], 495 | "source": [ 496 | "def predictedOutcome(prices, curr_patt_start, window_len, return_period, \n", 497 | " sim_threshold, stride_step=1):\n", 498 | " ''' Predicted outcome is just be the average of past similar patt outcomes. '''\n", 499 | " \n", 500 | " stored_patts_outcome_returns = stored_patts_returnOutcome(prices, curr_patt_start, \n", 501 | " window_len, return_period, \n", 502 | " sim_threshold, stride_step)\n", 503 | " \n", 504 | " return np.mean(stored_patts_outcome_returns)" 505 | ] 506 | }, 507 | { 508 | "cell_type": "markdown", 509 | "metadata": {}, 510 | "source": [ 511 | "This function calculates the actual return of the pattern we are trying to predict." 512 | ] 513 | }, 514 | { 515 | "cell_type": "code", 516 | "execution_count": 70, 517 | "metadata": {}, 518 | "outputs": [], 519 | "source": [ 520 | "def curr_patt_returnOutcome(prices, curr_patt_start, window_len, return_period): # curr_patt_start will be 'i' in the loop\n", 521 | " ''' Actual cumulative return of the current pattern. ''' \n", 522 | " curr_patt_start_price = prices[curr_patt_start]\n", 523 | " curr_patt_outcome_price = prices[curr_patt_start + window_len + return_period-1]\n", 524 | " curr_patt_outcome_return = (curr_patt_outcome_price / curr_patt_start_price -1 ) * 100\n", 525 | " \n", 526 | " return curr_patt_outcome_return" 527 | ] 528 | }, 529 | { 530 | "cell_type": "markdown", 531 | "metadata": {}, 532 | "source": [ 533 | "### Visualizations" 534 | ] 535 | }, 536 | { 537 | "cell_type": "code", 538 | "execution_count": 74, 539 | "metadata": {}, 540 | "outputs": [], 541 | "source": [ 542 | "def run_charts(prices, curr_patt_start, window_len, return_period, \n", 543 | " sim_threshold, stride_step=1):\n", 544 | " \n", 545 | " fig = plt.figure(figsize=(9,9)) \n", 546 | " \n", 547 | " curr_cum_patt = curr_cumPattern(prices, curr_patt_start, window_len, stride_step)\n", 548 | " curr_daily_patt = curr_dailyPattern(prices, curr_patt_start, window_len, stride_step)\n", 549 | " sim_patts_cum = retrieve_cumSimPatts(prices, curr_patt_start, window_len, \n", 550 | " sim_threshold, stride_step)\n", 551 | " sim_patts_daily = retrieve_dailySimPatts(prices, curr_patt_start, window_len, \n", 552 | " sim_threshold, stride_step)\n", 553 | " \n", 554 | " stored_patts_outcome_returns = stored_patts_returnOutcome(prices, curr_patt_start, \n", 555 | " window_len, return_period, \n", 556 | " sim_threshold, stride_step)\n", 557 | " \n", 558 | " pred_outcome = predictedOutcome(prices, curr_patt_start, window_len, return_period, \n", 559 | " sim_threshold, stride_step) \n", 560 | " \n", 561 | " curr_patt_outcome_return = curr_patt_returnOutcome(prices, curr_patt_start, \n", 562 | " window_len, return_period) \n", 563 | " \n", 564 | "\n", 565 | " # CUMULATIVE PATTERNS\n", 566 | " ax1 = fig.add_subplot(211)\n", 567 | " # Similar patterns:\n", 568 | " counter = 0\n", 569 | " for i in sim_patts_cum: \n", 570 | " if stored_patts_outcome_returns[counter:counter+1] > curr_cum_patt[0][-1]:\n", 571 | " dot_color = 'green'\n", 572 | " else: dot_color = 'red' \n", 573 | " plt.scatter( window_len + return_period - 1, \n", 574 | " stored_patts_outcome_returns[counter:counter+1], \n", 575 | " c = dot_color, alpha=0.3) \n", 576 | " plt.plot(sim_patts_cum[counter:counter+1][0], alpha=0.5)\n", 577 | " counter += 1\n", 578 | " # Predicted Outcome:\n", 579 | " plt.scatter( window_len + return_period - 2 , pred_outcome, \n", 580 | " c='yellow', label = 'Predicted Outcome') \n", 581 | " # Actual Outcome:\n", 582 | " plt.scatter( window_len + return_period - 2 , curr_patt_outcome_return , \n", 583 | " c='purple', label = 'Actual Outcome')\n", 584 | " # Current Pattern:\n", 585 | " plt.plot(curr_cum_patt[0], linewidth=3, c='blue', label = 'Current Pattern') \n", 586 | " plt.title('Cumulative Pattern Comparison')\n", 587 | " plt.legend()\n", 588 | "\n", 589 | "\n", 590 | " # DAILY PATTERNS\n", 591 | " ax2 = fig.add_subplot(212)\n", 592 | " plt.scatter(window_len + return_period - 1, 1, c='grey', alpha=0.01) # this is just to keep x-axis same as cumulative chart\n", 593 | " # Similar patterns:\n", 594 | " counter = 0\n", 595 | " for i in sim_patts_daily:\n", 596 | " plt.plot(sim_patts_daily[counter:counter+1][0], alpha=0.5)\n", 597 | " counter += 1\n", 598 | " # Current Pattern:\n", 599 | " plt.plot(curr_daily_patt[0], linewidth=3, c='blue', label = 'Current Pattern')\n", 600 | " plt.title('Daily Pattern Comparison')\n", 601 | " plt.legend()" 602 | ] 603 | }, 604 | { 605 | "cell_type": "code", 606 | "execution_count": 111, 607 | "metadata": {}, 608 | "outputs": [ 609 | { 610 | "data": { 611 | "image/png": "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\n", 612 | "text/plain": [ 613 | "" 614 | ] 615 | }, 616 | "metadata": {}, 617 | "output_type": "display_data" 618 | } 619 | ], 620 | "source": [ 621 | "run_charts(prices=price, curr_patt_start=455, window_len=21, return_period=10, \n", 622 | " sim_threshold=0.8)" 623 | ] 624 | }, 625 | { 626 | "cell_type": "markdown", 627 | "metadata": {}, 628 | "source": [] 629 | }, 630 | { 631 | "cell_type": "code", 632 | "execution_count": 80, 633 | "metadata": {}, 634 | "outputs": [], 635 | "source": [ 636 | "def run_update(prices, window_len, return_period, sim_threshold, stride_step=1): \n", 637 | " \n", 638 | " # Setup empty df to capture scores:\n", 639 | " confusion_matrix = pd.DataFrame(columns = ['Up_pred', 'Down_pred'])\n", 640 | " confusion_matrix['Scores'] = ['Up_outcome', 'Down_outcome', 'Accuracy']\n", 641 | " confusion_matrix = confusion_matrix.set_index('Scores')\n", 642 | " \n", 643 | " true_positive = 0\n", 644 | " false_positive = 0\n", 645 | " true_negative = 0\n", 646 | " false_negative = 0\n", 647 | " \n", 648 | " \n", 649 | " for i in range(1, int(len(prices)/window_len)):\n", 650 | " curr_patt_start = len(prices) - return_period - window_len*i\n", 651 | " \n", 652 | " # Storing patterns:\n", 653 | " stored_cum_patts = stored_cumPatterns(prices, window_len, stride_step=1)\n", 654 | " stored_daily_patts = stored_dailyPatterns(prices, window_len, stride_step=1)\n", 655 | " \n", 656 | " curr_cum_patt = curr_cumPattern(prices, curr_patt_start, window_len, stride_step)\n", 657 | " curr_daily_patt = curr_dailyPattern(prices, curr_patt_start, window_len, stride_step) \n", 658 | " \n", 659 | " # Comparing patterns:\n", 660 | " patt_comps = pattComp(prices, curr_patt_start, window_len, stride_step)[2] # 2=both_comp\n", 661 | " sim_patts_daily = retrieve_dailySimPatts(prices, curr_patt_start, window_len, \n", 662 | " sim_threshold, stride_step)\n", 663 | " sim_patts_cum = retrieve_cumSimPatts(prices, curr_patt_start, window_len, \n", 664 | " sim_threshold, stride_step)\n", 665 | " # Pattern return outcomes and pred:\n", 666 | " stored_patts_outcome_returns = stored_patts_returnOutcome(prices, curr_patt_start, \n", 667 | " window_len, \n", 668 | " return_period, \n", 669 | " sim_threshold, \n", 670 | " stride_step)\n", 671 | " pred_outcome = predictedOutcome(prices, curr_patt_start, window_len, \n", 672 | " return_period, sim_threshold, stride_step)\n", 673 | " curr_patt_outcome_return = curr_patt_returnOutcome(prices, curr_patt_start, \n", 674 | " window_len, return_period)\n", 675 | " \n", 676 | " # Scoring: \n", 677 | " if pred_outcome > curr_cum_patt[0][-1] and curr_patt_outcome_return >= curr_cum_patt[0][-1]:\n", 678 | " true_positive += 1\n", 679 | " elif pred_outcome > curr_cum_patt[0][-1] and curr_patt_outcome_return < curr_cum_patt[0][-1]:\n", 680 | " false_positive += 1\n", 681 | " elif pred_outcome < curr_cum_patt[0][-1] and curr_patt_outcome_return <= curr_cum_patt[0][-1]:\n", 682 | " true_negative += 1\n", 683 | " else: false_negative += 1\n", 684 | " \n", 685 | "\n", 686 | " # Record scores in rgr_scores df:\n", 687 | " confusion_matrix.iloc[0, 0] = true_positive\n", 688 | " confusion_matrix.iloc[0, 1] = false_positive\n", 689 | " confusion_matrix.iloc[1, 1] = true_negative\n", 690 | " confusion_matrix.iloc[1, 0] = false_negative\n", 691 | " \n", 692 | " correct_preds = true_positive + true_negative\n", 693 | " incorrect_preds = false_positive + false_negative\n", 694 | " accuracy = correct_preds / (correct_preds + incorrect_preds)\n", 695 | " \n", 696 | " confusion_matrix.iloc[2:3, 0:1] = accuracy\n", 697 | "\n", 698 | " return confusion_matrix" 699 | ] 700 | }, 701 | { 702 | "cell_type": "code", 703 | "execution_count": 81, 704 | "metadata": {}, 705 | "outputs": [ 706 | { 707 | "data": { 708 | "text/html": [ 709 | "
\n", 710 | "\n", 723 | "\n", 724 | " \n", 725 | " \n", 726 | " \n", 727 | " \n", 728 | " \n", 729 | " \n", 730 | " \n", 731 | " \n", 732 | " \n", 733 | " \n", 734 | " \n", 735 | " \n", 736 | " \n", 737 | " \n", 738 | " \n", 739 | " \n", 740 | " \n", 741 | " \n", 742 | " \n", 743 | " \n", 744 | " \n", 745 | " \n", 746 | " \n", 747 | " \n", 748 | " \n", 749 | " \n", 750 | " \n", 751 | " \n", 752 | " \n", 753 | "
Up_predDown_pred
Scores
Up_outcome8939
Down_outcome4049
Accuracy0.635945NaN
\n", 754 | "
" 755 | ], 756 | "text/plain": [ 757 | " Up_pred Down_pred\n", 758 | "Scores \n", 759 | "Up_outcome 89 39\n", 760 | "Down_outcome 40 49\n", 761 | "Accuracy 0.635945 NaN" 762 | ] 763 | }, 764 | "execution_count": 81, 765 | "metadata": {}, 766 | "output_type": "execute_result" 767 | } 768 | ], 769 | "source": [ 770 | "run_update(prices=price, window_len=21, return_period=10, sim_threshold=0.8, stride_step=1)" 771 | ] 772 | }, 773 | { 774 | "cell_type": "code", 775 | "execution_count": null, 776 | "metadata": {}, 777 | "outputs": [], 778 | "source": [] 779 | } 780 | ], 781 | "metadata": { 782 | "kernelspec": { 783 | "display_name": "Python 3", 784 | "language": "python", 785 | "name": "python3" 786 | }, 787 | "language_info": { 788 | "codemirror_mode": { 789 | "name": "ipython", 790 | "version": 3 791 | }, 792 | "file_extension": ".py", 793 | "mimetype": "text/x-python", 794 | "name": "python", 795 | "nbconvert_exporter": "python", 796 | "pygments_lexer": "ipython3", 797 | "version": "3.7.2" 798 | } 799 | }, 800 | "nbformat": 4, 801 | "nbformat_minor": 2 802 | } 803 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | ## Chart Pattern Recognition 2 | ### Identifying stock chart patterns and evaluating predicted trade outcomes 3 | 4 | This feature engineering example involves a method for chart pattern recognition. Stemming from the idea that voice recognition is basically looking for patterns in waveforms, it seemed plausible that this could apply to normalized stock returns. This example uses closing price data for Microsoft from January 2000 to April 2018 (data from Quandl). 5 | 6 | The following approach takes a rolling one-month window of price data, normalizes the data by converting it to cumulative percent returns over the period, and then stores the pattern. Next, it steps the window forward by one day and repeats the process to collect all possible historical patterns. 7 | 8 | Then we can compare the current period’s pattern to historical patterns, extract those patterns similar to the current pattern, and use the mean outcome of those similar patterns as the basis for the buy or sell recommendation. This is shown by the dots on the right-hand side of the chart — the green and red dots are the outcomes of the historical patterns, the yellow dot is the mean of those outcomes, which is the recommendation, and the purple dot is the actual outcome of the current pattern being evaluated. 9 | 10 | ![My image](https://github.com/footfalcon/Chart_Pattern_Recognition/blob/master/images/chart.png) 11 | 12 | Initial testing across about 200 patterns to evaluate predictive strength generated a 64% accuracy rate. 13 | 14 | ![My image](https://github.com/footfalcon/Chart_Pattern_Recognition/blob/master/images/table.png 15 | ) 16 | -------------------------------------------------------------------------------- /images/chart.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/footfalcon/Chart_Pattern_Recognition/7805427ad11ac0870cf8ff967200709eedb78e38/images/chart.png -------------------------------------------------------------------------------- /images/table.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/footfalcon/Chart_Pattern_Recognition/7805427ad11ac0870cf8ff967200709eedb78e38/images/table.png --------------------------------------------------------------------------------