モデルシリーズ: クラスタリング_5 つのクラスタリングアルゴリズムの比較レビュー

記事ディレクトリ

導入
1. クラスタリングアルゴリズムの種類
2. 設定
3. 最適なクラスター数を決定する
4. K 平均法
5. 階層的クラスタリング
6. DBSCAN クラスタリングアルゴリズム
DBSCAN
7. 混合ガウスモデル (GMM)
8. 全アルゴリズムの比較

導入

クラスタリングは、教師なし学習の最も一般的に使用される形式の 1 つです。データ内の自然なグループ化を自動的に検出します。

クラスタリングは、何も知らないデータを探索する場合に特に役立ちます。思いもよらなかったつながりを発見できるかもしれません。クラスタリングは、データ内で識別されたクラスターの 1 つに属するものとして既存および新規の例をマッピングしてラベルを付ける特徴エンジニアリングの方法としても使用できます。

典型的な実用的なアプリケーションには、不正行為の検出、図書館での書籍の分類、マーケティングでの顧客のセグメンテーションなどがあります。

1. クラスタリングアルゴリズムの種類

選択できるクラスタリングアルゴリズムは多数あります。さまざまなクラスタリングアルゴリズムとさまざまな構成を検討することをお勧めします。特定のデータに最適なクラスタリングアルゴリズムを見つけるには時間がかかる場合がありますが、それが見つかると、データに関する貴重な洞察が得られます。

重心ベース

これらのタイプのアルゴリズムは、データ内の複数の重心に基づいてデータポイントを分離します。各データポイントは、重心からの二乗距離に基づいてクラスターに割り当てられます。
これは、最も一般的に使用されるクラスタリングのタイプです。K-Means アルゴリズムは、重心ベースのクラスタリングアルゴリズムの 1 つです。ここで、k はクラスターの数であり、アルゴリズムのハイパーパラメーターです。

階層ベース (接続ベース)

この考え方は、物体は遠くの物体よりも近くの物体とより密接に関連しているという中心的な考え方に基づいています。
クラスターのツリーを構築するので、すべてがトップダウンで整理されます。最初に、各データポイントは別個のクラスターとして扱われます。各反復では、1 つのクラスターまたは K 個のクラスターが形成されるまで、同様のクラスターが他のクラスターとマージされます。

密度ベース

データは、データポイントの高濃度領域の周囲の低濃度領域に基づいてグループ化されます。基本的に、アルゴリズムはデータポイントが密集している場所を見つけ、それらをクラスターと呼びます。
クラスターは任意の形状にすることができます。予想される条件によって制限されることはありません。
このタイプのクラスタリングアルゴリズムでは、外れ値をクラスターに割り当てようとしないため、外れ値は無視されます。

ディストリビューションベース

これは、データが同じ分布に属する可能性が高い確率に基づいてデータを適合させるクラスタリングモデルです。
中心点が確立されます。データポイントの中心からの距離が増加するにつれて、それがクラスターに属する確率は減少します。
このモデルは、合成データやさまざまなサイズのクラスターに対して適切に機能します。
この方法は、モデルの複雑さが制限されていない限り、過学習になる傾向があります。多くの場合、モデルがより複雑になるとデータがより適切に説明されるため、適切なモデルの複雑さを選択することが難しくなります。

2. 設定

2.1 データセット

7つのデータセットを使用することにしました。そのうち 6 つは視覚化の練習に使用され、1 つは実際のデータの問題を解決するために使用されます。

演習データセット:
https://www.kaggle.com/datasets/joonasyoon/clustering-exercises

実際のデータセット:
https://www.kaggle.com/datasets/shrutipandit707/onlineretaildata

2.2 ライブラリのインポート

# 导入必要的库
import numpy as np
import pandas as pd
import seaborn as sns
from matplotlib import pyplot as plt

from collections import Counter

%matplotlib inline

2.3 データのインポート

# 导入所需的库
import pandas as pd

# 读取数据文件
blob_df = pd.read_csv("../input/clustering-exercises/blob.csv")  # 读取blob.csv文件并将数据存储在blob_df中
dart_df = pd.read_csv("../input/clustering-exercises/dart.csv")  # 读取dart.csv文件并将数据存储在dart_df中
outliers_df = pd.read_csv("../input/clustering-exercises/outliers.csv")  # 读取outliers.csv文件并将数据存储在outliers_df中
spiral2_df = pd.read_csv("../input/clustering-exercises/spiral2.csv")  # 读取spiral2.csv文件并将数据存储在spiral2_df中
basic2_df = pd.read_csv("../input/clustering-exercises/basic2.csv")  # 读取basic2.csv文件并将数据存储在basic2_df中
boxes3_df = pd.read_csv("../input/clustering-exercises/boxes3.csv")  # 读取boxes3.csv文件并将数据存储在boxes3_df中

raw_df = pd.read_csv("../input/onlineretaildata/Online_Retail.csv", encoding='unicode_escape')  # 读取Online_Retail.csv文件并将数据存储在raw_df中，使用unicode_escape编码解决编码问题

2.4 いくつかの視覚的表示

# 创建子图

fig, axes = plt.subplots(nrows=2, ncols=3,figsize=(13,13))

# 设置整个图的标题
fig.suptitle('EXERCISE DATA SETS\n', size = 18)

# 在第一个子图中绘制散点图，x轴为blob_df的x列，y轴为blob_df的y列，颜色根据blob_df的color列确定，点的大小为10，颜色映射为"Set3"
axes[0,0].scatter(blob_df['x'], blob_df['y'], c=blob_df['color'], s=10, cmap = "Set3")
# 设置第一个子图的标题
axes[0,0].set_title("Blob");

# 在第二个子图中绘制散点图，x轴为dart_df的x列，y轴为dart_df的y列，颜色根据dart_df的color列确定，点的大小为10，颜色映射为"Set3"
axes[0,1].scatter(dart_df['x'], dart_df['y'], c=dart_df['color'], s=10, cmap = "Set3")
# 设置第二个子图的标题
axes[0,1].set_title("Dart");

# 在第三个子图中绘制散点图，x轴为basic2_df的x列，y轴为basic2_df的y列，颜色根据basic2_df的color列确定，点的大小为10，颜色映射为"Set3"
axes[0,2].scatter(basic2_df['x'], basic2_df['y'], c=basic2_df['color'], s=10, cmap = "Set3")
# 设置第三个子图的标题
axes[0,2].set_title("Basic");

# 在第四个子图中绘制散点图，x轴为outliers_df的x列，y轴为outliers_df的y列，颜色根据outliers_df的color列确定，点的大小为10，颜色映射为"Set3"
axes[1,0].scatter(outliers_df['x'], outliers_df['y'], c=outliers_df['color'], s=10, cmap = "Set3")
# 设置第四个子图的标题
axes[1,0].set_title("Outliers");

# 在第五个子图中绘制散点图，x轴为spiral2_df的x列，y轴为spiral2_df的y列，颜色根据spiral2_df的color列确定，点的大小为10，颜色映射为"Set3"
axes[1,1].scatter(spiral2_df['x'], spiral2_df['y'], c=spiral2_df['color'], s=10, cmap = "Set3")
# 设置第五个子图的标题
axes[1,1].set_title("Spiral");

# 在第六个子图中绘制散点图，x轴为boxes3_df的x列，y轴为boxes3_df的y列，颜色根据boxes3_df的color列确定，点的大小为10，颜色映射为"Set3"
axes[1,2].scatter(boxes3_df['x'], boxes3_df['y'], c=boxes3_df['color'], s=10, cmap = "Set3")
# 设置第六个子图的标题
axes[1,2].set_title("Boxes");

# 调整子图的布局
plt.tight_layout()

2.5 特徴量エンジニアリング

クラスタリングを実行する前に、いくつかの準備があります。

# 对数据框进行描述性统计分析，包括所有列的统计信息
raw_df.describe(include='all')

	請求書番号	証券コード	説明	量	請求書の日付	単価	顧客ID	国
カウント	541909	541909	540455	541909.000000	541909	541909.000000	406829.000000	541909
個性的	25900	4070	4223	NaN	23260	NaN	NaN	38
上	573585	85123A	ホワイトハンギングハートTライトホルダー	NaN	2011年10月31日 14:41	NaN	NaN	イギリス
周波数	1114	2313	2369	NaN	1114	NaN	NaN	495478
平均	NaN	NaN	NaN	9.552250	NaN	4.611114	15287.690570	NaN
標準	NaN	NaN	NaN	218.081158	NaN	96.759853	1713.600303	NaN
分	NaN	NaN	NaN	-80995.000000	NaN	-11062.060000	12346.000000	NaN
25%	NaN	NaN	NaN	1.000000	NaN	1.250000	13953.000000	NaN
50%	NaN	NaN	NaN	3.000000	NaN	2.080000	15152.000000	NaN
75%	NaN	NaN	NaN	10.000000	NaN	4.130000	16791.000000	NaN
最大	NaN	NaN	NaN	80995.000000	NaN	38970.000000	18287.000000	NaN

# 删除指定列
raw_df.drop(['StockCode', 'InvoiceDate','Description','Country'],axis = 1, inplace =True)

# 输出处理后的数据
print(raw_df)

# 打印出原始数据中"Quantity"列的最小值
print(raw_df["Quantity"].min())

# 打印出原始数据中"UnitPrice"列的最小值
print(raw_df["UnitPrice"].min())

-80995
-11062.06

負の値は返品を意味する場合があります。これは電子商取引にとって重要な要素ですが、この研究では、返品のないトランザクションのみを保持します (私たちの目的は、さまざまなクラスタリング手法を導入して比較することです)。

# 从原始数据框中筛选出数量大于0的数据
df = raw_df.loc[raw_df["Quantity"] > 0]

# 从筛选后的数据框中再次筛选出单价大于0的数据
df = df.loc[df["UnitPrice"] > 0]

# 打印DataFrame中"Quantity"列的最小值
print(df["Quantity"].min())

# 打印DataFrame中"UnitPrice"列的最小值
print(df["UnitPrice"].min())

1
0.001

# 创建一个新的列Total，用于存储每个产品的总金额
df["Total"] = df["Quantity"] * df["UnitPrice"]



# 删除数据框中的'Quantity'和'UnitPrice'列
df.drop(['Quantity', 'UnitPrice'], axis=1, inplace=True)

# 检查数据中的缺失值
df.isnull().sum()

InvoiceNo          0
CustomerID    132220
Total              0
dtype: int64



# 删除具有缺失值的customerId列
df.dropna(axis=0, inplace=True)

# axis=0表示按行删除，inplace=True表示在原始DataFrame上进行修改

新しい機能を作成します。

頻度: トランザクションの合計数
金額：取引総額

# 对数据框df按照'CustomerID'进行分组，计算每个顾客的'Total'总和
Amount = df.groupby('CustomerID')['Total'].sum()

# 重置索引，将'CustomerID'变为列
Amount = Amount.reset_index()

# 将列名改为'CustomerID'和'Amount'
Amount.columns=['CustomerID','Amount']

# 对数据框df按照'CustomerID'进行分组，计算每个顾客的'InvoiceNo'计数
Frequency=df.groupby('CustomerID')['InvoiceNo'].count()

# 重置索引，将'CustomerID'变为列
Frequency=Frequency.reset_index()

# 将列名改为'CustomerID'和'Frequency'
Frequency.columns=['CustomerID','Frequency']

# 将Amount和Frequency两个数据框按照'CustomerID'进行内连接合并
df1 = pd.merge(Amount, Frequency, on='CustomerID', how='inner')

# 显示合并后的前几行数据
df1.head()

	顧客ID	額	頻度
0	12346.0	77183.60	1
1	12347.0	4310.00	182
2	12348.0	1797.24	31
3	12349.0	1757.55	73
4	12350.0	334.40	17



# 删除 'CustomerID' 列
df1.drop(['CustomerID'], axis=1, inplace=True)  # 使用drop方法删除指定列，axis=1表示按列删除，inplace=True表示在原DataFrame上进行修改

2.6 外れ値の検出


# 使用describe函数对df1进行描述性统计分析
# 参数include='all'表示包括所有数据类型的统计结果
df1.describe(include='all')

	額	頻度
カウント	4338.000000	4338.000000
平均	2054.266460	91.720609
標準	8989.230441	228.785094
分	3.750000	1.000000
25%	307.415000	17.000000
50%	674.485000	41.000000
75%	1661.740000	100.000000
最大	280206.020000	7847.000000


# 创建一个包含1行2列的图表，并设置图表的大小为6x6
fig, axes = plt.subplots(nrows=1, ncols=2, figsize=(6,6))

# 设置整个图表的标题为"Outliers"，并设置标题的字体大小为25
fig.suptitle('Outliers\n', size=25)

# 在第一个子图中绘制一个箱线图，数据为df1['Amount']，颜色使用'Spectral'调色板，同时设置子图的标题为"Amount"
sns.boxplot(ax=axes[0], data=df1['Amount'], palette='Spectral').set_title("Amount")

# 在第二个子图中绘制一个箱线图，数据为df1['Frequency']，颜色使用'Spectral'调色板，同时设置子图的标题为"Frequency"
sns.boxplot(ax=axes[1], data=df1['Frequency'], palette='Spectral').set_title("Frequency")

# 调整子图的布局，使得子图之间没有重叠
plt.tight_layout()

外れ値に関して大きな問題があるようです。

外れ値検出モデルの選択

分布が正規ではない
分布が大きく偏っている
大きな外れ値があります

隔離フォレストは正規分布を想定しておらず、多次元レベルで外れ値を検出できます。孤立した森林は、高い計算効率によっても特徴付けられます。このアルゴリズムは、外れ値は小さくて明確な観測値であるため、識別が容易になるという原則に基づいています。だからこそ私は人里離れた森を選んだのです。

外れ値の検出方法については、https:
//www.kaggle.com/code/marcinrutecki/outlier-detection-methodsを参照してください。

# 导入IsolationForest模块
from sklearn.ensemble import IsolationForest

# 复制df1数据框到df2
df2 = df1.copy()



# 创建IsolationForest模型，设置参数n_estimators为150，max_samples为'auto'，contamination为0.1，max_features为1.0
model = IsolationForest(n_estimators=150, max_samples='auto', contamination=float(0.1), max_features=1.0)

