跳至主要內容

Final Project, K-Means Clustering

AI悦创原创英国-布里斯托尔英国-布里斯托尔大约 41 分钟...约 12274 字

Clustering

聚类

  • Clustering is a machine learning task that groups similar objects together.

聚类是一项机器学习任务，它将相似的对象分组在一起。

  • Given a dataset with observations, D:=xii=1nD:={x_i}^n_{i=1} ,we would like to divide DD into KK disjoint subsets: D=Ui∈{1...K}Diand⋂i∈{1...K}Di=θD = U_{i\in{\{1\text{...}K\}}}D_i and \bigcap_{i_\in{\{1\text{...}K\}}} D_i=\theta

给定一个包含观测数据的数据集，我们想将DD划分为KK个不相交的子集：

  • Such that observations in each subset DiD_i are similar to each other.

使得每个子集DiD_i中的观测值彼此相似。

Clustering Example

聚类示例

  • The subsets found by clustering is not unique.

    聚类找到的子集不是唯一的。

    • depending on how the similarity is defined, you can get different clustering results.

      根据“相似性是如何定义”的不同方式，您可以得到不同的聚类结果。

  • Clustering of animals: Land vs. Sea.

    动物的聚类：陆地 vs. 海洋。

Clustering Example, 2

  • Clustering of animals: Mammals vs. Non-mammals.

Similarities

Similarities 的中文意思是相似之处。

  • In mathematics, similarities between objects are usually defined by a metric or distance function.

在数学中，对象之间的相似性通常由度量或距离函数定义。

  • One classic choice of distance is Euclidean distances.

一个经典的距离选择是欧几里得距离。

  • If two objects can be expressed as two points a and b in a d-dimensional Euclidean space, the Euclidean distance is dist(a,b):=∑i=1...d(ai−bi)2dist(a\text{,}b):=\sqrt{\sum_{i=1\text{...}d}(a_i-b_i)^2}

IRIS dataset

IRIS 数据集

Ronald Fisher created Iris dataset, where he measured the length, width of the sepals and petals 150 iris flowers.

罗纳德·费雪创建了鸢尾花数据集，其中他测量了150朵鸢尾花的萼片和花瓣的长度和宽度。您可以在以下链接中了解更多信息：Ronald Fisher和Iris dataset。

  • In this dataset, each flower is a 4-dimensional vector.

在这个数据集中，每朵花都是一个四维向量。

> iris # load iris dataset in R by typing "iris".
    Sepal.Length Sepal.Width Petal.Length Petal.Width
1            5.1		3.5          1.4         0.2
2            4.9		3.0          1.4         0.2
3            4.7		x3.2          1.3         0.2
...

在R中输入"iris"来加载鸢尾花数据集。

K-Means Clustering Algorithm

K-Means 聚类算法

Given a dataset and a distance function, how to do clustering?

给定一个数据集和一个距离函数，如何进行聚类？

  • K-means is a simple and popular choice.

K-means 是一个简单且流行的选择。

  • It computes the similarity between each observation and "centers" of each subset, then assign observations to different subsets.

它计算每个观测值与每个子集的“中心”之间的相似度，然后将观测值分配给不同的子集。

  • After the assignments are made, it updates the centers to be the average of observations in each subset.

分配任务后，它会更新中心点，使其成为每个子集中观测值的平均值。

  • It repeatedly carries out the previous two steps until assignments do not change.

它会重复执行前两个步骤，直到分配不再改变为止。

K-Means Clustering Algorithm

K-Means 聚类算法

Suppose your dataset DD contains nn observations in d-dimensional space.Then K-Means divides DD into D1,......,DKD_1,......,D_K subsets using the following algorithm.

