c45决策树算法python

C4.5决策树算法是一种基于信息增益的分类算法，由Ross Quinlan在ID3基础上发展而来。它通过计算属性对数据集划分的信息增益或信息增益比，选择最优属性作为当前节点的分裂依据，递归地构建决策树。

在Python中，你可以使用scikit-learn库来实现C4.5决策树。以下是一个简单的例子：

from sklearn.tree import DecisionTreeClassifier
import pandas as pd

# 假设你已经有了一个DataFrame 'data'，其中包含特征列和目标列
X = data.iloc[:, :-1]  # 特征
y = data.iloc[:, -1]   # 目标变量

# 创建并训练C4.5决策树模型
clf = DecisionTreeClassifier(criterion='gini', splitter='best')  # 'gini' 是信息熵的一种变体
clf.fit(X, y)

# 对新的数据进行预测
new_data = ...  # 新的数据点
prediction = clf.predict(new_data)

相关问题

c45决策树算法python实现

决策树是一种常用的分类算法，其中C4.5决策树算法是决策树的一种改进算法。下面是一个基于Python的C4.5决策树算法的实现示例：

首先，我们需要定义一个节点类，用于存储每个节点的信息和属性。

class Node:
    def __init__(self, attribute=None, threshold=None, label=None, left=None, right=None):
        self.attribute = attribute  # 属性名
        self.threshold = threshold  # 划分阈值
        self.label = label  # 叶子节点的类别
        self.left = left  # 左子节点
        self.right = right  # 右子节点

然后，我们需要定义一个C4.5决策树算法类，其中包含以下方法：

1. `__init__`：初始化决策树模型。
2. `entropy`：计算数据集的熵。
3. `conditional_entropy`：计算数据集在某个属性上的条件熵。
4. `information_gain`：计算信息增益。
5. `majority_vote`：统计数据集中出现最多的类别。
6. `build_tree`：构建决策树。
7. `predict`：预测新样本的类别。

import numpy as np
from collections import Counter

class C45DecisionTree:
    def __init__(self, max_depth=5, min_samples_split=2):
        self.max_depth = max_depth  # 最大深度
        self.min_samples_split = min_samples_split  # 最小分割样本数
       
    def entropy(self, y):
        """计算数据集的熵"""
        counter = Counter(y)
        probs = [count / len(y) for count in counter.values()]
        return -sum(p * np.log2(p) for p in probs)
    
    def conditional_entropy(self, X, y, feature_idx, threshold):
        """计算数据集在某个属性上的条件熵"""
        left_mask = X[:, feature_idx] < threshold
        right_mask = X[:, feature_idx] >= threshold
        left_probs = len(y[left_mask]) / len(y)
        right_probs = len(y[right_mask]) / len(y)
        left_entropy = self.entropy(y[left_mask])
        right_entropy = self.entropy(y[right_mask])
        return left_probs * left_entropy + right_probs * right_entropy
    
    def information_gain(self, X, y, feature_idx, threshold):
        """计算信息增益"""
        parent_entropy = self.entropy(y)
        child_entropy = self.conditional_entropy(X, y, feature_idx, threshold)
        return parent_entropy - child_entropy
    
    def majority_vote(self, y):
        """统计数据集中出现最多的类别"""
        counter = Counter(y)
        most_common = counter.most_common(1)
        return most_common[0][0]
    
    def build_tree(self, X, y, depth=0):
        """构建决策树"""
        # 判断是否达到最大深度或最小分割样本数
        if depth >= self.max_depth or len(y) < self.min_samples_split:
            return Node(label=self.majority_vote(y))
        
        n_features = X.shape[1]
        best_feature, best_threshold, best_gain = None, None, 0
        for feature_idx in range(n_features):
            # 计算每个属性的信息增益
            thresholds = np.unique(X[:, feature_idx])
            for threshold in thresholds:
                gain = self.information_gain(X, y, feature_idx, threshold)
                if gain > best_gain:
                    best_feature, best_threshold, best_gain = feature_idx, threshold, gain
                    
        # 判断是否需要划分
        if best_gain > 0:
            left_mask = X[:, best_feature] < best_threshold
            right_mask = X[:, best_feature] >= best_threshold
            left_node = self.build_tree(X[left_mask], y[left_mask], depth + 1)
            right_node = self.build_tree(X[right_mask], y[right_mask], depth + 1)
            return Node(attribute=best_feature, threshold=best_threshold,
                        left=left_node, right=right_node)
        
        # 无法划分，返回叶子节点
        return Node(label=self.majority_vote(y))
    
    def predict(self, X):
        """预测新样本的类别"""
        node = self.root
        while node.label is None:
            if X[node.attribute] < node.threshold:
                node = node.left
            else:
                node = node.right
        return node.label

