不愧是腾讯，细节太全面。。。

import torch

def kmeans(data, k, max_iters=100):
    # 随机初始化聚类中心
    centroids = data[torch.randperm(data.size(0))[:k]]
    
    for _ in range(max_iters):
        # 分配步骤
        distances = torch.cdist(data, centroids)
        cluster_assignments = torch.argmin(distances, dim=1)
        
        # 更新聚类中心
        for i in range(k):
            cluster_points = data[cluster_assignments == i]
            if len(cluster_points) > 0:
                centroids[i] = cluster_points.mean(dim=0)
    
    return cluster_assignments, centroids

# 生成示例数据
data = torch.randn(100, 2)

# 设置聚类数量K
k = 3

# 运行K-means算法
cluster_assignments, centroids = kmeans(data, k)

# 打印聚类中心
print("聚类中心：", centroids)

import torch
import torch.nn as nn
import torch.optim as optim
import matplotlib.pyplot as plt
import numpy as np

# 生成一些随机的线性可分数据
np.random.seed(0)
X = np.random.randn(300, 2)
Y = np.random.choice([-1, 1], size=(300,))
X[Y == 1] += 1

# 将数据转换为PyTorch张量
X = torch.tensor(X, dtype=torch.float32)
Y = torch.tensor(Y, dtype=torch.float32)

# 定义线性SVM模型
class LinearSVM(nn.Module):
    def __init__(self):
        super(LinearSVM, self).__init__()
        self.fc = nn.Linear(2, 1)

    def forward(self, x):
        return self.fc(x)

# 定义训练函数
def train_model(model, criterion, optimizer, num_epochs=1000):
    for epoch in range(num_epochs):
        optimizer.zero_grad()
        outputs = model(X).squeeze()
        loss = criterion(outputs, Y)
        loss.backward()
        optimizer.step()
        if (epoch+1) % 100 == 0:
            print(f'Epoch [{epoch+1}/{num_epochs}], Loss: {loss.item():.4f}')

# 初始化模型、损失函数和优化器
model = LinearSVM()
criterion = nn.HingeEmbeddingLoss(margin=1.0)
optimizer = optim.SGD(model.parameters(), lr=0.01)

# 训练模型
train_model(model, criterion, optimizer)

# 绘制决策边界
w = model.fc.weight.detach().numpy().flatten()
b = model.fc.bias.detach().numpy().flatten()

plt.scatter(X[:, 0], X[:, 1], c=Y.numpy())
plt.xlabel('X1')
plt.ylabel('X2')

x1 = np.linspace(-3, 3, 100)
x2 = (-w[0] * x1 - b) / w[1]
plt.plot(x1, x2, '-r', label='Decision Boundary')
plt.legend()
plt.show()

import torch
import torch.nn as nn
import torch.optim as optim
import numpy as np
import matplotlib.pyplot as plt

# 生成环形数据集
def generate_data(num_samples):
    theta = np.random.uniform(0, 2*np.pi, num_samples)
    r = 2 + np.random.randn(num_samples)
    x1 = r * np.cos(theta)
    x2 = r * np.sin(theta)
    X = np.vstack((x1, x2)).T
    y = np.where(r < 2, 0, 1)
    return X, y

# 定义RBF核函数
def rbf_kernel(X1, X2, sigma=1):
    dist_sq = np.sum(X1**2, axis=1, keepdims=True) + np.sum(X2**2, axis=1) - 2 * np.dot(X1, X2.T)
    return np.exp(-dist_sq / (2 * sigma**2))

# SVM模型
class SVM(nn.Module):
    def __init__(self, input_dim):
        super(SVM, self).__init__()
        self.input_dim = input_dim
        self.fc = nn.Linear(input_dim, 1)

    def forward(self, x):
        return self.fc(x)

# 训练SVM模型
def train_svm(X_train, y_train, kernel_func, lr=0.01, num_epochs=1000):
    device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
    X_train = torch.tensor(X_train, dtype=torch.float32, device=device)
    y_train = torch.tensor(y_train, dtype=torch.float32, device=device).view(-1, 1)

    model = SVM(X_train.shape[1]).to(device)
    criterion = nn.HingeEmbeddingLoss()
    optimizer = optim.SGD(model.parameters(), lr=lr)

    for epoch in range(num_epochs):
        optimizer.zero_grad()
        outputs = model(X_train).squeeze()
        loss = criterion(outputs, y_train)
        loss.backward()
        optimizer.step()

        if (epoch+1) % 100 == 0:
            print(f'Epoch [{epoch+1}/{num_epochs}], Loss: {loss.item():.4f}')

    return model

# 画出决策边界
def plot_decision_boundary(X, y, model):
    plt.figure(figsize=(8, 6))
    plt.scatter(X[:, 0], X[:, 1], c=y, cmap=plt.cm.RdBu, marker='o', edgecolors='k', s=100)
    plt.xlabel('X1')
    plt.ylabel('X2')

    x1_min, x1_max = X[:, 0].min() - 1, X[:, 0].max() + 1
    x2_min, x2_max = X[:, 1].min() - 1, X[:, 1].max() + 1
    xx1, xx2 = np.meshgrid(np.arange(x1_min, x1_max, 0.1), np.arange(x2_min, x2_max, 0.1))
    Z = model(torch.tensor(np.c_[xx1.ravel(), xx2.ravel()], dtype=torch.float32)).detach().numpy().reshape(xx1.shape)
    plt.contour(xx1, xx2, Z, levels=[-1, 0, 1], colors='k', linestyles=['--', '-', '--'])
    plt.title('Decision Boundary')
    plt.show()

