Pythonにおけるk-means法を使用したクラスタリング手法12選

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

# データの生成
np.random.seed(42)
X = np.random.rand(100, 2)

# K-meansクラスタリングの実行
kmeans = KMeans(n_clusters=3, random_state=42)
kmeans.fit(X)

# 結果の可視化
plt.scatter(X[:, 0], X[:, 1], c=kmeans.labels_, cmap='viridis')
plt.scatter(kmeans.cluster_centers_[:, 0], kmeans.cluster_centers_[:, 1], marker='x', s=200, linewidths=3, color='r')
plt.title('K-meansクラスタリング結果')
plt.show()

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

# サンプルデータの生成
np.random.seed(42)
X = np.array([[170, 60], [175, 65], [180, 70], [160, 55], [165, 58], 
              [185, 75], [155, 50], [190, 80], [178, 68], [182, 72]])

# KMeansモデルの初期化とフィッティング
kmeans = KMeans(n_clusters=3, random_state=42)
kmeans.fit(X)

# 結果の可視化
plt.scatter(X[:, 0], X[:, 1], c=kmeans.labels_, cmap='viridis')
plt.scatter(kmeans.cluster_centers_[:, 0], kmeans.cluster_centers_[:, 1], 
            marker='x', s=200, linewidths=3, color='r')
plt.xlabel('身長 (cm)')
plt.ylabel('体重 (kg)')
plt.title('K-means クラスタリング結果')
plt.show()

# クラスタの中心座標を表示
print("クラスタの中心座標:")
for i, center in enumerate(kmeans.cluster_centers_):
    print(f"クラスタ {i}: 身長 {center[0]:.2f}cm, 体重 {center[1]:.2f}kg")

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

# サンプルデータの生成（前回と同じ）
np.random.seed(42)
X = np.array([[170, 60], [175, 65], [180, 70], [160, 55], [165, 58], 
              [185, 75], [155, 50], [190, 80], [178, 68], [182, 72]])

# KMeansモデルの初期化とフィッティング
kmeans = KMeans(n_clusters=3, random_state=42)
kmeans.fit(X)

# カラーマップの設定
colors = ['#FF9999', '#66B2FF', '#99FF99']
cmap = ListedColormap(colors)

# 結果の可視化
plt.figure(figsize=(10, 8))
scatter = plt.scatter(X[:, 0], X[:, 1], c=kmeans.labels_, cmap=cmap, s=100)
plt.scatter(kmeans.cluster_centers_[:, 0], kmeans.cluster_centers_[:, 1], 
            marker='x', s=200, linewidths=3, color='r')

# データポイントにラベルを付ける
for i, (x, y) in enumerate(X):
    plt.annotate(f'Person {i+1}', (x, y), xytext=(5, 5), 
                 textcoords='offset points')

plt.xlabel('身長 (cm)')
plt.ylabel('体重 (kg)')
plt.title('K-means クラスタリング結果の詳細可視化')

# 凡例を追加
legend1 = plt.legend(*scatter.legend_elements(),
                    loc="lower right", title="クラスタ")
plt.add_artist(legend1)

# クラスタの中心座標を表示
for i, center in enumerate(kmeans.cluster_centers_):
    plt.annotate(f'Cluster {i+1}\n({center[0]:.0f}cm, {center[1]:.0f}kg)', 
                 (center[0], center[1]), xytext=(10, 10),
                 textcoords='offset points', fontweight='bold')

plt.grid(True)
plt.show()

import numpy as np
from scipy.cluster.hierarchy import dendrogram, linkage
from matplotlib import pyplot as plt

# サンプルデータの生成
np.random.seed(42)
X = np.random.rand(20, 2)

# 階層的クラスタリングの実行（ウォード法）
Z = linkage(X, 'ward')

# デンドログラムの描画
plt.figure(figsize=(10, 7))
dendrogram(Z)
plt.title('階層的クラスタリング（ウォード法）のデンドログラム')
plt.xlabel('サンプル番号')
plt.ylabel('距離')
plt.show()

# クラスタ数を3に設定した場合の結果表示
from scipy.cluster.hierarchy import fcluster

cluster_labels = fcluster(Z, t=3, criterion='maxclust')

plt.figure(figsize=(10, 7))
plt.scatter(X[:, 0], X[:, 1], c=cluster_labels, cmap='viridis')
plt.title('階層的クラスタリング結果（クラスタ数: 3）')
plt.xlabel('X')
plt.ylabel('Y')
plt.colorbar(label='クラスタ番号')
plt.show()

import numpy as np
from sklearn.cluster import DBSCAN
from sklearn.datasets import make_moons
import matplotlib.pyplot as plt

