无监督学习（聚类）

无监督学习

无监督学习

• 无监督学习
• 前言
• 一、无监督学习是什么？
• • 1）机器学习的分类
  • 2）解释（图文结合）
  • 3）区别
• 二、无监督学习应用范围
• 三、无标注数据的结构
• • 1）用处
• 四、聚类
• • 1）聚类的含义：
  • 2) 怎么判断是好的聚类：
  • • 原则：
  • 3）聚类的分类：
  • • 1）软聚类（soft clustering） vs. 硬聚（hard clustering）
    • 2）层次聚类 vs. 非层次聚类（图）+举例
  • 3）==算法==：
  • • • 凝聚式层次聚类（步骤+图文显示）
      • 分裂式层次聚类
      • 分裂式层次聚类vs. 凝聚式层次聚类
      • K-medoids 聚类（及其变种与改进：PAM，CLARA）
      • PAM(小样本)：
      • CLARA（对大样本）
  • 4)数据聚类步骤：
  • 5)相似度 and 相似度度量（区别）
  • • 相似度（Similarity）
    • 相似度度量（Similarity Measure）
• 总结

前言

无监督学习是机器学习的一个重要分支，它在没有明确标签的数据上进行模式识别和数据分组。本文将详细介绍无监督学习的基本概念、应用范围、无标注数据的结构、聚类方法及其评估标准。

一、无监督学习是什么？

1）机器学习的分类

无监督学习
监督学习
半监督学习

2）解释（图文结合）

• 有监督：涉及人力的介入
• 无监督：不牵扯人力
• 半监督学习：通过一些（少量）有标注数据和很多无标注的数据学习条件分布P(Y|X)

3）区别

+-------------------+        +-------------------+        +-----------------------------+ 
|      监督学习      |        |     无监督学习     |        |      半监督学习              |
|  (需标注数据)      |        |  (无需标注数据)    |        |  (少量标注 + 大量未标注数据)   |
|  [图片：标注数据]  |        |  [图片：原始数据]   |        |  [图片：少量标注 + 原始数据]   |
|  目标：预测标签    |        |  目标：发现模式     |        |  目标：利用未标注数据提升性能  |
+-------------------+        +-------------------+        +-----------------------------+

二、无监督学习应用范围

• 生物学:基因数据的相似度往往在聚类中被用于预测种群结构
• 图像处理:自动相册
• 经济（市场商务智能BI）:找到不同的顾客群体:趋势预测;分析销售数据中的隐藏模式，以预测未来的销售趋势或消费者偏好变化
• www:每周新闻摘要

三、无标注数据的结构

1）用处

1. 构建模型找到输入的合理表示

2. 发现数据的结构

• 数据聚类：在没有预先定义的类别时将数据分为不同的组，帮助理解数据的自然分组情况。

• 客户细分：根据购买行为将顾客分为不同群体。
  图像分类：将相似的图像归为一类，如人物照片、风景照片等。

3. 降维

• 减少变量数量：通过降维技术（如主成分分析PCA、t-SNE等），可以在保留主要信息的前提下减少数据维度，简化模型复杂度并提高计算效率。
• 应用场景：
  可视化高维数据：将高维数据投影到二维或三维空间，便于直观观察。

4. 离群点检测

5. 刻画数据密度

+-------------------+        +-------------------+        +-----------------------------+
|  数据聚类          |        |       降维        |        |       离群点检测             |
|  [图片：聚类结果]  |        | [图片：降维后数据] |         |  [图片：离群点标记]          |
|  目标：分组数据    |        |  目标：简化特征    |         |  目标：识别异常数据          |
+-------------------+        +-------------------+        +-----------------------------+

+-------------------+        +-------------------+
|  特征学习          |        |  数据密度刻画      |
|  [图片：特征表示]  |        |  [图片：密度分布]  |
|  目标：提取特征    |        |  目标：理解分布    |
+-------------------+        +-------------------+

四、聚类

1）聚类的含义：

物以类聚，人以群分
将相似的对象归入同一个“类”

在"无监督学习" (unsupervised learning) 中，训练样本的标记信息是未知的,目标是通过对无标记训练样本的学习来揭示数据的内在性质及规律，为进一步的数据分析提供基础.

