榨干算力！腾讯云HAI-CPU+DEEPSEEK的高吞吐训练配置秘籍

import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import LogTransform, PCA
from sklearn.feature_selection import RandomizedLasso
from sklearn.tree import DecisionTreeClassifier
import matplotlib.pyplot as plt
import itertools

# 读取数据集并进行预处理
data = np.load('data.npy')
X = data[:, :-1]
y = data[:, -1]

# 特征选择和标准化
selected_features = list(range(len(X)))
rlasso = RandomizedLasso randomly_mask=0.5, fit=False)
selected_features = list(rlasso.fit_transform(X).nonzeroIndices())
X = X[:, selected_features]
X_train, X_test, y_train, y_test = train_test_split(
    X, y,
    test_size=0.2,
    random_state=42
)
log_transformer = LogTransform()
X_train = log_transformer.fit_transform(X_train)
X_test = log_transformer.transform(X_test)

# 决策树实现
class DecisionTree:
    def __init__(self, X, y, max_depth=10):
        self.X = X
        self.y = y
        self.max_depth = max_depth
        self.root = None

    def build_tree(self, node, index=0):
        if node is None:
            return None
        # 当前节点的特征和对应的值
        current_features = self.X[node]
        current_labels = self.y[node]
        if np.all_equal(current_labels):
            node.is_leaf = True
            node.label = current_labels[0]
            return node
        # 选择最优特征进行分割
        best_feature, best_split = self.select_best_feature(node, index)
        node.feature = best_feature
        mid = np.split(current_features, best_split)
        node.left = self.build_tree(mid[0], index +1)
        node.right = self.build_tree(mid[1], index+1)

    def select_best_feature(self, node, index):
        features = list(range(len(self.X)))
        importances = []
        for i in range(index +1, len(features)):
            if node is not None and hasattr(node, 'importance'):
                importances.append((features[i], node.importance))
            else:
                break
        # 选择增益最大的特征
        max_info = -np.inf
        best_feature = None
        for f, imp in importances:
            if imp > max_info:
                max_info = imp
                best_feature = f
        split = np.find_split(self.X[node], best_feature)
        return best_feature, split

    def predict(self, X):
        node = self.root
        if node is None:
            return 0
        while node.feature is not None:
            # 特征对应的值
            value = X[node.feature]
            if node.is_leaf:
                return int(node.label)
            if value <= node.split[0]:
                node = node.left
            else:
                node = node.right
        return 0

# 初始化模型
dt_model = DecisionTree(X_train, y_train)

# 训练树结构
for i in range(dt_model.max_depth):
    print(f"正在构建第 {i+1} 层的树...")
    dt_model.build_tree(dt_model.root, i)

# 预测测试集
y_pred = dt_model.predict(X_test)
print("预测结果:", y_pred[:10])

# 评估模型性能
from sklearn.metrics import accuracy_score, roc_curve

y_true = np.argmax(y_test, axis=1)
accuracy = accuracy_score(y_true[:100], y_pred[:100])
print(f"准确率: {accuracy:.4f}")

# 绘制决策树结构图（示例简化）
def draw_tree(node):
    if node is None:
        return
    children = []
    for child in [node.left, node.right]:
        if child is not None:
            children.append(child)
    if len(children) == 0:
        continue
    # 绘制节点
    plt.text(node.feature + 5, node.split[0] - 0.5,
             f"特征={node.feature}, 值分割点={node.split[0]:.2f}")
    draw_tree(node.left)
    draw_tree(node.right)

draw_tree(dt_model.root)
plt.show()