# 半月型のデータセットを生成
X, _ = make_moons(n_samples=200, noise=0.05, random_state=42)

# DBSCANの実行
dbscan = DBSCAN(eps=0.3, min_samples=5)
cluster_labels = dbscan.fit_predict(X)

# 結果の可視化
plt.figure(figsize=(10, 7))
scatter = plt.scatter(X[:, 0], X[:, 1], c=cluster_labels, cmap='viridis')
plt.title('DBSCANクラスタリング結果')
plt.xlabel('X')
plt.ylabel('Y')
plt.colorbar(scatter, label='クラスタラベル')
plt.show()

# クラスタ数とノイズポイントの数を表示
n_clusters = len(set(cluster_labels)) - (1 if -1 in cluster_labels else 0)
n_noise = list(cluster_labels).count(-1)
print(f'推定されたクラスタ数: {n_clusters}')
print(f'ノイズとして分類されたポイント数: {n_noise}')

from sklearn.datasets import load_iris
from sklearn.decomposition import PCA
import matplotlib.pyplot as plt
import numpy as np

# Irisデータセットの読み込み
iris = load_iris()
X = iris.data
y = iris.target

# PCAの実行
pca = PCA(n_components=2)
X_pca = pca.fit_transform(X)

# 結果の可視化
plt.figure(figsize=(10, 8))
scatter = plt.scatter(X_pca[:, 0], X_pca[:, 1], c=y, cmap='viridis')
plt.title('PCAによるIrisデータセットの2次元可視化')
plt.xlabel('第1主成分')
plt.ylabel('第2主成分')
plt.colorbar(scatter, label='品種')

# 主成分の寄与率を表示
print("各主成分の寄与率:")
print(pca.explained_variance_ratio_)

plt.show()

from sklearn.datasets import load_digits
from sklearn.manifold import TSNE
import matplotlib.pyplot as plt
import numpy as np

# MNISTデータセット（簡易版）の読み込み
digits = load_digits()
X = digits.data
y = digits.target

# t-SNEの実行
tsne = TSNE(n_components=2, random_state=42)
X_tsne = tsne.fit_transform(X)

# 結果の可視化
plt.figure(figsize=(12, 8))
scatter = plt.scatter(X_tsne[:, 0], X_tsne[:, 1], c=y, cmap='tab10')
plt.title('t-SNEによるMNISTデータセットの2次元可視化')
plt.colorbar(scatter, label='数字')

# ランダムに選んだ点にラベルを付ける
for i in range(10):
    idx = np.where(y == i)[0]
    idx = np.random.choice(idx)
    plt.annotate(str(y[idx]), (X_tsne[idx, 0], X_tsne[idx, 1]), xytext=(5, 5), 
                 textcoords='offset points', fontsize=12, fontweight='bold')

plt.show()

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

# データセットの生成
X, _ = make_blobs(n_samples=300, centers=4, cluster_std=0.60, random_state=0)

# エルボー法の実装
wcss = []
for i in range(1, 11):
    kmeans = KMeans(n_clusters=i, init='k-means++', max_iter=300, n_init=10, random_state=0)
    kmeans.fit(X)
    wcss.append(kmeans.inertia_)

# エルボーカーブのプロット
plt.figure(figsize=(10, 8))
plt.plot(range(1, 11), wcss, marker='o')
plt.title('エルボー法によるクラスタ数の決定')
plt.xlabel('クラスタ数')
plt.ylabel('WCSS (Within-Cluster Sum of Squares)')
plt.show()

# 最適なクラスタ数の決定（簡易的な方法）
differences = np.diff(wcss)
elbow_point = np.argmin(differences) + 1
print(f"エルボー法により推定された最適なクラスタ数: {elbow_point + 1}")

from sklearn.cluster import KMeans
from sklearn.metrics import silhouette_samples, silhouette_score
import matplotlib.pyplot as plt
import numpy as np

# 先ほどのデータセットを使用
# X, _ = make_blobs(n_samples=300, centers=4, cluster_std=0.60, random_state=0)

# 最適なクラスタ数でK-meansを実行
n_clusters = 4  # エルボー法で決定したクラスタ数
kmeans = KMeans(n_clusters=n_clusters, random_state=0)
cluster_labels = kmeans.fit_predict(X)

# シルエットスコアの計算
silhouette_avg = silhouette_score(X, cluster_labels)
sample_silhouette_values = silhouette_samples(X, cluster_labels)

print(f"全体の平均シルエットスコア: {silhouette_avg:.3f}")

