聚类：k-Means 和 k-Medoid

news2024/9/23 15:28:23

1. 前言

在《对静态分析缺陷报告进行聚类，以降低维护成本》 提到使用 k-Medoid 通过相似缺陷的聚类，来减少程序员对大量缺陷分析的工作量。

k-Medoid 和传统的 k-Means 聚类算法有什么差别呢？

简单的说，K-Medoid 算法是一种基于 K-Means 算法的聚类方法，它通过选择数据集中的点作为中心（medoid），而不是计算均值来代表聚类中心。这种方法对异常值和噪声更加鲁棒，因为它使用的是实际的数据点作为聚类中心，而不是计算出的均值点。

于是将先前的 K-Means 算法做了改进，实现了 K-Medoid 算法。

2. 聚类算法

  • 聚类基本算法步骤
  1. 初始化：选择K个数据点作为初始的质心。可以使用随机选取，也有很多改进的选取方法，以降低迭代的次数；
  2. 分配：将每个数据点分配给最近的质心，形成K个聚类。
  3. 重新计算新的质心：对于每个聚类，找到一个新的质心。
  4. 迭代：重复步骤2和3，直到满足停止条件，如质心不再改变或达到预设的迭代次数。
  5. 终止：当聚类结果稳定或达到迭代次数后，算法终止。

2.1. K-Means 聚类

K-Means 聚类, 在计算每个簇的质心时, 是使用簇的中心点（均值）。

  • K-Means 聚类的质心计算公式
    对于K-Means聚类，每个簇的质心是该簇内所有点的均值。
    假设第( i )个簇包含 N_i个数据点，每个数据点有( d )个特征。
    第( i )个簇的质心 \mu_i​ 的计算公式为：
    \mu_i = \frac{1}{N_i} \sum_{j \in C_i} x_j

其中：

  • \mu_i​ 是第( i )个簇的质心。
  • N_i 是第( i )个簇中的点的数量。
  • C_i是第( i )个簇中的点的集合。
  • x_j 是第( j )个点的坐标。

  • 特点：
    • 简单，易于实现。
    • 对于大规模数据集效率较高。
    • 对初始中心点的选择敏感，可能导致局部最优解。
    • 对异常值和噪声敏感。

  • 适用场景：
    • 数据分布近似为高斯分布。
    • 需要快速聚类结果的场景。

2.2. K-Medoid 聚类

K-Medoid 聚类, 在计算每个簇的质心时, 由一个实际的数据点（Medoid）代表。

  • K-Medoid 聚类的质心计算公式
    K-Medoid聚类不使用质心的概念，而是使用Medoid。Medoid是簇中与其他点距离之和最小的点。
    因此，K-Medoid算法中没有直接计算质心的公式，而是通过以下步骤确定Medoid：
  1. 对于每个簇，计算每个点到该簇内其他所有点的总距离。
  2. 选择总距离最小的点作为Medoid。

这个过程可以表示为：

\text{medoid}_i = \arg \min_{x_j \in C_i} \sum_{x_k \in C_i} d(x_j, x_k)

其中：

  • \text{medoid}_i 是第 i 个簇的 Medoid。

  • d(x_j, x_k)  是点 x_j和x_k 之间的距离。

  • C_i​ 是第( i )个簇中的点的集合。

  • 特点：

    • 对异常值和噪声具有较好的鲁棒性。
    • 计算复杂度较高，因为需要重新计算所有点到 Medoid 的距离。
    • 可以处理非凸形状的聚类。
    • 可能找到全局最优解，因为每次迭代都可能改变 Medoid。

  • 适用场景：

    • 数据分布不规则或包含异常值。
    • 需要更鲁棒的聚类结果。

2.3. K-Means vs K-Medoid

在 K-Medoid 算法中，Medoid 的确定是一个优化问题，需要评估簇内所有点作为 Medoid 时的总距离，并选择使这个总距离最小的点。这个过程通常比 K-Means 中的质心计算更为复杂，因为它涉及到对每个簇内所有点的两两距离计算。

比较项K-MeansK-Medoid
中心点K-Means使用计算出的中心点K-Medoid使用实际的数据点作为中心
鲁棒性K-Means容易受到这些因素的影响K-Medoid对异常值和噪声更鲁棒
计算复杂度K-Means通常更快，因为它只需要计算均值K-Medoid需要计算每个点到Medoid的距离，计算量更大
聚类形状K-Means倾向于创建圆形或球形的簇K-Medoid可以适应更复杂的形状
全局最优对初始中心点的选择敏感，可能导致局部最优解K-Medoid更可能找到全局最优解，因为它在每次迭代中都重新评估所有点作为Medoid的可能性