# 使用模型对数据进行训练
model.fit(df2)

/opt/conda/lib/python3.7/site-packages/sklearn/base.py:451: UserWarning: X does not have valid feature names, but IsolationForest was fitted with feature names
  "X does not have valid feature names, but"





IsolationForest(contamination=0.1, n_estimators=150)

# 给df添加'scores'和'anomaly'列
scores = model.decision_function(df2)  # 使用模型的decision_function方法计算每个样本的异常分数
anomaly = model.predict(df2)  # 使用模型的predict方法预测每个样本的异常标签
df2['scores'] = scores  # 将异常分数添加到df的'scores'列
df2['anomaly'] = anomaly  # 将异常标签添加到df的'anomaly'列

anomaly = df2.loc[df2['anomaly'] == -1]  # 从df中筛选出异常样本
anomaly_index = list(anomaly.index)  # 获取异常样本的索引列表
print('Total number of outliers is:', len(anomaly))  # 打印异常样本的总数

# 以上代码的作用是使用一个模型对数据集df2进行异常检测，并将异常分数和异常标签添加到df2中。
# 首先，使用模型的decision_function方法计算每个样本的异常分数，并使用模型的predict方法预测每个样本的异常标签。
# 然后，将异常分数添加到df2的'scores'列，将异常标签添加到df2的'anomaly'列。
# 接着，从df2中筛选出异常样本，并将其索引保存在anomaly_index列表中。
# 最后，打印异常样本的总数。

Total number of outliers is: 434

df2 = df2.drop(anomaly_index, axis = 0).reset_index(drop=True)
print(df2.head())



# 创建一个包含1行2列的图表，大小为6x6
fig, axes = plt.subplots(nrows=1, ncols=2, figsize=(6,6))

# 设置图表的标题
fig.suptitle('Outliers\n', size = 25)

# 在第一个子图中绘制箱线图，数据为df2['Amount']，颜色使用'Spectral'调色板，设置标题为"Amount"
sns.boxplot(ax=axes[0], data=df2['Amount'], palette='Spectral').set_title("Amount")

# 在第二个子图中绘制箱线图，数据为df2['Frequency']，颜色使用'Spectral'调色板，设置标题为"Frequency"
sns.boxplot(ax=axes[1], data=df2['Frequency'], palette='Spectral').set_title("Frequency")

# 调整子图的布局，使其紧凑显示
plt.tight_layout()

Isolation Forest アルゴリズムが良好に実行されていることがわかります。

# 删除不再需要的列
df.drop(['scores', 'anomaly'], axis=1, inplace=True)

2.7 データのスケーリング

# 导入StandardScaler类
from sklearn.preprocessing import StandardScaler

# 创建StandardScaler对象
scaler = StandardScaler()

# 使用StandardScaler对象对df2进行标准化处理，并将结果保存到df3中
df3 = scaler.fit_transform(df2)

3. 最適なクラスター数を決定する

最適なクラスター数の選択は、k-means クラスター化などのクラスター化アルゴリズムをデータセットに適用するための鍵となります。このアルゴリズムでは、ユーザーが生成するクラスターの数 k を指定する必要があります。これはかなり恣意的なプロセスであり、クラスター分析を実行する際の最も弱い部分の 1 つです。

エルボー法とコンター法の主な違いは、エルボー法ではユークリッド距離のみが計算されるのに対し、コンター法では分散、歪度、高低差などの変数が考慮されることです。

図の表現内容に応じて、エルボ法/SSE図とコンター法を使い分けることができます。

3.1 エルボールール

エルボールールは、データセット内のクラスターの数を決定するためのヒューリスティックです。この方法では、説明された変動をクラスター数の関数としてプロットし、使用するクラスターの数として曲線のエルボを選択します。

エルボールールは、K-means クラスタリングで最適な「K」を見つけることをグラフィカルに表現したものです。これは、クラスターの中点とクラスター重心の間の距離の二乗の合計である WCSS (クラスター内二乗和) を見つけることによって機能します。

最適なクラスター数は次のように定義できます。

さまざまな値の k に対してクラスタリングアルゴリズム (k-means クラスタリングなど) を計算します。たとえば、k を 1 から 10 クラスターまで変化させます。
各 k について、クラスター内の合計平方和 (WSS) が計算されます。
クラスター数 k に応じて wss 曲線を描きます。
プロット内の屈曲点 (エルボ) の位置は、クラスターの適切な数の指標として考慮されることがよくあります。

# 导入KMeans聚类算法
from sklearn.cluster import KMeans

# 创建一个空列表，用于存储每个簇内平方和的值
wcss = []

# 循环1到10，分别计算每个簇内平方和的值，并将其添加到wcss列表中
for i in range(1, 11):
    # 创建KMeans聚类算法对象，设置聚类数为i，初始化方式为k-means++，随机种子为42
    kmeans = KMeans(n_clusters = i, init = 'k-means++', random_state = 42)
    
    # 使用KMeans算法对数据进行聚类
    kmeans.fit(df3)
    
    # 将每个簇内平方和的值添加到wcss列表中
    wcss.append(kmeans.inertia_)

# 绘制聚类数与簇内平方和的关系图
plt.plot(range(1, 11), wcss)
plt.title('The Elbow Method')
plt.xlabel('Number of clusters')
plt.ylabel('WCSS')
plt.show()

# 导入KMeans类和KElbowVisualizer类
from yellowbrick.cluster import KElbowVisualizer
model = KMeans() # 创建一个KMeans对象

# 创建一个KElbowVisualizer对象
# k是聚类簇的数量范围
# timings参数设置为True，以便显示训练时间
visualizer = KElbowVisualizer(model, k=(2,30), timings= True)

# 将数据拟合到可视化器中
visualizer.fit(df3)

# 显示可视化结果
visualizer.show()

<AxesSubplot:title={'center':'Distortion Score Elbow for KMeans Clustering'}, xlabel='k', ylabel='distortion score'>

3.2 シルエット法

平均シルエット法は、クラスタリングの品質を測定するために使用されます。つまり、各オブジェクトがそのクラスタ内でどの程度うまく機能するかを判断します。平均シルエット幅が大きいほど、クラスタリングが良好であることを示します。最適なクラスター数 k は、可能な k 値の範囲内で平均プロファイルを最大化する値です (Kaufman and Rousseeuw、1990)。

アルゴリズムの計算手順は次のとおりです。

さまざまな k 値に対してクラスタリングアルゴリズム (k-means クラスタリングなど) を計算します。
k の値ごとに、観測値の平均シルエット (avg.sil) を計算します。
クラスタ番号 k に応じて avg.sil の曲線を描きます。
最大値の位置が適切なクラスタ数とみなされる。

シルエットスコアの値の範囲は[-1, 1]です。

シルエットスコア 1 は、クラスターが非常に密で、十分に分離されていることを示します。スコア 0 はクラスターの重複を示します。0 未満のスコアは、クラスターに属するデータが間違っているか正しくない可能性があることを示します。

# 导入所需的库
from sklearn import datasets
from sklearn.metrics import silhouette_score

# 实例化KMeans模型，设置聚类数为5，随机种子为42
km = KMeans(n_clusters=5, random_state=42)

# 使用KMeans模型对数据进行拟合和预测
km.fit_predict(df3)

# 计算轮廓系数
score = silhouette_score(df3, km.labels_, metric='euclidean')

# 打印轮廓系数的平均得分
print('Silhouetter Average Score: %.3f' % score)

Silhouetter Average Score: 0.476

# 导入需要的库
from yellowbrick.cluster import SilhouetteVisualizer
# 创建一个图表和子图
fig, ax = plt.subplots(3, 2, figsize=(13,8))
# 设置图表标题
fig.suptitle('2-7个聚类的轮廓分析', size = 18)
# 调整子图布局
plt.tight_layout()

# 遍历每个聚类数
for i in [2, 3, 4, 5, 6, 7]:
    '''
    创建一个具有不同聚类数的KMeans实例
    '''
    km = KMeans(n_clusters=i, init='k-means++', n_init=10, max_iter=100, random_state=42)
    # 将子图分为2行3列，获取当前子图的位置
    q, mod = divmod(i, 2)
    '''
    创建一个带有KMeans实例的SilhouetteVisualizer实例
    拟合可视化器
    '''
    visualizer = SilhouetteVisualizer(km, colors='yellowbrick', ax=ax[q-1][mod])
    visualizer.fit(df3)

ここでは選択はそれほど明白ではありません。その理由は次のとおりです。

平均シルエットスコアが平均より低いクラスターが 5 ～ 7 個あります。
等高線プロットのサイズは大きく変動します。
サイズの変動は同様ではありませんが、6 クラスターと 7 クラスターの方が優れています。
各クラスターを表す等高線プロットの太さも決定要因となります。残念ながら、他のクラスターよりも著しく厚いクラスターが 1 つあります。

3.3 系統樹図

この手法は、凝集型階層クラスタリング手法に特有のものです。この方法では、まず各ポイントを個別のクラスターとして扱い、ポイント間の距離に基づいて階層的な方法でポイントをクラスターに接続します。階層的クラスタリングに最適なクラスター数を求めるために、クラスターがマージまたは分割される順序を示すデンドログラムと呼ばれる樹状図を使用しました。

# 导入所需的库
import scipy.cluster.hierarchy as sch
from matplotlib import pyplot

# 创建一个图形窗口，设置大小为12x5
pyplot.figure(figsize=(12, 5))

# 使用ward方法计算数据集的层次聚类，并生成树状图
dendrogram = sch.dendrogram(sch.linkage(df3, method='ward'))

# 设置图形的标题为"Dendrogram"
plt.title('Dendrogram')

# 设置y轴的标签为"Euclidean distances"
plt.ylabel('Euclidean distances')

# 显示图形
plt.show()

4. K 平均法

K-Means クラスタリングはおそらく最もよく知られたクラスタリングアルゴリズムであり、サンプルをクラスタに割り当てて各クラスタ内の分散を最小限に抑えます。
これは重心ベースのアルゴリズムであり、最も単純な教師なし学習アルゴリズムです。
このアルゴリズムは、クラスター内のデータポイントの分散を最小限に抑えようとします。これが、ほとんどの人が教師なし機械学習に取り組む方法です。

K-means++ (sklearn の K-Means のデフォルトの初期パラメータ) は、K-means アルゴリズムの欠点を克服するために使用されるアルゴリズムです。目標は、最初の重心をランダムに割り当て、次に最大二乗距離に基づいて残りの重心を選択することにより、初期重心を分散することです。重心をできるだけ遠くに押し出すという考え方です。

K-means++ の初期化計算コストは標準の K-means アルゴリズムよりも高くなりますが、最適解に収束するまでの実行時間は K-means++ の方が大幅に短縮されます。これは、最初に選択された重心がすでに別のクラスターに存在している可能性が高いためです。

ここに画像の説明を挿入します

4.1 K 平均法の利点と欠点

K-Means は一般的なクラスタリングアルゴリズムですが、次のような利点と欠点があります。

アドバンテージ：

理解しやすく、実装も簡単です。
大量のデータを処理できます。
数値データ、離散データなど、さまざまなタイプのデータに適用できます。
早く収束できる。

欠点:

クラスタの数は事前に指定する必要があり、その数が正しくないと、クラスタリングの結果が不良になる可能性があります。
形状、サイズ、密度が異なるクラスターにはうまく機能しません。
ノイズや異常値に敏感です。
初期クラスタリング中心の選択に影響を受けやすいため、局所的な最適解に陥る可能性があります。

K-Means クラスタリングの利点:

シンプル- 実装は簡単です
高性能- K-Means クラスタリングテクノロジは、計算コストの点で高速かつ効率的です。
解釈が簡単- K-Means は、簡単に解釈して視覚化できるクラスターを返します。
大規模なデータセットに適しています- クラスタリングアルゴリズムは一般に低速ですが、K-means アルゴリズムは比較的高速であるため、大規模なデータセットに対して非常に効果的です。

K-Means クラスタリングの欠点:

球状密度を仮定します。これは、クラスターが自然に不規則な形状を持つ状況では、k-means クラスタリングが適切に機能しないことを意味します。これは比較的厳密な仮定です。
スケールに敏感- 変数の一方のスケールが他方よりもはるかに大きい場合、その変数は計算された距離に不均衡な影響を及ぼします。これは、通常、K-means クラスタリングを使用する前にデータを再スケーリングする必要があることを意味します。
カテゴリ変数を組み込むのは困難- すべての特徴が数値である場合、K 平均法が適しています。いくつかのカテゴリ特徴がある場合は、データを近似する方法がありますが、一般に、ほとんどの特徴は数値である必要があります。
外れ値に敏感- K-Means には外れ値の検出方法がありません。外れ値が重心の位置に影響を与える場合や、外れ値が独自のクラスターを形成して無視されない場合があります。
初期化条件に敏感- K 平均法クラスタリングは、アルゴリズムの初期化に使用される開始条件 (シードの選択やデータポイントの順序など) に敏感です。開始点の選択が不運だと、結果として得られるクラスターが恣意的に悪いものになる可能性があります。この問題は、k-means++ (sklearn のデフォルトの初期化メソッド) と呼ばれるバリアントによって解決できます。
クラスターの数を選択する必要があります。K 平均法クラスタリングでは、作成されるクラスターの数を事前に指定する必要があります。「k」の正しい値を選択することは、モデル選択の難しい問題です。
高次元データではうまく機能しません- このアルゴリズムはユークリッド距離に依存しているため、高次元ではうまく機能しません。潜在的な特徴が多数ある場合は、クラスターを作成する前に、特徴選択または次元削減アルゴリズムをデータに適用することを検討する必要があります。
このアルゴリズムは確率的です。つまり、同じデータセットに対して複数回実行すると、異なる答えが得られます。これは多くのアプリケーションにとって大きな問題です。
K 平均法は、多かれ少なかれ線形分離可能なクラスターのみを分離できます。クラスターが原点からの距離に基づいている場合、K 平均法はクラスターを識別できません。この問題は、極座標に切り替えることで解決できます。

K 平均法アルゴリズムにおける初期化感度の問題を回避する方法:

