Introduction to Clustering and K-Means in R

Clustering is a technique used to group similar data points into clusters. Among the various clustering algorithms, K-Means is widely used for its simplicity and efficiency. This introductory unit will guide you through setting up R and performing K-Means clustering.

Setting Up R and RStudio

1. Install R:

   • Go to the CRAN (The Comprehensive R Archive Network) website: https://cran.r-project.org/
   • Download and install the version of R suitable for your operating system.

2. Install RStudio:

   • RStudio is an integrated development environment (IDE) for R.
   • Go to the RStudio website: https://rstudio.com/products/rstudio/download/
   • Download and install the suitable version for your operating system.

Basic Setup in R

This section assumes you have R and RStudio installed on your machine.

1. Load Required Libraries:

   # Install the necessary package if not already installed
   if (!require("tidyverse")) install.packages("tidyverse")
   if (!require("ggplot2")) install.packages("ggplot2")
   if (!require("cluster")) install.packages("cluster")
   
   # Load the libraries
   library(tidyverse)
   library(ggplot2)
   library(cluster)

2. Loading a Sample Dataset

   # We'll use the built-in 'iris' dataset for this example
   data(iris)
   head(iris)

Performing K-Means Clustering

1. Preprocess the Data:

   • Remove non-numeric columns if any.

   # Removing the Species column
   iris_data <- iris %>% select(-Species)

2. Determine the Optimal Number of Clusters (k):

   • Use the Elbow Method to plot within-group sum of squares (WSS) for different k values and identify the "elbow point".

   set.seed(123)
   wss <- sapply(1:10, function(k) {
     kmeans(iris_data, centers = k, nstart = 20)$tot.withinss
   })
   
   # Plot the WSS to visualize the Elbow
   plot(1:10, wss,
        type = "b", pch = 19, frame = FALSE,
        xlab = "Number of clusters K",
        ylab = "Total within-clusters sum of squares")

3. Apply K-Means Clustering:

   • Let's assume the optimal number of clusters is 3.

   set.seed(123)
   kmeans_result <- kmeans(iris_data, centers = 3, nstart = 25)

4. Visualizing Clusters:

   • Use ggplot2 for a scatter plot to visualize the clusters.

   library(ggplot2)
   
   # Add the cluster information to the original dataframe
   iris$Cluster <- as.factor(kmeans_result$cluster)
   
   # Plotting the clusters
   ggplot(iris, aes(Petal.Length, Petal.Width, color = Cluster)) +
     geom_point(size = 3) +
     labs(title = "K-Means Clustering of Iris Data",
          x = "Petal Length",
          y = "Petal Width") +
     theme_minimal()

Conclusion

This guide has covered the initial steps to set up R, load necessary packages, preprocess data, determine the number of clusters using the Elbow Method, and perform & visualize K-Means clustering. Following these steps will help you run K-Means clustering analysis on your datasets.

Data Preprocessing and Cleaning in R for K-Means Clustering

This section covers practical steps for cleaning and preprocessing data to prepare it for K-Means Clustering in R.

Step 1: Load Required Libraries

Ensure necessary libraries are loaded.

library(dplyr)
library(tidyr)
library(ggplot2)

Step 2: Load Data

Assume dataset.csv is your data file that contains the data you want to preprocess.

data <- read.csv("dataset.csv")

Step 3: Inspect the Data

Check for missing values and look at the structure.

summary(data)
str(data)

Step 4: Handle Missing Values

Remove rows with missing values or impute them.

# Remove rows with any NA values
cleaned_data <- na.omit(data)

# Alternatively, you can impute missing values
# using the median for each column
cleaned_data <- data %>%
  mutate(across(everything(), ~ifelse(is.na(.), median(., na.rm = TRUE), .)))

Step 5: Normalize the Data

Normalize the numeric columns to have a mean of 0 and standard deviation of 1.

numeric_columns <- sapply(cleaned_data, is.numeric)
cleaned_data[numeric_columns] <- scale(cleaned_data[numeric_columns])

Step 6: Encode Categorical Variables

Convert categorical variables to numerical ones using one-hot encoding.

# Use dummy variables for categorical columns
cleaned_data <- cleaned_data %>%
  mutate(across(where(is.factor), as.character)) %>%
  mutate(across(where(is.character), as.factor)) %>%
  dummy_cols(select_columns = names(select(cleaned_data, where(is.factor))), remove_first_dummy = TRUE)