3. 基础定义

3.1. 距离计算类型

用于测试不同的距离计算公式对聚类结果的影响。

public enum DistanceEnum {
    EUCLIDEAN("欧氏距离"),
    MANHATTAN("曼哈顿距离"),
    MINKOWSKI("闵可夫斯基距离"),
    CHEBYSHEV("切比雪夫距离"),
    COSINE("余弦距离"),
    OTHERS("其他");

    private String distance;

    private DistanceEnum(String distance) {
        this.distance = distance;
    }
}

3.2. 用例和质心定义

用于存放用例数据或质心。

/**
 * 用例和质心的定义
 */
public class CaseRecord {
    // 用例 id
    private String id;
    // 用例的特征键值
    private Map<String, String> attributeMap;
    // 用例的向量
    private double[] vector;
    // 用例所属的质心
    private CaseRecord center;
    // 距离计算类型
    private DistanceEnum distanceType;
    // 距离值
    private double distance;
    // 聚类用例的数量
    private int clusterSize;
    // F-measure rate
    private Rate rate;
}

3.3. 定义算法接口

根据上面的算法流程，定义算法接口

/**
 * cluster interface
 * 
 */
public interface Cluster {
    /**
     * 聚类过程
     * 
     * @param k number of cluseter
     * @param distanceType distance calculate type
     * @param recordList record list
     * @return cluster center and cluster records
     * @throws SdongException module exception
     */
    Map<CaseRecord, List<CaseRecord>> cluster(int k, DistanceEnum distanceType, List<CaseRecord> recordList)
            throws SdongException;

    /**
     * 初始化聚类中心
     * 
     * @param k number of cluseter
     * @param recordList record list
     * @return cluster center
     */
    Map<CaseRecord, List<CaseRecord>> initialCenter(int k, List<CaseRecord> recordList);

    /**
     * 将数据分配给最近的质心
     * 
     * @param k number of cluseter
     * @param distanceType distance calculate type
     * @param centerMap cluster center map<center, records list>
     * @param recordList record list
     * @throws SdongException module exception
     */
    void putRecordToCenter(int k, DistanceEnum distanceType, Map<CaseRecord, List<CaseRecord>> centerMap,
            List<CaseRecord> recordList) throws SdongException;

    /**
     * 重新计算质心，并判断质心是否变化
     * 
     * @param k number of cluseter
     * @param distanceType distance calculate type
     * @param centerMap current cluster map<center, records list>
     * @return center changed return true, else returen false
     * @throws SdongException module exception
     */
    boolean newCenter(int k, DistanceEnum distanceType, Map<CaseRecord, List<CaseRecord>> centerMap)
            throws SdongException;
}

4. 聚类算法的实现

K-Means 和 K-Medoid 算法都使用相同的聚类过程、初始化聚类中心 和 分配数据到最近的质心 三个方法相同，所以将这些方法放到抽象类：ClusterAbstract 中减少重复代码。

4.1. 聚类过程

对应聚类过程定义，实现聚类过程函数(cluster)。
为了观察和统计需要，增加打印每次质心的变化，同时统计运算过程耗时。

@Override
public Map<CaseRecord, List<CaseRecord>> cluster(int k, DistanceEnum distanceType, List<CaseRecord> recordList)
    throws SdongException {
    Stopwatch stopwatch = Stopwatch.createStarted();
    LOG.info("Cluster process start.");

    // step 1: 初始化聚类中心
    Map<CaseRecord, List<CaseRecord>> centers = initialCenter(k, recordList);

    int loop = 0;
    boolean change = true;
    do {
        loop = loop + 1;
        AlgorithmUtil.printCenter(loop, centers, false);
        
        // step 2: 将数据分配给最近的质心
        putRecordToCenter(k, distanceType, centers, recordList);
        AlgorithmUtil.printCenter(loop, centers, false);

        // step 3: 重新计算质心，并判断质心是否变化
        change = newCenter(k, distanceType, centers);
    } while (change);

    AlgorithmUtil.printCenter(loop, centers, true);

    stopwatch.stop();
    LOG.info("Cluster process loop:{}, use: {} ns", loop, stopwatch.elapsed(TimeUnit.NANOSECONDS));
    return centers;
}

4.2. 初始化聚类中心

为了避免结果的随机性，这里没有使用随机生成初始质心。而先统计了数据中各向量的最小值和最大值。并按 K 均分。得到初始的质心。

后面的 K-Means 和 K-Medoid 都是采用这个方法。