反復された k-means - アルゴリズムは繰り返し実行されます。重心を初期化してクラスターを形成することにより、最小のクラスター内距離と大きなクラスター間距離が得られます。
K-Means++ - スマートな重心初期化手法。1 つの重心のみがランダムに初期化され、他の重心は初期重心から非常に遠く離れた位置に選択されます。これにより、収束が高速化され、重心の初期化が不十分になる可能性が減ります。sklearn のデフォルトの初期化メソッド。K means++ は比較的良好な結果を提供します。

4.2 K 平均法のバリエーション

K 平均法アルゴリズムのいくつかのバリエーション:

k-medians クラスタリング- 各次元で (平均の代わりに) 中央値を使用します。
k-medoids (中心点の周囲のパーティション) - 平均の代わりに中心点を使用し、任意の距離関数の距離の合計を最小化します。
ファジー C 平均法クラスタリング- 各データポイントが各クラスターに対してファジーな程度のメンバーシップを持つ K 平均法のソフトバージョン。
k-means++ - よりスマートな重心初期化 (sklearn のデフォルト初期化) を備えた標準の k-means アルゴリズム。

4.3 データセットでの K-Means モデルのトレーニング

# 复制数据集
# 复制df3数据集到df_kmeans
df_kmeans = df3.copy()

# 复制blob_df数据集到df_blob_kmeans
df_blob_kmeans = blob_df.copy()

# 复制dart_df数据集到df_dart_kmeans
df_dart_kmeans = dart_df.copy()

# 复制basic2_df数据集到df_basic_kmeans
df_basic_kmeans = basic2_df.copy()

# 复制outliers_df数据集到df_outliers_kmeans
df_outliers_kmeans = outliers_df.copy()

# 复制spiral2_df数据集到df_spiral2_kmeans
df_spiral2_kmeans = spiral2_df.copy()

# 复制boxes3_df数据集到df_boxes3_kmeans
df_boxes3_kmeans = boxes3_df.copy()

# 从数据框中删除名为'color'的列
df_blob_kmeans.drop(['color'], axis=1, inplace=True)  # 在df_blob_kmeans数据框中删除名为'color'的列
df_dart_kmeans.drop(['color'], axis=1, inplace=True)  # 在df_dart_kmeans数据框中删除名为'color'的列
df_basic_kmeans.drop(['color'], axis=1, inplace=True)  # 在df_basic_kmeans数据框中删除名为'color'的列
df_outliers_kmeans.drop(['color'], axis=1, inplace=True)  # 在df_outliers_kmeans数据框中删除名为'color'的列
df_spiral2_kmeans.drop(['color'], axis=1, inplace=True)  # 在df_spiral2_kmeans数据框中删除名为'color'的列
df_boxes3_kmeans.drop(['color'], axis=1, inplace=True)  # 在df_boxes3_kmeans数据框中删除名为'color'的列


# 使用KMeans算法进行聚类，将数据分为6个簇，使用k-means++初始化方法，随机种子为42
kmeans = KMeans(n_clusters = 6, init = 'k-means++', random_state = 42)

# 对数据进行聚类，并返回每个样本所属的簇的索引
y_kmeans = kmeans.fit_predict(df_kmeans)

# 使用KMeans算法进行聚类，将数据分为4个簇，使用k-means++初始化方法，随机种子为42
kmeans_blob = KMeans(n_clusters = 4, init = 'k-means++', random_state = 42)

# 对数据进行聚类，并返回每个样本所属的簇的索引
y_kmeans_blob = kmeans_blob.fit_predict(df_blob_kmeans)

# 使用KMeans算法进行聚类，将数据分为2个簇，使用k-means++初始化方法，随机种子为42
kmeans_dart = KMeans(n_clusters = 2, init = 'k-means++', random_state = 42)

# 对数据进行聚类，并返回每个样本所属的簇的索引
y_kmeans_dart = kmeans_dart.fit_predict(df_dart_kmeans)

# 使用KMeans算法进行聚类，将数据分为5个簇，使用k-means++初始化方法，随机种子为42
kmeans_basic = KMeans(n_clusters = 5, init = 'k-means++', random_state = 42)

# 对数据进行聚类，并返回每个样本所属的簇的索引
y_kmeans_basic = kmeans_basic.fit_predict(df_basic_kmeans)

# 使用KMeans算法进行聚类，将数据分为3个簇，使用k-means++初始化方法，随机种子为42
kmeans_outliers = KMeans(n_clusters = 3, init = 'k-means++', random_state = 42)

# 对数据进行聚类，并返回每个样本所属的簇的索引
y_kmeans_outliers = kmeans_outliers.fit_predict(df_outliers_kmeans)

# 使用KMeans算法进行聚类，将数据分为2个簇，使用k-means++初始化方法，随机种子为42
kmeans_spiral2 = KMeans(n_clusters = 2, init = 'k-means++', random_state = 42)

# 对数据进行聚类，并返回每个样本所属的簇的索引
y_kmeans_spiral2 = kmeans_spiral2.fit_predict(df_spiral2_kmeans)

# 使用KMeans算法进行聚类，将数据分为12个簇，使用k-means++初始化方法，随机种子为42
kmeans_boxes3 = KMeans(n_clusters = 12, init = 'k-means++', random_state = 42)

# 对数据进行聚类，并返回每个样本所属的簇的索引
y_kmeans_boxes3 = kmeans_boxes3.fit_predict(df_boxes3_kmeans)

# 在df_blob_kmeans数据集中创建名为“Cluster”的列，并将y_kmeans_blob赋值给该列
df_blob_kmeans['Cluster'] = y_kmeans_blob

# 在df_dart_kmeans数据集中创建名为“Cluster”的列，并将y_kmeans_dart赋值给该列
df_dart_kmeans['Cluster'] = y_kmeans_dart

# 在df_basic_kmeans数据集中创建名为“Cluster”的列，并将y_kmeans_basic赋值给该列
df_basic_kmeans['Cluster'] = y_kmeans_basic

# 在df_outliers_kmeans数据集中创建名为“Cluster”的列，并将y_kmeans_outliers赋值给该列
df_outliers_kmeans['Cluster'] = y_kmeans_outliers

# 在df_spiral2_kmeans数据集中创建名为“Cluster”的列，并将y_kmeans_spiral2赋值给该列
df_spiral2_kmeans['Cluster'] = y_kmeans_spiral2

# 在df_boxes3_kmeans数据集中创建名为“Cluster”的列，并将y_kmeans_boxes3赋值给该列
df_boxes3_kmeans['Cluster'] = y_kmeans_boxes3

4.4 比較結果

# 创建子图
fig, axes = plt.subplots(nrows=6, ncols=2,figsize=(10,30))
# 创建一个包含6行2列的子图，总共12个子图，设置整个图的大小为10x30

# 设置总标题
fig.suptitle('ANSWER vs K-Means\n', size = 18)
# 设置总标题为'ANSWER vs K-Means'，字体大小为18

# 绘制Answer Blob子图
axes[0,0].scatter(blob_df['x'], blob_df['y'], c=blob_df['color'], s=10, cmap = "Set3")
# 在第1行第1列的子图中绘制散点图，横坐标为blob_df的'x'列，纵坐标为blob_df的'y'列，点的颜色根据blob_df的'color'列确定，点的大小为10，使用"Set3"颜色映射

axes[0,0].set_title("Answer Blob")
# 设置第1行第1列子图的标题为"Answer Blob"

# 绘制K-Means Blob子图
axes[0,1].scatter(df_blob_kmeans['x'], df_blob_kmeans['y'], c=df_blob_kmeans['Cluster'], s=10, cmap = "Set3")
# 在第1行第2列的子图中绘制散点图，横坐标为df_blob_kmeans的'x'列，纵坐标为df_blob_kmeans的'y'列，点的颜色根据df_blob_kmeans的'Cluster'列确定，点的大小为10，使用"Set3"颜色映射

axes[0,1].set_title("K-Means Blob")
# 设置第1行第2列子图的标题为"K-Means Blob"

# 绘制Answer Dart子图
axes[1,0].scatter(dart_df['x'], dart_df['y'], c=dart_df['color'], s=10, cmap = "Set3")
# 在第2行第1列的子图中绘制散点图，横坐标为dart_df的'x'列，纵坐标为dart_df的'y'列，点的颜色根据dart_df的'color'列确定，点的大小为10，使用"Set3"颜色映射

axes[1,0].set_title("Answer Dart")
# 设置第2行第1列子图的标题为"Answer Dart"

# 绘制K-Means Dart子图
axes[1,1].scatter(df_dart_kmeans['x'], df_dart_kmeans['y'], c=df_dart_kmeans['Cluster'], s=10, cmap = "Set3")
# 在第2行第2列的子图中绘制散点图，横坐标为df_dart_kmeans的'x'列，纵坐标为df_dart_kmeans的'y'列，点的颜色根据df_dart_kmeans的'Cluster'列确定，点的大小为10，使用"Set3"颜色映射

axes[1,1].set_title("K-Means Dart")
# 设置第2行第2列子图的标题为"K-Means Dart"

# 绘制Answer Basic子图
axes[2,0].scatter(basic2_df['x'], basic2_df['y'], c=basic2_df['color'], s=10, cmap = "Set3")
# 在第3行第1列的子图中绘制散点图，横坐标为basic2_df的'x'列，纵坐标为basic2_df的'y'列，点的颜色根据basic2_df的'color'列确定，点的大小为10，使用"Set3"颜色映射

axes[2,0].set_title("Answer Basic")
# 设置第3行第1列子图的标题为"Answer Basic"

# 绘制K-Means Basic子图
axes[2,1].scatter(df_basic_kmeans['x'], df_basic_kmeans['y'], c=df_basic_kmeans['Cluster'], s=10, cmap = "Set3")
# 在第3行第2列的子图中绘制散点图，横坐标为df_basic_kmeans的'x'列，纵坐标为df_basic_kmeans的'y'列，点的颜色根据df_basic_kmeans的'Cluster'列确定，点的大小为10，使用"Set3"颜色映射

axes[2,1].set_title("K-Means Basic")
# 设置第3行第2列子图的标题为"K-Means Basic"

# 绘制Answer Outliers子图
axes[3,0].scatter(outliers_df['x'], outliers_df['y'], c=outliers_df['color'], s=10, cmap = "Set3")
# 在第4行第1列的子图中绘制散点图，横坐标为outliers_df的'x'列，纵坐标为outliers_df的'y'列，点的颜色根据outliers_df的'color'列确定，点的大小为10，使用"Set3"颜色映射

axes[3,0].set_title("Answer Outliers")
# 设置第4行第1列子图的标题为"Answer Outliers"

# 绘制K-Means Outliers子图
axes[3,1].scatter(df_outliers_kmeans['x'], df_outliers_kmeans['y'], c=df_outliers_kmeans['Cluster'], s=10, cmap = "Set3")
# 在第4行第2列的子图中绘制散点图，横坐标为df_outliers_kmeans的'x'列，纵坐标为df_outliers_kmeans的'y'列，点的颜色根据df_outliers_kmeans的'Cluster'列确定，点的大小为10，使用"Set3"颜色映射

axes[3,1].set_title("K-Means Outliers")
# 设置第4行第2列子图的标题为"K-Means Outliers"

# 绘制Answer Spiral子图
axes[4,0].scatter(spiral2_df['x'], spiral2_df['y'], c=spiral2_df['color'], s=10, cmap = "Set3")
# 在第5行第1列的子图中绘制散点图，横坐标为spiral2_df的'x'列，纵坐标为spiral2_df的'y'列，点的颜色根据spiral2_df的'color'列确定，点的大小为10，使用"Set3"颜色映射

axes[4,0].set_title("Answer Spiral")
# 设置第5行第1列子图的标题为"Answer Spiral"

# 绘制K-Means Spiral子图
axes[4,1].scatter(df_spiral2_kmeans['x'], df_spiral2_kmeans['y'], c=df_spiral2_kmeans['Cluster'], s=10, cmap = "Set3")
# 在第5行第2列的子图中绘制散点图，横坐标为df_spiral2_kmeans的'x'列，纵坐标为df_spiral2_kmeans的'y'列，点的颜色根据df_spiral2_kmeans的'Cluster'列确定，点的大小为10，使用"Set3"颜色映射

axes[4,1].set_title("K-Means Spiral")
# 设置第5行第2列子图的标题为"K-Means Spiral"

# 绘制Answer Boxes子图
axes[5,0].scatter(boxes3_df['x'], boxes3_df['y'], c=boxes3_df['color'], s=10, cmap = "Set3")
# 在第6行第1列的子图中绘制散点图，横坐标为boxes3_df的'x'列，纵坐标为boxes3_df的'y'列，点的颜色根据boxes3_df的'color'列确定，点的大小为10，使用"Set3"颜色映射

axes[5,0].set_title("Answer Boxes")
# 设置第6行第1列子图的标题为"Answer Boxes"

# 绘制K-Means Boxes子图
axes[5,1].scatter(df_boxes3_kmeans['x'], df_boxes3_kmeans['y'], c=df_boxes3_kmeans['Cluster'], s=10, cmap = "Set3")
# 在第6行第2列的子图中绘制散点图，横坐标为df_boxes3_kmeans的'x'列，纵坐标为df_boxes3_kmeans的'y'列，点的颜色根据df_boxes3_kmeans的'Cluster'列确定，点的大小为10，使用"Set3"颜色映射

axes[5,1].set_title("K-Means Boxes")
# 设置第6行第2列子图的标题为"K-Means Boxes"

# 调整子图布局
plt.tight_layout()
# 调整子图的布局，使得子图之间的间距合适，防止重叠

4.5 オンライン小売データに対する K-Means アルゴリズムの使用

# 将df2复制给df_kmeans，因为我们需要引用之前的df来添加聚类编号
df_kmeans = df2.copy()

# 检查每个聚类中的项数，并创建一个名为'Cluster'的列
df_kmeans['Cluster'] = y_kmeans

# 统计每个聚类中的项数，并显示结果
df_kmeans['Cluster'].value_counts()

1    1945
4     853
0     441
5     308
2     215
3     142
Name: Cluster, dtype: int64

# 设置图形大小
plt.figure(figsize=(15,7))