聚类试图将数据集中的样本划分为若干个通常是不相交的子集，每个子集,称为一个"簇" (cluster).

同一个类中的对象相似
不同类中的对象有明显差异

Q1:对象相似怎么进行评判？？？

聚类性能度量亦称聚类"有效性指标" (validity index).

相似度定义

https://blog.csdn.net/oisflo/article/details/143809408

余弦相似度 (Cosine Similarity)
欧几里得距离 (Euclidean Distance)
曼哈顿距离 (Manhattan Distance)

2) 怎么判断是好的聚类：

簇/类内(intra-cluster)相似度
簇/类间(inter-cluster)相似度

原则：

类内距离小，类间距离大

“相似度度量” (similarity easure) ，距离越大，相似度越小.

3）聚类的分类：

1）软聚类（soft clustering） vs. 硬聚（hard clustering）

• 软：同一个对象可以属于不同类
• 硬：同一个对象只能属于一个类
（图）+举例

2）层次聚类 vs. 非层次聚类（图）+举例

层次：一个所有类间的层次结构（tree）

非层次： 平的，只有一层

3）算法：

凝聚式层次聚类（步骤+图文显示）

目的：把最相似的两个簇类ci和cj合并成一个

分裂式层次聚类

目的：分裂式层次聚类的过程与凝聚式相反。最初所有对象在一个簇中，随着算法的进行，最不相似的对象逐渐被分离出来，形成多个小簇

分裂式层次聚类vs. 凝聚式层次聚类

####K-means 算法：

• 模型: 向量空间模型

• 策略: 最小化类内对象的欧式距离
• 算法：具体步骤+应用举例（图像压缩）
具体步骤：

1. 初始化：将每个对象视为一个独立的簇。

2. 计算距离矩阵：计算所有簇之间的距离（可以使用欧几里得距离、曼哈顿距离等）。

3. 合并最近簇：找到距离最小的一对簇，并将它们合并成一个新的簇。

4. 更新距离矩阵：重新计算新簇与其他簇之间的距离。

5. 重复步骤 3 和 4：继续合并最近的簇，直到满足停止条件（如簇的数量达到预定值或所有对象归为一个簇）。

6. 代码：

  from sklearn.cluster import KMeans
  import numpy as np

  # 示例数据
  X = np.array([[1, 2], [1, 4], [1, 0],
                [10, 2], [10, 4], [10, 0]])

  # 创建并训练 KMeans 模型
  kmeans = KMeans(n_clusters=2, random_state=0).fit(X)
  print("簇标签:", kmeans.labels_)
  

K-medoids 聚类（及其变种与改进：PAM，CLARA）

计算使得cost最小的类中心

PAM(小样本)：

随机用一个非中心对象替换类中心->类的质量提高则保留替换类的质量
• 代价函数：类内对象与类中心的平均不相似度
代码演示：

import numpy as np
from scipy.spatial.distance import cdist

def pam(data, k, max_iter=100):
    # Step 1: Initialize medoids randomly
    n_samples, _ = data.shape
    medoids_idx = np.random.choice(n_samples, k, replace=False)
    medoids = data[medoids_idx]
    
    for _ in range(max_iter):
        # Step 2: Assign each data point to the nearest medoid
        distances = cdist(data, medoids, metric='euclidean')
        labels = np.argmin(distances, axis=1)
        
        # Step 3: Calculate the cost function
        cost = np.sum(np.min(distances, axis=1))
        
        # Step 4: Try to replace each medoid with a non-medoid
        for i in range(k):
            current_medoid = medoids[i]
            current_cost = cost
            
            # Try replacing the current medoid with each non-medoid
            for j in range(n_samples):
                if j not in medoids_idx:
                    new_medoids = medoids.copy()
                    new_medoids[i] = data[j]
                    new_distances = cdist(data, new_medoids, metric='euclidean')
                    new_labels = np.argmin(new_distances, axis=1)
                    new_cost = np.sum(np.min(new_distances, axis=1))
                    
                    # Step 5: If the new cost is lower, replace the medoid
                    if new_cost < current_cost:
                        medoids = new_medoids
                        medoids_idx[i] = j
                        cost = new_cost
                        break
    
    return medoids, labels