@Override
public Map<CaseRecord, List<CaseRecord>> initialCenter(int k, List<CaseRecord> caseList) {
    Map<CaseRecord, List<CaseRecord>> centers = new HashMap<>(k);
    int verctorSize = caseList.get(0).getVector().length;

    // keep vector value range: min and max
    double[] min = new double[verctorSize];
    double[] max = new double[verctorSize];

    double[] vector;
    int ind = 0;
    for (CaseRecord useCase : caseList) {
        vector = useCase.getVector();
        for (int i = 0; i < verctorSize; i++) {
            if (ind == 0) {
                min[i] = vector[i];
                max[i] = vector[i];
                continue;
            }
            if (vector[i] < min[i]) {
                min[i] = vector[i];
            }
            if (vector[i] > max[i]) {
                max[i] = vector[i];
            }
        }
        ind = ind + 1;
    }

    for (int j = 0; j < verctorSize; j++) {
        LOG.info("ind={},min={}, max={}", j, min[j], max[j]);
    }

    // initial center per each vector min and max and k
    double distance;
    CaseRecord center;
    for (int c = 0; c < k; c++) {
        center = new CaseRecord();
        double[] centerVector = new double[verctorSize];
        center.setVector(centerVector);
        for (int i = 0; i < verctorSize; i++) {
            distance = max[i] - min[i];
            centerVector[i] = min[i] + distance * c / (k - 1);
        }
        centers.computeIfAbsent(center, key -> new ArrayList<>());
    }
    return centers;
}

4.3. 分配数据到最近的质心

这个也是公共部分，

@Override
public void putRecordToCenter(int k, DistanceEnum distanceType, Map<CaseRecord, List<CaseRecord>> centers,
    List<CaseRecord> recordList) throws SdongException {
    CaseRecord nearCenter = null;
    double minDistance = 0.0;
    double distance;
    CaseRecord center;
    int ind = 0;

    // clear center related records
    for (CaseRecord entry : centers.keySet()) {
        centers.put(entry, new ArrayList<>());
    }

    // put record to the nearest center
    for (CaseRecord caseRecord : recordList) {
        ind = 0;
        for (Map.Entry<CaseRecord, List<CaseRecord>> entry : centers.entrySet()) {
            center = entry.getKey();
            distance = Distance.getDistance(distanceType, caseRecord.getVector(), center.getVector(), 0.0);
            if (ind == 0) {
                minDistance = distance;
                nearCenter = center;
                ind = ind + 1;
                continue;
            }

            // 余弦相似度 是越大越好
            if (distanceType == DistanceEnum.COSINE) {
                if (distance > minDistance) {
                    minDistance = distance;
                    nearCenter = center;
                }
            } else {
                if (distance < minDistance) {
                    minDistance = distance;
                    nearCenter = center;
                }
            }
        }
        caseRecord.setDistance(minDistance);

        centers.get(nearCenter).add(caseRecord);
    }
}

4.4. 重新计算质心

4.4.1. K-Means

public class Kmeans extends ClusterAbstract {
    private static final Logger LOG = LogManager.getLogger(Kmeans.class);

    @Override
    public boolean newCenter(int k, DistanceEnum distanceType, Map<CaseRecord, List<CaseRecord>> centerMap) {
        boolean change = false;
        CaseRecord newCenter;
        int size;
        int vectorSize;
        double[] vector;
        double[] caseVector;
        // save new center
        Map<CaseRecord, List<CaseRecord>> newCenterMap = new HashMap<>(k);
        

        Iterator<Map.Entry<CaseRecord, List<CaseRecord>>> iterator = centerMap.entrySet().iterator();
        Map.Entry<CaseRecord, List<CaseRecord>> entry;
        while (iterator.hasNext()) {
            entry = iterator.next();
            newCenter = new CaseRecord();
            vectorSize = entry.getKey().getVector().length;

            // sum vector for center
            vector = new double[vectorSize];
            newCenter.setVector(vector);            
            for (CaseRecord useCase : entry.getValue()) {
                caseVector = useCase.getVector();
                for (int i = 0; i < vectorSize; i++) {
                    vector[i] = vector[i] + caseVector[i];
                }
            }

            // avrage vector for center
            size = entry.getValue().size();
            for (int i = 0; i < vectorSize; i++) {
                vector[i] = vector[i] / size;
            }

            // if center change, remove old center and add to new CenterMap
            if (checkCenterChange(entry.getKey().getVector(), newCenter.getVector())) {
                iterator.remove();
                newCenterMap.put(newCenter, new ArrayList<>());
                change = true;
            }
        }

        // merge new center
        centerMap.putAll(newCenterMap);

        return change;
    }

    private static boolean checkCenterChange(double[] vectorOrg, double[] vectorNew) {
        boolean change = false;
        int vectorSize = vectorOrg.length;
        for (int ind = 0; ind < vectorSize; ind++) {
            if (Double.compare(vectorOrg[ind], vectorNew[ind]) != 0) {
                return true;
            }
        }
        return change;
    }
}