# 绘制散点图
sns.scatterplot(data=df_kmeans, x='Amount', y='Frequency', hue='Cluster', s=15, palette="Set3")

# 参数解释：
# data：要绘制的数据集
# x：x轴数据列名
# y：y轴数据列名
# hue：根据该列的值对数据点进行着色
# s：数据点的大小
# palette：颜色调色板，用于设置数据点的颜色

<AxesSubplot:xlabel='Amount', ylabel='Frequency'>

5. 階層的クラスタリング

階層クラスタリング (階層クラスター分析または HCA とも呼ばれる) は、クラスターの階層構造を構築することを目的としたクラスター分析手法です。オブジェクト間の類似性に基づいて、オブジェクトをクラスターにグループ化します。一般に、結合と分割は貪欲に決定されます。階層的クラスタリングの結果は、通常、樹状図の形式で表示されます。

階層的クラスタリングは、特に興味深い観察があり、それらの観察に類似した観察を識別できるようにしたい場合に特に役立ちます。

階層的クラスタリングには次のようなものがあります。

凝集型- 単一の要素から始まり、それらを単一のクラスターにグループ化します。

Schizoid - 完全なデータセットから始まり、それをパーティションに分割します。

凝集クラスタリングは、小さなクラスターを見つけるのに最適です。アルゴリズムが完了すると、最終結果は樹状図のように見えるため、クラスターを簡単に視覚化できます。

ここに画像の説明を挿入します

5.1 階層的クラスタリングの長所と短所

階層的クラスタリングの利点:

特定の観測値に最も類似した観測値を取得する- このアルゴリズムは、どの観測値が互いに最も類似しているかに関する詳細情報を提供します。他の多くのアルゴリズムでは、この種の詳細は提供されません。
初期化条件の影響を受けにくい- シードセットやデータセットの順序などの初期化条件の影響を受けません。異なる初期化条件で解析を再実行すると、通常は非常に似た結果が得られ、場合によってはまったく同じ結果が得られることもあります。
カテゴリ変数を含む状況に適応できる- 数値変数とカテゴリ変数が混在する状況にも比較的簡単に適応できます。これを行うには、使用される距離メトリックが、成長者の距離などの混合データタイプに適していることを確認する必要があります。
外れ値に対する感度が低い- いくつかの外れ値が存在しても、アルゴリズムが他のデータポイントでどのように実行されるかに影響を与える可能性は低くなります。
クラスターの形状に関するそれほど厳密ではない仮定- アルゴリズムは、クラスターの形状についてより厳密ではない仮定を立てます。使用する距離メトリックに応じて、一部のクラスター形状は他のクラスター形状よりも検出しやすい場合がありますが、柔軟性が高くなります。

階層的クラスタリングの欠点:

比較的遅い- これは数学的に非常に複雑なアルゴリズムです。階層的クラスタリングでは通常、データセット内のすべての観測値間のペアごとの距離を計算する必要があるため、データセットのサイズが大きくなるにつれて、必要な計算量も急速に増加します。
クラスターの数を指定する必要がありますが、アルゴリズムの主要部分の実行後に変更できるため、アルゴリズムを最初から実行せずに、別のクラスター数を試すことができます。
スケーリングに敏感- クラスタリングを実行する前にデータの再スケーリングが必要になる場合があります。正確な感度の程度は、ポイント間の距離の計算に使用する距離メトリックによって異なります。
ヒューリスティックな影響- これにより、プロセスに多くの手動介入が発生するため、結果が意味があるかどうかを分析するには、アプリケーション/ドメイン固有の知識が必要になります。
可視化が難しい場合がある・データサンプル数が多くなると、樹形図の可視化による分析や意思決定ができなくなる。

5.2 階層的クラスタリングの変形

BIRCH は、大規模なデータセットの高速処理を可能にする階層クラスタリングの拡張機能です。標準の階層クラスタリングよりもメモリ要件が低くなります。

5.3 データセットでの階層的クラスタリングモデルのトレーニング

# 复制数据集df3并命名为df_AgglomerativeC
df_AgglomerativeC = df3.copy()

# 复制数据集blob_df并命名为df_blob_AgglomerativeC
df_blob_AgglomerativeC = blob_df.copy()

# 复制数据集dart_df并命名为df_dart_AgglomerativeC
df_dart_AgglomerativeC = dart_df.copy()

# 复制数据集basic2_df并命名为df_basic2_AgglomerativeC
df_basic2_AgglomerativeC = basic2_df.copy()

# 复制数据集outliers_df并命名为df_outliers_AgglomerativeC
df_outliers_AgglomerativeC = outliers_df.copy()

# 复制数据集spiral2_df并命名为df_spiral2_AgglomerativeC
df_spiral2_AgglomerativeC = spiral2_df.copy()

# 复制数据集boxes3_df并命名为df_boxes3_AgglomerativeC
df_boxes3_AgglomerativeC = boxes3_df.copy()

# 以下代码是对数据框中的某一列进行删除操作
# df_blob_AgglomerativeC是一个数据框，通过调用drop()函数，删除了名为'color'的列
# inplace=True表示在原数据框上进行修改，而不是返回一个新的数据框

# 删除df_blob_AgglomerativeC数据框中的'color'列
df_blob_AgglomerativeC.drop(['color'], axis=1, inplace=True)

# 删除df_dart_AgglomerativeC数据框中的'color'列
df_dart_AgglomerativeC.drop(['color'], axis=1, inplace=True)

# 删除df_basic2_AgglomerativeC数据框中的'color'列
df_basic2_AgglomerativeC.drop(['color'], axis=1, inplace=True)

# 删除df_outliers_AgglomerativeC数据框中的'color'列
df_outliers_AgglomerativeC.drop(['color'], axis=1, inplace=True)

# 删除df_spiral2_AgglomerativeC数据框中的'color'列
df_spiral2_AgglomerativeC.drop(['color'], axis=1, inplace=True)

# 删除df_boxes3_AgglomerativeC数据框中的'color'列
df_boxes3_AgglomerativeC.drop(['color'], axis=1, inplace=True)

# 导入AgglomerativeClustering模块
from sklearn.cluster import AgglomerativeClustering

# 创建AgglomerativeClustering对象，设置聚类数为6，相似度度量为欧氏距离，链接方式为ward
AgglomerativeC = AgglomerativeClustering(n_clusters=6, affinity='euclidean', linkage='ward')

# 使用AgglomerativeC对象对数据集df_AgglomerativeC进行聚类，并返回聚类结果
y_AgglomerativeC = AgglomerativeC.fit_predict(df_AgglomerativeC)

# 创建AgglomerativeClustering对象，设置聚类数为4，相似度度量为欧氏距离，链接方式为ward
AgglomerativeC_blob = AgglomerativeClustering(n_clusters=4, affinity='euclidean', linkage='ward')

# 使用AgglomerativeC_blob对象对数据集df_blob_AgglomerativeC进行聚类，并返回聚类结果
y_AgglomerativeC_blob = AgglomerativeC_blob.fit_predict(df_blob_AgglomerativeC)

# 创建AgglomerativeClustering对象，设置聚类数为2，相似度度量为欧氏距离，链接方式为ward
AgglomerativeC_dart = AgglomerativeClustering(n_clusters=2, affinity='euclidean', linkage='ward')

# 使用AgglomerativeC_dart对象对数据集df_dart_AgglomerativeC进行聚类，并返回聚类结果
y_AgglomerativeC_dart = AgglomerativeC_dart.fit_predict(df_dart_AgglomerativeC)

# 创建AgglomerativeClustering对象，设置聚类数为5，相似度度量为欧氏距离，链接方式为ward
AgglomerativeC_basic = AgglomerativeClustering(n_clusters=5, affinity='euclidean', linkage='ward')

# 使用AgglomerativeC_basic对象对数据集df_basic2_AgglomerativeC进行聚类，并返回聚类结果
y_AgglomerativeC_basic = AgglomerativeC_basic.fit_predict(df_basic2_AgglomerativeC)

# 创建AgglomerativeClustering对象，设置聚类数为3，相似度度量为欧氏距离，链接方式为ward
AgglomerativeC_outliers = AgglomerativeClustering(n_clusters=3, affinity='euclidean', linkage='ward')

# 使用AgglomerativeC_outliers对象对数据集df_outliers_AgglomerativeC进行聚类，并返回聚类结果
y_AgglomerativeC_outliers = AgglomerativeC_outliers.fit_predict(df_outliers_AgglomerativeC)

# 创建AgglomerativeClustering对象，设置聚类数为2，相似度度量为欧氏距离，链接方式为ward
AgglomerativeC_spiral2 = AgglomerativeClustering(n_clusters=2, affinity='euclidean', linkage='ward')

# 使用AgglomerativeC_spiral2对象对数据集df_spiral2_AgglomerativeC进行聚类，并返回聚类结果
y_AgglomerativeC_spiral2 = AgglomerativeC_spiral2.fit_predict(df_spiral2_AgglomerativeC)

# 创建AgglomerativeClustering对象，设置聚类数为12，相似度度量为欧氏距离，链接方式为ward
AgglomerativeC_boxes3 = AgglomerativeClustering(n_clusters=12, affinity='euclidean', linkage='ward')

# 使用AgglomerativeC_boxes3对象对数据集df_boxes3_AgglomerativeC进行聚类，并返回聚类结果
y_AgglomerativeC_boxes3 = AgglomerativeC_boxes3.fit_predict(df_boxes3_AgglomerativeC)

# 在数据集df_blob_AgglomerativeC中创建'Cluster'列，并将聚类结果y_AgglomerativeC_blob赋值给该列
df_blob_AgglomerativeC['Cluster'] = y_AgglomerativeC_blob

# 在数据集df_dart_AgglomerativeC中创建'Cluster'列，并将聚类结果y_AgglomerativeC_dart赋值给该列
df_dart_AgglomerativeC['Cluster'] = y_AgglomerativeC_dart

# 在数据集df_basic2_AgglomerativeC中创建'Cluster'列，并将聚类结果y_AgglomerativeC_basic赋值给该列
df_basic2_AgglomerativeC['Cluster'] = y_AgglomerativeC_basic

# 在数据集df_outliers_AgglomerativeC中创建'Cluster'列，并将聚类结果y_AgglomerativeC_outliers赋值给该列
df_outliers_AgglomerativeC['Cluster'] = y_AgglomerativeC_outliers

# 在数据集df_spiral2_AgglomerativeC中创建'Cluster'列，并将聚类结果y_AgglomerativeC_spiral2赋值给该列
df_spiral2_AgglomerativeC['Cluster'] = y_AgglomerativeC_spiral2

# 在数据集df_boxes3_AgglomerativeC中创建'Cluster'列，并将聚类结果y_AgglomerativeC_boxes3赋值给该列
df_boxes3_AgglomerativeC['Cluster'] = y_AgglomerativeC_boxes3

5.4 比較結果

# 创建子图fig, axes = plt.subplots(nrows=6, ncols=2,figsize=(10,30))
# 创建一个6行2列的子图，总共有12个子图，设置子图的大小为10x30

# 设置总标题fig.suptitle('ANSWER vs Hierarchical clustering\n', size = 18)
# 设置总标题为'ANSWER vs Hierarchical clustering\n'，字体大小为18

# 绘制Answer Blob散点图
axes[0,0].scatter(blob_df['x'], blob_df['y'], c=blob_df['color'], s=10, cmap = "Set3")
# 在第1行第1列的子图中绘制Answer Blob散点图
# x轴数据为blob_df的'x'列，y轴数据为blob_df的'y'列，颜色根据blob_df的'color'列确定，点的大小为10，颜色映射为"Set3"

axes[0,0].set_title("Answer Blob")
# 设置第1行第1列子图的标题为"Answer Blob"

# 绘制Hierarchical clustering Blob散点图
axes[0,1].scatter(df_blob_AgglomerativeC['x'], df_blob_AgglomerativeC['y'], c=df_blob_AgglomerativeC['Cluster'], s=10, cmap = "Set3")
# 在第1行第2列的子图中绘制Hierarchical clustering Blob散点图
# x轴数据为df_blob_AgglomerativeC的'x'列，y轴数据为df_blob_AgglomerativeC的'y'列，颜色根据df_blob_AgglomerativeC的'Cluster'列确定，点的大小为10，颜色映射为"Set3"

axes[0,1].set_title("Hierarchical clustering Blob")
# 设置第1行第2列子图的标题为"Hierarchical clustering Blob"

# 绘制Answer Dart散点图
axes[1,0].scatter(dart_df['x'], dart_df['y'], c=dart_df['color'], s=10, cmap = "Set3")
# 在第2行第1列的子图中绘制Answer Dart散点图
# x轴数据为dart_df的'x'列，y轴数据为dart_df的'y'列，颜色根据dart_df的'color'列确定，点的大小为10，颜色映射为"Set3"

axes[1,0].set_title("Answer Dart")
# 设置第2行第1列子图的标题为"Answer Dart"

# 绘制Hierarchical clustering Dart散点图
axes[1,1].scatter(df_dart_AgglomerativeC['x'], df_dart_AgglomerativeC['y'], c=df_dart_AgglomerativeC['Cluster'], s=10, cmap = "Set3")
# 在第2行第2列的子图中绘制Hierarchical clustering Dart散点图
# x轴数据为df_dart_AgglomerativeC的'x'列，y轴数据为df_dart_AgglomerativeC的'y'列，颜色根据df_dart_AgglomerativeC的'Cluster'列确定，点的大小为10，颜色映射为"Set3"

axes[1,1].set_title("Hierarchical clustering Dart")
# 设置第2行第2列子图的标题为"Hierarchical clustering Dart"

# 绘制Answer Basic散点图
axes[2,0].scatter(basic2_df['x'], basic2_df['y'], c=basic2_df['color'], s=10, cmap = "Set3")
# 在第3行第1列的子图中绘制Answer Basic散点图
# x轴数据为basic2_df的'x'列，y轴数据为basic2_df的'y'列，颜色根据basic2_df的'color'列确定，点的大小为10，颜色映射为"Set3"

axes[2,0].set_title("Answer Basic")
# 设置第3行第1列子图的标题为"Answer Basic"

