David Landup

Dimitrije Stamenic

Joel Olawanle

In this tutorial, you will learn how to perform POST HTTP requests in React using the two primary methods - Fetch API and Axios. You will also get to know how to do this in functional and class components in React.

POST HTTP Request in React

K-means clustering is an unsupervised learning algorithm that groups data based on each point euclidean distance to a central point called centroid. The centroids are defined by the means of all points that are in the same cluster. The algorithm first chooses random points as centroids and then iterates adjusting them until full convergence.
<blockquote>
An important thing to remember when using K-means, is that the number of clusters is a hyperparameter, it will be defined before running the model.
</blockquote>
K-means can be implemented using Scikit-Learn with just 3 lines of code. Scikit-Learn also already has a centroid optimization method available, kmeans++, that helps the model converge faster.

 <div class="alert alert-reference">
 <div class="flex">
 
 <div class="flex-shrink-0 mr-3">
 <img src="/assets/images/icon-link-solid.svg" class="icon" aria-hidden="true" />
 </div>
 
 <div class="w-full">
 Advice If you'd like to read an in-depth guide to K-Means Clustering, read our <a href="https://stackabuse.com/k-means-clustering-with-scikit-learn/" target="_blank">Definitive Guide to K-Means Clustering with Scikit-Learn&quot;!</a>

 </div>
 </div>
 </div>
 To apply the K-means clustering algorithm, let's load the Palmer Penguins dataset, choose the columns that will be clustered, and use Seaborn to plot a scatter plot with color coded clusters.

 <div class="alert alert-note">
 <div class="flex">
 
 <div class="flex-shrink-0 mr-3">
 <img src="/assets/images/icon-information-circle-solid.svg" class="icon" aria-hidden="true" />
 </div>
 
 <div class="w-full">
 Note: You can download the dataset from this <a href="https://gist.github.com/cassiasamp/197b4e070f5f4da890ca4d226d088d1f" target="_blank">link</a>.

 </div>
 </div>
 </div>
 Let's import the libraries and load the Penguins dataset, trimming it to the chosen columns and dropping rows with missing data (there were only 2):
<pre><code class="hljs">import pandas as pd
import seaborn as sns
import matplotlib.pyplot as plt
from sklearn.cluster import KMeans