假设你的数据集DD包含dd维空间中的nn个观测值。然后，K-Means算法使用以下算法将DD划分为D1,……,DKD_1\text{,……,}D_K子集。

  1. Randomly pick KK observations from your dataset, as KK centers: c1,......cKc_1\text{,......}c_K
  2. For each observation xi∈Dx_i\in{D} ,
    1. For each k∈{1...K}k\in{\{1\text{...}K\}},compute the distance d(i,k)=dist(xi,ck)d(i\text{,}k)=dist(x_i\text{,}c_k)
    2. Assign XiX_i to the subset Dk=k′D_{k=k'}，where k′=arg minkdik'=arg\space min_kd_i,kk
    3. Compute the new centers: c1,......,cKc_1\text{,......,}c_K，where ck:=1∣DK∣∑xi∈DkXjc_k:=\frac{1}{|D_K|}\sum_{x_i\in D_k}X_j,
    4. i.e., the average of all observations in subset DkD_k.
    5. Repeat 2 and 3 until the assignment does not change any more.

K-Means Clustering Algorithm: Demo

K-Means聚类算法：演示

The new centers do not lead to a different assignment comparing to iteration 2.

Stop.

Coursework: Part I (15 points)

The first part of this coursework is generating a toy dataset for our K-means algorithm. Let us assume K=2K=2 for now.

  1. Set the random seed to 1.
  2. Generate a dataset DD , containing 100 random observations from two 2-dimensional normal distribution with different means.
    1. DD can be either a matrix or data frame.
    2. You should sample 50 observations from one normal distribution and 50 from the other normal distribution.
  3. Create C=c1, c2C = {c_1\text{, }c_2} by randomly picking 2 centers from your dataset.
    1. The choice of centers needs to be random.
    2. You are not allowed to specify centers yourself.
  4. Visualize using points function.
    1. It is up to you how to visualize your dataset.

Coursework: Part II (30 points)

  • Now, let us write the K-means algorithm and test it on the toy dataset.
  • Below is a list of suggested steps of writing your code. However, you can write your code differently.

  1. Write a function dist that computes the distance di,kd_{i\text{,}k} .

  2. Write a function assign that assigns xix_i to Dk=k′D_{k=k'} .

  3. Find a way to apply assign to all observations in D.Obtain an 100-dimensional vector k_prime whose i−thi-th component is the i-th observation's assignment k'.

  4. Write a function update_centers that updates centers in CC with the new assignments stored in k_prime .

  5. Write a function visualize that visualizes c1,c2c_1\text{,}c_2 and D1, D2D_1\text{, }D_2.

  6. Write a loop that calls assign , update_centers and visualize repeatedly until the elements in k_prime do not change any more.

Coursework: Part III (15 points)

Now, let us apply K-means algorithm to a real-world dataset iris .

  • Load iris dataset by typing iris and inspect the dataset.
  • There are 5 variables in this dataset:
    • Sepal.Length
    • Sepal.Width
    • Petal.Length
    • Petal.Width
    • Species
  • The first four variables are the properties of flowers. The fifth variable indicates the types of flowers.
  1. Create a new R file.
  2. Create a list of 6 new datasets from the iris dataset, by picking every pairs of variables from the first four variables.
  3. Find a way to apply the K-means algorithm you previously wrote to the entire list of iris datasets and perform clustering analysis.
  4. Visualize the assignments obtained from the K-means algorithm, and save your plots (6 in total) as 6 png files.

The following code saves a plot to the points.png file.

#create file
png("./points.png", width = 500, height = 500)
#create the plot
plot(c(-5,5),c(-5,5),type = "n")
points(rnorm(10), rnorm(10), cex = 2)
#close the file
dev.off()

Marking Criteria

  • Part I: 15 points

  • Part II: 30 points

  • Part III: 15 points

  • Vectorization and FP: 20 points

    • Your code uses vectorization and does not use unnecessary loops.
    • Your code uses some FP features (not necessarily completely written in FP).

  • Coding Style: 20 points.

    • Variable naming, Code formatting, Comments

  • You are encouraged to discuss this coursework with other students.

  • All coursework questions should be addressed to the lecturer or TA during lab sessions or using the blackboard forum.

  • You are only allowed to use the base R.

  • You are not allowed to use external machine learning libraries without the permission from the lecturer.

  • You are not allowed to copy other people's work.

    • You are not allowed to pass your work to other students.

  • Discuss with others but write the code by yourself!!

Submission

  • Deadline: 8th May.
  • Submit a zip file containing all your R scripts (Rmd files if you use R markdown).
    • You do not need to submit any data file.
    • You do not need to submit any images your code generate.

Answer

1. 题目解析

这个题目要求你使用 R 语言编写一个 K-means 聚类算法，并将该算法应用于一个玩具数据集和真实的数据集（Iris 数据集）。题目分为三部分：

  1. 第一部分（15 分）：生成一个包含 100 个随机观测的玩具数据集，这些观测来自两个具有不同均值的二维正态分布。然后从数据集中随机选择 2 个聚类中心，并使用 points 函数进行可视化。

  2. 第二部分（30 分）：编写 K-means 算法并在玩具数据集上测试。需要编写一系列函数（包括计算距离、分配观测值、更新中心等），并使用循环反复调用这些函数，直到观测值的分配不再发生变化。

  3. 第三部分（15 分）：将 K-means 算法应用于真实世界的数据集（Iris 数据集）。从 Iris 数据集中创建一个新的数据集列表，选择前四个变量的所有变量对。将 K-means 算法应用于整个 Iris 数据集列表并执行聚类分析。将从 K-means 算法获得的分配进行可视化，并将 6 个图像保存为 6 个 png 文件。

此外，还有一些额外的评分标准，包括使用向量化和函数式编程（20 分），以及代码风格（20 分）。最后，你需要在截止日期（5 月 8 日）前提交一个包含所有 R 脚本（或 Rmd 文件，如果使用 R Markdown）的 zip 文件。

2. 代码运行方式

为了在 R 中运行上面的代码，请按照以下步骤操作：

  1. 打开 R 或 RStudio。
  2. 在 R 控制台或脚本编辑器中粘贴上面提供的修复后的代码。
  3. 如果您在 R 控制台中粘贴了代码，只需按 Enter 键运行它。如果您在脚本编辑器中粘贴了代码，请选择全部代码，然后按 Ctrl+Enter（在 Windows 和 Linux 上）或 Cmd+Enter（在 macOS 上）运行它。
  4. 代码运行完毕后，您将在 R 图形窗口中看到数据集的可视化图，包括观测值和随机选择的中心。

请注意，如果您还没有安装 R 或 RStudio，您需要首先下载并安装它们。您可以从以下链接下载 R：

RStudio 可以从这里下载：https://www.rstudio.com/products/rstudio/download/

3. 开始编写

3.1 第一部分

第一部分

第一部分（15 分）：生成一个包含 100 个随机观测的玩具数据集，这些观测来自两个具有不同均值的二维正态分布。然后从数据集中随机选择 2 个聚类中心，并使用 points 函数进行可视化。

为了完成第一部分，你需要按照以下步骤使用 R 语言编写代码：

  1. 设置随机种子为 1。
  2. 生成一个包含 100 个随机观测的数据集 D，观测值来自两个具有不同均值的二维正态分布。从一个正态分布中采样 50 个观测值，从另一个正态分布中采样 50 个观测值。
  3. 从数据集中随机选择 2 个聚类中心。
  4. 使用 points 函数可视化数据集。
答案
# 设置随机种子
set.seed(1)

# 生成玩具数据集
mean1 <- c(1, 1)
mean2 <- c(5, 5)
cov_matrix <- matrix(c(1, 0, 0, 1), ncol = 2)
group1 <- MASS::mvrnorm(n = 50, mu = mean1, Sigma = cov_matrix)
group2 <- MASS::mvrnorm(n = 50, mu = mean2, Sigma = cov_matrix)
toy_data <- rbind(group1, group2)

# 随机选择 2 个聚类中心
initial_centers <- toy_data[sample(nrow(toy_data), 2), ]

# 使用 points 函数进行可视化
plot(toy_data, col = "blue", main = "Toy Dataset with Initial Centers")
points(initial_centers, col = "red", pch = 19)

这段代码首先设置了随机种子，然后使用给定的均值和协方差矩阵生成了两个正态分布的观测值。接下来，它将两组观测值合并成一个数据集，并从中随机选择了 2 个聚类中心。最后，它使用 points 函数在同一图中绘制了数据集和初始聚类中心。

Q1

Question 0

上面用了哪两种均值的二维正态分布？

在上面的示例代码中，我们使用了两种具有不同均值的二维正态分布。第一个分布的均值向量为 mean1 <- c(1, 1)，第二个分布的均值向量为 mean2 <- c(5, 5)。这意味着第一个分布的观测值主要集中在 (1, 1) 附近，而第二个分布的观测值主要集中在 (5, 5) 附近。两个分布共享相同的协方差矩阵 cov_matrix <- matrix(c(1, 0, 0, 1), ncol = 2)，表示两个正态分布具有相同的形状和方向。

Question 1

为什么设置随机种子？然后为什么设置为1？

设置随机种子的目的是确保你的代码在每次运行时都能产生相同的随机数。这在进行数据分析和编写可重复的代码时非常有用，因为它可以确保每次运行的结果都是一致的。这样，你可以更容易地调试和比较不同算法的性能。

在本例中，我们设置随机种子为 1，是因为它是一个简单的整数值。实际上，你可以选择任何整数作为随机种子，只要你在整个分析过程中保持一致就行。这里选择 1 只是一个任意的选择，主要是为了方便。如果你想尝试不同的随机种子，你可以更改这个值，但请注意，这可能会导致你的聚类结果和其他人的不同。

Question 2

不同的随机种子的效果

当然可以。以下是一个使用两个不同随机种子的示例，你可以观察到不同的初始聚类中心。

# 定义一个用于生成和可视化数据集的函数
generate_and_visualize <- function(seed) {
  set.seed(seed)

  mean1 <- c(1, 1)
  mean2 <- c(5, 5)
  cov_matrix <- matrix(c(1, 0, 0, 1), ncol = 2)
  group1 <- MASS::mvrnorm(n = 50, mu = mean1, Sigma = cov_matrix)
  group2 <- MASS::mvrnorm(n = 50, mu = mean2, Sigma = cov_matrix)
  toy_data <- rbind(group1, group2)

  initial_centers <- toy_data[sample(nrow(toy_data), 2), ]

  plot(toy_data, col = "blue", main = paste("Toy Dataset with Initial Centers (Seed:", seed, ")"))
  points(initial_centers, col = "red", pch = 19)
}

# 使用随机种子 1
generate_and_visualize(1)

# 使用随机种子 42
generate_and_visualize(42)

这段代码定义了一个名为 generate_and_visualize 的函数，该函数接受一个随机种子作为输入。这个函数生成一个玩具数据集并选择初始聚类中心，然后在图中显示数据集和初始中心。

我们调用了这个函数两次，分别使用随机种子 1 和 42。你会看到两个图形具有不同的初始聚类中心，这是因为不同的随机种子导致了不同的随机选择。这个例子展示了如何随机种子影响随机数生成和初始聚类中心的选择。

题目说 K=2，这个是用不到吗？

实际上，K=2 在这个部分并不会直接用到，但它在接下来的部分中将非常关键。当我们在第二部分实现 K-means 算法时，你将需要使用 K=2 作为聚类的数量。

在第一部分中，我们已经生成了一个包含 100 个随机观测的玩具数据集，并从数据集中随机选择了 2 个聚类中心。在这里，K=2 指的是我们将在接下来的部分中使用 K-means 算法将这些观测值划分为 2 个聚类。

所以，上面的代码确实满足了第一部分的要求。在接下来的部分中，你将使用 K=2 来实现 K-means 算法，并将其应用于这个玩具数据集。

3.2 第二部分

3.2.1 K-means 概念

K-means 算法是什么？

K-means 算法是一种无监督l学习算法，主要用于聚类分析。在数据挖掘、机器学习和统计学等领域中，K-means 算法被广泛应用。这个算法的主要目的是将数据集中的数据点划分为 K 个不同的簇（即类别），使得每个数据点与所属簇的质心（centroid）的距离之和最小。质心是一个簇中所有数据点的均值向量。

K-means 算法的基本步骤如下：

  1. 初始化：选择 K 个初始质心，可以随机选择数据集中的 K 个数据点作为初始质心。
  2. 分配：将每个数据点分配给离它最近的质心所属的簇。
  3. 更新：重新计算每个簇的质心，质心是该簇中所有数据点的平均值。
  4. 重复：重复步骤 2 和 3，直到质心不再发生显著变化或达到预先设定的最大迭代次数。

K-means算法有几个注意事项：

  1. K 值的选择：K值会直接影响聚类结果。选择合适的 K 值可以通过多种方法，如肘部法则（Elbow method）和轮廓系数（Silhouette coefficient）。
  2. 初始质心的选择：K-means算法对初始质心敏感。不同的初始质心可能导致不同的聚类结果。为了解决这个问题，可以使用K-means++算法进行初始质心的选择。
  3. 局部最优解：K-means算法可能会收敛到局部最优解，而非全局最优解。为了找到更好的聚类结果，可以多次运行算法并选择最佳结果。

为了完成第二部分，你需要编写以下函数并在玩具数据集上测试 K-means 算法：

  1. 编写一个 dist 函数，用于计算距离 di,kd_{i\text{,}k}。
  2. 编写一个 assign 函数，用于将 xix_i 分配给 Dk=k′D_{k=k'}。
  3. 为数据集 D 中的所有观测值应用 assign 函数。获得一个 100 维向量 k_prime，其中第 i 个分量表示第 i 个观测值的分配 k'。
  4. 编写一个 update_centers 函数，用于根据 k_prime 中的新分配更新集合 C 中的聚类中心。
  5. 编写一个 visualize 函数，用于可视化 c1,c2c_1\text{,}c_2 和 D1, D2D_1\text{, }D_2。
  6. 编写一个循环，反复调用 assign、update_centers 和 visualize 函数，直到 k_prime 中的元素不再发生变化。

下面是完成第二部分所需的各个步骤：

  1. 计算距离函数：
dist <- function(x, center) {
  return(sqrt(sum((x - center)^2)))
}
  1. 分配观测值的函数：
答案
assign <- function(x, centers) {
  return(which.min(sapply(centers, dist, x = x)))
}
  1. 应用分配函数：
答案
k_prime <- apply(toy_data, 1, assign, centers = initial_centers)
  1. 更新聚类中心的函数：
答案
update_centers <- function(data, assignments, K) {
  return(lapply(1:K, function(k) colMeans(data[assignments == k, ])))
}
  1. 可视化函数：
答案
visualize <- function(data, centers, assignments, K) {
  plot(data, col = assignments, main = "K-means Clustering")
  points(matrix(unlist(centers), ncol = 2, byrow = TRUE), col = 1:K, pch = 19)
}
  1. 编写循环：
代码
prev_assignments <- NULL
while (!identical(prev_assignments, k_prime)) {
  centers <- update_centers(toy_data, k_prime, K = 2)
  prev_assignments <- k_prime
  k_prime <- apply(toy_data, 1, assign, centers = centers)
  visualize(toy_data, centers, k_prime, K = 2)
}

这些代码将实现 K-means 算法，并在玩具数据集上进行测试。通过反复调用 assign、update_centers 和 visualize 函数，算法将持续进行聚类，直到观测值的分配不再发生变化。

详细注释
# 定义一个计算距离的函数，输入是观测值 x 和聚类中心 center
dist <- function(x, center) {
  # 计算 Euclidean 距离并返回
  return(sqrt(sum((x - center)^2)))
}

# 定义一个分配观测值的函数，输入是观测值 x 和聚类中心 centers
assign <- function(x, centers) {
  # 对每个聚类中心计算距离，并返回距离最小的中心的索引
  return(which.min(sapply(centers, dist, x = x)))
}

# 对所有观测值应用分配函数
k_prime <- apply(toy_data, 1, assign, centers = initial_centers)

# 定义一个更新聚类中心的函数，输入是数据集 data、观测值的分配 assignments 和聚类数量 K
update_centers <- function(data, assignments, K) {
  # 对每个聚类，计算其观测值的列均值，得到新的聚类中心
  return(lapply(1:K, function(k) colMeans(data[assignments == k, ])))
}

# 定义一个可视化函数，输入是数据集 data、聚类中心 centers、观测值的分配 assignments 和聚类数量 K
visualize <- function(data, centers, assignments, K) {
  # 绘制观测值，使用分配的聚类编号作为颜色
  plot(data, col = assignments, main = "K-means Clustering")
  # 绘制聚类中心，使用不同颜色和特殊符号
  points(matrix(unlist(centers), ncol = 2, byrow = TRUE), col = 1:K, pch = 19)
}

# 初始化循环所需的变量
prev_assignments <- NULL

# 当前分配与前一次分配不同时，循环继续
while (!identical(prev_assignments, k_prime)) {
  # 使用当前分配更新聚类中心
  centers <- update_centers(toy_data, k_prime, K = 2)
  # 保存当前分配
  prev_assignments <- k_prime
  # 为所有观测值重新分配聚类
  k_prime <- apply(toy_data, 1, assign, centers = centers)
  # 可视化当前聚类和聚类中心
  visualize(toy_data, centers, k_prime, K = 2)
}

3.3 第三部分

  1. 加载 Iris 数据集并检查其内容。
  2. 创建一个新的数据集列表，其中包含 Iris 数据集的前四个变量的所有变量对（共 6 对）。
  3. 编写一个函数或循环，以将您在第二部分编写的 K-means 算法应用于整个 Iris 数据集列表。执行聚类分析。
  4. 为每个数据集的聚类结果创建可视化。可以使用类似于第二部分的 visualize 函数。
  5. 将 6 个可视化图像保存为 6 个 png 文件。

下面是一个示例代码：

# 加载 iris 数据集
data(iris)

# 创建新的数据集列表
iris_pairs <- list()
counter <- 1
for (i in 1:3) {
  for (j in (i + 1):4) {
    iris_pairs[[counter]] <- iris[, c(i, j)]
    colnames(iris_pairs[[counter]]) <- colnames(iris)[c(i, j)]
    counter <- counter + 1
  }
}

# 应用 K-means 算法
clustering_results <- lapply(iris_pairs, function(x) {
  kmeans(x, centers = 3, nstart = 20)
})

# 可视化聚类结果并保存为 png 文件
for (i in 1:length(clustering_results)) {
  png(paste0("iris_pair_", i, ".png"), width = 500, height = 500)
  plot(iris_pairs[[i]], col = clustering_results[[i]]$cluster, pch = 20, main = paste0("Iris Pair ", i))
  points(clustering_results[[i]]$centers, col = 1:3, pch = 8, cex = 2)
  dev.off()
}

这段代码首先加载 Iris 数据集并创建包含所有变量对的数据集列表。然后，它将 K-means 算法应用于整个列表，并为每个聚类结果创建可视化。最后，将每个可视化保存为一个单独的 png 文件。

# 加载数据集
data(iris)
iris_data <- iris[, -5]  # 去除 Species 列

# 创建变量组合列表
variable_pairs <- combn(1:4, 2, simplify = FALSE)

# 定义可视化函数
visualize_iris <- function(data, centers, assignments, pair, K) {
    png(paste0("iris_pair_", pair[1], "_", pair[2], ".png"), width = 500, height = 500)
    plot(data[, pair], col = assignments, main = paste("K-means Clustering (", colnames(data)[pair[1]], "vs", colnames(data)[pair[2]], ")"))
    points(matrix(unlist(centers), ncol = 2, byrow = TRUE), col = 1:K, pch = 19)
    dev.off()
}

K <- 2

for (pair in variable_pairs) {
    # 初始化聚类中心
    initial_centers <- iris_data[sample(nrow(iris_data), K), pair]
    
    # 聚类算法
    prev_assignments <- NULL
    k_prime <- apply(iris_data[, pair], 1, assign, centers = initial_centers)
    
    while (!identical(prev_assignments, k_prime)) {
        centers <- update_centers(iris_data[, pair], k_prime, K)
        prev_assignments <- k_prime
        k_prime <- apply(iris_data[, pair], 1, assign, centers = centers)
    }
    
    # 可视化结果
    visualize_iris(iris_data, centers, k_prime, pair, K)
}
# 加载数据集
data(iris)
# 从 iris 数据集中去除 Species 列，只保留数值型变量
iris_data <- iris[, -5]

# 创建所有可能的变量组合列表
variable_pairs <- combn(1:4, 2, simplify = FALSE)

# 定义可视化函数
visualize_iris <- function(data, centers, assignments, pair, K) {
  # 为每个变量对生成一个 PNG 文件
  png(paste0("iris_pair_", pair[1], "_", pair[2], ".png"), width = 500, height = 500)
  # 绘制散点图，显示聚类结果
  plot(data[, pair], col = assignments, main = paste("K-means Clustering (", colnames(data)[pair[1]], "vs", colnames(data)[pair[2]], ")"))
  # 绘制聚类中心
  points(matrix(unlist(centers), ncol = 2, byrow = TRUE), col = 1:K, pch = 19)
  # 关闭图形设备，将图像保存到文件
  dev.off()
}

# 设置聚类数目 K
K <- 2

# 遍历所有可能的变量组合
for (pair in variable_pairs) {
  # 从 iris_data 中随机选择 K 个观测值作为初始聚类中心
  initial_centers <- iris_data[sample(nrow(iris_data), K), pair]

  # 对数据进行聚类
  prev_assignments <- NULL
  # 使用 assign 函数对每个观测值分配初始聚类
  k_prime <- apply(iris_data[, pair], 1, assign, centers = initial_centers)

  # 使用 K-means 聚类算法更新聚类分配和中心
  while (!identical(prev_assignments, k_prime)) {
    # 更新聚类中心
    centers <- update_centers(iris_data[, pair], k_prime, K)
    # 更新聚类分配
    prev_assignments <- k_prime
    k_prime <- apply(iris_data[, pair], 1, assign, centers = centers)
  }

  # 可视化聚类结果并将其保存为 PNG 文件
  visualize_iris(iris_data, centers, k_prime, pair, K)
}
公众号：AI悦创【二维码】

AI悦创·编程一对一

AI悦创·推出辅导班啦，包括「Python 语言辅导班、C++ 辅导班、java 辅导班、算法/数据结构辅导班、少儿编程、pygame 游戏开发、Web、Linux」，全部都是一对一教学：一对一辅导 + 一对一答疑 + 布置作业 + 项目实践等。当然，还有线下线上摄影课程、Photoshop、Premiere 一对一教学、QQ、微信在线，随时响应！微信：Jiabcdefh

C++ 信息奥赛题解，长期更新！长期招收一对一中小学信息奥赛集训，莆田、厦门地区有机会线下上门，其他地区线上。微信：Jiabcdefh

方法一：QQ

方法二：微信：Jiabcdefh

你认为这篇文章怎么样？
  • 0
  • 0
  • 0
  • 0
  • 0
  • 0
0  字
评论
  • 按正序
  • 按倒序
  • 按热度