# 生成数据
X_train, y_train = generate_data(200)

# 使用RBF核函数的SVM模型进行训练
model = train_svm(X_train, y_train, rbf_kernel)

# 画出决策边界
plot_decision_boundary(X_train, y_train, model)

import torch
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 = torch.tensor(iris.data)
y = torch.tensor(iris.target)

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

# 定义决策树分类器
class DecisionTree:
    def __init__(self, max_depth=None):
        self.model = DecisionTreeClassifier(max_depth=max_depth)

    def fit(self, X, y):
        self.model.fit(X, y)

    def predict(self, X):
        return self.model.predict(X)

# 实例化决策树分类器并进行训练
dt = DecisionTree(max_depth=3)  # 设置最大深度为3，进行预剪枝
dt.fit(X_train, y_train)

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

# 计算准确率
accuracy = accuracy_score(y_test, y_pred)
print("预剪枝决策树的准确率:", accuracy)

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

# 创建一个合成的数据集
X, _ = make_blobs(n_samples=300, centers=4, cluster_std=0.60, random_state=0)

# 使用层次聚类算法
agglomerative = AgglomerativeClustering(n_clusters=4)
clusters = agglomerative.fit_predict(X)

# 可视化聚类结果
plt.scatter(X[:, 0], X[:, 1], c=clusters, cmap='viridis', alpha=0.5)
plt.title('Hierarchical Clustering')
plt.xlabel('X1')
plt.ylabel('X2')
plt.show()

import numpy as np
from sklearn.linear_model import LinearRegression
import matplotlib.pyplot as plt

# 生成一些随机数据作为示例
np.random.seed(0)
X = 2 * np.random.rand(1000, 1)
y = 4 + 3 * X + np.random.randn(1000, 1)

# 使用sklearn中的线性回归模型
lin_reg = LinearRegression()
lin_reg.fit(X, y)

# 打印模型系数
print("Intercept:", lin_reg.intercept_)
print("Coefficient:", lin_reg.coef_)

# 绘制数据和拟合直线
plt.scatter(X, y)
plt.plot(X, lin_reg.predict(X), color='red')
plt.xlabel('X')
plt.ylabel('y')
plt.title('Linear Regression')
plt.show()

import numpy as np
from sklearn.linear_model import LogisticRegression
import matplotlib.pyplot as plt

# 生成一些随机数据作为示例
np.random.seed(0)
X = 2 * np.random.rand(100, 1)
y = (X > 1).astype(int).reshape(-1)

# 使用sklearn中的逻辑回归模型
log_reg = LogisticRegression()
log_reg.fit(X, y)

# 打印模型系数
print("Intercept:", log_reg.intercept_)
print("Coefficient:", log_reg.coef_)

# 绘制数据和决策边界
plt.scatter(X, y)
plt.plot(np.sort(X, axis=0), log_reg.predict_proba(np.sort(X, axis=0))[:, 1], color='red')
plt.xlabel('X')
plt.ylabel('Probability of y=1')
plt.title('Logistic Regression')
plt.show()

from sklearn.ensemble import RandomForestClassifier, GradientBoostingClassifier
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score

# 生成一些示例数据
X, y = make_classification(n_samples=1000, n_features=20, random_state=42)

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

# 使用随机森林进行训练和预测
rf_clf = RandomForestClassifier(n_estimators=100, random_state=42)
rf_clf.fit(X_train, y_train)
rf_preds = rf_clf.predict(X_test)
rf_accuracy = accuracy_score(y_test, rf_preds)
print("Random Forest Accuracy:", rf_accuracy)

# 使用梯度提升树进行训练和预测
gb_clf = GradientBoostingClassifier(n_estimators=100, random_state=42)
gb_clf.fit(X_train, y_train)
gb_preds = gb_clf.predict(X_test)
gb_accuracy = accuracy_score(y_test, gb_preds)
print("Gradient Boosting Accuracy:", gb_accuracy)

import numpy as np

class LinearRegression:
    def __init__(self, learning_rate=0.01, n_iterations=1000):
        self.learning_rate = learning_rate
        self.n_iterations = n_iterations
        self.weights = None
        self.bias = None

    def fit(self, X, y):
        n_samples, n_features = X.shape
        self.weights = np.zeros(n_features)
        self.bias = 0

        for _ in range(self.n_iterations):
            y_predicted = np.dot(X, self.weights) + self.bias

            # 计算损失函数的梯度
            dw = (1 / n_samples) * np.dot(X.T, (y_predicted - y))
            db = (1 / n_samples) * np.sum(y_predicted - y)

            # 更新参数
            self.weights -= self.learning_rate * dw
            self.bias -= self.learning_rate * db

    def predict(self, X):
        return np.dot(X, self.weights) + self.bias