# シルエットプロットの作成
plt.figure(figsize=(12, 8))
y_lower = 10
for i in range(n_clusters):
    ith_cluster_silhouette_values = sample_silhouette_values[cluster_labels == i]
    ith_cluster_silhouette_values.sort()

    size_cluster_i = ith_cluster_silhouette_values.shape[0]
    y_upper = y_lower + size_cluster_i

    color = plt.cm.nipy_spectral(float(i) / n_clusters)
    plt.fill_betweenx(np.arange(y_lower, y_upper),
                      0, ith_cluster_silhouette_values,
                      facecolor=color, edgecolor=color, alpha=0.7)

    plt.text(-0.05, y_lower + 0.5 * size_cluster_i, str(i))
    y_lower = y_upper + 10

plt.title("シルエット分析の結果")
plt.xlabel("シルエットスコア")
plt.ylabel("クラスタラベル")
plt.axvline(x=silhouette_avg, color="red", linestyle="--")
plt.yticks([])  # y軸のラベルを消す
plt.show()

# クラスタリング結果の散布図
plt.figure(figsize=(10, 8))
scatter = plt.scatter(X[:, 0], X[:, 1], c=cluster_labels, cmap='viridis')
centers = kmeans.cluster_centers_
plt.scatter(centers[:, 0], centers[:, 1], c='red', marker='x', s=200, linewidths=3)
plt.title("K-meansクラスタリング結果")
plt.colorbar(scatter, label='クラスタラベル')
plt.show()

import numpy as np
from sklearn.cluster import KMeans

# 大規模なデータセットを想定
X = np.random.rand(1000000, 10)

# サブサンプリング
sample_size = 100000
indices = np.random.choice(X.shape[0], sample_size, replace=False)
X_sampled = X[indices]

# サブサンプルでクラスタリング
kmeans = KMeans(n_clusters=5)
kmeans.fit(X_sampled)

from sklearn.cluster import MiniBatchKMeans

# ミニバッチK-meansの実行
mbkmeans = MiniBatchKMeans(n_clusters=5, batch_size=1000)
mbkmeans.fit(X)

from sklearn.cluster import MiniBatchKMeans
import numpy as np

# 大規模データセットをシミュレート
X = np.random.rand(1000000, 10)

# インクリメンタル学習の設定
mbkmeans = MiniBatchKMeans(n_clusters=5, batch_size=1000)

# バッチサイズ
batch_size = 10000

# インクリメンタル学習の実行
for i in range(0, X.shape[0], batch_size):
    X_batch = X[i:i+batch_size]
    mbkmeans.partial_fit(X_batch)

print("学習完了")

from sklearn.cluster import KMeans

kmeans = KMeans(n_clusters=5, max_iter=1000)  # max_iterを大きく設定
kmeans.fit(X)

kmeans = KMeans(n_clusters=5, init='k-means++')
kmeans.fit(X)

best_kmeans = None
best_inertia = float('inf')

for _ in range(10):  # 10回試行
    kmeans = KMeans(n_clusters=5)
    kmeans.fit(X)
    if kmeans.inertia_ < best_inertia:
        best_inertia = kmeans.inertia_
        best_kmeans = kmeans

print("最良の結果を選択しました")

kmeans = KMeans(n_clusters=5, init='k-means++', n_init=10)
kmeans.fit(X)

import numpy as np
from sklearn.cluster import KMeans
from scipy.stats import mode

def ensemble_kmeans(X, n_clusters, n_runs=10):
    labels_list = []
    for _ in range(n_runs):
        kmeans = KMeans(n_clusters=n_clusters)
        labels = kmeans.fit_predict(X)
        labels_list.append(labels)

    # 最頻値を取ることでアンサンブル
    ensemble_labels = mode(labels_list, axis=0)[0].ravel()
    return ensemble_labels

# アンサンブルK-meansの実行
ensemble_labels = ensemble_kmeans(X, n_clusters=5)
print("アンサンブルクラスタリング完了")

from sklearn.cluster import AgglomerativeClustering, KMeans

# 階層的クラスタリングの実行
hc = AgglomerativeClustering(n_clusters=5)
hc_labels = hc.fit_predict(X)

# 階層的クラスタリングの結果を初期値として使用
kmeans = KMeans(n_clusters=5, init=hc_labels, n_init=1)
kmeans.fit(X)

print("階層的クラスタリングとK-meansの組み合わせ完了")

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

# サンプルのニュース記事データ
news_articles = [
    "The stock market saw significant gains today.",
    "A new study reveals the health benefits of regular exercise.",
    "Tech company launches innovative smartphone with AI capabilities.",
    "Scientists discover a new species in the Amazon rainforest.",
    "Global efforts to combat climate change are intensifying.",
    "Economists predict a strong recovery for the housing market.",
    "Breakthrough in renewable energy technology announced.",
    "Sports team wins championship after an exciting final match.",
    "Medical researchers make progress in cancer treatment.",
    "Political tensions rise as countries disagree on trade policies."
]

