机器学习十大算法的 Python 代码示例，我们将使用常见的scikit-learn库来实现，数据集使用鸢尾花数据集。

1. 决策树算法（Decision Tree）

from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.tree import DecisionTreeClassifier
from sklearn.metrics import accuracy_score

# 加载数据集
iris = load_iris()
X = iris.data
y = iris.target

# 划分训练集和测试集
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)

# 创建决策树分类器
clf = DecisionTreeClassifier()
clf.fit(X_train, y_train)

# 预测
y_pred = clf.predict(X_test)

# 计算准确率
accuracy = accuracy_score(y_test, y_pred)
print(f"决策树准确率: {accuracy}")

2. 朴素贝叶斯算法（Naive Bayes）

from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.naive_bayes import GaussianNB
from sklearn.metrics import accuracy_score

# 加载数据集
iris = load_iris()
X = iris.data
y = iris.target

# 划分训练集和测试集
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)

# 创建朴素贝叶斯分类器
clf = GaussianNB()
clf.fit(X_train, y_train)

# 预测
y_pred = clf.predict(X_test)

# 计算准确率
accuracy = accuracy_score(y_test, y_pred)
print(f"朴素贝叶斯准确率: {accuracy}")

3. 支持向量机（Support Vector Machine，SVM）

from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.svm import SVC
from sklearn.metrics import accuracy_score

# 加载数据集
iris = load_iris()
X = iris.data
y = iris.target

# 划分训练集和测试集
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)

# 创建 SVM 分类器
clf = SVC()
clf.fit(X_train, y_train)

# 预测
y_pred = clf.predict(X_test)

# 计算准确率
accuracy = accuracy_score(y_test, y_pred)
print(f"SVM 准确率: {accuracy}")

4. K 近邻算法（K – Nearest Neighbor，KNN）

from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.neighbors import KNeighborsClassifier
from sklearn.metrics import accuracy_score

# 加载数据集
iris = load_iris()
X = iris.data
y = iris.target

# 划分训练集和测试集
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)

# 创建 KNN 分类器
clf = KNeighborsClassifier()
clf.fit(X_train, y_train)

# 预测
y_pred = clf.predict(X_test)

# 计算准确率
accuracy = accuracy_score(y_test, y_pred)
print(f"KNN 准确率: {accuracy}")

5. 逻辑回归（Logistic Regression）

from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import accuracy_score

# 加载数据集
iris = load_iris()
X = iris.data
y = iris.target

# 划分训练集和测试集
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)

# 创建逻辑回归分类器
clf = LogisticRegression(max_iter=1000)
clf.fit(X_train, y_train)

# 预测
y_pred = clf.predict(X_test)

# 计算准确率
accuracy = accuracy_score(y_test, y_pred)
print(f"逻辑回归准确率: {accuracy}")

6. 随机森林算法（Random Forest）

from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import accuracy_score

# 加载数据集
iris = load_iris()
X = iris.data
y = iris.target

# 划分训练集和测试集
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)

# 创建随机森林分类器
clf = RandomForestClassifier()
clf.fit(X_train, y_train)

# 预测
y_pred = clf.predict(X_test)

# 计算准确率
accuracy = accuracy_score(y_test, y_pred)
print(f"随机森林准确率: {accuracy}")

7. 梯度提升树（Gradient Boosting Decision Tree，GBDT）

from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.ensemble import GradientBoostingClassifier
from sklearn.metrics import accuracy_score

# 加载数据集
iris = load_iris()
X = iris.data
y = iris.target

# 划分训练集和测试集
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)

# 创建 GBDT 分类器
clf = GradientBoostingClassifier()
clf.fit(X_train, y_train)

# 预测
y_pred = clf.predict(X_test)

# 计算准确率
accuracy = accuracy_score(y_test, y_pred)
print(f"GBDT 准确率: {accuracy}")

8. K – 均值聚类算法（K – Means Clustering）

from sklearn.datasets import load_iris
from sklearn.cluster import KMeans
import matplotlib.pyplot as plt

# 加载数据集
iris = load_iris()
X = iris.data

# 创建 KMeans 聚类器
kmeans = KMeans(n_clusters=3, random_state=42)
kmeans.fit(X)

# 获取聚类标签
labels = kmeans.labels_

# 可视化聚类结果（取前两个特征）
plt.scatter(X[:, 0], X[:, 1], c=labels, cmap='viridis')
centers = kmeans.cluster_centers_
plt.scatter(centers[:, 0], centers[:, 1], c='red', marker='X', s=200)
plt.title('K - Means Clustering')
plt.xlabel('Sepal length')
plt.ylabel('Sepal width')
plt.show()

9. 主成分分析（Principal Component Analysis，PCA）

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

# 加载数据集
iris = load_iris()
X = iris.data

# 创建 PCA 对象，降维到 2 维
pca = PCA(n_components=2)
X_pca = pca.fit_transform(X)

# 可视化降维后的数据
plt.scatter(X_pca[:, 0], X_pca[:, 1], c=iris.target, cmap='viridis')
plt.title('PCA of Iris Dataset')
plt.xlabel('Principal Component 1')
plt.ylabel('Principal Component 2')
plt.show()

10. AdaBoost 算法（Adaptive Boosting）

from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.ensemble import AdaBoostClassifier
from sklearn.metrics import accuracy_score

# 加载数据集
iris = load_iris()
X = iris.data
y = iris.target

# 划分训练集和测试集
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)

# 创建 AdaBoost 分类器
clf = AdaBoostClassifier()
clf.fit(X_train, y_train)

# 预测
y_pred = clf.predict(X_test)

