使用Python编写心脏病预测的代码，要求自己编写决策树和随机森林算法来实现这段代码不能导入sklearn库

好的，如果不使用sklearn库，你可以手动实现决策树和随机森林算法，以下是参考代码：

1. 决策树算法实现

# 定义节点类
class Node:
    def __init__(self, feature=None, threshold=None, left=None, right=None, value=None):
        self.feature = feature   # 划分属性
        self.threshold = threshold   # 划分阈值
        self.left = left   # 左子树
        self.right = right   # 右子树
        self.value = value   # 叶节点值

# 定义决策树类
class DecisionTree:
    def __init__(self, max_depth=None, min_samples_split=2, min_samples_leaf=1):
        self.max_depth = max_depth   # 树的最大深度
        self.min_samples_split = min_samples_split   # 内部节点分裂所需最小样本数
        self.min_samples_leaf = min_samples_leaf   # 叶节点所需最小样本数
        self.root = None   # 决策树根节点

    # 计算基尼指数
    def _gini(self, y):
        _, counts = np.unique(y, return_counts=True)
        proportions = counts / len(y)
        return 1 - np.sum(proportions ** 2)

    # 计算条件基尼指数
    def _conditional_gini(self, X, y, feature, threshold):
        left_idx = X[:, feature] < threshold
        left_y = y[left_idx]
        right_y = y[~left_idx]
        left_gini = self._gini(left_y)
        right_gini = self._gini(right_y)
        left_prop = len(left_y) / len(y)
        right_prop = len(right_y) / len(y)
        return left_prop * left_gini + right_prop * right_gini

    # 选择最优划分属性和阈值
    def _best_split(self, X, y):
        best_feature, best_threshold, best_score = None, None, np.inf
        for feature in range(X.shape[1]):
            thresholds = np.unique(X[:, feature])
            for threshold in thresholds:
                score = self._conditional_gini(X, y, feature, threshold)
                if score < best_score:
                    best_feature, best_threshold, best_score = feature, threshold, score
        return best_feature, best_threshold

    # 递归构建决策树
    def _build_tree(self, X, y, depth):
        if depth == 0 or len(y) < self.min_samples_split or np.unique(y).shape[0] == 1:
            return Node(value=np.mean(y))
        feature, threshold = self._best_split(X, y)
        if self._conditional_gini(X, y, feature, threshold) == np.inf:
            return Node(value=np.mean(y))
        left_idx = X[:, feature] < threshold
        right_idx = X[:, feature] >= threshold
        left = self._build_tree(X[left_idx], y[left_idx], depth - 1)
        right = self._build_tree(X[right_idx], y[right_idx], depth - 1)
        return Node(feature, threshold, left, right)

    # 训练决策树
    def fit(self, X, y):
        self.root = self._build_tree(X, y, self.max_depth)

    # 预测单个样本
    def _predict_one(self, x, node):
        if node.value is not None:
            return node.value
        if x[node.feature] < node.threshold:
            return self._predict_one(x, node.left)
        else:
            return self._predict_one(x, node.right)

    # 预测多个样本
    def predict(self, X):
        return np.array([self._predict_one(x, self.root) for x in X])

2. 随机森林算法实现

# 定义随机森林类
class RandomForest:
    def __init__(self, n_estimators=100, max_depth=None, min_samples_split=2, min_samples_leaf=1, max_features=None):
        self.n_estimators = n_estimators   # 决策树个数
        self.max_depth = max_depth   # 树的最大深度
        self.min_samples_split = min_samples_split   # 内部节点分裂所需最小样本数
        self.min_samples_leaf = min_samples_leaf   # 叶节点所需最小样本数
        self.max_features = max_features   # 每棵决策树使用的最大特征数
        self.trees = []   # 决策树集合

    # 训练随机森林
    def fit(self, X, y):
        n_features = X.shape[1]
        if self.max_features is None:
            self.max_features = int(np.sqrt(n_features))
        for _ in range(self.n_estimators):
            indices = np.random.choice(n_features, self.max_features, replace=False)
            tree = DecisionTree(max_depth=self.max_depth, min_samples_split=self.min_samples_split, min_samples_leaf=self.min_samples_leaf)
            tree.fit(X[:, indices], y)
            self.trees.append((indices, tree))

    # 预测单个样本
    def _predict_one(self, x):
        predictions = []
        for indices, tree in self.trees:
            prediction = tree.predict(x[indices].reshape(1, -1))[0]
            predictions.append(prediction)
        return np.mean(predictions)

    # 预测多个样本
    def predict(self, X):
        return np.array([self._predict_one(x) for x in X])

以上就是手动实现决策树和随机森林算法的代码，希望对你有所帮助！