# TF-IDFベクトル化
vectorizer = TfidfVectorizer(stop_words='english')
X = vectorizer.fit_transform(news_articles)

# K-meansクラスタリングの実行
n_clusters = 3
kmeans = KMeans(n_clusters=n_clusters, random_state=42)
kmeans.fit(X)

# 結果の可視化（2次元に削減して表示）
from sklearn.decomposition import TruncatedSVD

svd = TruncatedSVD(n_components=2)
X_2d = svd.fit_transform(X)

plt.figure(figsize=(12, 8))
scatter = plt.scatter(X_2d[:, 0], X_2d[:, 1], c=kmeans.labels_, cmap='viridis')
plt.title('ニュース記事のクラスタリング結果')
plt.colorbar(scatter, label='クラスタ')

for i, txt in enumerate(news_articles):
    plt.annotate(f'Article {i+1}', (X_2d[i, 0], X_2d[i, 1]), xytext=(5, 5), 
                 textcoords='offset points', fontsize=8)

plt.show()

# 各クラスタの代表的な単語を表示
print("各クラスタの代表的な単語:")
order_centroids = kmeans.cluster_centers_.argsort()[:, ::-1]
terms = vectorizer.get_feature_names_out()

for i in range(n_clusters):
    print(f"Cluster {i}:")
    for ind in order_centroids[i, :10]:
        print(f" {terms[ind]}", end='')
    print()

import numpy as np
import pandas as pd
from sklearn.cluster import KMeans
from tslearn.preprocessing import TimeSeriesScalerMeanVariance
from tslearn.clustering import TimeSeriesKMeans
import matplotlib.pyplot as plt

# 人工的な株価データの生成
np.random.seed(42)
n_series = 50
n_points = 100

def generate_stock_data(trend, volatility):
    return np.cumsum(trend + np.random.normal(0, volatility, n_points))

stock_data = np.array([generate_stock_data(np.random.uniform(-0.1, 0.1), np.random.uniform(0.5, 1.5)) 
                       for _ in range(n_series)])

# データの正規化
scaler = TimeSeriesScalerMeanVariance(mu=0., std=1.)
stock_data_scaled = scaler.fit_transform(stock_data)

# 時系列K-meansクラスタリングの実行
n_clusters = 3
tskm = TimeSeriesKMeans(n_clusters=n_clusters, metric="dtw", random_state=42)
labels = tskm.fit_predict(stock_data_scaled)

# 結果の可視化
plt.figure(figsize=(15, 10))
for i in range(n_clusters):
    cluster = stock_data_scaled[labels == i]
    for series in cluster:
        plt.plot(series.ravel(), alpha=0.4, color=f'C{i}')
    plt.plot(tskm.cluster_centers_[i].ravel(), linewidth=2, color=f'C{i}', label=f'Cluster {i} Center')

plt.title('株価時系列データのクラスタリング結果')
plt.legend()
plt.show()

# クラスタごとの株価の特徴を分析
for i in range(n_clusters):
    cluster = stock_data[labels == i]
    mean_return = np.mean([np.mean(np.diff(series)) for series in cluster])
    volatility = np.mean([np.std(np.diff(series)) for series in cluster])
    print(f"Cluster {i}:")
    print(f"  平均リターン: {mean_return:.4f}")
    print(f"  平均ボラティリティ: {volatility:.4f}")

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

# 画像の読み込み
image = io.imread('path_to_your_image.jpg')  # 適切な画像パスに変更してください
image = image / 255.0  # 正規化

# 画像データの整形
h, w, d = image.shape
image_array = np.reshape(image, (h * w, d))

# K-meansクラスタリングの実行
n_clusters = 5
kmeans = KMeans(n_clusters=n_clusters, random_state=42)
labels = kmeans.fit_predict(image_array)

# セグメンテーション結果の生成
segmented_image = kmeans.cluster_centers_[labels]
segmented_image = np.reshape(segmented_image, (h, w, d))

# 結果の可視化
fig, axes = plt.subplots(1, 2, figsize=(15, 7))
axes[0].imshow(image)
axes[0].set_title('Original Image')
axes[0].axis('off')
axes[1].imshow(segmented_image)
axes[1].set_title('Segmented Image')
axes[1].axis('off')
plt.show()

# 各セグメントの色情報を表示
print("各セグメントの代表色 (RGB):")
for i, color in enumerate(kmeans.cluster_centers_):
    print(f"Segment {i}: R={color[0]:.2f}, G={color[1]:.2f}, B={color[2]:.2f}")