Step 7: Verify Data

Verify the preprocessed data to ensure it's in the expected format.

summary(cleaned_data)
str(cleaned_data)

Ready for K-Means Clustering

Now, your data is clean and ready for K-Means Clustering. Proceed with clustering on the cleaned_data object.

# Example K-Means Clustering
set.seed(123)  # for reproducibility
kmeans_result <- kmeans(cleaned_data, centers = 3, nstart = 25)

# View the clustering result
print(kmeans_result)

Follow these steps for efficient data preprocessing and cleaning tailored for K-Means Clustering in R. Now, proceed to the next steps in your clustering project.

K-Means Algorithm in R

K-Means Clustering Workflow

Step 1: Load Necessary Libraries

library(tidyverse)
library(cluster) # for silhouette width calculation
library(ggplot2) # for visualization

Step 2: Define K-Means Function and Data Preparation

First, let's generate some sample data if you do not have one. If you already have data, use that instead.

set.seed(42)
# Generating sample data
data <- data.frame(x = rnorm(100), y = rnorm(100))

Step 3: Apply K-Means Clustering

Choose a number of clusters, say 3, and apply the K-Means algorithm.

k <- 3
kmeans_result <- kmeans(data, centers = k, nstart = 25)

Step 4: Evaluate Cluster Quality

We can use the Silhouette method to evaluate how well clusters are defined.

sil_width <- silhouette(kmeans_result$cluster, dist(data))
avg_sil <- mean(sil_width[, 3])
print(paste("Average Silhouette Width: ", round(avg_sil, 2)))

Step 5: Visualize Clusters

Plot the clusters using ggplot2.

data$cluster <- as.factor(kmeans_result$cluster)
ggplot(data, aes(x = x, y = y, color = cluster)) +
  geom_point(size = 2) +
  ggtitle('K-Means Clustering') +
  theme_minimal()

Full Code Implementation

Below is the full code implementation for the steps listed above:

library(tidyverse)
library(cluster)
library(ggplot2)

# Generating sample data
set.seed(42)
data <- data.frame(x = rnorm(100), y = rnorm(100))

# Apply K-Means algorithm
k <- 3
kmeans_result <- kmeans(data, centers = k, nstart = 25)

# Evaluate cluster quality using silhouette width
sil_width <- silhouette(kmeans_result$cluster, dist(data))
avg_sil <- mean(sil_width[, 3])
print(paste("Average Silhouette Width: ", round(avg_sil, 2)))

# Visualize the clusters
data$cluster <- as.factor(kmeans_result$cluster)
ggplot(data, aes(x = x, y = y, color = cluster)) +
  geom_point(size = 2) +
  ggtitle('K-Means Clustering') +
  theme_minimal()

This implementation allows you to conduct K-Means clustering in R using built-in functions and libraries, and visualize and evaluate the results. The process starts from applying the algorithm, assessing the quality of the clusters, and ends with visualizing the clustering result.

Part 4: Choosing the Optimal Number of Clusters

In this section, we will implement a method to determine the optimal number of clusters for K-Means Clustering in R. We will use the Elbow Method and the Silhouette Method for this purpose.

Elbow Method

The Elbow Method involves iterating over a range of possible cluster numbers, computing the within-cluster sum of squares (WSS), and then plotting the results. The "elbow" point (where the WSS starts to decrease more slowly) is considered the optimal number of clusters.

# Load necessary library
library(ggplot2)

# Assuming 'data' is your preprocessed and cleaned dataset
set.seed(123) # for reproducibility

# Compute WSS for a range of cluster numbers
wss <- sapply(1:10, function(k) {
  kmeans(data, centers = k, nstart = 25)$tot.withinss
})

# Plot WSS vs. number of clusters
elbow_plot <- data.frame(Clusters = 1:10, WSS = wss)
ggplot(elbow_plot, aes(x = Clusters, y = WSS)) + 
  geom_line() + 
  geom_point() + 
  ggtitle("Elbow Method for Optimal Clusters") +
  xlab("Number of Clusters") + 
  ylab("Total Within Sum of Squares")

print(elbow_plot)

Silhouette Method

The Silhouette Method evaluates how similar each point in one cluster is to other points in the same cluster compared to points in other clusters. This method involves calculating the Silhouette coefficient for each cluster size.

# Load necessary library
library(cluster)

# Compute average silhouette width for a range of cluster numbers
sil_width <- sapply(2:10, function(k) {
  pam(data, k = k)$silinfo$avg.width
})