# 绘制Hierarchical clustering Basic散点图
axes[2,1].scatter(df_basic2_AgglomerativeC['x'], df_basic2_AgglomerativeC['y'], c=df_basic2_AgglomerativeC['Cluster'], s=10, cmap = "Set3")
# 在第3行第2列的子图中绘制Hierarchical clustering Basic散点图
# x轴数据为df_basic2_AgglomerativeC的'x'列，y轴数据为df_basic2_AgglomerativeC的'y'列，颜色根据df_basic2_AgglomerativeC的'Cluster'列确定，点的大小为10，颜色映射为"Set3"

axes[2,1].set_title("Hierarchical clustering Basic")
# 设置第3行第2列子图的标题为"Hierarchical clustering Basic"

# 绘制Answer Outliers散点图
axes[3,0].scatter(outliers_df['x'], outliers_df['y'], c=outliers_df['color'], s=10, cmap = "Set3")
# 在第4行第1列的子图中绘制Answer Outliers散点图
# x轴数据为outliers_df的'x'列，y轴数据为outliers_df的'y'列，颜色根据outliers_df的'color'列确定，点的大小为10，颜色映射为"Set3"

axes[3,0].set_title("Answer Outliers")
# 设置第4行第1列子图的标题为"Answer Outliers"

# 绘制Hierarchical clustering Outliers散点图
axes[3,1].scatter(df_outliers_AgglomerativeC['x'], df_outliers_AgglomerativeC['y'], c=df_outliers_AgglomerativeC['Cluster'], s=10, cmap = "Set3")
# 在第4行第2列的子图中绘制Hierarchical clustering Outliers散点图
# x轴数据为df_outliers_AgglomerativeC的'x'列，y轴数据为df_outliers_AgglomerativeC的'y'列，颜色根据df_outliers_AgglomerativeC的'Cluster'列确定，点的大小为10，颜色映射为"Set3"

axes[3,1].set_title("Hierarchical clustering Outliers")
# 设置第4行第2列子图的标题为"Hierarchical clustering Outliers"

# 绘制Answer Spiral散点图
axes[4,0].scatter(spiral2_df['x'], spiral2_df['y'], c=spiral2_df['color'], s=10, cmap = "Set3")
# 在第5行第1列的子图中绘制Answer Spiral散点图
# x轴数据为spiral2_df的'x'列，y轴数据为spiral2_df的'y'列，颜色根据spiral2_df的'color'列确定，点的大小为10，颜色映射为"Set3"

axes[4,0].set_title("Answer Spiral")
# 设置第5行第1列子图的标题为"Answer Spiral"

# 绘制Hierarchical clustering Spiral散点图
axes[4,1].scatter(df_spiral2_AgglomerativeC['x'], df_spiral2_AgglomerativeC['y'], c=df_spiral2_AgglomerativeC['Cluster'], s=10, cmap = "Set3")
# 在第5行第2列的子图中绘制Hierarchical clustering Spiral散点图
# x轴数据为df_spiral2_AgglomerativeC的'x'列，y轴数据为df_spiral2_AgglomerativeC的'y'列，颜色根据df_spiral2_AgglomerativeC的'Cluster'列确定，点的大小为10，颜色映射为"Set3"

axes[4,1].set_title("Hierarchical clustering Spiral")
# 设置第5行第2列子图的标题为"Hierarchical clustering Spiral"

# 绘制Answer Boxes散点图
axes[5,0].scatter(boxes3_df['x'], boxes3_df['y'], c=boxes3_df['color'], s=10, cmap = "Set3")
# 在第6行第1列的子图中绘制Answer Boxes散点图
# x轴数据为boxes3_df的'x'列，y轴数据为boxes3_df的'y'列，颜色根据boxes3_df的'color'列确定，点的大小为10，颜色映射为"Set3"

axes[5,0].set_title("Answer Boxes")
# 设置第6行第1列子图的标题为"Answer Boxes"

# 绘制Hierarchical clustering Boxes散点图
axes[5,1].scatter(df_boxes3_AgglomerativeC['x'], df_boxes3_AgglomerativeC['y'], c=df_boxes3_AgglomerativeC['Cluster'], s=10, cmap = "Set3")
# 在第6行第2列的子图中绘制Hierarchical clustering Boxes散点图
# x轴数据为df_boxes3_AgglomerativeC的'x'列，y轴数据为df_boxes3_AgglomerativeC的'y'列，颜色根据df_boxes3_AgglomerativeC的'Cluster'列确定，点的大小为10，颜色映射为"Set3"

axes[5,1].set_title("Hierarchical clustering Boxes")
# 设置第6行第2列子图的标题为"Hierarchical clustering Boxes"

# 调整子图布局
plt.tight_layout()
# 调整子图的布局，使得子图之间的间距合适，避免重叠

5.5 オンライン小売データの階層的クラスタリング

# 将df2复制给df_AgglomerativeC，因为我们需要引用之前的df来添加聚类号码
df_AgglomerativeC = df2.copy()

# 检查每个聚类中的项数，并创建一个名为'Cluster'的列
df_AgglomerativeC['Cluster'] = y_AgglomerativeC

# 统计每个聚类中的项数
df_AgglomerativeC['Cluster'].value_counts()

2    1848
4     992
1     398
0     334
5     193
3     139
Name: Cluster, dtype: int64


# 设置图形大小
plt.figure(figsize=(15,7))

# 绘制散点图
sns.scatterplot(data=df_AgglomerativeC, x='Amount', y='Frequency', hue='Cluster', s=15, palette="Set3")

# 添加文注释：设置图形的大小为15x7
# 添加文注释：使用seaborn库的scatterplot函数绘制散点图
# 添加文注释：散点图的x轴数据为'Amount'，y轴数据为'Frequency'
# 添加文注释：根据'Cluster'列的值对散点进行着色
# 添加文注释：散点的大小为15，颜色使用"Set3"调色板

<AxesSubplot:xlabel='Amount', ylabel='Frequency'>

6. DBSCAN クラスタリングアルゴリズム

DBSCAN は、Density Clustering Applications with Noise の略です。これは、密度ベースのクラスタリングアルゴリズムです。
不規則な形のクラスターを見つけることができます。低密度領域ごとに領域を分離するため、外れ値も適切に検出します。このアルゴリズムは、奇妙な形状のデータを扱う場合、K-means よりも優れています。

DBSCAN

DBSCAN は、データポイントを異なるクラスターに分割できる密度クラスタリングアルゴリズムです。その中心となるアイデアは、高密度のポイントをクラスタリングし、低密度のポイントを他のポイントから分離することです。

ここに画像の説明を挿入します

6.1 DBSCAN の長所と短所

DBSCAN の利点:

不規則な形状とサイズのクラスターを処理します- DBSCAN は、クラスターの形状について最小限の仮定を行う数少ないアルゴリズムの 1 つです。これは、DBSCAN を使用して、奇妙な、または不規則な形状のクラスターを検出できることを意味します。
堅牢- このアルゴリズムは外れ値を検出し、クラスターから完全に除外できます。
クラスターの数を指定する必要がない- DBSCAN のもう 1 つの利点は、ユーザーがクラスターの数を指定する必要がないことです。DBSCAN は、データ内に存在するクラスターの数を自動的に検出できます。これは、必要なクラスターの数が不明な場合に役立ちます。
初期化条件の影響を受けにくい- DBSCAN は、他のクラスタリングアルゴリズムに比べて、データセット内の観測の順序や使用されるシードなどの初期化条件の影響を受けにくいです。
比較的高速- DBSCAN は一般に K-Means クラスタリングよりも低速ですが、階層クラスタリングやスペクトルクラスタリングよりは高速です。

DBSCAN の欠点:

カテゴリ特徴を組み込むのが難しい- ほとんどの特徴が数値である場合は、DBSCAN を使用する必要があります。
クラスター境界を検出するにはデータ密度の低下が必要- アルゴリズムがクラスター間の境界を検出できるようにするには、クラスター間のデータポイントの密度を低下させる必要があります。データ密度を低下させることなく重複する複数のクラスターがある場合、それらは 1 つのクラスターにグループ化される場合があります。
密度が異なるクラスターの処理が難しい- DBSCAN は、データポイントの密度が特定のしきい値を下回る場所を確認することで、クラスターの開始場所と終了場所を決定します。密度の低いクラスター内のすべてのポイントを捕捉するしきい値を見つけるのは困難な場合があり、また、密度の高いクラスター内の逸脱値が多すぎる場合に除外することも困難な場合があります。
スケールに敏感- DBSCAN は変数のスケールに敏感です。これは、変数のスケールが大幅に異なる場合は、変数を再スケールする必要があることを意味します。
高次元データの処理が難しい- 多くの機能が存在すると DBSCAN のパフォーマンスが低下する傾向があります。高次元データセットがある場合は、次元削減または特徴選択手法を使用して特徴の数を減らす必要があります。
Epsilon パラメータと MinPts パラメータを設定する必要があります。これは少し難しいかもしれません。

6.2 正しい初期パラメータの選択

DBSCAN アルゴリズムには 2 つのパラメーターが必要です。アルゴリズムにとって正しい値を選択することが重要です。

イプシロン (ε) は、密度をチェックするために使用される、各データポイントの周囲に作成される円の半径です。

この手法では、各ポイントとその k 個の最近傍ポイントの間の平均距離が計算されます。ここで、k = 選択した MinPts 値です。次に、平均 k 個の距離が昇順に k 個の距離グラフ上にプロットされます。イプシロンの値は、K 距離マップから決定できます。このグラフの最大曲率点 (変曲点) は、イプシロンの値 (つまり、グラフの傾きが最大になる場所) を示します。

minPoints (MinPts) は、データポイントをコアポイントとして分類するために円内に必要なデータポイントの最小数です。

DBSCAN の MinPts 値を自動的に決定する方法はありません。minPoints を 1 に設定しても、各ポイントが別個のクラスターになるため、意味がありません。したがって、少なくとも 3 である必要があります。通常、これは次元の 2 倍、または次元 + 1 です。ドメイン知識もその価値を決定します。

データセットにノイズが多い場合は、より大きな MinPts 値を選択します。
2 次元データの場合は、DBSCAN のデフォルトの MinPts = 4 (Ester et al.、1996) を使用します。

minPoints の値は、データセットのディメンションより少なくとも 1 大きい必要があります。

MinPts >= 寸法 * 2

または

MinPts >= ディメンション + 1

重要なヒント:

データセットに適した Epsilon および MinPts パラメーターを見つけるのが難しい場合があります。以下にいくつかのヒントを示します。

大きくてノイズの多いデータセットの場合は、より大きな MinPts 値を使用します。
結果として得られるクラスターが大きすぎる場合は、イプシロンを減らします。
ノイズが多すぎる場合は、イプシロンを増やします。
適切なクラスタリングには反復が必要です。

ここに画像の説明を挿入します

K 距離プロットをプロットするには、データセット内の各データポイントとその最も近いデータポイントの間の距離を計算する必要があります。sklearn.neighborsを使用してNearestNeighborsこれを実現できます。

# 复制数据集df3并赋值给df_DBScan
df_DBScan = df3.copy()

# 复制数据集blob_df并赋值给df_blob_DBScan
df_blob_DBScan = blob_df.copy()

# 复制数据集dart_df并赋值给df_dart_DBScan
df_dart_DBScan = dart_df.copy()

# 复制数据集basic2_df并赋值给df_basic2_DBScan
df_basic2_DBScan = basic2_df.copy()

# 复制数据集outliers_df并赋值给df_outliers_DBScan
df_outliers_DBScan = outliers_df.copy()

# 复制数据集spiral2_df并赋值给df_spiral2_DBScan
df_spiral2_DBScan = spiral2_df.copy()

# 复制数据集boxes3_df并赋值给df_boxes3_DBScan
df_boxes3_DBScan = boxes3_df.copy()

# 导入NearestNeighbors类
from sklearn.neighbors import NearestNeighbors

# 创建一个NearestNeighbors对象，设置n_neighbors参数为4
nn = NearestNeighbors(n_neighbors=4)

# 使用df_dart_DBScan数据拟合NearestNeighbors模型
nbrs = nn.fit(df_dart_DBScan)

# 使用拟合好的模型计算最近邻的距离和索引
distances, indices = nbrs.kneighbors(df_dart_DBScan)

# 对距离进行排序
distances = np.sort(distances, axis=0)

# 取第二列的距离值
distances = distances[:,1]

# 创建一个6x6的图像
plt.figure(figsize=(6,6))

# 绘制距离图
plt.plot(distances)

# 设置图像标题和坐标轴标签
plt.title('K-distance Graph for "Dart df"',fontsize=20)
plt.xlabel('Data Points sorted by distance',fontsize=14)
plt.ylabel('Epsilon',fontsize=14)

# 显示图像
plt.show()

K-Distance グラフでは、イプシロンの最適な値は最大曲率の点にあり、この場合は 8 です。
MinPts の場合は、4 (2 * 次元) を選択します。

6.3 DBSCAN のバリアントアルゴリズム

一般化 DBSCAN (GDBSCAN) - ε パラメーターと minPts パラメーターを元のアルゴリズムから述語に移動し、削除します。

OPTICS (クラスター構造を特定するための順序付けポイント) - 高密度のコアサンプルを見つけて、そこからクラスターを展開します。DBSCAN とは異なり、可変近傍半径のクラスタリング階層が維持されます。DBSCAN の現在の sklearn 実装よりも大規模なデータセットに適しています。

HDBSCAN - DBSCAN の階層バージョンで、これも OPTICS より高速で、階層から最も顕著なクラスターで構成されるフラットパーティションを抽出できます。

DBSCAN は、部分空間クラスタリングアルゴリズム PreDeCon および SUBCLU の一部としても使用されます。

6.4 データセットでの DBSCAN クラスタリングモデルのトレーニング

このセクションでは、DBSCAN アルゴリズムを使用してデータセットに対してクラスタリングを実行します。DBSCAN は、データポイントをコアポイント、境界ポイント、およびノイズポイントに分割できる密度クラスタリングアルゴリズムです。このアルゴリズムの利点は、クラスターの数を自動的に決定でき、任意の形状のクラスターを処理できることです。このセクションでは、sklearn ライブラリの DBSCAN クラスを使用してモデルをトレーニングします。