最后，我们可以使用该算法对一个数据集进行分类。

# 导入数据集
from sklearn.datasets import load_iris
iris = load_iris()
X = iris.data
y = iris.target

# 构建决策树
model = C45DecisionTree(max_depth=5, min_samples_split=2)
model.root = model.build_tree(X, y)

# 对新样本进行分类
new_sample = [5.0, 3.6, 1.3, 0.25]
label = model.predict(new_sample)
print(label)

以上代码输出结果为 `0`，表示该新样本属于第一类。

c45决策树算法代码

当然可以！以下是一个使用C4.5决策树算法的简单代码示例：

import math

def entropy(data):
    # 计算数据集的熵值
    label_counts = {}
    for row in data:
        label = row[-1]
        if label not in label_counts:
            label_counts[label] = 0
        label_counts[label] += 1

    entropy = 0.0
    for count in label_counts.values():
        probability = count / len(data)
        entropy -= probability * math.log2(probability)
    return entropy

def split_data(data, attribute, value):
    # 根据给定的属性和属性值划分数据集
    subset = []
    for row in data:
        if row[attribute] == value:
            reduced_row = row[:attribute]
            reduced_row.extend(row[attribute+1:])
            subset.append(reduced_row)
    return subset

def choose_best_attribute(data):
    # 选择最佳划分属性
    num_attributes = len(data[0]) - 1
    base_entropy = entropy(data)
    best_info_gain = 0.0
    best_attribute = -1

    for i in range(num_attributes):
        attribute_values = [row[i] for row in data]
        unique_values = set(attribute_values)
        new_entropy = 0.0
        for value in unique_values:
            subset = split_data(data, i, value)
            probability = len(subset) / len(data)
            new_entropy += probability * entropy(subset)
        info_gain = base_entropy - new_entropy
        if info_gain > best_info_gain:
            best_info_gain = info_gain
            best_attribute = i

    return best_attribute

def majority_count(labels):
    # 计算标签列表中出现次数最多的标签
    label_counts = {}
    for label in labels:
        if label not in label_counts:
            label_counts[label] = 0
        label_counts[label] += 1
    sorted_labels = sorted(label_counts.items(), key=lambda x: x[1], reverse=True)
    return sorted_labels[0][0]

def create_decision_tree(data, attributes):
    # 创建决策树
    labels = [row[-1] for row in data]

    if labels.count(labels[0]) == len(labels):
        return labels[0]

    if len(data[0]) == 1:
        return majority_count(labels)

    best_attribute = choose_best_attribute(data)
    best_attribute_label = attributes[best_attribute]
    decision_tree = {best_attribute_label: {}}
    del(attributes[best_attribute])
    attribute_values = [row[best_attribute] for row in data]
    unique_values = set(attribute_values)

    for value in unique_values:
        subset = split_data(data, best_attribute, value)
        decision_tree[best_attribute_label][value] = create_decision_tree(subset, attributes[:])

    return decision_tree

# 示例用法
data = [['青年', '否', '否', '一般', '否'],
        ['青年', '否', '否', '好', '否'],
        ['青年', '是', '否', '好', '是'],
        ['青年', '是', '是', '一般', '是'],
        ['青年', '否', '否', '一般', '否'],
        ['中年', '否', '否', '一般', '否'],
        ['中年', '否', '否', '好', '否'],
        ['中年', '是', '是', '好', '是'],
        ['中年', '否', '是', '非常好', '是'],
        ['中年', '否', '是', '非常好', '是'],
        ['老年', '否', '是', '非常好', '是'],
        ['老年', '否', '是', '好', '是'],
        ['老年', '是', '否', '好', '是'],
        ['老年', '是', '否', '非常好', '是'],
        ['老年', '否', '否', '一般', '否']]
attributes = ['年龄', '有工作', '有自己的房子', '信贷情况']

decision_tree = create_decision_tree(data, attributes)
print(decision_tree)

希望这个简单的示例能帮助你理解C4.5决策树算法的实现！