当前位置：首页 > article >正文

机器学习之无监督学习

article 2025/3/13 9:03:18

无监督学习（Unsupervised Learning）是机器学习的一个重要分支，其特点是在训练过程中不使用标签数据。与有监督学习不同，无监督学习的目标是从未标记的数据中发现隐藏的结构、模式或关系。无监督学习广泛应用于聚类、降维、异常检测等领域。

1. 无监督学习的核心任务

无监督学习主要解决以下两类问题：

1.1 聚类（Clustering）

将数据划分为若干个组（簇），使得同一组内的数据点相似，而不同组之间的数据点差异较大。常见的聚类算法包括：

K-Means：将数据划分为 K 个簇，最小化簇内距离。
层次聚类：通过构建树状结构（ dendrogram）将数据分层聚类。
DBSCAN：基于密度的聚类算法，能够识别噪声和异常点。

1.2 降维（Dimensionality Reduction）

将高维数据映射到低维空间，同时保留数据的主要特征。常见的降维算法包括：

主成分分析（PCA）：通过线性变换将数据投影到方差最大的方向。
t-SNE：用于可视化高维数据的非线性降维方法。
自编码器（Autoencoder）：通过神经网络实现非线性降维。

2. 无监督学习的应用场景

2.1 数据探索

通过聚类和降维，发现数据中的潜在结构和模式。
例如，在客户细分中，将客户分为不同的群体以制定个性化营销策略。

2.2 数据预处理

降维可以减少数据的维度，提高计算效率并缓解“维度灾难”。
例如，在图像处理中，使用 PCA 压缩图像数据。

2.3 异常检测

通过聚类或密度估计，识别数据中的异常点。
例如，在金融领域，检测信用卡欺诈交易。

2.4 生成模型

通过学习数据的分布，生成新的数据样本。
例如，生成对抗网络（GAN）和变分自编码器（VAE）。

3. 常见的无监督学习算法示例

3.1 K-Means 聚类

K-Means 是一种经典的聚类算法，通过迭代优化簇中心和簇分配来最小化簇内距离。

from sklearn.cluster import KMeans
import numpy as np
import matplotlib.pyplot as plt

# 创建一些随机数据
np.random.seed(0)
X = np.random.rand(100, 2)  # 100 个样本，2 个特征

# 使用 K-Means 聚类
kmeans = KMeans(n_clusters=3)  # 设置簇的数量为 3
kmeans.fit(X)

# 获取聚类结果
labels = kmeans.labels_
centers = kmeans.cluster_centers_

# 可视化结果
plt.scatter(X[:, 0], X[:, 1], c=labels, cmap='viridis')  # 绘制数据点
plt.scatter(centers[:, 0], centers[:, 1], c='red', marker='x')  # 绘制簇中心
plt.title("K-Means Clustering")
plt.show()

3.2 主成分分析（PCA）

PCA 是一种线性降维方法，通过投影到方差最大的方向来保留数据的主要特征。

from sklearn.decomposition import PCA
import numpy as np

# 创建一些随机数据
X = np.random.rand(100, 10)

# 使用 PCA 降维
pca = PCA(n_components=2)
X_reduced = pca.fit_transform(X)

3.3 t-SNE

t-SNE 是一种非线性降维方法，特别适合高维数据的可视化。

from sklearn.manifold import TSNE
import numpy as np

# 创建一些随机数据
X = np.random.rand(100, 20)

# 使用 t-SNE 降维
tsne = TSNE(n_components=2)
X_reduced = tsne.fit_transform(X)

3.4 自编码器（Autoencoder）

自编码器是一种神经网络模型，通过编码和解码过程实现数据降维。

import torch
import torch.nn as nn

# 定义自编码器模型
class Autoencoder(nn.Module):
    def __init__(self):
        super(Autoencoder, self).__init__()
        self.encoder = nn.Sequential(
            nn.Linear(20, 10),
            nn.ReLU(),
            nn.Linear(10, 2)  # 降维到 2 维
        )
        self.decoder = nn.Sequential(
            nn.Linear(2, 10),
            nn.ReLU(),
            nn.Linear(10, 20)
        )

    def forward(self, x):
        x = self.encoder(x)
        x = self.decoder(x)
        return x

# 初始化模型和优化器
model = Autoencoder()
optimizer = torch.optim.Adam(model.parameters(), lr=0.001)
criterion = nn.MSELoss()

# 训练模型
for epoch in range(100):
    optimizer.zero_grad()
    outputs = model(inputs)
    loss = criterion(outputs, inputs)
    loss.backward()
    optimizer.step()