# 删除df_blob_DBScan中的'color'列
df_blob_DBScan.drop(['color'], axis=1, inplace=True)

# 删除df_dart_DBScan中的'color'列
df_dart_DBScan.drop(['color'], axis=1, inplace=True)

# 删除df_basic2_DBScan中的'color'列
df_basic2_DBScan.drop(['color'], axis=1, inplace=True)

# 删除df_outliers_DBScan中的'color'列
df_outliers_DBScan.drop(['color'], axis=1, inplace=True)

# 删除df_spiral2_DBScan中的'color'列
df_spiral2_DBScan.drop(['color'], axis=1, inplace=True)

# 删除df_boxes3_DBScan中的'color'列
df_boxes3_DBScan.drop(['color'], axis=1, inplace=True)

# 导入DBSCAN模型
from sklearn.cluster import DBSCAN

# 创建DBSCAN对象，设置eps为20，min_samples为9，使用欧氏距离作为距离度量
dbscan = DBSCAN(eps=20, min_samples=9, metric='euclidean')

# 使用DBSCAN模型对df_DBScan进行拟合和预测
y_DBScan = dbscan.fit_predict(df_DBScan)

# 创建不同参数的DBSCAN对象
DBScan_blob = DBSCAN(eps=13, min_samples=45, metric='euclidean')
DBScan_dart = DBSCAN(eps=8, min_samples=4, metric='euclidean')
DBScan_basic = DBSCAN(eps=15, min_samples=4, metric='euclidean')
DBScan_outliers = DBSCAN(eps=20, min_samples=4, metric='euclidean')
DBScan_spiral2 = DBSCAN(eps=5.7, min_samples=4, metric='euclidean')
DBScan_boxes3 = DBSCAN(eps=6, min_samples=4, metric='euclidean')

# 使用不同参数的DBSCAN模型对相应的数据集进行拟合和预测
y_DBScan_blob = DBScan_blob.fit_predict(df_blob_DBScan)
y_DBScan_dart = DBScan_dart.fit_predict(df_dart_DBScan)
y_DBScan_basic = DBScan_basic.fit_predict(df_basic2_DBScan)
y_DBScan_outliers = DBScan_outliers.fit_predict(df_outliers_DBScan)
y_DBScan_spiral2 = DBScan_spiral2.fit_predict(df_spiral2_DBScan)
y_DBScan_boxes3 = DBScan_boxes3.fit_predict(df_boxes3_DBScan)

# 在数据集中创建'Cluster'列
df_blob_DBScan['Cluster'] = y_DBScan_blob  # 将DBScan算法聚类结果y_DBScan_blob赋值给df_blob_DBScan的'Cluster'列
df_dart_DBScan['Cluster'] = y_DBScan_dart  # 将DBScan算法聚类结果y_DBScan_dart赋值给df_dart_DBScan的'Cluster'列
df_basic2_DBScan['Cluster'] = y_DBScan_basic  # 将DBScan算法聚类结果y_DBScan_basic赋值给df_basic2_DBScan的'Cluster'列
df_outliers_DBScan['Cluster'] = y_DBScan_outliers  # 将DBScan算法聚类结果y_DBScan_outliers赋值给df_outliers_DBScan的'Cluster'列
df_spiral2_DBScan['Cluster'] = y_DBScan_spiral2  # 将DBScan算法聚类结果y_DBScan_spiral2赋值给df_spiral2_DBScan的'Cluster'列
df_boxes3_DBScan['Cluster'] = y_DBScan_boxes3  # 将DBScan算法聚类结果y_DBScan_boxes3赋值给df_boxes3_DBScan的'Cluster'列

# 上述代码是将DBScan算法聚类结果赋值给数据集中的'Cluster'列，以便后续分析和可视化。每个数据集都有一个对应的聚类结果y_DBScan_xxx，将其赋值给对应的数据集的'Cluster'列即可。

6.5 比較結果

# 导入matplotlib库
import matplotlib.pyplot as plt

# 创建子图fig, axes，其中nrows=6表示创建6行，ncols=2表示创建2列，figsize=(10,30)表示设置子图的大小
fig, axes = plt.subplots(nrows=6, ncols=2, figsize=(10,30))

# 设置总标题fig.suptitle，size=18表示设置标题的字体大小
fig.suptitle('ANSWER vs DBSCAN clustering\n', size = 18)

# 绘制Answer Blob子图，其中c表示颜色，s表示点的大小，cmap表示颜色映射
axes[0,0].scatter(blob_df['x'], blob_df['y'], c=blob_df['color'], s=10, cmap = "Set3")
axes[0,0].set_title("Answer Blob") # 设置子图标题

# 绘制DBSCAN clustering Blob子图
axes[0,1].scatter(df_blob_DBScan['x'], df_blob_DBScan['y'], c=df_blob_DBScan['Cluster'], s=10, cmap = "Set3")
axes[0,1].set_title("DBSCAN clustering Blob") # 设置子图标题

# 绘制Answer Dart子图
axes[1,0].scatter(dart_df['x'], dart_df['y'], c=dart_df['color'], s=10, cmap = "Set3")
axes[1,0].set_title("Answer Dart") # 设置子图标题

# 绘制DBSCAN clustering Dart子图
axes[1,1].scatter(df_dart_DBScan['x'], df_dart_DBScan['y'], c=df_dart_DBScan['Cluster'], s=10, cmap = "Set3")
axes[1,1].set_title("DBSCAN clustering Dart") # 设置子图标题

# 绘制Answer Basic子图
axes[2,0].scatter(basic2_df['x'], basic2_df['y'], c=basic2_df['color'], s=10, cmap = "Set3")
axes[2,0].set_title("Answer Basic") # 设置子图标题

# 绘制DBSCAN clustering Basic子图
axes[2,1].scatter(df_basic2_DBScan['x'], df_basic2_DBScan['y'], c=df_basic2_DBScan['Cluster'], s=10, cmap = "Set3")
axes[2,1].set_title("DBSCAN clustering Basic") # 设置子图标题

# 绘制Answer Outliers子图
axes[3,0].scatter(outliers_df['x'], outliers_df['y'], c=outliers_df['color'], s=10, cmap = "Set3")
axes[3,0].set_title("Answer Outliers") # 设置子图标题

# 绘制DBSCAN clustering Outliers子图
axes[3,1].scatter(df_outliers_DBScan['x'], df_outliers_DBScan['y'], c=df_outliers_DBScan['Cluster'], s=10, cmap = "Set3")
axes[3,1].set_title("DBSCAN clustering Outliers") # 设置子图标题

# 绘制Answer Spiral子图
axes[4,0].scatter(spiral2_df['x'], spiral2_df['y'], c=spiral2_df['color'], s=10, cmap = "Set3")
axes[4,0].set_title("Answer Spiral") # 设置子图标题

# 绘制DBSCAN clustering Spiral子图
axes[4,1].scatter(df_spiral2_DBScan['x'], df_spiral2_DBScan['y'], c=df_spiral2_DBScan['Cluster'], s=10, cmap = "Set3")
axes[4,1].set_title("DBSCAN clustering Spiral") # 设置子图标题

# 绘制Answer Boxes子图
axes[5,0].scatter(boxes3_df['x'], boxes3_df['y'], c=boxes3_df['color'], s=10, cmap = "Set3")
axes[5,0].set_title("Answer Boxes") # 设置子图标题

# 绘制DBSCAN clustering Boxes子图
axes[5,1].scatter(df_boxes3_DBScan['x'], df_boxes3_DBScan['y'], c=df_boxes3_DBScan['Cluster'], s=10, cmap = "Set3")
axes[5,1].set_title("DBSCAN clustering Boxes") # 设置子图标题

# 调整子图布局
plt.tight_layout()

6.6 オンライン小売データに対する DBSCAN クラスタリングモデルの使用

# 复制df2数据框并命名为df_DBScan，因为我们需要引用之前的df数据框来添加聚类编号
df_DBScan = df2.copy()

# 检查每个聚类中的数据项数量，并创建一个名为'Cluster'的列
df_DBScan['Cluster'] = y_DBScan

# 统计每个聚类的数量，并显示在'Cluster'列中

0    3904
Name: Cluster, dtype: int64


# 设置图形的大小
plt.figure(figsize=(15,7))

# 绘制散点图
sns.scatterplot(data=df_DBScan, x='Amount', y='Frequency', hue='Cluster', s=15, palette="Set3")

# 参数解释：
# - data：指定要绘制的数据集
# - x：指定x轴的数据列
# - y：指定y轴的数据列
# - hue：指定用于分组的数据列，根据该列的不同取值，散点图的颜色会有所区分
# - s：指定散点的大小
# - palette：指定颜色的调色板，用于设置散点的颜色

<AxesSubplot:xlabel='Amount', ylabel='Frequency'>

7. 混合ガウスモデル (GMM)

混合ガウスモデル (GMM) は、入力データセットを最もよくシミュレートする多次元ガウス確率分布の混合を見つけようとします。最も単純なケースでは、GMM を使用して K 平均法のようなクラスターを見つけることができますが、GMM には内部に確率モデルが含まれているため、確率的なクラスターの割り当ても見つけることができます。

混合ガウスモデルは、複数のガウス分布を使用して任意の形状のデータを適合させます。

この混合モデルには、隠れ層として複数の単一ガウスモデルが存在します。したがって、モデルは、データポイントが特定のガウス分布、つまりデータポイントが属するクラスターに属する確率を計算します。

ここに画像の説明を挿入します

7.1 混合ガウスモデルの長所と短所

混合ガウスモデルには次のような利点と欠点があります。

混合ガウスモデル (GMM) の利点:

各クラスターに属する確率の推定値- モデルは、各クラスターに属する各データポイントの確率の推定値を提供します。これらの確率推定は、2 つのクラスター間の境界にあるあいまいなデータポイントを調べるときに役立ちます。
球状クラスターを想定しない- モデルは、すべてのクラスターが一様な形状の球であることを想定しません。代わりに、ガウス混合モデルを使用して、さまざまな形状のクラスターを適合させることができます。
さまざまなサイズのクラスターの処理- 混合ガウスモデルを使用して、さまざまなサイズのクラスターに対応することもできます。
スケールに依存しない- これは、変数をクラスタリングに使用する前に変数を再スケールする必要がないことを意味します。
混合メンバーシップへの適応- kmeans では、点は 1 つのクラスターにのみ属しますが、GMM では、点はさまざまな程度で各クラスターに属します。この次数は、各クラスターの (多変量) 正規分布から点が生じる確率に基づきます。ここで、クラスターの中心は分布の平均であり、クラスターの共分散はその共分散です。タスクに応じて、混合メンバーシップがより適切な場合もあります (例: ニュース記事が複数のトピッククラスターに属することができる)、または不適切である場合もあります (例: 生物は 1 つの種のみに属することができます)。

混合ガウスモデル (GMM) の欠点:

カテゴリカルな特徴の統合が難しい- このモデルは、すべての特徴が正規分布に従うという前提に基づいて動作するため、カテゴリデータに簡単に適応できません。
特徴は正規分布していると想定されます。これは、このクラスタリングアルゴリズムを使用する前に、特徴の分布を確認するために時間を費やす必要があることを意味します。
クラスターの形状についていくつかの仮定を立てます。これは、クラスターの形状が非常に不規則である場合、混合ガウスモデルがあまり適切に機能しないことを意味します。
各クラスターの共分散を推定するには十分なデータが必要です。共分散を適切に推定するには、各クラスターに十分なデータポイントがあることを確認する必要があります。必要なデータ量はそれほど多くありませんが、共分散行列を推定しない単純なアルゴリズムよりも多くなります。
クラスターの数を指定する必要があります。混合ガウスモデルは、特徴が正規分布に従うという仮定の下で動作するため、データ内に多くの外れ値が存在することによって影響を受ける可能性があります。混合ガウスモデルの一部の実装では、外れ値を個別のクラスターに分離できます。
使用されるシードやクラスターの中心に使用される開始点などの初期化条件に敏感です。これは、アルゴリズムを複数回実行すると、異なる結果が得られる可能性があることを意味します。
遅い- データセットに多くのフィーチャがある場合、これは特に顕著です。

7.2 GMM のバリエーション

変分ベイジアンガウス混合モデル - ガウス混合モデルの成分数の指定を回避します。

7.3 GMM モデルのトレーニング

# 复制数据集df3到df_GMM
df_GMM = df3.copy()

# 复制数据集blob_df到df_blob_GMM
df_blob_GMM = blob_df.copy()

# 复制数据集dart_df到df_dart_GMM
df_dart_GMM = dart_df.copy()

# 复制数据集basic2_df到df_basic2_GMM
df_basic2_GMM = basic2_df.copy()

# 复制数据集outliers_df到df_outliers_GMM
df_outliers_GMM = outliers_df.copy()

# 复制数据集spiral2_df到df_spiral2_GMM
df_spiral2_GMM = spiral2_df.copy()

# 复制数据集boxes3_df到df_boxes3_GMM
df_boxes3_GMM = boxes3_df.copy()

# 给df_blob_GMM数据框删除'color'列
df_blob_GMM.drop(['color'], axis=1, inplace=True)

# 给df_dart_GMM数据框删除'color'列
df_dart_GMM.drop(['color'], axis=1, inplace=True)

# 给df_basic2_GMM数据框删除'color'列
df_basic2_GMM.drop(['color'], axis=1, inplace=True)

# 给df_outliers_GMM数据框删除'color'列
df_outliers_GMM.drop(['color'], axis=1, inplace=True)

# 给df_spiral2_GMM数据框删除'color'列
df_spiral2_GMM.drop(['color'], axis=1, inplace=True)

# 给df_boxes3_GMM数据框删除'color'列
df_boxes3_GMM.drop(['color'], axis=1, inplace=True)

# 导入所需的库
from sklearn.mixture import GaussianMixture

# 创建一个高斯混合模型对象，指定模型的分量数量为8
gmm = GaussianMixture(n_components=8)

# 使用高斯混合模型对数据进行拟合和预测，得到预测结果
y_GMM = gmm.fit_predict(df_GMM)

# 创建高斯混合模型对象，指定模型的分量数量为4
GMM_blob = GaussianMixture(n_components=4)