4.4.2. K-Medoid

public class Kmedoid extends ClusterAbstract {
    private static final Logger LOG = LogManager.getLogger(Kmedoid.class);

    @Override
    public boolean newCenter(int k, DistanceEnum distanceType, Map<CaseRecord, List<CaseRecord>> centerMap)
        throws SdongException {
        boolean change = false;
        int ind = 0;
        CaseRecord newCenter = null;
        Map<CaseRecord, List<CaseRecord>> newCenterMap = new HashMap<>(k);
        Iterator<Map.Entry<CaseRecord, List<CaseRecord>>> iterator = centerMap.entrySet().iterator();
        while (iterator.hasNext()) {
            Map.Entry<CaseRecord, List<CaseRecord>> entry = iterator.next();
            
            // calcuate mix distance medoid as new center
            double minDistance = 0.0;
            ind = 0;
            for (CaseRecord medoid : entry.getValue()) {
                medoid.setDistance(calculateDistenceSum(distanceType, medoid, entry.getValue()));
                if (ind == 0) {
                    minDistance = medoid.getDistance();
                    newCenter = medoid;
                    ind = ind + 1;
                    continue;
                }

                // 余弦相似度 是越大越好
                if (distanceType == DistanceEnum.COSINE) {
                    if (medoid.getDistance() > minDistance) {
                        minDistance = medoid.getDistance();
                        newCenter = medoid;
                    }
                } else {
                    if (medoid.getDistance() < minDistance) {
                        minDistance = medoid.getDistance();
                        newCenter = medoid;
                    }
                }
            }

            // if center change, remove old center and add to new CenterMap
            if (!entry.getKey().equals(newCenter)) {
                iterator.remove();
                newCenterMap.put(newCenter, new ArrayList<>());
                change = true;
            }
        }

        // merege new center
        centerMap.putAll(newCenterMap);

        return change;
    }

    private static double calculateDistenceSum(DistanceEnum distanceType, CaseRecord medoid, List<CaseRecord> clusterList)
        throws SdongException {
        double sum = 0.0;
        for (CaseRecord cur : clusterList) {
            sum = sum + Distance.getDistance(distanceType, medoid.getVector(), cur.getVector(), 0.0);
        }
        return sum;
    }
}

5. 验证测试

5.1. 鸢尾花(Iris)数据集

鸢尾花数据集可以在UCI机器学习库中找到，这是最原始和广泛引用的来源之一。具体地址是：UCI Machine Learning Repository - Iris Dataset

鸢尾花(Iris)数据集它由三种不同品种的鸢尾花的测量数据组成：山鸢尾(setosa)、变色鸢尾(versicolor)和维吉尼亚鸢尾(virginica)。

鸢尾花数据集包含了150个样本，每个样本有四个特征：花萼长度(sepal length)、花萼宽度(sepal width)、花瓣长度(petal length)和花瓣宽度(petal width)。除了样本数据外，每个样本还有一个对应的目标类别，即鸢尾花的品种。

特征名称描述
sepal_length花萼长度
sepal_width花萼宽度
petal length花瓣长度
petal width花瓣宽度
类型山鸢尾(setosa)、变色鸢尾(versicolor)和维吉尼亚鸢尾(virginica)

5.2. 数据集数据

  • 数据分布

从各维度的投影来看，山鸢尾(setosa) 形状相对独特，通过聚类应该能够容易分辨。但变色鸢尾(versicolor)和维吉尼亚鸢尾(virginica)的形状相似，数据在四个维度上存在一定的重合，并不一定能很好的通过聚类区分出来。

5.3. K-Means 测试结果

  • 测试代码
@Test
void kmeansClusterTest_EUCLIDEAN() {
    kmeansClusterTest(DistanceEnum.EUCLIDEAN);
}

@Test
void kmeansClusterTest_COSINE() {
    kmeansClusterTest(DistanceEnum.COSINE);
}