# Plot Silhouette Width vs. number of clusters
silhouette_plot <- data.frame(Clusters = 2:10, Silhouette_Width = sil_width)
ggplot(silhouette_plot, aes(x = Clusters, y = Silhouette_Width)) + 
  geom_line() + 
  geom_point() + 
  ggtitle("Silhouette Method for Optimal Clusters") +
  xlab("Number of Clusters") + 
  ylab("Average Silhouette Width")

print(silhouette_plot)

Conclusion

By examining the plots generated by both the Elbow Method and the Silhouette Method, you can determine the optimal number of clusters for your dataset. Typically, an optimal number of clusters would be at the elbow point in the WSS plot and where the average silhouette width is maximized.

Implementing K-Means Clustering in R

Loading the Necessary Libraries

# Load necessary libraries
library(tidyverse)
library(cluster)

Loading and Preparing the Data

Assuming your data is already preprocessed and stored in a data frame named df, ensure it is selected for clustering.

# Load your data (assumed to be already preprocessed)
df <- read.csv("path/to/your/cleaned_data.csv")

# Extracting the relevant features for clustering
# Assuming you're focusing on numeric data in 'df'
df_clustering <- df %>% select_if(is.numeric)

Scaling the Data

Scaling ensures that each feature contributes equally to the distance calculations.

# Standardizing the data
df_scaled <- scale(df_clustering)

Running K-Means Clustering

This example assumes you have determined the optimal number of clusters, k.

# Set the number of clusters
k <- 3 # replace with your optimal number

# Applying K-Means Clustering
set.seed(123) # for reproducibility
kmeans_result <- kmeans(df_scaled, centers = k, nstart = 25)

Analyzing the Results

# Inspecting cluster centers
print(kmeans_result$centers)

# Assigning cluster labels to the original data
df$cluster <- kmeans_result$cluster

# View the first few rows of the data with cluster assignment
head(df)

Visualizing the Clusters

Using a simple 2D plot to visualize, use ggplot2.

# Visualizing clusters in a 2D space using PCA for dimensionality reduction
pca_result <- prcomp(df_scaled, center = TRUE, scale. = TRUE)
pca_data <- as.data.frame(pca_result$x)

# Add cluster assignment
pca_data$cluster <- as.factor(df$cluster)

# 2D plot with ggplot2
ggplot(pca_data, aes(x = PC1, y = PC2, color = cluster)) +
  geom_point(size = 2) +
  labs(title = "K-Means Clustering Result",
       x = "Principal Component 1",
       y = "Principal Component 2") +
  theme_minimal()

Silhouette Analysis for Cluster Quality

To evaluate the quality of the clustering.

# Calculating silhouette width for each sample
silhouette_result <- silhouette(kmeans_result$cluster, dist(df_scaled))

# Overall quality of clusters
summary(silhouette_result)

# Plotting the silhouette
plot(silhouette_result, col = 1:k, border = NA)

Summary

This implementation covers loading necessary libraries, preparing and scaling the data, running the K-Means clustering, analyzing results, visualizing the clusters, and evaluating the cluster quality. Apply these steps directly to your specific project environment.

Visualizing Clustering Results in R

Step 1: Load Necessary Libraries and Data

Assuming you have implemented K-Means clustering and have a data frame data with clustering results.

# Load necessary libraries
library(ggplot2)
library(cluster)

# Your data frame `data` should have a column `cluster` with the cluster assignments,
# and `x` and `y` columns for the features to be plotted.

# Example:
data <- data.frame(
  x = rnorm(100),
  y = rnorm(100),
  cluster = sample(1:3, 100, replace = TRUE)
)

Step 2: Basic Scatter Plot with Clusters

# Create a scatter plot colored by cluster
ggplot(data, aes(x = x, y = y, color = as.factor(cluster))) +
  geom_point(size = 3) +
  labs(title = "K-Means Clustering Results",
       x = "Feature 1 (x)",
       y = "Feature 2 (y)",
       color = "Cluster") +
  theme_minimal()

Step 3: Centroid Visualization

# Assuming `kmeans_result` is the result of your K-Means clustering
# Extract the centroids
centroids <- as.data.frame(kmeans_result$centers)

# Add the cluster column to centroids for plotting
centroids$cluster <- factor(1:nrow(centroids))