# 使用高斯混合模型对数据进行拟合和预测，得到预测结果
y_GMM_blob = GMM_blob.fit_predict(df_blob_GMM)

# 创建高斯混合模型对象，指定模型的分量数量为2
GMM_dart = GaussianMixture(n_components=2)

# 使用高斯混合模型对数据进行拟合和预测，得到预测结果
y_GMM_dart = GMM_dart.fit_predict(df_dart_GMM)

# 创建高斯混合模型对象，指定模型的分量数量为5
GMM_basic = GaussianMixture(n_components=5)

# 使用高斯混合模型对数据进行拟合和预测，得到预测结果
y_GMM_basic = GMM_basic.fit_predict(df_basic2_GMM)

# 创建高斯混合模型对象，指定模型的分量数量为3
GMM_outliers = GaussianMixture(n_components=3)

# 使用高斯混合模型对数据进行拟合和预测，得到预测结果
y_GMM_outliers = GMM_outliers.fit_predict(df_outliers_GMM)

# 创建高斯混合模型对象，指定模型的分量数量为2
GMM_spiral2 = GaussianMixture(n_components=2)

# 使用高斯混合模型对数据进行拟合和预测，得到预测结果
y_GMM_spiral2 = GMM_spiral2.fit_predict(df_spiral2_GMM)

# 创建高斯混合模型对象，指定模型的分量数量为12
GMM_boxes3 = GaussianMixture(n_components=12)

# 使用高斯混合模型对数据进行拟合和预测，得到预测结果
y_GMM_boxes3 = GMM_boxes3.fit_predict(df_boxes3_GMM)

# 在数据集df_blob_GMM中创建一个名为"Cluster"的列
df_blob_GMM['Cluster'] = y_GMM_blob  
# 将GMM聚类算法的结果y_GMM_blob赋值给df_blob_GMM数据集的"Cluster"列

# 在数据集df_dart_GMM中创建一个名为"Cluster"的列
df_dart_GMM['Cluster'] = y_GMM_dart  
# 将GMM聚类算法的结果y_GMM_dart赋值给df_dart_GMM数据集的"Cluster"列

# 在数据集df_basic2_GMM中创建一个名为"Cluster"的列
df_basic2_GMM['Cluster'] = y_GMM_basic  
# 将GMM聚类算法的结果y_GMM_basic赋值给df_basic2_GMM数据集的"Cluster"列

# 在数据集df_outliers_GMM中创建一个名为"Cluster"的列
df_outliers_GMM['Cluster'] = y_GMM_outliers  
# 将GMM聚类算法的结果y_GMM_outliers赋值给df_outliers_GMM数据集的"Cluster"列

# 在数据集df_spiral2_GMM中创建一个名为"Cluster"的列
df_spiral2_GMM['Cluster'] = y_GMM_spiral2  
# 将GMM聚类算法的结果y_GMM_spiral2赋值给df_spiral2_GMM数据集的"Cluster"列

# 在数据集df_boxes3_GMM中创建一个名为"Cluster"的列
df_boxes3_GMM['Cluster'] = y_GMM_boxes3  
# 将GMM聚类算法的结果y_GMM_boxes3赋值给df_boxes3_GMM数据集的"Cluster"列

7.4 比較結果

# 创建子图fig, axes，其中nrows=6表示子图行数为6，ncols=2表示子图列数为2，figsize=(10,30)表示整个图的大小为10*30
fig, axes = plt.subplots(nrows=6, ncols=2, figsize=(10,30))

# 设置整个图的标题为'ANSWER vs GMM clustering\n'，字体大小为18
fig.suptitle('ANSWER vs GMM clustering\n', size = 18)

# 绘制第一个子图，显示Answer Blob的散点图，其中x、y、color分别表示数据的横坐标、纵坐标和颜色，s=10表示散点的大小为10，cmap="Set3"表示使用Set3颜色映射
axes[0,0].scatter(blob_df['x'], blob_df['y'], c=blob_df['color'], s=10, cmap = "Set3")
axes[0,0].set_title("Answer Blob") # 设置子图标题为"Answer Blob"

# 绘制第二个子图，显示GMM clustering Blob的散点图，其中x、y、Cluster分别表示数据的横坐标、纵坐标和聚类结果，s=10表示散点的大小为10，cmap="Set3"表示使用Set3颜色映射
axes[0,1].scatter(df_blob_GMM['x'], df_blob_GMM['y'], c=df_blob_GMM['Cluster'], s=10, cmap = "Set3")
axes[0,1].set_title("GMM clustering Blob") # 设置子图标题为"GMM clustering Blob"

# 绘制第三个子图，显示Answer Dart的散点图，其中x、y、color分别表示数据的横坐标、纵坐标和颜色，s=10表示散点的大小为10，cmap="Set3"表示使用Set3颜色映射
axes[1,0].scatter(dart_df['x'], dart_df['y'], c=dart_df['color'], s=10, cmap = "Set3")
axes[1,0].set_title("Answer Dart") # 设置子图标题为"Answer Dart"

# 绘制第四个子图，显示GMM clustering Dart的散点图，其中x、y、Cluster分别表示数据的横坐标、纵坐标和聚类结果，s=10表示散点的大小为10，cmap="Set3"表示使用Set3颜色映射
axes[1,1].scatter(df_dart_GMM['x'], df_dart_GMM['y'], c=df_dart_GMM['Cluster'], s=10, cmap = "Set3")
axes[1,1].set_title("GMM clustering Dart") # 设置子图标题为"GMM clustering Dart"

# 绘制第五个子图，显示Answer Basic的散点图，其中x、y、color分别表示数据的横坐标、纵坐标和颜色，s=10表示散点的大小为10，cmap="Set3"表示使用Set3颜色映射
axes[2,0].scatter(basic2_df['x'], basic2_df['y'], c=basic2_df['color'], s=10, cmap = "Set3")
axes[2,0].set_title("Answer Basic") # 设置子图标题为"Answer Basic"

# 绘制第六个子图，显示GMM clustering Basic的散点图，其中x、y、Cluster分别表示数据的横坐标、纵坐标和聚类结果，s=10表示散点的大小为10，cmap="Set3"表示使用Set3颜色映射
axes[2,1].scatter(df_basic2_GMM['x'], df_basic2_GMM['y'], c=df_basic2_GMM['Cluster'], s=10, cmap = "Set3")
axes[2,1].set_title("GMM clustering Basic") # 设置子图标题为"GMM clustering Basic"

# 绘制第七个子图，显示Answer Outliers的散点图，其中x、y、color分别表示数据的横坐标、纵坐标和颜色，s=10表示散点的大小为10，cmap="Set3"表示使用Set3颜色映射
axes[3,0].scatter(outliers_df['x'], outliers_df['y'], c=outliers_df['color'], s=10, cmap = "Set3")
axes[3,0].set_title("Answer Outliers") # 设置子图标题为"Answer Outliers"

# 绘制第八个子图，显示GMM clustering Outliers的散点图，其中x、y、Cluster分别表示数据的横坐标、纵坐标和聚类结果，s=10表示散点的大小为10，cmap="Set3"表示使用Set3颜色映射
axes[3,1].scatter(df_outliers_GMM['x'], df_outliers_GMM['y'], c=df_outliers_GMM['Cluster'], s=10, cmap = "Set3")
axes[3,1].set_title("GMM clustering Outliers") # 设置子图标题为"GMM clustering Outliers"

# 绘制第九个子图，显示Answer Spiral的散点图，其中x、y、color分别表示数据的横坐标、纵坐标和颜色，s=10表示散点的大小为10，cmap="Set3"表示使用Set3颜色映射
axes[4,0].scatter(spiral2_df['x'], spiral2_df['y'], c=spiral2_df['color'], s=10, cmap = "Set3")
axes[4,0].set_title("Answer Spiral") # 设置子图标题为"Answer Spiral"

# 绘制第十个子图，显示GMM clustering Spiral的散点图，其中x、y、Cluster分别表示数据的横坐标、纵坐标和聚类结果，s=10表示散点的大小为10，cmap="Set3"表示使用Set3颜色映射
axes[4,1].scatter(df_spiral2_GMM['x'], df_spiral2_GMM['y'], c=df_spiral2_GMM['Cluster'], s=10, cmap = "Set3")
axes[4,1].set_title("GMM clustering Spiral") # 设置子图标题为"GMM clustering Spiral"

# 绘制第十一个子图，显示Answer Boxes的散点图，其中x、y、color分别表示数据的横坐标、纵坐标和颜色，s=10表示散点的大小为10，cmap="Set3"表示使用Set3颜色映射
axes[5,0].scatter(boxes3_df['x'], boxes3_df['y'], c=boxes3_df['color'], s=10, cmap = "Set3")
axes[5,0].set_title("Answer Boxes") # 设置子图标题为"Answer Boxes"

# 绘制第十二个子图，显示GMM clustering Boxes的散点图，其中x、y、Cluster分别表示数据的横坐标、纵坐标和聚类结果，s=10表示散点的大小为10，cmap="Set3"表示使用Set3颜色映射
axes[5,1].scatter(df_boxes3_GMM['x'], df_boxes3_GMM['y'], c=df_boxes3_GMM['Cluster'], s=10, cmap = "Set3")
axes[5,1].set_title("GMM clustering Boxes") # 设置子图标题为"GMM clustering Boxes"

# 调整子图的布局
plt.tight_layout()

7.5 オンライン小売データの GMM クラスタリングモデル

# 将df2复制给df_GMM，因为我们需要引用之前的df来添加聚类编号
df_GMM = df2.copy()

# 检查每个聚类中的项数，并创建一个名为'Cluster'的列
df_GMM['Cluster'] = y_GMM

# 统计每个聚类中的项数，并显示出来
df_GMM['Cluster'].value_counts()

0    1165
3    1011
7     543
2     367
6     311
5     253
4     149
1     105
Name: Cluster, dtype: int64


# 设置图形的大小
plt.figure(figsize=(15,7))

# 绘制散点图
sns.scatterplot(data=df_GMM, x='Amount', y='Frequency', hue='Cluster', s=15, palette="Set3")

# 参数说明：
# data：要绘制的数据集
# x：x轴的数据列
# y：y轴的数据列
# hue：根据该列的值对数据点进行着色
# s：数据点的大小
# palette：颜色调色板，用于设置数据点的颜色

<AxesSubplot:xlabel='Amount', ylabel='Frequency'>

8. 全アルゴリズムの比較

# 创建子图fig, axes = plt.subplots(nrows=6, ncols=5,figsize=(30,30))
# 创建一个6行5列的子图，设置整个图的大小为30x30

# 设置总标题fig.suptitle('ANSWER vs different algorithm\n', size = 18)
# 设置总标题为'ANSWER vs different algorithm'，字体大小为18

# 绘制Answer Blob散点图
axes[0,0].scatter(blob_df['x'], blob_df['y'], c=blob_df['color'], s=10, cmap = "Set3")
# 在第1行第1列的子图中绘制Answer Blob的散点图
# x轴数据为blob_df的x列，y轴数据为blob_df的y列，颜色根据color列的值确定，点的大小为10，颜色映射为"Set3"
axes[0,0].set_title("Answer Blob")
# 设置该子图的标题为"Answer Blob"

# 绘制GMM clustering Blob散点图
axes[0,1].scatter(df_blob_GMM['x'], df_blob_GMM['y'], c=df_blob_GMM['Cluster'], s=10, cmap = "Set3")
# 在第1行第2列的子图中绘制GMM clustering Blob的散点图
# x轴数据为df_blob_GMM的x列，y轴数据为df_blob_GMM的y列，颜色根据Cluster列的值确定，点的大小为10，颜色映射为"Set3"
axes[0,1].set_title("GMM clustering Blob")
# 设置该子图的标题为"GMM clustering Blob"

# 绘制K-Means Blob散点图
axes[0,2].scatter(df_blob_kmeans['x'], df_blob_kmeans['y'], c=df_blob_kmeans['Cluster'], s=10, cmap = "Set3")
# 在第1行第3列的子图中绘制K-Means Blob的散点图
# x轴数据为df_blob_kmeans的x列，y轴数据为df_blob_kmeans的y列，颜色根据Cluster列的值确定，点的大小为10，颜色映射为"Set3"
axes[0,2].set_title("K-Means Blob")
# 设置该子图的标题为"K-Means Blob"

# 绘制Hierarchical clustering Blob散点图
axes[0,3].scatter(df_blob_AgglomerativeC['x'], df_blob_AgglomerativeC['y'], c=df_blob_AgglomerativeC['Cluster'], s=10, cmap = "Set3")
# 在第1行第4列的子图中绘制Hierarchical clustering Blob的散点图
# x轴数据为df_blob_AgglomerativeC的x列，y轴数据为df_blob_AgglomerativeC的y列，颜色根据Cluster列的值确定，点的大小为10，颜色映射为"Set3"
axes[0,3].set_title("Hierarchical clustering Blob")
# 设置该子图的标题为"Hierarchical clustering Blob"

# 绘制DBSCAN clustering Blob散点图
axes[0,4].scatter(df_blob_DBScan['x'], df_blob_DBScan['y'], c=df_blob_DBScan['Cluster'], s=10, cmap = "Set3")
# 在第1行第5列的子图中绘制DBSCAN clustering Blob的散点图
# x轴数据为df_blob_DBScan的x列，y轴数据为df_blob_DBScan的y列，颜色根据Cluster列的值确定，点的大小为10，颜色映射为"Set3"
axes[0,4].set_title("DBSCAN clustering Blob")
# 设置该子图的标题为"DBSCAN clustering Blob"

# 绘制Answer Dart散点图
axes[1,0].scatter(dart_df['x'], dart_df['y'], c=dart_df['color'], s=10, cmap = "Set3")
# 在第2行第1列的子图中绘制Answer Dart的散点图
# x轴数据为dart_df的x列，y轴数据为dart_df的y列，颜色根据color列的值确定，点的大小为10，颜色映射为"Set3"
axes[1,0].set_title("Answer Dart")
# 设置该子图的标题为"Answer Dart"