df = pd.read_csv(&#x27;penguins.csv&#x27;)
print(df.shape) # (344, 9)
df = df[[&#x27;bill_length_mm&#x27;, &#x27;flipper_length_mm&#x27;]]
df = df.dropna(axis=0)
</code></pre>
We can use the Elbow method to have an indication of clusters for our data. It consists in the interpretation of a line plot with an elbow shape. The number of clusters is where the elbow bends. The x axis of the plot is the number of clusters and the y axis is the Within Clusters Sum of Squares (WCSS) for each number of clusters:
<pre><code class="hljs">wcss = []

for i in range(1, 11):
 clustering = KMeans(n_clusters=i, init=&#x27;k-means++&#x27;, random_state=42)
 clustering.fit(df)
 wcss.append(clustering.inertia_)
 
ks = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
sns.lineplot(x = ks, y = wcss);
</code></pre>
<img src="https://s3.stackabuse.com/media/articles/k-means-clustering-with-the-elbow-method-1.png" alt="">
The elbow method indicates our data has 2 clusters. Let's plot the data before and after clustering:
<pre><code class="hljs">fig, axes = plt.subplots(nrows=1, ncols=2, figsize=(15,5))
sns.scatterplot(ax=axes[0], data=df, x=&#x27;bill_length_mm&#x27;, y=&#x27;flipper_length_mm&#x27;).set_title(&#x27;Without clustering&#x27;)
sns.scatterplot(ax=axes[1], data=df, x=&#x27;bill_length_mm&#x27;, y=&#x27;flipper_length_mm&#x27;, hue=clustering.labels_).set_title(&#x27;Using the elbow method&#x27;);
</code></pre>
<img src="https://s3.stackabuse.com/media/articles/k-means-clustering-with-the-elbow-method-2.png" alt="">
<blockquote>
This example shows how the Elbow method is only a reference when used to choose the number of clusters. We already know that we have 3 types of penguins in the dataset, but if we were to determine their number by using the Elbow method, 2 clusters would be our result.
</blockquote>
Since K-means is sensitive to data variance, let's look at the descriptive statistics of the columns we are clustering:
<pre><code class="hljs">df.describe().T # T is to transpose the table and make it easier to read
</code></pre>
This results in:
<pre><code class="hljs"> 					count 	mean 		std 		min 	25% 	50% 	75% 	max
bill_length_mm 		342.0 	43.921930 	5.459584 	32.1 	39.225 	44.45 	48.5 	59.6
flipper_length_mm 	342.0 	200.915205 	14.061714 	172.0 	190.000 197.00 	213.0 	231.0
</code></pre>
Notice that the mean is far from the standard deviation (std), this indicates high variance. Let's try to reduce it by scaling the data with Standard Scaler:
<pre><code class="hljs">from sklearn.preprocessing import StandardScaler

ss = StandardScaler()
scaled = ss.fit_transform(df)
</code></pre>
Now, let's repeat the Elbow method process for the scaled data:
<pre><code class="hljs">wcss_sc = []

for i in range(1, 11):
 clustering_sc = KMeans(n_clusters=i, init=&#x27;k-means++&#x27;, random_state=42)
 clustering_sc.fit(scaled)
 wcss_sc.append(clustering_sc.inertia_)
 
ks = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
sns.lineplot(x = ks, y = wcss_sc);
</code></pre>
<img src="https://s3.stackabuse.com/media/articles/k-means-clustering-with-the-elbow-method-3.png" alt="">
This time, the suggested number of clusters is 3. We can plot the data with the cluster labels again along with the two former plots for comparison:
<pre><code class="hljs">fig, axes = plt.subplots(nrows=1, ncols=3, figsize=(15,5))
sns.scatterplot(ax=axes[0], data=df, x=&#x27;bill_length_mm&#x27;, y=&#x27;flipper_length_mm&#x27;).set_title(&#x27;Without clustering&#x27;)
sns.scatterplot(ax=axes[1], data=df, x=&#x27;bill_length_mm&#x27;, y=&#x27;flipper_length_mm&#x27;, hue=clustering.labels_).set_title(&#x27;With the Elbow method&#x27;)
sns.scatterplot(ax=axes[2], data=df, x=&#x27;bill_length_mm&#x27;, y=&#x27;flipper_length_mm&#x27;, hue=clustering_sc.labels_).set_title(&#x27;With the Elbow method and scaled data&#x27;);
</code></pre>
<img src="https://s3.stackabuse.com/media/articles/k-means-clustering-with-the-elbow-method-4.png" alt="">
When using K-means Clustering, you need to predetermine the number of clusters. As we have seen when using a method to choose our k number of clusters, the result is only a suggestion and can be impacted by the amount of variance in data. It is important to conduct an in-depth analysis and generate more than one model with different _k_s when clustering.
If there is no prior indication of how many clusters are in the data, visualize it, test it and interpret it to see if the clustering results make sense. If not, cluster again. Also, look at more than one metric and instantiate different clustering models - for K-means, look at silhouette score and maybe Hierarchical Clustering to see if the results stay the same.

Cássia Sampaio

In this short guide - learn how to apply the Elbow method to determine the optimal K (number of clusters) for K-means clustering using Python and Scikit-Learn.

K-Means Clustering with the Elbow method

<h2 id="introduction">Introduction</h2>
As pointed out in a previous article that deals with <a href="/reading-files-with-python/">reading data from files</a>, file handling is essential knowledge of every professional and hobbyist Python programmer. This feature is a core part of the Python language, and no extra module needs to be loaded to do it properly.
<blockquote>
In this article, we will take a look at how to write data to a file line by line, as a list of lines, and append data at the end of a file.
</blockquote>
<h2 id="basicsofwritingfilesinpython">Basics of Writing Files in Python</h2>
There are three common functions to operate with files in Python:
<ul>
<li><code>open()</code> to open a file,</li>
<li><code>seek()</code> to set the file's current position at the given offset,</li>
<li><code>close()</code> to close the file afterwards.</li>
</ul>

 <div class="alert alert-note">
 <div class="flex">
 
 <div class="flex-shrink-0 mr-3">
 <img src="/assets/images/icon-information-circle-solid.svg" class="icon" aria-hidden="true" />
 </div>
 
 <div class="w-full">
 Note: <code>open()</code> is a built-in Python function that returns a file handle that represents a <a rel="nofollow" target="_blank" href="https://docs.python.org/3/glossary.html#term-file-object">file object</a> to be used to access the file for reading, writing, or appending.

 </div>
 </div>
 </div>
 Writing to a file requires a few decisions - the name of the file in which to store data and the access mode of the file. Available are two modes, writing to a new file (and overwriting any existing data) and appending data at the end of a file that already exists. The according abbreviations are &quot;w&quot;, and &quot;a&quot;, and have to be specified before opening a file.

 <div class="alert alert-note">
 <div class="flex">
 
 <div class="flex-shrink-0 mr-3">
 <img src="/assets/images/icon-information-circle-solid.svg" class="icon" aria-hidden="true" />
 </div>
 
 <div class="w-full">
 Note: Besides mentioned &quot;w&quot; and &quot;a&quot; flags, there is another, more powerful one - the &quot;w+&quot; flag, which opens file for both reading and writing.

 </div>
 </div>
 </div>
 <h2 id="writingasinglelinetoafile">Writing a Single Line to a File</h2>
This first example is pretty similar to writing to files with the popular programming languages C and C++. The process is pretty straightforward. First, we open the file using the built-in <code>open()</code> function for writing, write a single line of text to the file using the <code>write()</code> method, and then close the file using the <code>close()</code> method. Keep in mind that due to the way we opened the <code>helloworld.txt</code> file it will either be created if it does not exist yet, or it will be completely overwritten:
<pre><code class="hljs">filehandle = open(&#x27;helloworld.txt&#x27;, &#x27;w&#x27;)
filehandle.write(&#x27;Hello, world!\n&#x27;)
filehandle.close()
</code></pre>
This entire process can be shortened using the <code>with</code> statement:
<pre><code class="hljs">with open(&#x27;helloworld.txt&#x27;, &#x27;w&#x27;) as filehandle:
 filehandle.write(&#x27;Hello, world!\n&#x27;)
</code></pre>
As already said before, keep in mind that opening the <code>helloworld.txt</code> file this way will either create if it does not exist yet or completely overwrite it.
<h2 id="writingalistoflinestoafile">Writing a List of Lines to a File</h2>
In reality, a file does not consist only of a single line, but much more data. Therefore, the contents of the file are stored in a list that represents a file buffer. To write the entire file buffer we'll use the <code>writelines()</code> method:
<pre><code class="hljs">filehandle = open(&quot;helloworld.txt&quot;, &quot;w&quot;)
filebuffer = [&quot;a first line of text&quot;, &quot;a second line of text&quot;, &quot;a third line&quot;]
filehandle.writelines(filebuffer)
filehandle.close()
</code></pre>
Running the previous Python program and then using the <code>cat</code> command we can see that the file <code>helloworld.txt</code> has the following content:
<pre><code class="hljs">$ cat helloworld.txt
a first line of texta second line of texta third line
</code></pre>
This happens because the <code>writelines()</code> method does not automatically add any line separators when writing the data, even though intuitively, it should write individual lines.
This can easily be remedied by adding a <code>\n</code> (newline) character at the end of each line. Additionally, we can simplify the loop using a generator expression:
<pre><code class="hljs">with open(&#x27;helloworld.txt&#x27;, &#x27;w&#x27;) as filehandle:
 filebuffer = [&quot;a line of text&quot;, &quot;another line of text&quot;, &quot;a third line&quot;]
 filehandle.writelines(f&quot;{line for line in filebuffer}\n&quot;)
</code></pre>
Now, the output file <code>helloworld.txt</code> has the desired content:
<pre><code class="hljs">$ cat helloworld.txt
a first line of text
a second line of text
a third line
</code></pre>
<h2 id="appendingdatatoafile">Appending Data to a File</h2>
So far, we have stored data in new files or in overwritten data in existing files. But what if we want to append data to the end of an existing file? In this case, we would need to open the existing file using a different access mode. We change the access code to <code>'a'</code> instead of <code>'w'</code>:
<pre><code class="hljs">filehandle = open(&#x27;helloworld.txt&#x27;,&#x27;a&#x27;)
filehandle.write(&#x27;\n&#x27; + &#x27;Hello, world!\n&#x27;)
filehandle.close()
</code></pre>
As before, we can also rewrite the previous code using the <code>with</code> statement:
<pre><code class="hljs">with open(&#x27;helloworld.txt&#x27;, &#x27;a&#x27;) as filehandle:
 filehandle.write(f&#x27;\n Hello, world!\n&#x27;)
</code></pre>
Using the same <code>helloworld.txt</code> file from before, running this code will produce the following file contents:
<pre><code class="hljs">$ cat helloworld.txt
Hello, world
a second line
and a third line

Hello, world!
</code></pre>
<h2 id="conclusion">Conclusion</h2>
Writing plain text data to files, or appending data to existing files, is as easy as reading from files in Python. As soon as a file is closed after writing or appending data, Python triggers a synchronization call. As a result, the updated file is immediately written to disk.

Frank Hofmann

In this short tutorial, we'll take a look at how to write data to a file in Python. We'll be taking a look at a couple of different illustrative examples - writing to a file line by line, writing multiple lines at once, and appending to the existing file.

Writing Files using Python

In this guide, we'll take a comprehensive look at how to cluster a dataset in Python using the K-Means algorithm with the Scikit-Learn library, how to use the elbow method, find optimal cluster number and implement K-Means from scratch.

Definitive Guide to K-Means Clustering with Scikit-Learn

<h2 id="introduction">Introduction</h2>
Working with visuals is an excellent way to keep our interface interactive and to capture the user's attention. Having objects animated on our screen creates a unique experience and increases interactivity.
<blockquote>
In this article, we will learn how to style hover in React using CSS, as well as how to do inline hover styling.
</blockquote>
Hover is a pseudo-class that simply allows us to add specific styles to make a user aware when their mouse is on and off a specific element. For this article, we'll use a box:
<pre><code class="hljs">const App = () =&gt; {
 return (
 &lt;div&gt;
 &lt;div className=&quot;box&quot;&gt;
 &lt;p&gt;Hover me!&lt;/p&gt;
 &lt;/div&gt;
 &lt;/div&gt;
 );
};
</code></pre>
which has this basic styling:
<pre><code class="hljs">.box {
 height: 200px;
 width: 200px;
 background-color: rgb(0, 191, 255);
 display: flex;
 justify-content: center;
 align-items: center;
 font-size: 30px;
 cursor: pointer;
}
</code></pre>
Essentially, we'll change the background color to <code>lightblue</code> when the mouse is over the box and then return it to its default style when the mouse is removed.
<h2 id="howtostylehoverinreact">How to Style Hover in React</h2>
There are two approaches to this: external and inline. External involves having a separate CSS file that makes it easy to style for hover, whereas inline styling does not allow us to style with pseudo-class, but we will learn how to style hover in inline CSS by using mouse events in this article.
<h3 id="howtostylehoverinreactwithcssexternalstyling">How to Style Hover in React With CSS External Styling</h3>
This is very similar to how HTML and CSS work; all we have to do is give the element a <code>className</code> (not <code>class</code>) or use the tag as the selector which we would target and then style the hover pseudo class:
<pre><code class="hljs">.box {
 height: 200px;
 width: 200px;
 background-color: rgb(0, 191, 255);
 display: flex;
 justify-content: center;
 align-items: center;
 font-size: 30px;
 cursor: pointer;
}

.box:hover {
 background-color: lightblue;
}
</code></pre>
All we did was add the <code>:hover</code> pseudo class to the previously styled selector and change any of the properties we wanted to change when the mouse was over the element.
<h3 id="howtostylehoverinreactwithinlinestyling">How to Style Hover in React With Inline Styling</h3>
By inline styling, we mean styling via the element's tag, which is accomplished with the <code>style</code> attribute. If we want to convert the preceding code to inline styling:
<pre><code class="hljs">const App = () =&gt; {
 return (
 &lt;div&gt;
 &lt;div
 style={{
 height: &#x27;200px&#x27;,
 width: &#x27;200px&#x27;,
 backgroundColor: &#x27;rgb(0, 191, 255)&#x27;,
 display: &#x27;flex&#x27;,
 justifyContent: &#x27;center&#x27;,
 alignItems: &#x27;center&#x27;,
 fontSize: &#x27;30px&#x27;,
 cursor: &#x27;pointer&#x27;,
 }}
 &gt;
 &lt;p&gt;Hover me!&lt;/p&gt;
 &lt;/div&gt;
 &lt;/div&gt;
 );
};
</code></pre>
Having styles like this repeated within our App could make it difficult to read, so we could create a style object if we're only styling a single object on a page, and there's no need in creating a file for it:
<pre><code class="hljs">const App = () =&gt; {

const boxStyle = {
 height: &#x27;200px&#x27;,
 width: &#x27;200px&#x27;,
 backgroundColor: &#x27;rgb(0, 191, 255)&#x27;,
 display: &#x27;flex&#x27;,
 justifyContent: &#x27;center&#x27;,
 alignItems: &#x27;center&#x27;,
 fontSize: &#x27;30px&#x27;,
 cursor: &#x27;pointer&#x27;,
};

 return (
 &lt;div&gt;
 &lt;div style={boxStyle}&gt;
 &lt;p&gt;Hover me!&lt;/p&gt;
 &lt;/div&gt;
 &lt;/div&gt;
 );
};
</code></pre>
So far, we've built our box. To style hover with inline CSS in React, we conditionally set inline styles using a state, as well as the <code>onMouseEnter</code> and <code>onMouseLeave</code> props, which tell us when the mouse is on the element and when it is not:
<pre><code class="hljs">import { useState } from &#x27;react&#x27;;

const App = () =&gt; {
 const [isHover, setIsHover] = useState(false);

 const handleMouseEnter = () =&gt; {
 setIsHover(true);
 };
 const handleMouseLeave = () =&gt; {
 setIsHover(false);
 };

 const boxStyle = {
 &lt;!-- ... --&gt;
 };

 return (
 &lt;div&gt;
 &lt;div
 style={boxStyle}
 onMouseEnter={handleMouseEnter}
 onMouseLeave={handleMouseLeave}
 &gt;
 &lt;p&gt;Hover me!&lt;/p&gt;
 &lt;/div&gt;
 &lt;/div&gt;
 );
};
</code></pre>
At this point, we can conditionally style any property using the <code>*isHover*</code> state:
<pre><code class="hljs">const boxStyle = {
 //...
 backgroundColor: isHover ? &#x27;lightblue&#x27; : &#x27;rgb(0, 191, 255)&#x27;,
};
</code></pre>
So far, we've seen how to implement it. Now, let's break down our code and explain why we used the syntax we did. We began by creating a state that stores a boolean value indicating when hovering occurs (<code>true</code>) and otherwise (by default it’s set to <code>false</code>):
<pre><code class="hljs">const [isHover, setIsHover] = useState(false);
</code></pre>
We then also added two events to the div to help change our state and know when the mouse is on the box and when it’s off the box:
<pre><code class="hljs">&lt;div
 style={boxStyle}
 onMouseEnter={handleMouseEnter}
 onMouseLeave={handleMouseLeave}
&gt;
 &lt;p&gt;Hover me!&lt;/p&gt;
&lt;/div&gt;
</code></pre>
The <code>onMouseEnter</code> event is triggered when the mouse enters the element, while the <code>onMouseLeave</code> event is triggered when it leaves. We assigned a function to each of these events, which we now use to change the state:
<pre><code class="hljs">const handleMouseEnter = () =&gt; {
 setIsHover(true);
};

const handleMouseLeave = () =&gt; {
 setIsHover(false);
};
</code></pre>
We set the <code>state</code> in each function based on the triggered event. Finally, we can use the state to conditionally style the box not only for <code>backgroundColor</code>, but also for any other style:
<pre><code class="hljs">const boxStyle = {
 //...
 backgroundColor: isHover ? &#x27;lightblue&#x27; : &#x27;rgb(0, 191, 255)&#x27;,
 color: isHover ? &#x27;red&#x27; : &#x27;green&#x27;,
};
</code></pre>
When we put all this together, we are now able to style hover in React with Inline style:
<pre><code class="hljs">import { useState } from &#x27;react&#x27;;

const App = () =&gt; {
 const [isHover, setIsHover] = useState(false);

 const handleMouseEnter = () =&gt; {
 setIsHover(true);
 };

 const handleMouseLeave = () =&gt; {
 setIsHover(false);
 };

 const boxStyle = {
 height: &#x27;200px&#x27;,
 width: &#x27;200px&#x27;,
 display: &#x27;flex&#x27;,
 justifyContent: &#x27;center&#x27;,
 alignItems: &#x27;center&#x27;,
 fontSize: &#x27;30px&#x27;,
 cursor: &#x27;pointer&#x27;,
 backgroundColor: isHover ? &#x27;lightblue&#x27; : &#x27;rgb(0, 191, 255)&#x27;,
 color: isHover ? &#x27;red&#x27; : &#x27;green&#x27;,
 };

 return (
 &lt;div&gt;
 &lt;div
 style={boxStyle}
 onMouseEnter={handleMouseEnter}
 onMouseLeave={handleMouseLeave}
 &gt;
 &lt;p&gt;Hover me!&lt;/p&gt;
 &lt;/div&gt;
 &lt;/div&gt;
 );
};

export default App;
</code></pre>
<h2 id="conclusion">Conclusion</h2>
We learned how to style hover in React using both external styling and inline styling in this article. Though inline styling is not recommended, it is useful to understand how it works in case we are prompted to use it.

In this tutorial, learn how to style a hover event in JavaScript and React, using internal and external styling, with CSS.

How to Style Hover in React

<h2 id="introduction">Introduction</h2>
It's always a good idea to have visuals on a website or web application because they help engage a user, but when these images are so large that a user has to scroll through, distorting the entire page, it achieves the opposite effect.
<blockquote>
In this article, we will learn how to resize images with React by using several possible approaches.
</blockquote>
Resizing images in React is very similar to resizing images in traditional HTML because we use CSS styles (either internal, inline, or external styling) via <code>className</code> or the <code>style</code> attribute. We can also use the <code>height</code> and <code>width</code> attributes on the <code>img</code> tag directly.

 <div class="alert alert-note">
 <div class="flex">
 
 <div class="flex-shrink-0 mr-3">
 <img src="/assets/images/icon-information-circle-solid.svg" class="icon" aria-hidden="true" />
 </div>
 
 <div class="w-full">
 Note: In React, we don't use <code>class</code> like we do in HTML, instead, we use <code>className</code>, which performs the same function as class and accepts string values.

 </div>
 </div>
 </div>
 The code would generally look something along the lines of:
<pre><code class="hljs">&lt;!-- index.css --&gt;
img {
 width: 500px;
 height: 600px;
}
</code></pre>
And our image would look like this:
<pre><code class="hljs">&lt;!-- App.js --&gt;
import Logo from &#x27;./images/react-logo.png&#x27;;
import &#x27;./index.css&#x27;;

const App = () =&gt; {
 return (
 &lt;div&gt;
 &lt;img src={Logo} alt=&quot;React Logo&quot; /&gt;
 &lt;/div&gt;
 );
};
</code></pre>

 <div class="alert alert-note">
 <div class="flex">
 
 <div class="flex-shrink-0 mr-3">
 <img src="/assets/images/icon-information-circle-solid.svg" class="icon" aria-hidden="true" />
 </div>
 
 <div class="w-full">
 Note: we used <code>img</code> as the selector, we can decide to give it a <code>className</code> and make use of it as the selector.

 </div>
 </div>
 </div>
 <h2 id="howtoresizeanimagewithinlinestyles">How to Resize an Image With Inline Styles</h2>
We used external styling in the previous example, but just like in traditional HTML, we can use the <code>style</code> attribute to add CSS styling. The <code>style</code> attribute value must be a JavaScript object with key-value pairs:
<pre><code class="hljs">import Logo from &#x27;./images/react-logo.png&#x27;;
const App = () =&gt; {
 return (
 &lt;div&gt;
 &lt;img style={{ width: 500, height: 600 }} src={Logo} alt=&quot;React Logo&quot; /&gt;
 &lt;/div&gt;
 );
};
</code></pre>
By default, the basic unit is in pixels, but suppose we want to make use of other units like <code>rem</code>, <code>%</code>, <code>vh</code>, etc. We will make use of string for the styles' key value:
<pre><code class="hljs">import Logo from &#x27;./images/react-logo.png&#x27;;
const App = () =&gt; {
 return (
 &lt;div&gt;
 &lt;img style={{ width: &quot;500%&quot;, height: &quot;600%&quot; }} src={Logo} alt=&quot;React Logo&quot; /&gt;
 &lt;/div&gt;
 );
};
</code></pre>
If we have many images that need similar styling and don't want to use external styling, we could create an object to hold these styles objects and then add the object to the <code>styles</code> attribute:
<pre><code class="hljs">import Logo from &#x27;./images/react-logo.png&#x27;;

const App = () =&gt; {
 const myImageStyle = { width: &#x27;500px&#x27;, height: &#x27;600px&#x27; };

 return (
 &lt;div&gt;
 &lt;img style={myImageStyle} src={Logo} alt=&quot;&quot; /&gt;
 &lt;/div&gt;
 );
};
</code></pre>
<h2 id="howtoresizeanimagewiththewidthandheightattributes">How to Resize an Image With the width And height Attributes</h2>
In traditional HTML, one way to resize images is to make use of the <code>height</code> and <code>width</code> property with the <code>img</code> tag and this also works with React:
<pre><code class="hljs">import Logo from &#x27;./images/react-logo.png&#x27;;
const App = () =&gt; {
 return (
 &lt;div&gt;
 &lt;img src={Logo} width=&quot;500&quot; height=&quot;600&quot; alt=&quot;&quot; /&gt;
 &lt;!-- OR --&gt;
 &lt;img src={Logo} width={500} height={600} alt=&quot;&quot; /&gt;
 &lt;/div&gt;
 );
};
</code></pre>
The main drawback of this method is that fiddling with the height and width tends to distort images, making them shrink, stretch or otherwise lose their ratio. This can be fixed by using <code>object-fit: cover;</code>.
<h2 id="stylingourimages">Styling Our Images</h2>
When we use the <code>height</code>, <code>width</code>, <code>max-height</code>, and other CSS properties to resize our images, they tend to distort them, making them shrink or stretch.
It's always a good idea to include the <code>object-fit</code> property, which specifies how an image should be resized to fit its container. This property can accept a variety of values such as <code>contain</code>, <code>cover</code>, <code>fill</code>, <code>none</code> and <code>scale-down</code>.
Other CSS properties, such as <code>max-width</code>, <code>min-width</code>, <code>max-height</code>, and <code>min-height</code>, can define the maximum and minimum values an image can hit, limiting distortion.
<h2 id="conclusion">Conclusion</h2>
In this article, we learned how to resize images in React by looking at the various options available to us.
However, it is preferable to use CSS styles rather than having to set fixed attributes to these images unless absolutely necessary when you want to receive these values dynamically, in which case inline styling can also be used.

In this tutorial, learn how to resize images in React, how to avoid shrinking and other distortion and how to style images, using JavaScript, HTML and CSS.

Resizing Images with React

<h2 id="introduction">Introduction</h2>
K-Means is one of the most popular clustering algorithms. By having central points to a cluster, it groups other points based on their distance to that central point.
A downside of K-Means is having to choose the number of clusters, K, prior to running the algorithm that groups points.
<blockquote>
If you'd like to read an in-depth guide to K-Means Clustering, take a look at <a href="https://stackabuse.com/k-means-clustering-with-scikit-learn/" target="_blank">&quot;K-Means Clustering with Scikit Learn&quot;</a>.
</blockquote>
<h2 id="elbowmethodandsilhouetteanalysis">Elbow Method and Silhouette Analysis</h2>
The most commonly used techniques for choosing the number of Ks are the Elbow Method and the Silhouette Analysis.
To facilitate the choice of Ks, the Yellowbrick library wraps up the code with for loops and a plot we would usually write into 4 lines of code.
To install Yellowbrick directly from a Jupyter notebook, run:
<pre><code class="hljs">! pip install yellowbrick
</code></pre>
Let's see how it works for a familiar dataset which is already part of Scikit Learn, the Iris dataset.
The first step is to import the dataset, <code>KMeans</code> and <code>yellowbrick</code> libraries, and load the data:
<pre><code class="hljs">from sklearn.datasets import load_iris
from sklearn.cluster import KMeans
from yellowbrick.cluster import KElbowVisualizer, SilhouetteVisualizer

iris = load_iris()
</code></pre>
Notice here, we import the <code>KElbowVisualizer</code> and <code>SilhouetteVisualizer</code> from <code>yellowbrick.cluster</code>, those are the modules we'll use to visualize Elbow and Silhouette results!
After loading the dataset, in the <code>data</code> key of the bunch (a data type which is an extension of a dictionary) are the values of the points we want to cluster. If you want to know what the numbers represent, take a look at <code>iris['feature_names']</code>.
It is known that the Iris dataset contains three types of irises: 'versicolor', 'virginica' and 'setosa'. You can also inspect the classes in <code>iris['target_names']</code> to verify.
So, we have 4 features to cluster and they should be separated into 3 different clusters according to what we already know. Let's see if our results with the Elbow Method and Silhouette Analysis will corroborate that.
First, we will select the feature values:
<pre><code class="hljs">print(iris[&#x27;feature_names&#x27;]) # displays [&#x27;sepal length (cm)&#x27;, &#x27;sepal width (cm)&#x27;, &#x27;petal length (cm)&#x27;, &#x27;petal width (cm)&#x27;]
print(iris[&#x27;target_names&#x27;]) # displays array([&#x27;setosa&#x27;, &#x27;versicolor&#x27;, &#x27;virginica&#x27;], dtype=&#x27;&lt;U10&#x27;)

X = iris[&#x27;data&#x27;]
</code></pre>
Then, we can create a <code>KMeans</code> model, a <code>KElbowVisualizer()</code> instance which will receive that model along with the number of ks for which a metric will be computed, in this case from 2 to 11 Ks.
After that, we fit the visualizer with the data using <code>fit()</code> and display the plot with <code>show()</code>. If a metric is not specified, the visualizer uses the distortion metric, which computes the sum of squared distances from each point to its assigned center:
<pre><code class="hljs">model = KMeans(random_state=42)

elb_visualizer = KElbowVisualizer(model, k=(2,11))
elb_visualizer.fit(X) 
elb_visualizer.show() 
</code></pre>
<img src="https://s3.stackabuse.com/media/articles/kmeans-elbow-method-and-silhouette-analysis-with-yellowbrick-1.png" alt="elbow method for k means clustering">
Now, we already have a Distortion Score Elbow for KMeans Clustering plot with a vertical line marking which would be the best number of ks, in this case, <code>4</code>.
Seems the Elbow Method with a distortion metric wasn't the best choice if we didn't know the actual number of clusters. Will Silhouette also indicate that there are 4 clusters? To answer that, we just need to repeat the last code with a model with 4 clusters and a different visualizer object:
<pre><code class="hljs">model_4clust = KMeans(n_clusters = 4, random_state=42)

sil_visualizer = SilhouetteVisualizer(model_4clust)
sil_visualizer.fit(X) 
sil_visualizer.show()
</code></pre>
<img src="https://s3.stackabuse.com/media/articles/kmeans-elbow-method-and-silhouette-analysis-with-yellowbrick-2.png" alt="silhouette score for k means cluster using elbow method">
The code displays a Silhouette Plot of KMeans Clustering for 150 Samples in 4 Centers. To analyze these clusters, we need to look at the value of the silhouette coefficient (or score), its best value is closer to 1. The average value we have is <code>0.5</code>, marked by the vertical line, and not so good.
We also need to look at the distribution between clusters - a good plot has similar sizes of clustered areas or well-distributed points. In this graph, there are 3 smaller clusters (number 3, 2, 1) and one larger cluster (number 0), which isn't the result we were expecting.
Let's repeat the same plot for 3 clusters to see what happens:
<pre><code class="hljs">model_3clust = KMeans(n_clusters = 3, random_state=42)

sil_visualizer = SilhouetteVisualizer(model_3clust)
sil_visualizer.fit(X) 
sil_visualizer.show()
</code></pre>
<img src="https://s3.stackabuse.com/media/articles/kmeans-elbow-method-and-silhouette-analysis-with-yellowbrick-3.png" alt="silhouette for k means clusters">
By changing the number of clusters, the silhouette score got <code>0.05</code> higher and the clusters are more balanced. If we didn't know the actual number of clusters, by experimenting and combining both techniques, we would have chosen <code>3</code> instead of <code>2</code> as the number of Ks.
This is an example of how combining and comparing different metrics, visualizing data, and experimenting with different values of clusters is important to lead the result in the right direction. And also, how having a library that facilitates that analysis can help in that process!

In this short guide - learn how to perform the elbow method and silhouette analysis for K-Means cluster identification, using Yellowbrick and Scikit-Learn, with Python.

K-Means Elbow Method and Silhouette Analysis with Yellowbrick and Scikit Learn

In this definitive guide, learn everything you need to know about agglomeration hierarchical clustering with Python, Scikit-Learn and Pandas, with practical code samples, tips and tricks from professionals, as well as PCA, DBSCAN and other applied techniques.

Definitive Guide to Hierarchical Clustering with Python and Scikit-Learn

In this guide, learn how to write a custom GPT-Style (transformer) NLP deep learning network in just 5 lines of code, using TensorFlow and Keras/KerasNLP and Python, and perform text generation with an autoregressive natural language model.