# 计算准确率
accuracy = accuracy_score(y_test, y_pred)
print(f"AdaBoost 准确率: {accuracy}")

这些代码示例展示了如何使用scikit-learn库实现机器学习十大算法，并在鸢尾花数据集上进行简单的训练和测试。你可以根据实际需求调整参数和使用其他数据集。

K-Means 是一种无监督学习算法，用于将数据点划分为 k 个不同的簇。下面是使用 PyTorch 实现 K-Means 算法的代码示例：

import torch

def kmeans(X, k, max_iter=100):
    """
    K-Means 算法的 PyTorch 实现

    参数:
    X (torch.Tensor): 输入数据，形状为 (n_samples, n_features)
    k (int): 簇的数量
    max_iter (int): 最大迭代次数

    返回:
    torch.Tensor: 每个数据点所属的簇的索引
    torch.Tensor: 每个簇的中心点
    """
    # 随机初始化中心点
    n_samples, n_features = X.shape
    indices = torch.randperm(n_samples)[:k]
    centroids = X[indices]

    for _ in range(max_iter):
        # 计算每个数据点到每个中心点的距离
        distances = torch.cdist(X, centroids)

        # 找到每个数据点最近的中心点
        labels = torch.argmin(distances, dim=1)

        # 更新中心点
        new_centroids = torch.zeros(k, n_features, dtype=X.dtype, device=X.device)
        for i in range(k):
            cluster_points = X[labels == i]
            if len(cluster_points) > 0:
                new_centroids[i] = torch.mean(cluster_points, dim=0)
            else:
                # 如果某个簇为空，重新随机初始化该中心点
                new_centroids[i] = X[torch.randint(0, n_samples, (1,))]

        # 判断是否收敛
        if torch.allclose(centroids, new_centroids):
            break

        centroids = new_centroids

    return labels, centroids

你可以使用以下方式调用这个函数：

# 生成一些示例数据
n_samples = 100
n_features = 2
X = torch.randn(n_samples, n_features)

# 运行 K-Means 算法
k = 3
labels, centroids = kmeans(X, k)

print("每个数据点所属的簇的索引:", labels)
print("每个簇的中心点:", centroids)

代码解释：

1. 初始化中心点：从输入数据中随机选择 k 个点作为初始中心点。
2. 迭代更新：
   • 计算每个数据点到每个中心点的距离。
   • 找到每个数据点最近的中心点，并将其分配到该簇。
   • 更新每个簇的中心点，即计算该簇中所有数据点的平均值。
3. 收敛判断：如果中心点不再发生变化，则认为算法收敛，停止迭代。

注意事项：

• 该实现使用欧几里得距离来计算数据点之间的距离。
• 如果某个簇为空，我们重新随机初始化该簇的中心点，以避免出现中心点为零向量的情况。

K近邻（K-Nearest Neighbors，KNN）算法是一种基本的分类与回归方法。下面分别给出KNN分类和KNN回归的Python实例代码。

1. KNN分类实例

我们将使用scikit-learn库中的鸢尾花数据集进行KNN分类。

from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.neighbors import KNeighborsClassifier
from sklearn.metrics import accuracy_score

# 加载鸢尾花数据集
iris = load_iris()
X = iris.data  # 特征数据
y = iris.target  # 标签数据

# 划分训练集和测试集
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)

# 创建KNN分类器，这里k值设为5
knn = KNeighborsClassifier(n_neighbors=5)

# 训练模型
knn.fit(X_train, y_train)

# 进行预测
y_pred = knn.predict(X_test)

# 计算准确率
accuracy = accuracy_score(y_test, y_pred)
print(f"KNN分类准确率: {accuracy}")

代码解释：

1. 数据加载：使用load_iris函数加载鸢尾花数据集。
2. 数据划分：使用train_test_split函数将数据集划分为训练集和测试集，测试集占比为30%。
3. 模型创建：使用KNeighborsClassifier创建KNN分类器，n_neighbors参数指定K值为5。
4. 模型训练：使用fit方法对训练数据进行训练。
5. 模型预测：使用predict方法对测试数据进行预测。
6. 准确率计算：使用accuracy_score函数计算预测结果的准确率。

2. KNN回归实例

我们将使用scikit-learn库中的波士顿房价数据集进行KNN回归。

from sklearn.datasets import load_boston
from sklearn.model_selection import train_test_split
from sklearn.neighbors import KNeighborsRegressor
from sklearn.metrics import mean_squared_error

# 加载波士顿房价数据集
boston = load_boston()
X = boston.data  # 特征数据
y = boston.target  # 标签数据

# 划分训练集和测试集
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)

# 创建KNN回归器，这里k值设为5
knn_reg = KNeighborsRegressor(n_neighbors=5)

# 训练模型
knn_reg.fit(X_train, y_train)

# 进行预测
y_pred = knn_reg.predict(X_test)

# 计算均方误差
mse = mean_squared_error(y_test, y_pred)
print(f"KNN回归均方误差: {mse}")

代码解释：

1. 数据加载：使用load_boston函数加载波士顿房价数据集。
2. 数据划分：使用train_test_split函数将数据集划分为训练集和测试集，测试集占比为30%。
3. 模型创建：使用KNeighborsRegressor创建KNN回归器，n_neighbors参数指定K值为5。
4. 模型训练：使用fit方法对训练数据进行训练。
5. 模型预测：使用predict方法对测试数据进行预测。
6. 均方误差计算：使用mean_squared_error函数计算预测结果的均方误差。

需要注意的是，波士顿房价数据集在scikit-learn 1.2及以上版本中已被移除，如果你使用的是较新版本，可以使用fetch_california_housing数据集代替。