# 绘制GMM clustering Dart散点图
axes[1,1].scatter(df_dart_GMM['x'], df_dart_GMM['y'], c=df_dart_GMM['Cluster'], s=10, cmap = "Set3")
# 在第2行第2列的子图中绘制GMM clustering Dart的散点图
# x轴数据为df_dart_GMM的x列，y轴数据为df_dart_GMM的y列，颜色根据Cluster列的值确定，点的大小为10，颜色映射为"Set3"
axes[1,1].set_title("GMM clustering Dart")
# 设置该子图的标题为"GMM clustering Dart"

# 绘制K-Means Dart散点图
axes[1,2].scatter(df_dart_kmeans['x'], df_dart_kmeans['y'], c=df_dart_kmeans['Cluster'], s=10, cmap = "Set3")
# 在第2行第3列的子图中绘制K-Means Dart的散点图
# x轴数据为df_dart_kmeans的x列，y轴数据为df_dart_kmeans的y列，颜色根据Cluster列的值确定，点的大小为10，颜色映射为"Set3"
axes[1,2].set_title("K-Means Dart")
# 设置该子图的标题为"K-Means Dart"

# 绘制Hierarchical clustering Dart散点图
axes[1,3].scatter(df_dart_AgglomerativeC['x'], df_dart_AgglomerativeC['y'], c=df_dart_AgglomerativeC['Cluster'], s=10, cmap = "Set3")
# 在第2行第4列的子图中绘制Hierarchical clustering Dart的散点图
# x轴数据为df_dart_AgglomerativeC的x列，y轴数据为df_dart_AgglomerativeC的y列，颜色根据Cluster列的值确定，点的大小为10，颜色映射为"Set3"
axes[1,3].set_title("Hierarchical clustering Dart")
# 设置该子图的标题为"Hierarchical clustering Dart"

# 绘制DBSCAN clustering Dart散点图
axes[1,4].scatter(df_dart_DBScan['x'], df_dart_DBScan['y'], c=df_dart_DBScan['Cluster'], s=10, cmap = "Set3")
# 在第2行第5列的子图中绘制DBSCAN clustering Dart的散点图
# x轴数据为df_dart_DBScan的x列，y轴数据为df_dart_DBScan的y列，颜色根据Cluster列的值确定，点的大小为10，颜色映射为"Set3"
axes[1,4].set_title("DBSCAN clustering Dart")
# 设置该子图的标题为"DBSCAN clustering Dart"

# 绘制Answer Basic散点图
axes[2,0].scatter(basic2_df['x'], basic2_df['y'], c=basic2_df['color'], s=10, cmap = "Set3")
# 在第3行第1列的子图中绘制Answer Basic的散点图
# x轴数据为basic2_df的x列，y轴数据为basic2_df的y列，颜色根据color列的值确定，点的大小为10，颜色映射为"Set3"
axes[2,0].set_title("Answer Basic")
# 设置该子图的标题为"Answer Basic"

# 绘制GMM clustering Basic散点图
axes[2,1].scatter(df_basic2_GMM['x'], df_basic2_GMM['y'], c=df_basic2_GMM['Cluster'], s=10, cmap = "Set3")
# 在第3行第2列的子图中绘制GMM clustering Basic的散点图
# x轴数据为df_basic2_GMM的x列，y轴数据为df_basic2_GMM的y列，颜色根据Cluster列的值确定，点的大小为10，颜色映射为"Set3"
axes[2,1].set_title("GMM clustering Basic")
# 设置该子图的标题为"GMM clustering Basic"

# 绘制K-Means Basic散点图
axes[2,2].scatter(df_basic_kmeans['x'], df_basic_kmeans['y'], c=df_basic_kmeans['Cluster'], s=10, cmap = "Set3")
# 在第3行第3列的子图中绘制K-Means Basic的散点图
# x轴数据为df_basic_kmeans的x列，y轴数据为df_basic_kmeans的y列，颜色根据Cluster列的值确定，点的大小为10，颜色映射为"Set3"
axes[2,2].set_title("K-Means Basic")
# 设置该子图的标题为"K-Means Basic"

# 绘制Hierarchical clustering Basic散点图
axes[2,3].scatter(df_basic2_AgglomerativeC['x'], df_basic2_AgglomerativeC['y'], c=df_basic2_AgglomerativeC['Cluster'], s=10, cmap = "Set3")
# 在第3行第4列的子图中绘制Hierarchical clustering Basic的散点图
# x轴数据为df_basic2_AgglomerativeC的x列，y轴数据为df_basic2_AgglomerativeC的y列，颜色根据Cluster列的值确定，点的大小为10，颜色映射为"Set3"
axes[2,3].set_title("Hierarchical clustering Basic")
# 设置该子图的标题为"Hierarchical clustering Basic"

# 绘制DBSCAN clustering Basic散点图
axes[2,4].scatter(df_basic2_DBScan['x'], df_basic2_DBScan['y'], c=df_basic2_DBScan['Cluster'], s=10, cmap = "Set3")
# 在第3行第5列的子图中绘制DBSCAN clustering Basic的散点图
# x轴数据为df_basic2_DBScan的x列，y轴数据为df_basic2_DBScan的y列，颜色根据Cluster列的值确定，点的大小为10，颜色映射为"Set3"
axes[2,4].set_title("DBSCAN clustering Basic")
# 设置该子图的标题为"DBSCAN clustering Basic"

# 绘制Answer Outliers散点图
axes[3,0].scatter(outliers_df['x'], outliers_df['y'], c=outliers_df['color'], s=10, cmap = "Set3")
# 在第4行第1列的子图中绘制Answer Outliers的散点图
# x轴数据为outliers_df的x列，y轴数据为outliers_df的y列，颜色根据color列的值确定，点的大小为10，颜色映射为"Set3"
axes[3,0].set_title("Answer Outliers")
# 设置该子图的标题为"Answer Outliers"

# 绘制GMM clustering Outliers散点图
axes[3,1].scatter(df_outliers_GMM['x'], df_outliers_GMM['y'], c=df_outliers_GMM['Cluster'], s=10, cmap = "Set3")
# 在第4行第2列的子图中绘制GMM clustering Outliers的散点图
# x轴数据为df_outliers_GMM的x列，y轴数据为df_outliers_GMM的y列，颜色根据Cluster列的值确定，点的大小为10，颜色映射为"Set3"
axes[3,1].set_title("GMM clustering Outliers")
# 设置该子图的标题为"GMM clustering Outliers"

# 绘制K-Means Outliers散点图
axes[3,2].scatter(df_outliers_kmeans['x'], df_outliers_kmeans['y'], c=df_outliers_kmeans['Cluster'], s=10, cmap = "Set3")
# 在第4行第3列的子图中绘制K-Means Outliers的散点图
# x轴数据为df_outliers_kmeans的x列，y轴数据为df_outliers_kmeans的y列，颜色根据Cluster列的值确定，点的大小为10，颜色映射为"Set3"
axes[3,2].set_title("K-Means Outliers")
# 设置该子图的标题为"K-Means Outliers"

# 绘制Hierarchical clustering Outliers散点图
axes[3,3].scatter(df_outliers_AgglomerativeC['x'], df_outliers_AgglomerativeC['y'], c=df_outliers_AgglomerativeC['Cluster'], s=10, cmap = "Set3")
# 在第4行第4列的子图中绘制Hierarchical clustering Outliers的散点图
# x轴数据为df_outliers_AgglomerativeC的x列，y轴数据为df_outliers_AgglomerativeC的y列，颜色根据Cluster列的值确定，点的大小为10，颜色映射为"Set3"
axes[3,3].set_title("Hierarchical clustering Outliers")
# 设置该子图的标题为"Hierarchical clustering Outliers"

# 绘制DBSCAN clustering Outliers散点图
axes[3,4].scatter(df_outliers_DBScan['x'], df_outliers_DBScan['y'], c=df_outliers_DBScan['Cluster'], s=10, cmap = "Set3")
# 在第4行第5列的子图中绘制DBSCAN clustering Outliers的散点图
# x轴数据为df_outliers_DBScan的x列，y轴数据为df_outliers_DBScan的y列，颜色根据Cluster列的值确定，点的大小为10，颜色映射为"Set3"
axes[3,4].set_title("DBSCAN clustering Outliers")
# 设置该子图的标题为"DBSCAN clustering Outliers"

# 绘制Answer Spiral散点图
axes[4,0].scatter(spiral2_df['x'], spiral2_df['y'], c=spiral2_df['color'], s=10, cmap = "Set3")
# 在第5行第1列的子图中绘制Answer Spiral的散点图
# x轴数据为spiral2_df的x列，y轴数据为spiral2_df的y列，颜色根据color列的值确定，点的大小为10，颜色映射为"Set3"
axes[4,0].set_title("Answer Spiral")
# 设置该子图的标题为"Answer Spiral"

# 绘制GMM clustering Spiral散点图
axes[4,1].scatter(df_spiral2_GMM['x'], df_spiral2_GMM['y'], c=df_spiral2_GMM['Cluster'], s=10, cmap = "Set3")
# 在第5行第2列的子图中绘制GMM clustering Spiral的散点图
# x轴数据为df_spiral2_GMM的x列，y轴数据为df_spiral2_GMM的y列，颜色根据Cluster列的值确定，点的大小为10，颜色映射为"Set3"
axes[4,1].set_title("GMM clustering Spiral")
# 设置该子图的标题为"GMM clustering Spiral"

# 绘制K-Means Spiral散点图
axes[4,2].scatter(df_spiral2_kmeans['x'], df_spiral2_kmeans['y'], c=df_spiral2_kmeans['Cluster'], s=10, cmap = "Set3")
# 在第5行第3列的子图中绘制K-Means Spiral的散点图
# x轴数据为df_spiral2_kmeans的x列，y轴数据为df_spiral2_kmeans的y列，颜色根据Cluster列的值确定，点的大小为10，颜色映射为"Set3"
axes[4,2].set_title("K-Means Spiral")
# 设置该子图的标题为"K-Means Spiral"

# 绘制Hierarchical clustering Spiral散点图
axes[4,3].scatter(df_spiral2_AgglomerativeC['x'], df_spiral2_AgglomerativeC['y'], c=df_spiral2_AgglomerativeC['Cluster'], s=10, cmap = "Set3")
# 在第5行第4列的子图中绘制Hierarchical clustering Spiral的散点图
# x轴数据为df_spiral2_AgglomerativeC的x列，y轴数据为df_spiral2_AgglomerativeC的y列，颜色根据Cluster列的值确定，点的大小为10，颜色映射为"Set3"
axes[4,3].set_title("Hierarchical clustering Spiral")
# 设置该子图的标题为"Hierarchical clustering Spiral"

# 绘制DBSCAN clustering Spiral散点图
axes[4,4].scatter(df_spiral2_DBScan['x'], df_spiral2_DBScan['y'], c=df_spiral2_DBScan['Cluster'], s=10, cmap = "Set3")
# 在第5行第5列的子图中绘制DBSCAN clustering Spiral的散点图
# x轴数据为df_spiral2_DBScan的x列，y轴数据为df_spiral2_DBScan的y列，颜色根据Cluster列的值确定，点的大小为10，颜色映射为"Set3"
axes[4,4].set_title("DBSCAN clustering Spiral")
# 设置该子图的标题为"DBSCAN clustering Spiral"

# 绘制Answer Boxes散点图
axes[5,0].scatter(boxes3_df['x'], boxes3_df['y'], c=boxes3_df['color'], s=10, cmap = "Set3")
# 在第6行第1列的子图中绘制Answer Boxes的散点图
# x轴数据为boxes3_df的x列，y轴数据为boxes3_df的y列，颜色根据color列的值确定，点的大小为10，颜色映射为"Set3"
axes[5,0].set_title("Answer Boxes")
# 设置该子图的标题为"Answer Boxes"

# 绘制GMM clustering Boxes散点图
axes[5,1].scatter(df_boxes3_GMM['x'], df_boxes3_GMM['y'], c=df_boxes3_GMM['Cluster'], s=10, cmap = "Set3")
# 在第6行第2列的子图中绘制GMM clustering Boxes的散点图
# x轴数据为df_boxes3_GMM的x列，y轴数据为df_boxes3_GMM的y列，颜色根据Cluster列的值确定，点的大小为10，颜色映射为"Set3"
axes[5,1].set_title("GMM clustering Boxes")
# 设置该子图的标题为"GMM clustering Boxes"

# 绘制K-Means Boxes散点图
axes[5,2].scatter(df_boxes3_kmeans['x'], df_boxes3_kmeans['y'], c=df_boxes3_kmeans['Cluster'], s=10, cmap = "Set3")
# 在第6行第3列的子图中绘制K-Means Boxes的散点图
# x轴数据为df_boxes3_kmeans的x列，y轴数据为df_boxes3_kmeans的y列，颜色根据Cluster列的值确定，点的大小为10，颜色映射为"Set3"
axes[5,2].set_title("K-Means Boxes")
# 设置该子图的标题为"K-Means Boxes"

# 绘制Hierarchical clustering Boxes散点图
axes[5,3].scatter(df_boxes3_AgglomerativeC['x'], df_boxes3_AgglomerativeC['y'], c=df_boxes3_AgglomerativeC['Cluster'], s=10, cmap = "Set3")
# 在第6行第4列的子图中绘制Hierarchical clustering Boxes的散点图
# x轴数据为df_boxes3_AgglomerativeC的x列，y轴数据为df_boxes3_AgglomerativeC的y列，颜色根据Cluster列的值确定，点的大小为10，颜色映射为"Set3"
axes[5,3].set_title("Hierarchical clustering Boxes")
# 设置该子图的标题为"Hierarchical clustering Boxes"

# 绘制DBSCAN clustering Boxes散点图
axes[5,4].scatter(df_boxes3_DBScan['x'], df_boxes3_DBScan['y'], c=df_boxes3_DBScan['Cluster'], s=10, cmap = "Set3")
# 在第6行第5列的子图中绘制DBSCAN clustering Boxes的散点图
# x轴数据为df_boxes3_DBScan的x列，y轴数据为df_boxes3_DBScan的y列，颜色根据Cluster列的值确定，点的大小为10，颜色映射为"Set3"
axes[5,4].set_title("DBSCAN clustering Boxes")
# 设置该子图的标题为"DBSCAN clustering Boxes"

# 调整子图布局
plt.tight_layout()
# 调整子图的布局，使得子图之间的间距合适，防止重叠