# 示例数据
data = np.array([[1, 2], [1, 4], [1, 0],
                 [4, 2], [4, 4], [4, 0]])

# 运行PAM算法
k = 2
medoids, labels = pam(data, k)

print("Medoids:", medoids)
print("Labels:", labels)

CLARA（对大样本）

step:
1.每次随机选取样本量中的一小部分进行PAM聚类
2.将剩余样本按照最小中心距离进行归类
3.重复步骤，选取误差最小

import numpy as np
from scipy.spatial.distance import cdist

def pam(data, k, max_iter=100):
    # Step 1: Initialize medoids randomly
    n_samples, _ = data.shape
    medoids_idx = np.random.choice(n_samples, k, replace=False)
    medoids = data[medoids_idx]
    
    for _ in range(max_iter):
        # Step 2: Assign each data point to the nearest medoid
        distances = cdist(data, medoids, metric='euclidean')
        labels = np.argmin(distances, axis=1)
        
        # Step 3: Calculate the cost function
        cost = np.sum(np.min(distances, axis=1))
        
        # Step 4: Try to replace each medoid with a non-medoid
        for i in range(k):
            current_medoid = medoids[i]
            current_cost = cost
            
            # Try replacing the current medoid with each non-medoid
            for j in range(n_samples):
                if j not in medoids_idx:
                    new_medoids = medoids.copy()
                    new_medoids[i] = data[j]
                    new_distances = cdist(data, new_medoids, metric='euclidean')
                    new_labels = np.argmin(new_distances, axis=1)
                    new_cost = np.sum(np.min(new_distances, axis=1))
                    
                    # Step 5: If the new cost is lower, replace the medoid
                    if new_cost < current_cost:
                        medoids = new_medoids
                        medoids_idx[i] = j
                        cost = new_cost
                        break
    
    return medoids, labels, cost

def clara(data, k, sample_size=1000, num_samples=5):
    n_samples, _ = data.shape
    best_cost = float('inf')
    best_medoids = None
    best_labels = None
    
    for _ in range(num_samples):
        # Step 1: Randomly select a sample
        sample_indices = np.random.choice(n_samples, sample_size, replace=False)
        sample_data = data[sample_indices]
        
        # Step 2: Apply PAM to the sample
        medoids, labels, cost = pam(sample_data, k)
        
        # Step 3: Assign the remaining data points to the nearest medoids
        distances = cdist(data, medoids, metric='euclidean')
        full_labels = np.argmin(distances, axis=1)
        
        # Step 4: Calculate the cost for the full dataset
        full_cost = np.sum(np.min(distances, axis=1))
        
        # Step 5: Keep track of the best clustering
        if full_cost < best_cost:
            best_cost = full_cost
            best_medoids = medoids
            best_labels = full_labels
    
    return best_medoids, best_labels

# 示例数据
data = np.random.rand(10000, 2)  # 10000个样本，每个样本2维

# 运行CLARA算法
k = 3
medoids, labels = clara(data, k)

print("Medoids:", medoids)
print("Labels:", labels)

4)数据聚类步骤：

1.无标注数据
2.对象间的 距离 或 相似度度量（可选）类间的距离或相似度度量
3. 聚类算法:K-Means,Gaussian Mixture Models (GMM),PAM（Partitioning Around Medoids）,CLARA（Clustering Large Applications）

5)相似度 and 相似度度量（区别）

相似度（Similarity）

相似度是指两个对象之间的相似程度。它是一个描述性的概念，通常用一个数值来表示两个对象之间的相似性程度。相似度的值通常在某个范围内，例如0到1之间，其中0表示完全不相似，1表示完全相似

相似度度量（Similarity Measure）

相似度度量是指用于计算两个对象之间相似度的具体方法或公式

总结

无监督学习是机器学习的一个重要分支，它在没有明确标签的数据上进行模式识别和数据分组。本文将详细介绍无监督学习的基本概念、应用范围、无标注数据的结构、聚类方法及其评估标准。