机器学习KNN与kmeans算法易混淆？一文来帮你分清楚!

import numpy as np
from collections import Counter

class KNN:
    def __init__(self, k=3):
        self.k = k
        
    def fit(self, X, y):
        self.X_train = X
        self.y_train = y
        
    def predict(self, X):
        predictions = [self._predict(x) for x in X]
        return predictions
        
    def _predict(self, x):
        # 计算距离
        distances = [np.linalg.norm(x - x_train) for x_train in self.X_train]
        # 获取最近的K个样本的索引
        k_indices = np.argsort(distances)[:self.k]
        # 获取这些样本的标签
        k_nearest_labels = [self.y_train[i] for i in k_indices]
        # 多数投票
        most_common = Counter(k_nearest_labels).most_common(1)
        return most_common[0][0]

import numpy as np
class kmeans:
    def __init__(self, k=3, max_iters=100):
        self.k = k
        self.max_iters = max_iters
        self.centroids = None
        self.clusters = None
        
    def fit(self, X):
        # 初始化质心
        self.centroids = self._initialize_centroids(X)
        
        for _ in range(self.max_iters):
            # 分配样本到最近的质心
            self.clusters = self._create_clusters(X, self.centroids)
            # 更新质心
            prev_centroids = self.centroids
            self.centroids = self._get_new_centroids(X, self.clusters)
            
            # 检查是否收敛
            if self._is_converged(prev_centroids, self.centroids):
                break
        
    def _initialize_centroids(self, X):
        # 随机选择K个样本作为初始质心
        indices = np.random.choice(len(X), size=self.k, replace=False)
        return X[indices]
        
    def _create_clusters(self, X, centroids):
        clusters = [[] for _ in range(self.k)]
        
        for idx, sample in enumerate(X):
            centroid_idx = self._closest_centroid(sample, centroids)
            clusters[centroid_idx].append(idx)
            
        return clusters
        
    def _closest_centroid(self, sample, centroids):
        distances = [np.linalg.norm(sample - c) for c in centroids]
        closest_idx = np.argmin(distances)
        return closest_idx
        
    def _get_new_centroids(self, X, clusters):
        centroids = np.zeros((self.k, X.shape[1]))
        
        for idx, cluster in enumerate(clusters):
            cluster_mean = np.mean(X[cluster], axis=0)
            centroids[idx] = cluster_mean
            
        return centroids
        
    def _is_converged(self, prev_centroids, centroids):
        distances = [np.linalg.norm(prev_centroids[i] - centroids[i]) for i in range(self.k)]
        return sum(distances) == 0

import matplotlib.pyplot as plt
from sklearn.datasets import make_blobs
from knn import KNN
from kmeans import kmeans

# 生成模拟数据
X, y = make_blobs(n_samples=300, centers=4, random_state=42)

# KNN可视化
plt.figure(figsize=(12, 5))

plt.subplot(1, 2, 1)
knn = KNN(k=3)
knn.fit(X, y)
y_pred = knn.predict(X)
plt.scatter(X[:, 0], X[:, 1], c=y_pred, cmap='viridis', s=50)
plt.title('KNN Classification Results')

# kmeans可视化
plt.subplot(1, 2, 2)
kmeans = kmeans(k=4)
kmeans.fit(X)
plt.scatter(X[:, 0], X[:, 1], c=kmeans.clusters, cmap='viridis', s=50)
plt.scatter(kmeans.centroids[:, 0], kmeans.centroids[:, 1], c='red', s=200, marker='X')
plt.title('kmeans Clustering Results')

plt.tight_layout()
plt.show()