TL;DR<\/h2>\n
There’s no TL;DR here — this is a deep dive. KMeans is a great clustering algorithm but, as we see here, falls short of being a useful means of calculating high timeframe support and resistance levels (at least for Bitcoin.)<\/p>\n
Intro: Support & Resistance Levels 101<\/h2>\n
Support and resistance levels are used in technical analysis to predict reversals in price trends. A falling price might<\/em> be likelier to stop falling when it nears a support level. Conversely, a rising stock price might<\/em> be likelier to stop increasing when it nears a resistance level. Support and resistance levels are not infallible and, as we will see later, determining such price ranges is no simple task.<\/p>\n Support levels become resistance levels once broken and likewise resistance levels become support levels when they are broken. As such, the same price levels can be either support\u00a0or<\/em> resistance depending on price action. According to Richard Schabacker’s classic\u00a0Technical Analysis & Stock Market Profits<\/em><\/a> such key levels can be described as follows:<\/p>\n This last one is important — certain numbers that stand out tend to become support and resistance levels. For example, $100, $500, or $1,000 may represent concrete areas of support and resistance. However, smaller whole-dollar amounts such as $15, $25, and $30 may also act as support and resistance depending on the dynamics of the underlying asset, price history, and time period.<\/p>\n In figure 1 we see a rising price “breaking through” a previous level to find a new range of resistance, after which the previous resistance level becomes a new support level. This figure illustrates how support and resistance levels can predict price reversals.<\/p>\n Figure 1 illustrates a\u00a0very <\/em>contrived example where support and resistance levels are clearly defined. In practice, technical analysts rarely see such well-defined levels. Let’s consider the daily chart for Amazon from 2018 to midway through 2022.<\/p>\n In 2018, Amazon’s price rose through the bottom line, briefly pulled back and retested, before rising further to the upper line where it met at the red circle marked\u00a02<\/em>. The price then fell, rose, and fell again within this range before eventually moving up again into a new “range.”<\/p>\n Towards the start of 2022, the price began to fall and, in March of 2022, began to fall sharply. The price then “found support” at the point on the upper line marked 5.<\/em> This is the same point on the line where, at the points marked 2 & 4, Amazon’s price had previously shown resistance.<\/p>\n There is much debate regarding how one identifies support and resistance levels. Below are some common points to consider:<\/p>\n How one chooses to incorporate each of these considerations greatly influences the nature of how support and resistance levels are calculated. For example, diagonal support and resistance can be powerful in helping predict small pullbacks during an uptrend. In this case, “breaking support” can be identified as a potential trend reversal.<\/p>\n In this weekly chart of the S&P 500 ETF, an ascending diagonal support and resistance level is established starting around November 2021 and moving through September 2022. As Figure 3 illustrates, these “trendlines” aren’t infallible and there are areas in which the price periodically rises above or below these lines.<\/p>\n Around September 2022, the first weekly close below this line is noted. The price recovers over the next few weeks, all the way up to the resistance line again, before entering a downtrend in the following weeks after that. The trendlines drawn here seem incredibly useful but have the benefit of hindsight. Calculating support and resistance levels in real-time is never as easy.<\/p>\n Drawing lines on this chart is much easier given the history available to guide one’s pencil. The phenomenon, known as Hindsight Bias<\/em>\u00a0a.k.a. the\u00a0I knew it all along<\/em> effect, typically makes drawing trendlines after the fact seem easy 1<\/sup>. Plotting these lines in real-time accurately enough to make trading decisions is much more difficult. For that, one needs some solid rules to fall back on.<\/p>\n There are many ways to calculate support and resistance. Here we will focus on two primary means:<\/p>\n Long-term levels<\/strong> are used to help predict large price reversals marking the start and completion of price movements on longer timelines such as the daily or weekly charts. Trendlines are more useful to predict intraday movements or shorter daily movements.<\/p>\n Here we use K-Means clustering<\/strong> to identify long-term support and resistance levels. For trendlines, a combination of linear regression and minima-maxima calculation is used. Each offer different benefits but, as with many technical indicators, are more powerful when used together.<\/p>\n This isn’t an article on k-means clustering and glazes over the technical details. Essentially, K-Means clustering is an algorithmic way to identify subsets within a larger set of values. See here for more details<\/a>.<\/p>\n Here we apply K-Means clustering to identify long-term support and resistance levels in Python using the With these dependencies, we can load our data, perform a KMeans clustering analysis, and then plot the results for visual inspection. The last part isn’t strictly necessary but will help assess the usefulness of our results.<\/p>\n To get started, we’ll load the data as a Note that we have\u00a0more<\/em> data here than expected. For 5 years each containing 52.1428 weeks we\u00a0should\u00a0<\/em>have a total of 260.714 periods in our data. A quick glance notes the last weekly period includes less than a full week, which means we’re only off by ~2 periods. For our application here — that’s close enough.<\/p>\n This step involves 2 actions; performing the analysis and assigning each price a cluster.<\/p>\n Many of the actual prices have been manually removed from the printout here to save space. However, the full printout of the Plotly integrates conveniently with DataFrame objects. One need only specify that Plotly is to be used via the With this code executed, an instance of the Plotly viewer will launch in the default web browser of the local system:<\/p>\n Here we see each marker, representing a single historical price, assigned a unique color based on which cluster it was assigned. From this data, we can extract our long-term support and resistance values by finding the boundaries between the clusters.<\/p>\n Figure 4 illustrates our clusters separated by color. Conceptually, there would exist a line between each cluster as well — these are the bounding regions that will represent our support and resistance lines. To find these, we need to calculate the minimum and maximum values from each cluster, then decide how we will interpret them.<\/p>\n Here we see each cluster has been assigned a unique This code produces the following chart — again launched in the local web browser:<\/p>\n These lines represent our support and resistance lines. However, there are some issues — both conceptual and practical — that we need to address:<\/p>\n Let’s address each of these in order.<\/p>\n Figure 5 shows a horizontal line plotted for both the minimum and maximum of each cluster. However, it makes conceptual sense that a single line could separate each cluster such that the maximum value of cluster 1 (containing smaller price values) could be combined with cluster 2 (containing larger price values) as such:<\/p>\n Here the maximum value from cluster 1 is combined (averaged) with the minimum value from cluster 2 to form a single boundary between each cluster. Conceptually, this one would represent a resistance line for prices in cluster 1 and a support line for prices in cluster 2.<\/p>\n To apply this concept to our data we need to first ensure that the data is sorted such that the first To assess our results we will again plot these values as before, except we use our values from This produces the following chart:<\/p>\n These lines look much cleaner and more conceptually appropriate. Now we can assess whether using the absolute minima and maxima are useful.<\/p>\n The bottommost and topmost horizontal blue lines represent the smallest and largest recorded prices, respectively. These prices do not provide a useful measure of support and resistance. Arguably, the maximum value\u00a0could<\/em> play a role in the future but the price would need to re-enter that “cluster” for it to be relevant. To drop the first and last lines, we will alter our previous code to the following:<\/p>\n Re-running the code from our original chart creation using this updated This chart looks much more akin to those reflecting support and resistance lines. At first glance, however, these lines don’t appear to be placed in entirely useful locations. To illustrate this point, consider the same figure with manually placed support and resistance lines:<\/p>\n These are by no means perfect but seem to reflect areas in which price action has reversed on several occasions. Finding more appropriate boundary lines can be approached by using different cluster values.<\/p>\n There are many ways in which one can approach optimizing the number of clusters chosen from a dataset. We will use the elbow method — but know there are plenty of other options<\/a>. The elbow method involves calculating a KMeans clustering for a series of different k values.<\/p>\n For each iteration, the sum of the squares of the distance from each cluster point to the cluster center is calculated. Fortunately, this measure is provided by the This provides a list of\u00a0really<\/em> big numbers from which we can approach our optimization. As described by the [The] Sum of squared distances of samples to their closest cluster center, weighted by the sample weights if provided.<\/em><\/p>\n Let’s now plot this new data to assess how we might begin approaching a method to programmatically select an optimal number of KMeans clusters. We’ll use a different graphing method here, still using Plotly:<\/p>\n Using our list of k values as the x-axis and the resulting This suggests that we should use a k-value of 2 — though that hardly seems accurate. Nonetheless, let’s consider have a look:<\/p>\n This seems to be practically useless, producing only a single line somewhere in the $26k range. Clearly, the elbow method isn’t the best approach here. Rather than spraying and praying let’s take a more manual approach and view the results of each of our potential k values ranging from 2 to 10 (1 being totally useless.)<\/p>\n None of these are great. Notice that the lines representing cluster boundaries aren’t dispersed evenly — they tend to be added nearest areas in which less volatility in price has been recorded over time. In other words, vertical regions in which there is a greater density of recorded points.<\/p>\n We’ve covered a fair amount of ground in this article so let’s recap. The following points of discussion have been addressed:<\/p>\n K-Means is a versatile clustering algorithm but lacks a clear directive for selecting an optimal number of clusters. As mentioned earlier, there are several common approaches by which such an optimization can be done. We tried the\u00a0Elbow<\/em> approach here, but other methods include:<\/p>\n Each of these approaches has its merits and may, or may not, be appropriate given a specific dataset. The\u00a0Elbow<\/em> approach is a popular method of optimizing clustering which is why it was elected here. However, it is by no means meant to be interpreted as the “best” k-means optimization technique.<\/p>\n K-means clustering can help distill structure from seemingly random data. It has its limits and, as was the case here, doesn’t always produce jaw-dropping results. This type of partitioning can help group data into segments that represent novel behaviors or values but don’t always hit the mark. In the context of high timeframe support and resistance calculations, it seems that K-Means is not a great solution.<\/p>\n There are many technical indicators used for algorithmic trading. These include the mean average divergence-convergence (MACD)<\/a>, stochastic oscillator<\/a>, simple moving averages<\/a>, and even the Bollinger Bands<\/a> method. Beyond single indicators, methods such as linear regression<\/a> can be used to help predict stock prices<\/a> as well. Conceivably, especially in the context of multivariate linear regression, support and resistance levels could be incorporated as meaningful features into a predictive model.<\/p>\n Support and resistance levels are popular measures in technical analysis for stock trading. Support levels reflect price ranges at which a certain stock has trouble exceeding while resistance levels are those at which a stock’s price tends not to fall below. Programmatic calculation of these levels is of paramount importance to algorithmic trading, technical analysis, […]<\/p>\n","protected":false},"author":2,"featured_media":2984,"comment_status":"closed","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":false,"inline_featured_image":false,"footnotes":""},"categories":[186,462,10],"tags":[673,672,674,238,143,495],"acf":[],"_links":{"self":[{"href":"https:\/\/www.alpharithms.com\/wp-json\/wp\/v2\/posts\/2951"}],"collection":[{"href":"https:\/\/www.alpharithms.com\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.alpharithms.com\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.alpharithms.com\/wp-json\/wp\/v2\/users\/2"}],"replies":[{"embeddable":true,"href":"https:\/\/www.alpharithms.com\/wp-json\/wp\/v2\/comments?post=2951"}],"version-history":[{"count":5,"href":"https:\/\/www.alpharithms.com\/wp-json\/wp\/v2\/posts\/2951\/revisions"}],"predecessor-version":[{"id":2986,"href":"https:\/\/www.alpharithms.com\/wp-json\/wp\/v2\/posts\/2951\/revisions\/2986"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/www.alpharithms.com\/wp-json\/wp\/v2\/media\/2984"}],"wp:attachment":[{"href":"https:\/\/www.alpharithms.com\/wp-json\/wp\/v2\/media?parent=2951"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.alpharithms.com\/wp-json\/wp\/v2\/categories?post=2951"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.alpharithms.com\/wp-json\/wp\/v2\/tags?post=2951"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}\n
![\"support](\"https:\/\/www.alpharithms.com\/wp-content\/uploads\/2951\/support-resistance-lines-concept-alpharithms-1.jpg\" "\\"support-resistance-lines-concept-alpharithms\\"")
<\/a>Real-World Example<\/h3>\n
![\"amazon](\"https:\/\/www.alpharithms.com\/wp-content\/uploads\/2951\/amazon-daily-chart-support-resistance-alpharithms.jpg\" "\\"amazon-daily-chart-support-resistance-alpharithms\\"")
<\/a>Identifying Support & Resistance Levels<\/h2>\n
\n
![\"spy](\"https:\/\/www.alpharithms.com\/wp-content\/uploads\/2951\/spy-weekly-chart-2021-2022-alpharithms.jpg\" "\\"spy-weekly-chart-2021-2022-alpharithms\\"")
<\/a>Calculating Support, Resistance, & Trendlines<\/h2>\n
\n
Support & Resistance via K-Means Clustering<\/h2>\n
scikit-learn<\/code> library and 5-years’ worth of historical weekly Bitcoin pricing data. To get started, complete the following actions:<\/p>\n\n
pip install scikit-learn<\/code><\/li>\npip install pandas<\/code><\/li>\npip install plotly<\/code>Download the historical data from Github<\/a> courtesy of Yahoo Finance<\/a>.<\/li>\n<\/ol>\nLoad Data as DataFrame<\/h3>\n
DataFrame<\/code> object:<\/p>\nimport pandas as pd\r\n\r\n# Load local CSV file and parse into dataframe object\r\nbtc = pd.read_csv('BTC-USD.06282017-06282022.csv')\r\n\r\n# Parse date as DateTime\r\nbtc['Date'] = pd.to_datetime(btc['Date'])\r\n\r\n# Set the date as the index\r\nbtc.set_index(['Date'], inplace=True)\r\n\r\n# View the results\r\nprint(btc)\r\n\r\n# Output\r\n Open High ... Adj Close Volume\r\nDate ... \r\n2017-06-26 2567.560059 2588.830078 ... 2506.469971 3393913024\r\n2017-07-03 2498.560059 2916.139893 ... 2518.439941 5831748992\r\n2017-07-10 2525.250000 2537.159912 ... 1929.819946 7453121024\r\n2017-07-17 1932.619995 2900.699951 ... 2730.399902 9947990080\r\n2017-07-24 2732.699951 2897.449951 ... 2757.179932 6942860928\r\n... ... ... ... ... ...\r\n2022-06-06 29910.283203 31693.291016 ... 26762.648438 215929645934\r\n2022-06-13 26737.578125 26795.589844 ... 20553.271484 309685915250\r\n2022-06-20 20553.371094 21783.724609 ... 21027.294922 175909056122\r\n2022-06-27 21028.238281 21478.089844 ... 20280.634766 42347230868\r\n2022-06-29 20291.271484 20360.972656 ... 20055.185547 24722872320\r\n\r\n[263 rows x 6 columns]<\/pre>\nPerform a KMeans Cluster Analysis<\/h3>\n
# Convert adjusted closing price to numpy array\r\nbtc_prices = np.array(btc[\"Adj Close\"])\r\nprint(\"BTC Prices:\\n\", btc_prices)\r\n\r\n# Perform cluster analysis\r\nK = 6\r\nkmeans = KMeans(n_clusters=6).fit(btc_prices.reshape(-1, 1))\r\n\r\n# predict which cluster each price is in\r\nclusters = kmeans.predict(btc_prices.reshape(-1, 1))\r\nprint(\"Clusters:\\n\", clusters)\r\n\r\n# View ouput\r\nBTC Prices:\r\n [ 2506.469971 2518.439941 1929.819946 2730.399902 2757.179932\r\n 3213.939941 4073.26001 4087.659912 4382.879883 4582.959961\r\n\r\n ... lots of extra data rows here ...\r\n\r\n 39716.953125 39469.292969 38469.09375 34059.265625 31305.113281\r\n 30323.722656 29445.957031 29906.662109 26762.648438 20553.271484\r\n 21027.294922 20280.634766 20055.185547]\r\n\r\nClusters:\r\n [0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 5 5 5 3 3 5 5 3 5 5 5 5 5 5 5 5 5\r\n 5 5 0 0 5 5 5 5 5 5 0 5 0 0 0 0 0 0 0 5 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\r\n 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 5 5 5 5 5 5 5 5 5 5 5 5 5\r\n 5 5 5 5 5 5 5 5 5 5 5 5 5 5 0 0 0 0 0 0 0 5 5 5 5 5 5 5 5 5 0 0 0 0 0 0 5\r\n 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 3 3 3 3 3 3 3 3 2 2\r\n 2 2 2 2 1 4 1 1 4 4 4 4 4 4 1 4 4 1 2 2 2 2 2 2 2 2 2 2 2 1 1 1 1 1 1 1 1\r\n 1 4 4 4 4 4 4 4 4 1 1 1 1 1 1 1 2 2 1 1 2 2 2 2 1 1 1 1 2 2 2 2 2 2 2 2 3\r\n 3 3 3 3]\r\n\r\n<\/pre>\n
clusters<\/code> variable indicates that each price has been assigned to one of the 6 total clusters. Let’s visualize this via Plotly as a scatter plot where each price has a unique color assigned based on which group it is in.<\/p>\nVisualizing Clusters via Plotly<\/h3>\n
set_options<\/code> method. With this configured, the following approach is taken to assign each historical price data point a unique color based on which cluster it was assigned by our KMeans<\/code> algorithm:<\/p>\n# Assigns plotly as visualization engine\r\npd.options.plotting.backend = 'plotly'\r\n\r\n# Arbitrarily 6 colors for our 6 clusters\r\ncolors = ['red', 'orange', 'yellow', 'green', 'blue', 'indigo']\r\n\r\n# Create Scatter plot, assigning each point a color based\r\n# on it's grouping where group_number == index of color.\r\nfig = btc.plot.scatter(\r\n x=btc.index,\r\n y=\"Adj Close\",\r\n color=[colors[i] for i in clusters],\r\n)\r\n\r\n# Configure some styles\r\nlayout = go.Layout(\r\n plot_bgcolor='#efefef',\r\n showlegend=False,\r\n # Font Families\r\n font_family='Monospace',\r\n font_color='#000000',\r\n font_size=20,\r\n xaxis=dict(\r\n rangeslider=dict(\r\n visible=False\r\n ))\r\n)\r\nfig.update_layout(layout)\r\n\r\n# Display plot in local browser window\r\nfig.show()<\/pre>\n
![\"colorized](\"https:\/\/www.alpharithms.com\/wp-content\/uploads\/2951\/colorized-btc-weekly-pricing-data-kmeans-clusters-alpharithms.jpg\" "\\"colorized-btc-weekly-pricing-data-kmeans-clusters-alpharithms\\"")
<\/a>Find Cluster Minimum & Maximum Values<\/h3>\n
# Create list to hold values, initialized with infinite values\r\nmin_max_values = []\r\n\r\n# init for each cluster group\r\nfor i in range(6):\r\n\r\n # Add values for which no price could be greater or less\r\n min_max_values.append([np.inf, -np.inf])\r\n\r\n# Print initial values\r\nprint(min_max_values)\r\n\r\n# Get min\/max for each cluster\r\nfor i in range(len(btc_prices)):\r\n\r\n # Get cluster assigned to price\r\n cluster = clusters[i]\r\n\r\n # Compare for min value\r\n if btc_prices[i] < min_max_values[cluster][0]:\r\n min_max_values[cluster][0] = btc_prices[i]\r\n\r\n # Compare for max value\r\n if btc_prices[i] > min_max_values[cluster][1]:\r\n min_max_values[cluster][1] = btc_prices[i]\r\n# Print resulting values\r\nprint(min_max_values)\r\n\r\n# Output\r\n[[inf, -inf], [inf, -inf], [inf, -inf], [inf, -inf], [inf, -inf], [inf, -inf]]\r\n[[15455.400391, 26762.648438], [41247.824219, 51753.410156], [29445.957031, 39974.894531], [1929.819946, 7564.345215], [54771.578125, 65466.839844], [7679.867188, 14156.400391]]\r\n<\/pre>\n
min, max<\/code> pair of prices. This is the smallest and largest price value for each uniquely-colored cluster of prices in Figure 4. These can be visualized as horizontal lines on our chart as follows. The following code adds these lines\u00a0and<\/em> adds a line to plot the price for added visual clarity:<\/p>\nimport plotly.graph_objects as go\r\n\r\n# Again, assign an arbitrary color to each of the 6 clusters\r\ncolors = ['red', 'orange', 'yellow', 'green', 'blue', 'indigo']\r\n\r\n# Create Scatter plot, assigning each point a color where\r\n# point group = color index.\r\nfig = btc.plot.scatter(\r\n x=btc.index,\r\n y=\"Adj Close\",\r\n color=[colors[i] for i in clusters],\r\n)\r\n\r\n# Add horizontal lines\r\nfor cluster_min, cluster_max in min_max_values:\r\n fig.add_hline(y=cluster_min, line_width=1, line_color=\"blue\")\r\n fig.add_hline(y=cluster_max, line_width=1, line_color=\"blue\")\r\n\r\n# Add a trace of the price for better clarity\r\nfig.add_trace(go.Trace(\r\n x=btc.index,\r\n y=btc['Adj Close'],\r\n line_color=\"black\",\r\n line_width=1\r\n))\r\n\r\n# Make it pretty\r\nlayout = go.Layout(\r\n plot_bgcolor='#efefef',\r\n showlegend=False,\r\n # Font Families\r\n font_family='Monospace',\r\n font_color='#000000',\r\n font_size=20,\r\n xaxis=dict(\r\n rangeslider=dict(\r\n visible=False\r\n ))\r\n)\r\nfig.update_layout(layout)\r\nfig.show()<\/pre>\n
![\"clustered](\"https:\/\/www.alpharithms.com\/wp-content\/uploads\/2951\/clustered-data-with-support-and-resistance-lines-alpharithms.jpg\" "\\"clustered-data-with-support-and-resistance-lines-alpharithms\\"")
<\/a>\n
Consolidating Boundary Lines<\/h3>\n
![\"combining](\"https:\/\/www.alpharithms.com\/wp-content\/uploads\/2951\/combining-cluster-minima-maxima-support-resistance-alpharithms.jpg\" "\\"combining-cluster-minima-maxima-support-resistance-alpharithms\\"")
<\/a>min, max<\/code> pair reflects the bottom-most cluster (cluster 1) on our chart and the last min, max<\/code> pair reflects the top-most cluster (cluster 6) on our chart. This will ensure that the combination of lines happens only between neighboring clusters. The following code will combine the lines appropriately, first sorting to ensure accurate adjacency:<\/p>\nprint(\"Initial Min\/Max Values:\\n\", min_max_values)\r\n\r\n# Create container for combined values\r\noutput = []\r\n\r\n# Sort based on cluster minimum\r\ns = sorted(min_max_values, key=lambda x: x[0])\r\n\r\n# For each cluster get average of\r\nfor i, (_min, _max) in enumerate(s):\r\n\r\n # Append min from first cluster\r\n if i == 0:\r\n output.append(_min)\r\n\r\n # Append max from last cluster\r\n if i == len(min_max_values) - 1:\r\n output.append(_max)\r\n\r\n # Append average from cluster and adjacent for all others\r\n else:\r\n output.append(sum([_max, s[i+1][0]]) \/ 2)\r\n\r\nprint(\"Sorted Min\/Max Values:\\n\", output)\r\n\r\n# Resulting output\r\nInitial Min\/Max Values:\r\n[[1929.819946, 7564.345215], [41247.824219, 51753.410156], [7679.867188, 14156.400391], [29445.957031, 39974.894531], [54771.578125, 65466.839844], [15455.400391, 26762.648438]]\r\n\r\nSorted Min\/Max Values:\r\n[1929.819946, 7622.106201500001, 14805.900391, 28104.3027345, 40611.359375, 53262.4941405, 65466.839844]<\/pre>\n
output<\/code> and only call a single add_hline<\/code> per group:<\/p>\n# Add horizontal lines\r\nfor cluster_avg in output:\r\n fig.add_hline(y=cluster_avg, line_width=1, line_color=\"blue\")<\/pre>\n
![\"combined](\"https:\/\/www.alpharithms.com\/wp-content\/uploads\/2951\/combined-cluster-min-max-support-resistance-levels-alpharithms.jpg\" "\\"combined-cluster-min-max-support-resistance-levels-alpharithms\\"")
<\/a>Assessing Absolute Minima\/Maxima<\/h3>\n
# Add horizontal lines \r\nfor cluster_avg in output[1:-1]:\r\n fig.add_hline(y=cluster_avg, line_width=1, line_color=\"blue\")<\/pre>\n
add_hline<\/code> snippet, we produce the following chart:<\/p>\n![\"removed](\"https:\/\/www.alpharithms.com\/wp-content\/uploads\/2951\/removed-min-max-cluster-boundaries-alpharithms.jpg\" "\\"removed-min-max-cluster-boundaries-alpharithms\\"")
<\/a>![\"manual](\"https:\/\/www.alpharithms.com\/wp-content\/uploads\/2951\/manual-support-resistance-lines-overlay-alpharithms.jpg\" "\\"manual-support-resistance-lines-overlay-alpharithms\\"")
<\/a>Determining the Right Number of Clusters<\/h3>\n
scikit-learn<\/code> KMeans class as the inertia_<\/code> property. We calculate each of these values as such:<\/p>\n# create a list to contain output values\r\nvalues = []\r\n\r\n# Define a range of cluster values to assess\r\nK = range(1, 10)\r\n\r\n# Performa a clustering using each value, save inertia_ value from each\r\nfor k in K:\r\n kmeans_n = KMeans(n_clusters=k)\r\n kmeans_n.fit(btc_prices.reshape(-1, 1))\r\n values.append(kmeans_n.inertia_)\r\n\r\n# Output\r\n[80453452183.20088, 10385720870.392435, 4899414919.598458, 3200341434.3973494, 2038101574.9904993, 1230938654.2410448, 913656416.2350059, 711089387.2186545, 573668652.8908113]\r\n<\/pre>\n
scikit-learn<\/code> documentation for the KMeans class<\/a>, the inertia_ property is:<\/p>\nimport plotly.graph_objects as go\r\n\r\n# Create initial figure\r\nfig = go.Figure()\r\n\r\n# Add line plot of inertia values\r\nfig.add_trace(go.Trace(\r\n x=list(K),\r\n y=values,\r\n line_color=\"black\",\r\n line_width=1\r\n))\r\n\r\n# Make it pretty\r\nlayout = go.Layout(\r\n plot_bgcolor='#efefef',\r\n showlegend=False,\r\n # Font Families\r\n font_family='Monospace',\r\n font_color='#000000',\r\n font_size=20,\r\n xaxis=dict(\r\n rangeslider=dict(\r\n visible=False\r\n ))\r\n)\r\nfig.update_layout(layout)\r\nfig.show()<\/pre>\n
inertia_<\/code> values as the y, we get the following graph:<\/p>\n![\"elbow](\"https:\/\/www.alpharithms.com\/wp-content\/uploads\/2951\/elbow-method-kmeans-optimization-alpharithms.jpg\" "\\"elbow-method-kmeans-optimization-alpharithms\\"")
<\/a>![\"k](\"https:\/\/www.alpharithms.com\/wp-content\/uploads\/2951\/k-mean-cluster-count-2-alpharithms.jpg\" "\\"k-mean-cluster-count-2-alpharithms\\"")
<\/a>![\"misc](\"https:\/\/www.alpharithms.com\/wp-content\/uploads\/2951\/misc-k-values-support-resistance-alpharithms.jpg\" "\\"misc-k-values-support-resistance-alpharithms\\"")
<\/a>Discussion<\/h2>\n
\n
\n
Final Thoughts<\/h2>\n
References<\/h2>\n
\n