# Scatter plot including centroids
ggplot(data, aes(x = x, y = y, color = as.factor(cluster))) +
  geom_point(size = 3) +
  geom_point(data = centroids, aes(x = x, y = y), 
             color = 'black', size = 5, shape = 8) +
  labs(title = "K-Means Clustering Results with Centroids",
       x = "Feature 1 (x)",
       y = "Feature 2 (y)",
       color = "Cluster") +
  theme_minimal()

Step 4: Silhouette Plot (Optional)

# Create silhouette plot to assess the quality of clustering
sil <- silhouette(kmeans_result$cluster, dist(data[, c("x", "y")]))

# Convert the silhouette object to a data frame
sil_data <- data.frame(cluster = factor(sil[, 1]),
                       silhouette_width = sil[, 3])

# Plot the silhouette widths
ggplot(sil_data, aes(x = cluster, y = silhouette_width)) + 
  geom_boxplot() + 
  labs(title = "Silhouette Plot",
       x = "Cluster",
       y = "Silhouette Width") +
  theme_minimal()

Summary

The steps provided show how to visualize clustering results in R using ggplot2. You can create scatter plots of the clustered data and include the centroids for better understanding. Additionally, you can use a silhouette plot to assess clustering quality. Applying these implementations directly to your data will aid in visualizing and interpreting your K-Means clustering results effectively.

Evaluating Cluster Quality

Once you have implemented K-Means clustering and visualized the results, it's crucial to evaluate the quality of your clustering. Several methods can be used for this purpose, including the Silhouette Score, Elbow Method, and the Davies-Bouldin Index. Below is an implementation in R for evaluating cluster quality using these methods.

1. Silhouette Score

The Silhouette Score measures how similar an object is to its own cluster compared to other clusters. It ranges from -1 to 1, where a higher value indicates better clustering quality.

# Assuming `kmeans_model` is your K-Means result and `data` is your dataset
library(cluster)

# Calculate the Silhouette Score
sil <- silhouette(kmeans_model$cluster, dist(data))
summary(sil)
plot(sil)

2. Elbow Method

The Elbow Method is used to determine the optimal number of clusters by plotting the total within-cluster sum of square (WSS) against the number of clusters.

# Function to compute total within-cluster sum of square
wss <- function(data, max_clusters = 10) {
  wss_values <- sapply(1:max_clusters, function(k){
    kmeans(data, k, nstart = 10)$tot.withinss
  })
  return(wss_values)
}

# Plotting Elbow Curve
wss_values <- wss(data)
plot(1:10, wss_values, type="b", pch = 19, frame = FALSE, 
     xlab="Number of clusters K",
     ylab="Total within-clusters sum of squares")

3. Davies-Bouldin Index

The Davies-Bouldin Index measures the average "similarity" ratio of each cluster with the cluster that is most similar to it. Lower values indicate better clustering.

library(clusterSim)

# Calculate the Davies-Bouldin Index
db_index <- index.DB(data, kmeans_model$cluster)$DB
print(db_index)

Conclusion

By using the above methods, you can quantitatively assess the quality of your K-Means clustering. Each method provides different insights into your clustering results, ensuring a robust evaluation process.

Advanced K-Means Techniques

To enhance the K-Means clustering methodology in R, we will explore advanced techniques such as initializing cluster centroids using the k-means++ algorithm, implementing the elbow method for optimal k, and incorporating silhouette analysis to better understand the quality of the clustering. Below, you will find thorough implementations for these advanced techniques.

Initialization with k-means++

The k-means++ algorithm helps in selecting initial cluster centroids to speed up convergence.

# Load necessary libraries
library(stats)

# k-means++ initialization function
kmeans_plus_plus <- function(data, k) {
  n <- nrow(data)
  centroids <- matrix(nrow=k, ncol=ncol(data))
  
  # Randomly select the first centroid
  centroids[1,] <- data[sample(1:n, 1), ]
  
  for (i in 2:k) {
    # Compute distances from the nearest centroid
    dist_sq <- apply(data, 1, function(x) min(colSums((t(centroids[1:(i-1),]) - x)^2)))
    
    # Based on distance probabilities, select next centroid
    prob <- dist_sq / sum(dist_sq)
    cumsum_prob <- cumsum(prob)
    selected <- which(runif(1) <= cumsum_prob)[1]
    centroids[i, ] <- data[selected, ]
  }
  
  return(centroids)
}