void kmeansClusterTest(DistanceEnum distanceType) {
    try {
        List<CaseRecord> list = ImportData.importIrisData();
        int k = 3;

        Kmeans kmeans = new Kmeans();
        Map<CaseRecord, List<CaseRecord>> centers = kmeans.cluster(k, distanceType, list);
        Evaluation.evaluationCluster(centers, AIConstants.CLUSTER_CATEGORY);
    } catch (SdongException e) {
        LOG.error("{}:{}", e.getErrorPosition(), e.getMessage());
        fail("should not get exception!");
    }
}
```

5.3.1. 距离的计算使用：欧氏距离

  • 测试结果
- setosa
id = 01J615ZPC3SDY81Z84QS54KVMP, size = 50, vector: vector[0] = 5.005999999999999,vector[1] = 3.428000000000001,vector[2] = 1.4620000000000002,vector[3] = 0.2459999999999999

- virginica
id = 01J615ZPCACZND4PWY1RMCY1BG, size = 38, vector: vector[0] = 6.8500000000000005,vector[1] = 3.073684210526315,vector[2] = 5.742105263157893,vector[3] = 2.0710526315789473

- versicolor
id = 01J615ZPCAGEB317YQE24V7WAP, size = 62, vector: vector[0] = 5.901612903225807,vector[1] = 2.748387096774194,vector[2] = 4.393548387096775,vector[3] = 1.4338709677419357

Cluster process loop:6, use: 271307900 ns
Evaluation process start.
Cluster:virginica, Precision: 0.9473684210526315, ReCall: 0.72, F1: 0.8181818181818181, purity: 0.0
Cluster:setosa, Precision: 1.0, ReCall: 1.0, F1: 1.0, purity: 0.0
Cluster:versicolor, Precision: 0.7741935483870968, ReCall: 0.96, F1: 0.8571428571428571, purity: 0.0
Avg rate, Precision: 0.907187323146576, ReCall: 0.8933333333333332, F1: 0.8917748917748917, purity: 0.8933333333333333
Evaluateion process use: 6528800 ns

5.3.2. 距离的计算使用：余弦距离

  • 测试结果
- setosa
id = 01J61T8WC7AV9SYXTGGS44XDXH, size = 50, vector: vector[0] = 5.005999999999999,vector[1] = 3.428000000000001,vector[2] = 1.4620000000000002,vector[3] = 0.2459999999999999

- virginica
id = 01J61T8WCG7XKZ4M57B4ERCNBG, size = 55, vector: vector[0] = 6.519999999999997,vector[1] = 2.965454545454545,vector[2] = 5.479999999999999,vector[3] = 1.9854545454545451

- versicolor
id = 01J61T8WCF05QJ44EJM3GW4GQX, size = 45, vector: vector[0] = 5.946666666666666,vector[1] = 2.757777777777778,vector[2] = 4.204444444444444,vector[3] = 1.2977777777777777

Cluster process loop:4, use: 186595900 ns
Evaluation process start.
Cluster:versicolor, Precision: 1.0, ReCall: 0.9, F1: 0.9473684210526316, purity: 0.0
Cluster:setosa, Precision: 1.0, ReCall: 1.0, F1: 1.0, purity: 0.0
Cluster:virginica, Precision: 0.9090909090909091, ReCall: 1.0, F1: 0.9523809523809523, purity: 0.0
Avg rate, Precision: 0.9696969696969697, ReCall: 0.9666666666666667, F1: 0.9665831244778613, purity: 0.9666666666666667
Evaluateion process use: 4176400 ns

5.4. K-Medoid 测试结果

  • 测试代码
@Test
void kMmedoidClusterTest_EUCLIDEAN() {
    kMmedoidClusterTest(DistanceEnum.EUCLIDEAN);
}

@Test
void kMmedoidClusterTest_COSINE() {
    kMmedoidClusterTest(DistanceEnum.COSINE);
}

void kMmedoidClusterTest(DistanceEnum distanceType) {
    try {
        List<CaseRecord> list = ImportData.importIrisData();
        int k = 3;

        Kmedoid kmedoids = new Kmedoid();
        Map<CaseRecord, List<CaseRecord>> centers = kmedoids.cluster(k, distanceType, list);
        Evaluation.evaluationCluster(centers, AIConstants.CLUSTER_CATEGORY);
    } catch (SdongException e) {
        LOG.error("{}:{}", e.getErrorPosition(), e.getMessage());
        fail("should not get exception!");
    }
}

5.4.1. 距离的计算使用：欧氏距离

  • 测试结果
- versicolor
id = 79, size = 62, vector: vector[0] = 6.0,vector[1] = 2.9,vector[2] = 4.5,vector[3] = 1.5

- virginica
id = 113, size = 38, vector: vector[0] = 6.8,vector[1] = 3.0,vector[2] = 5.5,vector[3] = 2.1

- setosa
id = 8, size = 50, vector: vector[0] = 5.0,vector[1] = 3.4,vector[2] = 1.5,vector[3] = 0.2

Cluster process loop:4, use: 224608300 ns
Evaluation process start.
Cluster:versicolor, Precision: 0.7741935483870968, ReCall: 0.96, F1: 0.8571428571428571, purity: 0.0
Cluster:virginica, Precision: 0.9473684210526315, ReCall: 0.72, F1: 0.8181818181818181, purity: 0.0
Cluster:setosa, Precision: 1.0, ReCall: 1.0, F1: 1.0, purity: 0.0
Avg rate, Precision: 0.9071873231465761, ReCall: 0.8933333333333332, F1: 0.8917748917748917, purity: 0.8933333333333333
2024-08-24 17:37:41.071 INFO [main] Evaluation.java.evaluationCluster.48: Evaluateion process use: 5386900 ns

5.4.2. 距离的计算使用：余弦距离

  • 测试结果
- versicolor
id = 87, size = 45, vector: vector[0] = 6.7,vector[1] = 3.1,vector[2] = 4.7,vector[3] = 1.5

- virginica
id = 113, size = 55, vector: vector[0] = 6.8,vector[1] = 3.0,vector[2] = 5.5,vector[3] = 2.1

- setosa
id = 39, size = 50, vector: vector[0] = 4.4,vector[1] = 3.0,vector[2] = 1.3,vector[3] = 0.2

Cluster process loop:3, use: 188439800 ns
Evaluation process start.
Cluster:setosa, Precision: 1.0, ReCall: 1.0, F1: 1.0, purity: 0.0
Cluster:virginica, Precision: 0.9090909090909091, ReCall: 1.0, F1: 0.9523809523809523, purity: 0.0
Cluster:versicolor, Precision: 1.0, ReCall: 0.9, F1: 0.9473684210526316, purity: 0.0
Avg rate, Precision: 0.9696969696969697, ReCall: 0.9666666666666667, F1: 0.9665831244778613, purity: 0.9666666666666667
Evaluateion process use: 4957100 ns

5.5. 结果分析

  • 结果汇总
聚类方法距离计算迭代次数精度召回率F1纯度
K-Means欧氏距离60.9071870.8933330.8917750.893333
K-Medoid欧氏距离40.9071870.8933330.8917750.893333
K-Means余弦距离40.9696970.9666670.9665830.966667
K-Medoid余弦距离30.9696970.9666670.9665830.966667

  • 分析结论
    • K-Means 和 K-Medoid 在相同距离算法的时候，K-Medoid 迭代次数少于 K-Means。
    • K-Means 和 K-Medoid 在相同距离算法的时候，得到的每个簇内的质心，位置接近；
    • K-Means 和 K-Medoid 聚类结果一致，都在山鸢尾(setosa)的聚类中，完全正确；但在变色鸢尾(versicolor)和维吉尼亚鸢尾(virginica)的聚类中，存在一定的偏差。这与前面数据分布的分析结果一致；
    • K-Means 和 K-Medoid 都在余弦距离的计算比欧式距离的计算得到了更好的聚类效果；
    • 在鸢尾花(Iris)数据集的聚类效果上，K-Means 和 K-Medoid 表现相同。
  • 遗留问题
    • 在分析过程中通过多次计算取均值来衡量资源的消耗，所以这里没有给出资源消耗的对比；
    • 在数据处理上，并为做归一化处理，后面需要考虑归一化对结果的影响；
    • K 值目前是固定的传入的，在实际应用中，需要完善 K 的选取过程；
    • 目前实现的是两类算法的基本算法，未采用一些优化算法，在维度较大的情况，需要改进现有算法。

6. 结论

  • 本文实现了 K-Means 和 K-Medoid 的算法；
  • 使用鸢尾花(Iris)数据集做了两种聚类方法在欧氏距离和余弦距离的聚类测试；
  • 通过精度、召回率、F1、纯度 对聚类效果做了评估；
  • 聚类分析可以揭示数据向量化是否能够捕捉到数据的内在结构和模式；
  • 聚类是验证数据向量化有效手段；
  • 聚类本身并不保证向量化是最优的，因为聚类结果可能受到所选聚类算法、参数设置、数据分布等因素的影响；
  • 聚类分析应与其他数据分析和模型评估方法结合使用，以全面评估数据向量化的有效性。

7. 参考

  • K-Means聚类算法研究综述，华东交通大学学报；
  • K-means clustering algorithms: A comprehensive review, variants analysis, and advances in the era of big data
  • An improved K-medoids algorithm based on step increasing and optimizing medoids
  • Fast and eager k-medoids clustering:O(k)runtime improvement of the PAM,CLARA,and CLARANS algorithms
  • Clustering by fast search and find of density peaks

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/2071390.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

golang RSA 解密前端jsencrypt发送的数据时异常 crypto/rsa: decryption error 解决方法

golang RSA 解密前端jsencrypt发送的数据时异常 crypto/rsa: decryption error 解决方法

golang中 RSA解密前端&#xff08;jsencrypt&#xff09;发来的密文后出现 "crypto/rsa: decryption error" &#xff0c; 这个问题首先需要确认你的私匙和公匙是否匹配&#xff0c; 如果匹配 那检查入参数据类型&#xff0c; 前端发送来的rsa加密后的数据一般都是…
阅读更多...
《黑神话：悟空》到底是用什么语言开发的

《黑神话：悟空》到底是用什么语言开发的

《黑神话&#xff1a;悟空》&#xff08;Black Myth: Wukong&#xff09;是一款由中国游戏开发公司游戏科学&#xff08;Game Science&#xff09;开发的动作角色扮演游戏。该游戏主要使用了以下技术栈&#xff1a; 开发引擎&#xff1a;游戏科学公司使用了**虚幻引擎5&#x…
阅读更多...
blender--二维平面图标变为三维网格

blender--二维平面图标变为三维网格

有时候我们希望把一些二维图片能变成三维网格&#xff0c;本案例我们就针对这一场景进行实现。 首先我们可以先去找一张需要的图片(注意&#xff0c;本例需要图片是svg格式)&#xff0c;我们可以在阿里巴巴矢量图标库等平台进行搜索&#xff0c;如图所示&#xff0c;找到需要的…
阅读更多...
Python优化算法12——蝴蝶优化算法(BOA)

Python优化算法12——蝴蝶优化算法(BOA)

科研里面优化算法都用的多&#xff0c;尤其是各种动物园里面的智能仿生优化算法&#xff0c;但是目前都是MATLAB的代码多&#xff0c;python几乎没有什么包&#xff0c;这次把优化算法系列的代码都从底层手写开始。 需要看以前的优化算法文章可以参考&#xff1a;Python优化算…
阅读更多...
ProtoBuf简要介绍与快速上手使用（C++版）

ProtoBuf简要介绍与快速上手使用（C++版）

文章目录 一、 初识ProtoBuf1. 序列化和反序列化概念2. ProtoBuf是什么3. ProtoBuf的使用特点 二、 讲解说明三、 快速上手1. 创建 .proto 文件2. 编译 contacts.proto 文件&#xff0c;生成C文件3. 序列化与反序列化的使用4. 小结 ProtoBuf 使用流程 一、 初识ProtoBuf 1. 序…
阅读更多...
线程是什么？和进程区别是什么？怎么用？

线程是什么？和进程区别是什么？怎么用？

目录 一、什么是进程 二、什么是线程 总结&#xff1a;线程和进程的区别&#xff1f; 三、线程的使用 四、线程的调用 一、什么是进程 进程&#xff0c;也叫任务。就是正常执行的程序。 一个程序有两种状态&#xff1a; 一是没有被执行&#xff0c;在硬盘上躺着的软件&…
阅读更多...
Qt Example Callout Extention(about QChart/QGraphicsView/QGraphicsItem)

Qt Example Callout Extention(about QChart/QGraphicsView/QGraphicsItem)

问题 Qt Example callout 展示了在平面直角坐标系中画tips。知识点涉及到QChart/QGraphicsView/QGraphicsItem。如何在平面直角坐标系中画点、折线、圆、长方形&#xff1f; Example路径 D:\Qt\5.15.2\Src\qtcharts\examples\charts\callout\callout.cpp 代码 main #incl…
阅读更多...
C++ 有向图拓扑排序算法

C++ 有向图拓扑排序算法

代码 #include <algorithm> #include <cassert> #include <functional> #include <map> #include <memory> #include <queue> #include <set> #include <unordered_set> #include <vector>namespace jc {template <…
阅读更多...
【JAVA基础】位运算

【JAVA基础】位运算

文章目录 位运算按位与操作按位或操作按位取反按位亦或 移位运算有符号左移有符号右移 位运算 处理数据的时候可以直接对组成整形数值的各个位完成操作 &|~^andornotxor 下面我们以byte类型为例子&#xff1a; 按位与操作 两个操作数&#xff0c;如果同为1则为1&#…
阅读更多...
【JavaEE初阶】IP协议

【JavaEE初阶】IP协议

目录 &#x1f4d5;引言 &#x1f334;IP协议的概念 &#x1f333;IP数据报 &#x1f6a9;IPv4协议头格式 &#x1f6a9;IPv6的诞生 &#x1f3c0;拓展 &#x1f384;IP地址 &#x1f6a9;IP地址的格式&#xff1a; &#x1f6a9;IP地址的分类 &#x1f3c0;网段划分…
阅读更多...
【计算机三级-数据库技术】操作题大题(第七套）

【计算机三级-数据库技术】操作题大题(第七套）

第七套操作题 第46题 假定要建立一个关于篮球职业联盟的数据库&#xff0c;需管理如下信息&#xff1a; 每个球队有球队名称、所在城市&#xff1b; 每位球员有球员姓名、薪酬; 每场比赛有比赛编号、比赛时间、比赛结果、参加比赛的主场球队、参加比赛的客场球队。 其中带下划…
阅读更多...
Redis—基础篇

Redis—基础篇

Redis基础 1. Redis 简介2. Redis 应用3. Redis 数据结构3.1 String3.2 hash3.3 list3.4 set3.5 sorted set 4. Redis 为什么快&#xff1f;5. Redis I/O 多路复用6. Redis 6.0多线程 1. Redis 简介 Redis 是一种基于键值对的 NoSQL 数据库 Redis 中的 value 支持 string、ha…
阅读更多...
关于jupyter notebook 的输出 (outputs )

关于jupyter notebook 的输出 (outputs )

jupyter notebook 的输出 (outputs )在元素达到一定的个数后&#xff0c;就会按一行一个元素进行展示&#xff0c;百来个还好&#xff0c;一旦过千&#xff0c;那滚轮势必撸冒烟&#xff0c;所以能不能解决呢&#xff1f; 先看个例子&#xff0c; 一个找质数、合数的函数 cal3&…
阅读更多...
【Linux篇】vim编译器

【Linux篇】vim编译器

1. 介绍 vi / vim是visual interface的简称&#xff0c;是Linux中最典型的文本编辑器。 同图形化界面中的文本编辑器一样&#xff0c;vi是命令行下对文本文件进行编辑的绝佳选择。 vim是vi的加强版本&#xff0c;兼容vi的所有指令&#xff0c;不仅能编译文本&#xff0c;而且…
阅读更多...
排序补充之快排的三路划分法

排序补充之快排的三路划分法

排序补充之快排的三路划分法 快排性能的关键点分析&#xff1a; 决定快排性能的关键点是每次单趟排序后&#xff0c;key对数组的分割&#xff0c;如果每次选key基本⼆分居中&#xff0c;那么快 排的递归树就是颗均匀的满⼆叉树&#xff0c;性能最佳。但是实践中虽然不可能每次…
阅读更多...
数学建模笔记（四）：熵权

数学建模笔记（四）：熵权

背景&基本思想介绍 在实际的评价类问题中&#xff0c;在前面所说的层次分析法以及Topsis法中&#xff0c;指标权重的确定往往是通过主观的评价得来的&#xff0c;如果在没有专家的情况下&#xff0c;我们自己的权重分配往往可能带有一定的主观性&#xff0c;有没有一种可以…
阅读更多...
linux系统离线安装docker并配置阿里云镜像源

linux系统离线安装docker并配置阿里云镜像源

制作docker.service文件 创建docker.service文件 cd /etc/systemd/system/ touch docker.service编辑docker.service文件 vim docker.service// 注意&#xff0c;将其中的ip地址&#xff0c;改成您的服务器地址&#xff0c;其它参数不用改。 //--insecure-registry192.168.8…
阅读更多...
代码随想录算法day22 | 回溯算法part04 | 491.递增子序列，46.全排列，47.全排列 II

代码随想录算法day22 | 回溯算法part04 | 491.递增子序列，46.全排列，47.全排列 II

491.递增子序列 本题和大家做过的 90.子集II 非常像&#xff0c;但又很不一样&#xff0c;很容易掉坑里。 力扣题目链接(opens new window) 给定一个整型数组, 你的任务是找到所有该数组的递增子序列&#xff0c;递增子序列的长度至少是2。 示例: 输入: [4, 6, 7, 7]输出: [[4,…
阅读更多...
【学习笔记】时间序列模型(ARIMA)

【学习笔记】时间序列模型(ARIMA)

文章目录 前言一、时间序列时间序列数据 二、ARIMA 模型大纲模型前提平稳性检验 差分整合移动平均自回归模型 ARIMA(p,q,d)自回归模型 (AR( p ))移动平均模型 (MA( q ))自回归移动平均模型(ARMA(p,q))差分自回归移动平均模型 ARIMA(p,d,q) 确定 p&#xff0c;q结果分析和模型检…
阅读更多...
SpringBoot集成kafka-消费者批量消费消息

SpringBoot集成kafka-消费者批量消费消息

SpringBoot集成kafka-消费者批量消费消息 1、消费者2、生产者3、application.yml配置文件4、实体类5、生产者发送消息测试类6、测试6.1、测试启动生产者6.2、测试启动消费者 1、消费者 设置批量接收消息 package com.power.consumer;import org.apache.kafka.clients.consume…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023