# Implementing k-means with k-means++ initialization
advanced_kmeans <- function(data, k) {
  initial_centroids <- kmeans_plus_plus(data, k)
  kmeans(data, centers = initial_centroids, iter.max = 100, nstart = 1)
}

Implementing the Elbow Method

The elbow method helps to determine the optimal number of clusters.

# Function to calculate total within-cluster sum of squares for different k
wss_plot <- function(data, max_k = 10) {
  wss <- sapply(1:max_k, function(k) {
    kmeans(data, centers = k, nstart = 10)$tot.withinss
  })
  
  plot(1:max_k, wss, type="b", pch = 19, frame = FALSE, 
       xlab = "Number of clusters K",
       ylab = "Total within-clusters sum of squares")
}

# Run the elbow method on a dataset
wss_plot(your_data, max_k = 10)

Silhouette Analysis

Silhouette analysis helps determine the quality of clustering by measuring how close each point in one cluster is to points in the neighboring clusters.

# Load required library
library(cluster)

# Silhouette Analysis Function
silhouette_analysis <- function(data, k_max) {
  avg_sil_width <- numeric(k_max)
  
  for (k in 2:k_max) {
    # Perform k-means clustering
    km_res <- kmeans(data, centers = k, nstart = 25)
    
    # Compute the silhouette width
    sil <- silhouette(km_res$cluster, dist(data))
    avg_sil_width[k] <- mean(sil[, 3])
  }
  
  plot(1:k_max, avg_sil_width, type='b', pch = 19, frame = FALSE,
       xlab = "Number of clusters K", ylab = "Average silhouette width")
  best_k <- which.max(avg_sil_width)
  return(best_k)
}

# Perform silhouette analysis on a dataset
optimal_k <- silhouette_analysis(your_data, k_max = 10)

By applying these advanced techniques, you can optimize the performance and quality of your K-Means clustering in R effectively.

Real-World Applications of K-Means Clustering in R

1. Customer Segmentation

Customer segmentation enables businesses to understand different customer groups and tailor marketing strategies accordingly.

Example Implementation

# Load required libraries
library(tidyverse)
library(cluster)
library(factoextra)

# Load dataset
# Example: Using in-built 'mtcars' dataset for demonstration
data("mtcars")

# Select relevant features for clustering
features <- mtcars %>% select(mpg, hp, wt)

# Standardize the data
scaled_features <- scale(features)

# Apply K-Means clustering
set.seed(123)
kmeans_result <- kmeans(scaled_features, centers=3, nstart=25)

# Add cluster results to original data
mtcars <- mtcars %>% mutate(cluster = kmeans_result$cluster)

# Print the first few rows of the dataset to show cluster assignments
head(mtcars)

# Visualize the clusters
fviz_cluster(kmeans_result, data = scaled_features)

2. Market Basket Analysis

Market Basket Analysis helps in identifying products frequently bought together, allowing for optimized inventory and promotions.

Example Implementation

# Install and load 'arules' package for associative rule mining
if(!require(arules)) install.packages('arules'); library(arules)

# Example: Using the 'Groceries' dataset from 'arules' package
data("Groceries")

# Convert transactions into a matrix
groceries_matrix <- as(groceries, "matrix")

# Transpose matrix to get items as features for clustering
item_features <- t(groceries_matrix)

# Standardize the data
scaled_items <- scale(item_features)

# Apply K-Means clustering
set.seed(123)
kmeans_items <- kmeans(scaled_items, centers=5, nstart=25)

# Assign clusters to items
item_clusters <- data.frame(item = colnames(item_features), cluster = kmeans_items$cluster)

# Print the first few rows of item clusters
head(item_clusters)

3. Image Compression

K-Means can be used to compress images by reducing the number of colors used in an image.

Example Implementation

# Load libraries for image processing
library(imager)

# Read image
image_path <- "path/to/your/image.jpg"
image <- load.image(image_path)

# Convert image to data frame
image_df <- as.data.frame(image, wide='c')

# Select and normalize RGB values
rgb_values <- image_df %>% select(r, g, b)
rgb_values <- scale(rgb_values)

# Apply K-Means with a predefined number of colors
set.seed(123)
k_colors <- 16
kmeans_colors <- kmeans(rgb_values, centers=k_colors, nstart=25)

# Replace each pixel with its corresponding cluster center
clustered_image <- kmeans_colors$centers[kmeans_colors$cluster, ]

# Reshape data to match original image dimensions
dim_clustered_image <- c(dim(image)[1], dim(image)[2], 3)
clustered_image <- array(clustered_image, dim = dim_clustered_image)

# Save the compressed image
clustered_image <- as.cimg(clustered_image)
save.image(clustered_image, "compressed_image.jpg")

4. Document Clustering

Document clustering groups similar documents, aiding in organizing large information repositories.

Example Implementation

# Load libraries
library(tm)
library(SnowballC)

# Sample Corpus
docs <- c("Data science is an inter-disciplinary field.",
          "Machine learning is a part of data science.",
          "Artificial Intelligence is the broader concept.",
          "R is a programming language widely used in data analysis.")

# Create corpus
corpus <- Corpus(VectorSource(docs))

# Text Preprocessing
corpus <- tm_map(corpus, content_transformer(tolower))
corpus <- tm_map(corpus, removePunctuation)
corpus <- tm_map(corpus, removeWords, stopwords('english'))
corpus <- tm_map(corpus, stemDocument)

# Create Document-Term Matrix
dtm <- DocumentTermMatrix(corpus)
dtm_matrix <- as.matrix(dtm)

# Apply K-Means clustering
set.seed(123)
kmeans_docs <- kmeans(dtm_matrix, centers=2, nstart=25)

# Print clustering results
print(kmeans_docs)

These codes demonstrate the real-world applications of K-Means Clustering in customer segmentation, market basket analysis, image compression, and document clustering. The provided examples should be executed in an R environment where prerequisites (datasets and libraries) are available.

K-Means Clustering Project: Part 10 - Project Challenges and Best Practices

Project Challenges

When implementing K-Means clustering in R, several challenges may arise. Below are the common issues and practical steps to handle them:

Challenge 1: Choosing the Right K

• Issue: Determining the number of clusters (K) can be difficult.
• Solution: Utilize the Elbow Method, Silhouette Analysis, or the Gap Statistic.

Example using the Elbow Method:

set.seed(123)
wcss <- vector()
for (i in 1:10) {
  kmeans_result <- kmeans(data, centers = i)
  wcss[i] <- kmeans_result$tot.withinss
}
plot(1:10, wcss, type = 'b', main = 'Elbow Method', xlab = 'Number of Clusters', ylab = 'WCSS')

Challenge 2: Data Scaling

• Issue: Features with larger scales can dominate the clustering result.
• Solution: Standardize your data before applying K-Means.

Example of Data Scaling:

scaled_data <- scale(data)

Challenge 3: Initialization Sensitivity

• Issue: K-Means results can vary depending on the initial centroids.
• Solution: Use multiple random starts or the nstart parameter in kmeans().

Example of Initialization:

set.seed(123)
kmeans_result <- kmeans(scaled_data, centers = 3, nstart = 25)

Challenge 4: Handling Outliers

• Issue: Outliers can distort cluster centers.
• Solution: Remove or treat outliers before clustering.

Example of Outlier Removal using the boxplot.stats function:

cleaned_data <- data[!data.column %in% boxplot.stats(data.column)$out, ]

Best Practices

Practice 1: Data Preprocessing

• Ensure Consistency: Handle missing values, standardize data, and encode categorical variables consistently.

Practice 2: Cluster Validation

• Perform Multiple Validations: Use different evaluation metrics like silhouette score, Dunn index, or Davies-Bouldin Index.

Example of Silhouette Analysis:

library(cluster)
silhouette_score <- silhouette(kmeans_result$cluster, dist(scaled_data))
plot(silhouette_score, main = 'Silhouette Plot')

Practice 3: Interpretability

• Understand Your Clusters: Use cluster profiling to make the clusters interpretable and actionable.

Example of Cluster Profiling:

aggregate(scaled_data, by = list(cluster = kmeans_result$cluster), FUN = mean)

Practice 4: Reproducibility

• Set Seed: Use set.seed() for reproducible results.

set.seed(123)

Practice 5: Documentation and Reporting

• Document Your Code: Ensure code clarity and comment on complex sections for future reference.
• Visual Reporting: Use visualizations to make your findings understandable.

Example of Cluster Visualization:

library(ggplot2)
ggplot(data, aes(x = Feature1, y = Feature2, color = as.factor(kmeans_result$cluster))) +
  geom_point() +
  labs(title = 'K-Means Clustering', x = 'Feature 1', y = 'Feature 2') +
  theme_minimal()

By adhering to these best practices and addressing common challenges effectively, you can enhance the performance and reliability of your K-Means clustering projects using R.