import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import classification_report
from sklearn.svm import SVC

# 读取数据
data = pd.read_csv('diabetes.csv')

# 请在下方作答 #
# 将目标特征与其他特征分离
X = data.drop('class', axis=1)  
y = data['class']  

# 划分训练集train_X, train_y和测试集train_X, train_y
train_X, test_X, train_y, test_y = train_test_split(X, y, test_size = .2, random_state = 0)

# 训练集标准化，返回结果为scaled_train_X
scaler = StandardScaler()
scaled_train_X = scaler.fit_transform(train_X)

# 构建支持向量机模型
clf = SVC()

# 模型训练
clf.fit(scaled_train_X, train_y)

# 测试集标准化
scaled_test_X = scaler.transform(test_X)

# 使用模型返回预测值
pred_y = clf.predict(scaled_test_X)

# 打印支持向量的个数，返回结果为列表，[-1标签的支持向量，+1标签的支持向量]
print(clf.n_support_)

# 使用classification_report函数进行模型评价
print(classification_report(test_y, pred_y))

# 构建惩罚系数C为0.3的模型，并与之前的模型做比较
clf_new = SVC(C=0.3)
clf_new.fit(scaled_train_X, train_y)
pred_y_new = clf_new.predict(scaled_test_X)

print(clf_new.n_support_)
print(classification_report(test_y, pred_y_new))

#调整惩罚系数C寻优

import numpy as np
# 请在下方作答 #
def rbf_kernel(X, Y, gamma=0.5):
    
    # 获取X和Y的大小
    num1 = X.shape[0]
    num2 = Y.shape[0]
    
    # 计算X和X^T的矩阵乘积
    gram_1 = X.dot(X.T)
    
    # 获取gram_1对角线位置的元素，组成大小(num1, 1)的列表，并将整个列表复制，扩展为(num1, num2)大小的矩阵component1
    component1 = np.tile(np.diag(gram_1).reshape(-1, 1), (1, num2))
    
    # 计算Y和Y^T的乘积
    gram_2 = Y.dot(Y.T)
     
    # 获取gram_2对角线位置的元素，组成(1, num2)的列表，并将整个列表复制，扩展为(num1, num2)大小的矩阵component2
    component2 = np.tile(np.diag(gram_2).reshape(1, -1), (num1, 1))
   
    # 计算2X和Y^T的内积 
    component3 = 2 * X.dot(Y.T)
  
    # 返回结果
    result = np.exp(gamma*(component3 - component1 - component2))
    return result

# 计算糖尿病患者训练数据集的核矩阵
rbf_matrix = rbf_kernel(scaled_train_X, scaled_train_X)

# 训练一个支持向量分类器
clf = SVC(kernel=rbf_kernel)
clf.fit(scaled_train_X, train_y)
pred_y = clf.predict(scaled_test_X)
print (clf.n_support_)
print (classification_report(test_y, pred_y))

# 调整gamma值寻找最优

import numpy as np
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import classification_report
from sklearn.svm import SVC
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
import matplotlib.pyplot as plt

def create_data():
    iris = load_iris()
    df = pd.DataFrame(iris.data, columns=iris.feature_names)
    df['label'] = iris.target
    df.columns = ['sepal length', 'sepal width', 'petal length', 'petal width', 'label']
    data = np.array(df.iloc[:100, [0, 1, -1]])
    for i in range(len(data)):
        if data[i,-1] == 0:
            data[i,-1] = -1
    # print(data)
    return data[:,:2], data[:,-1]

# 读取数据，拆分数据，训练测试集划分
X, y = create_data()
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.25)

class SVM:
    def __init__(self, max_iter=100, kernel='linear'):
        self.max_iter = max_iter
        self._kernel = kernel
    
    def init_args(self, features, labels):
        self.m, self.n = features.shape
        self.X = features
        self.Y = labels
        self.b = 0.0
        
        # 将Ei保存在一个列表里
        self.alpha = np.ones(self.m)
        self.E = [self._E(i) for i in range(self.m)]
        # 松弛变量
        self.C = 1.0
        
    def _KKT(self, i):
        y_g = self._g(i)*self.Y[i]
        if self.alpha[i] == 0:
            return y_g >= 1
        elif 0 < self.alpha[i] < self.C:
            return y_g == 1
        else:
            return y_g <= 1
    
    # g(x)预测值，输入xi（X[i]）
    def _g(self, i):
        r = self.b
        for j in range(self.m):
            r += self.alpha[j] * self.Y[j] * self.kernel(self.X[j], self.X[i])
        return r
    
    # 核函数
    def kernel(self, x1, x2):
        if self._kernel == 'linear':
            return np.dot(x1, x2)
        elif self._kernel == 'poly':
            return (sum([x1[k]*x2[k] for k in range(self.n)]) + 1)**2
    
        return 0
    
    # E（x）为g(x)对输入x的预测值和y的差
    def _E(self, i):
        return self._g(i) - self.Y[i]
    
    def _init_alpha(self):
        # 外层循环首先遍历所有满足0<a<C的样本点，检验是否满足KKT
        index_list = [i for i in range(self.m) if 0 < self.alpha[i] < self.C]
        # 否则遍历整个训练集
        non_satisfy_list = [i for i in range(self.m) if i not in index_list]
        index_list.extend(non_satisfy_list)
        
        for i in index_list:
            if self._KKT(i):
                continue
            
            E1 = self.E[i]
            # 如果E2是+，选择最小的；如果E2是负的，选择最大的
            if E1 >= 0:
                j = min(range(self.m), key=lambda x: self.E[x])
            else:
                j = max(range(self.m), key=lambda x: self.E[x])
            return i, j
        
    def _compare(self, _alpha, L, H):
        if _alpha > H:
            return H
        elif _alpha < L:
            return L
        else:
            return _alpha      
    
    def fit(self, features, labels):
        self.init_args(features, labels)
        
        for t in range(self.max_iter):
            # train
            i1, i2 =self._init_alpha()
            
            # 边界
            if self.Y[i1] == self.Y[i2]:
                L = max(0, self.alpha[i1]+self.alpha[i2]-self.C)
                H = min(self.C, self.alpha[i1]+self.alpha[i2])
            else:
                L = max(0, self.alpha[i2]-self.alpha[i1])
                H = min(self.C, self.C+self.alpha[i2]-self.alpha[i1])
                
            E1 = self.E[i1]
            E2 = self.E[i2]
            # eta=K11+K22-2K12
            eta = self.kernel(self.X[i1], self.X[i1]) + \
                  self.kernel(self.X[i2], self.X[i2]) - \
                  2 * self.kernel(self.X[i1], self.X[i2])
            if eta <= 0:
                # print('eta <= 0')
                continue
                
            alpha2_new_unc = self.alpha[i2] + self.Y[i2] * (E2 - E1) / eta
            alpha2_new = self._compare(alpha2_new_unc, L, H)
            
            alpha1_new = self.alpha[i1] + self.Y[i1] * self.Y[i2] * (self.alpha[i2] - alpha2_new)
            
            b1_new = -E1 - self.Y[i1] * self.kernel(self.X[i1], self.X[i1]) * (alpha1_new-self.alpha[i1]) - self.Y[i2] * self.kernel(self.X[i2], self.X[i1]) * (alpha2_new-self.alpha[i2])+ self.b 
            b2_new = -E2 - self.Y[i1] * self.kernel(self.X[i1], self.X[i2]) * (alpha1_new-self.alpha[i1]) - self.Y[i2] * self.kernel(self.X[i2], self.X[i2]) * (alpha2_new-self.alpha[i2])+ self.b 
            
            if 0 < alpha1_new < self.C:
                b_new = b1_new
            elif 0 < alpha2_new < self.C:
                b_new = b2_new
            else:
                # 选择中点
                b_new = (b1_new + b2_new) / 2
                
            # 更新参数
            self.alpha[i1] = alpha1_new
            self.alpha[i2] = alpha2_new
            self.b = b_new
            
            self.E[i1] = self._E(i1)
            self.E[i2] = self._E(i2)
        return 'train done!'
            
    def predict(self, data):
        r = self.b
        for i in range(self.m):
            r += self.alpha[i] * self.Y[i] * self.kernel(self.X[i], data)
            
        return 1 if r > 0 else -1
    
    def score(self, X_test, y_test):
        right_count = 0
        for i in range(len(X_test)):
            result = self.predict(X_test[i])
            if result == y_test[i]:
                right_count += 1
        return right_count / len(X_test)
    
    def _weight(self):
        # linear model
        yx = self.Y.reshape(-1, 1)*self.X
        self.w = np.dot(self.alpha, yx)
        return self.w

# 调用SVM进行模型训练与测试评估
svm = SVM(max_iter=100)
svm.fit(X_train, y_train)
svm.score(X_test, y_test)

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt

data = pd.read_csv("work/西瓜数据集3.0α.txt")
data

yes = data[data['Good melon'].isin(['是'])]
no = data[data['Good melon'].isin(['否'])]
fig, ax = plt.subplots(figsize=(12, 8))
ax.scatter(yes['Density'], yes['Sugar content'], marker='o', c='b', label='Yes')
ax.scatter(no['Density'], no['Sugar content'], marker='x', c='r', label='No')
ax.legend()
ax.set_xlabel('Density')
ax.set_ylabel('Sugar content')
plt.show() # 可以发现线性不可分

from sklearn import svm

# 使用线性核与高斯核进行比较
linear_svc = svm.SVC(kernel='linear')  # 线性核
rbf_svc = svm.SVC(kernel='rbf')        # 高斯核（RBF）

temp = {'是': 1, '否': -1}
X = np.array(data.iloc[:, :2])
y = np.array(data.iloc[:, 2].replace(temp))[None].T

linear_svc.fit(X, y)
linear_svc.score(X,y)
# 查看支持向量
linear_svc.support_vectors_

rbf_svc.fit(X, y)
rbf_svc.score(X,y)
# 查看支持向量
rbf_svc.support_vectors_

import matplotlib.colors as colors
import matplotlib.pyplot as plt
import numpy as np
import pandas as pd


class LogisticRegression:
    kern_param = 0
    X = np.array([])
    a = np.array([])
    kernel = None

    def __init__(self, kernel='poly', kern_param=None):
        if kernel == 'poly':
            self.kernel = self.__linear__
            if kern_param:
                self.kern_param = kern_param
            else:
                self.kern_param = 1
        elif kernel == 'gaussian':
            self.kernel = self.__gaussian__
            if kern_param:
                self.kern_param = kern_param
            else:
                self.kern_param = 0.1
        elif kernel == 'laplace':
            self.kernel = self.__laplace__
            if kern_param:
                self.kern_param = kern_param
            else:
                self.kern_param = 0.1

    def fit(self, X, y, max_rate=100, min_rate=0.001, gd_step=10, epsilon=0.0001):
        m = len(X)
        self.X = np.vstack([X.T, np.ones(m)]).T
        # Construct kernel matrix
        K =self.kernel(self.X, self.X, self.kern_param)  # 填空1：计算核矩阵
        # Gradient descent
        self.a = np.zeros([m])
        prev_cost = 0
        next_cost = self.__cost__(K, y, self.a)
        while np.fabs(prev_cost-next_cost) > epsilon:
            neg_grad = -self.__gradient__(K, y, self.a)
            best_rate = rate = max_rate
            min_cost = self.__cost__(K, y, self.a)
            while rate >= min_rate:
                cost = self.__cost__(K, y, self.a+neg_grad*rate)
                if cost < min_cost:
                    min_cost = cost
                    best_rate = rate
                rate /= gd_step
            self.a += neg_grad * best_rate
            prev_cost = next_cost
            next_cost = min_cost

    def predict(self, X):
        # 1. 添加偏置项（与训练数据处理一致）
        X = np.vstack([X.T, np.ones(len(X))]).T  # 形状变为 (n_samples, n_features + 1)
        
        # 2. 计算核矩阵（训练数据与测试数据之间的核函数值）
        K = self.kernel(self.X, X, self.kern_param)  # 形状：(训练样本数, 测试样本数)
        
        # 3. 计算预测得分（关键修正：移除 self.Y 的乘法）
        pred = np.dot(self.a, K) 
        
        # 4. Sigmoid转换为概率并二值化
        prob = self.__sigmoid__(pred)
        return (prob >= 0.5).astype(int)

    # Kernels
    @staticmethod
    def __linear__(a, b, parameter):
        return np.dot(a, np.transpose(b))

    @staticmethod
    def __gaussian__(a, b, kern_param):
        mat = np.zeros([len(a), len(b)])
        for i in range(0, len(a)):
            for j in range(0, len(b)):
                mat[i][j] = np.exp(-np.sum(np.square(np.subtract(a[i], b[j]))) / (2 * kern_param * kern_param))
        return mat

    @staticmethod
    def __laplace__(a, b, kern_param):
        mat = np.zeros([len(a), len(b)])
        for i in range(0, len(a)):
            for j in range(0, len(b)):
                mat[i][j] = np.exp(-np.linalg.norm(np.subtract(a[i], b[j])) / kern_param)
        return mat

    @staticmethod
    def __sigmoid__(X):
        return np.exp(X) / (1 + np.exp(X))

    @staticmethod
    def __cost__(K, y, a):
        return -np.dot(y, np.dot(a, K)) + np.sum(np.log(1 + np.exp(np.dot(a, K))))

    @classmethod
    def __gradient__(cls, K, y, a):
        return -np.dot(K, y - cls.__sigmoid__(np.dot(a, K)))


# Read data
data = pd.read_csv("work/西瓜数据集3.0α.txt")
X = np.array(data[['Density', 'Sugar content']])
y = np.array(data['Good melon']) == '是'

# Kernels
kernels = ['poly', 'gaussian', 'laplace']
titles = ['linear kernel', 'gaussian kernel, σ=0.1', 'laplace kernel, σ=0.1']

for i in range(0, len(kernels)):
    # Training
    # 填空3：实例化并训练模型
    model = LogisticRegression(kernel=kernels[i])
    model.fit(X, y)
    
    # Plot
    cmap = colors.LinearSegmentedColormap.from_list('watermelon', ['red', 'green'])
    xx, yy = np.meshgrid(np.arange(0.2, 0.8, 0.01), np.arange(0.0, 0.5, 0.01))
    Z = model.predict(np.c_[xx.ravel(), yy.ravel()])
    Z = Z.reshape(xx.shape)
    plt.contourf(xx, yy, Z, cmap=cmap, alpha=0.3, antialiased=True)
    plt.scatter(X[:, 0], X[:, 1], c=y, cmap=cmap)
    plt.xlabel('Density')
    plt.ylabel('Sugar content')
    plt.title(titles[i])
    plt.show()

import numpy as np
import pandas as pd
# 输入X和y
X = np.array([ [0,0,1],
[1,1,1],
[1,0,1],
[0,1,1]])

y = np.array([[0,1,1,0]]).T

# 请在下方作答 #
# Sigmoid激活函数以及其导数
def sigmoid(x, derivative = False):
    # 计算sigmoid的输出
    sigmoid_value =1 / (1 + np.exp(-x))
    if derivative == False:     
        return sigmoid_value
    
    elif derivative == True:
        # 计算sigmoid的导数
        return sigmoid_value * (1 - sigmoid_value)

# 迭代次数
iter_num  = 1000
eta = 0.1

# 初始化权重向量w
num, dim = X.shape
w_vec = np.ones((dim, 1))

for iter in range(iter_num):
    
    ## X通过权重向量w_vec，实现线性加和，结果为z1
    z_1 =  X.dot(w_vec)
    
    # 经过激活函数Sigmoid，获得输出a_1
    a_1 = sigmoid(z_1)
      
    # 模型输出a_1与真实值的误差
    error = a_1 - y
    
    # 权重更新
    w_vec_delta = X.T.dot(error * sigmoid(z_1, derivative=True))
    w_vec = w_vec + eta*w_vec_delta  

print (w_vec)

import pandas as pd
import numpy as np
from sklearn.datasets import load_iris
import matplotlib.pyplot as plt

# load data
iris = load_iris()
df = pd.DataFrame(iris.data, columns=iris.feature_names)
df['label'] = iris.target

df.columns = [
    'sepal length', 'sepal width', 'petal length', 'petal width', 'label'
]
df.label.value_counts()

data = np.array(df.iloc[:100, [0, 1, -1]])
X, y = data[:,:-1], data[:,-1]
y = np.array([1 if i == 1 else -1 for i in y])

plt.scatter(df[:50]['sepal length'], df[:50]['sepal width'], label='0')
plt.scatter(df[50:100]['sepal length'], df[50:100]['sepal width'], label='1')
plt.xlabel('sepal length')
plt.ylabel('sepal width')
plt.legend()

# 数据线性可分，二分类数据
# 此处为一元一次线性方程
class Model:
    def __init__(self):
        self.w = np.ones(len(data[0]) - 1, dtype=np.float32)
        self.b = 0
        self.l_rate = 0.1

    def f(self, x, w, b):
        y = np.sign(np.dot(x, w) + b)
        return y

    # 随机梯度下降法
    def fit(self, X_train, y_train):
        is_wrong = False
        while not is_wrong:
            wrong_count = 0
            for d in range(len(X_train)):
                X = X_train[d]
                y = y_train[d]
                if y * (np.dot(X, self.w) + self.b) <= 0: #判断样本被误分类
                    # 更新权重和偏置
                    self.w = self.w + self.l_rate * y * X
                    self.b = self.b + self.l_rate * y
                    wrong_count += 1
            if wrong_count == 0:
                is_wrong = True
        return 'Perceptron Model!'

    def score(self):
        pass

# 进行模型训练
perceptron = Model()
perceptron.fit(X, y)

x_points = np.linspace(4, 7, 10)
y_ = -(perceptron.w[0] * x_points + perceptron.b) / perceptron.w[1]
plt.plot(x_points, y_)

plt.plot(data[:50, 0], data[:50, 1], 'bo', color='blue', label='0')
plt.plot(data[50:100, 0], data[50:100, 1], 'bo', color='orange', label='1')
plt.xlabel('sepal length')
plt.ylabel('sepal width')
plt.legend()

import sklearn
from sklearn.linear_model import Perceptron
# 调用sklearn中Perceptron函数进行分类
clf = Perceptron(
    max_iter=5000,      # 增加最大迭代次数
    eta0=0.05,           # 调整学习率（原0.01可能过小）
    shuffle=True
)

# 4. 训练模型
clf.fit(X, y)
# Weights assigned to the features.
print(clf.coef_)
# 截距 Constants in decision function.
print(clf.intercept_)

# 画布大小
plt.figure(figsize=(10,10))

# 中文标题
plt.rcParams['font.sans-serif']=['SimHei']
plt.rcParams['axes.unicode_minus'] = False
plt.title('鸢尾花线性数据示例')

plt.scatter(data[:50, 0], data[:50, 1], c='b', label='Iris-setosa',)
plt.scatter(data[50:100, 0], data[50:100, 1], c='orange', label='Iris-versicolor')

# 画感知机的线
x_ponits = np.arange(4, 8)
y_ = -(clf.coef_[0][0]*x_ponits + clf.intercept_)/clf.coef_[0][1]
plt.plot(x_ponits, y_)

# 其他部分
plt.legend()  # 显示图例
plt.grid(False)  # 不显示网格
plt.xlabel('sepal length')
plt.ylabel('sepal width')
plt.legend()

import numpy as np
from sklearn.linear_model import Perceptron
import matplotlib.pyplot as plt
x=np.array([[1,0],[0,1],[0,0],[1,1]])
y=np.array([1, 1, -1, -1])
plt.plot(x[:2,0],x[:2,1],'bo',color='red',label='1')
plt.plot(x[2:4,0],x[2:4,1],'bo',color='blue',label='-1')
plt.xlabel('x1')
plt.ylabel('x2')
plt.legend()

# 请在下方作答
# 初始化感知机模型
clf = Perceptron(
    max_iter=1000,      # 增加最大迭代次数
    eta0=0.1,           # 学习率
    random_state=42,
    shuffle=True        # 每次迭代打乱数据
)

# 训练模型
clf.fit(X, y)

# 输出模型参数
print("特征权重 (w):", clf.coef_)
print("截距 (b):", clf.intercept_)

# 预测结果
predictions = clf.predict(X)
print("预测结果:", predictions)
print("真实标签:", y)

# 导入必要库
import numpy as np
import pandas as pd

# 读取数据（假设文件为tab分隔，包含特征和目标变量'status'）
weekend_data = pd.read_table('weekend.txt', sep=' ')

## 自定义熵计算函数
def cal_entropy(data, feature_name):
    '''
    计算给定特征的信息熵
    :param data: 输入的DataFrame数据集
    :param feature_name: 需要计算熵的目标特征名称
    :return: 保留三位小数的熵值
    '''
    entropy = 0  # 初始化熵值
    num = data.shape[0]  # 获取数据集总样本数
    
    # 统计目标特征各取值的频数（如：status特征中"出门"和"不出门"的数量）
    freq_stats = data[feature_name].value_counts()
    
    # 遍历每个不同取值计算熵
    for freq in freq_stats:
        prob = freq / num  # 计算当前取值的概率
        # 根据信息熵公式累加计算（注意：熵公式为负数求和）
        entropy -= prob * np.log2(prob)  # 等价于 entropy += -prob * log2(prob)
    
    return round(entropy, 3)  # 保留三位小数

## 计算初始信息熵（假设目标特征列为'status'）
data_entropy = cal_entropy(weekend_data, 'status')

## 自定义信息增益计算函数
def cal_infoGain(data, base_entropy):
    '''
    计算所有特征的信息增益并选择最优特征
    :param data: 输入的DataFrame数据集
    :param base_entropy: 数据集的初始熵值
    :return: 信息增益列表和最优特征名称
    '''
    infogain_list = []  # 存储各特征的信息增益
    total_samples = data.shape[0]  # 总样本数
    feature_list = list(data.columns.values)  # 获取所有特征名称
    feature_list.remove('status')  # 移除目标特征（避免计算自身）
    
    # 遍历每个特征计算信息增益
    for feature in feature_list:
        sub_entropy = 0  # 初始化条件熵
        
        # 获取当前特征的取值分布（如：天气特征的"晴朗/下雨/阴天"）
        value_counts = data[feature].value_counts()
        
        # 遍历特征的每个取值
        for value, count in value_counts.items():
            # 获取特征取当前值的子集
            subset = data[data[feature] == value]
            subset_samples = subset.shape[0]  # 子集样本数
            weight = subset_samples / total_samples  # 计算权重
            
            # 计算子集的熵并累加加权熵
            sub_entropy += weight * cal_entropy(subset, 'status')
        
        # 计算信息增益（信息增益 = 基础熵 - 条件熵）
        info_gain = base_entropy - sub_entropy
        infogain_list.append(round(info_gain, 4))  # 保留四位小数
    
    # 找到信息增益最大的特征
    max_gain = max(infogain_list)  # 最大增益值
    max_index = infogain_list.index(max_gain)  # 最大值索引
    best_feature = feature_list[max_index]  # 对应的最优特征名称
    
    return infogain_list, best_feature

## 执行信息增益计算
infogains, best_feature = cal_infoGain(weekend_data, data_entropy)

## 结果输出
print('各特征的信息增益：', infogains)
print('\n信息增益最大的特征：', best_feature)

import pandas as pd
from sklearn.tree import DecisionTreeClassifier, export_graphviz  # 补全export_graphviz导入
from sklearn.model_selection import train_test_split
from sklearn.metrics import classification_report

data = pd.read_csv('product.csv')

## 对数据集切片，获取除目标特征以外的其他特征的数据记录X
X = data[["天气", "是否周末", "是否有促销"]]  # 使用双括号选择多列

## 对数据集切片，获取目标特征`销量`的数据记录y
y = data["销量"]

## 使用train_test_split函数划分训练集train_X, train_y和测试集test_X, test_y
## 测试集所占比例为0.1,random_state为0
train_X, test_X, train_y, test_y = train_test_split(X, y, test_size=0.1, random_state=0)

## 构建分支节点选择方法为基尼指数的决策树模型tree_model，进行模型训练、测试与性能评估
tree_model = DecisionTreeClassifier(criterion='gini')  # 设置基尼指数准则
tree_model.fit(train_X, train_y)  # 模型训练

pred_y = tree_model.predict(test_X)  # 测试集预测
print("模型分类报告：")
print(classification_report(test_y, pred_y))  # 输出评估报告

## 决策树可视化（修正特征名称与数据列一致）
import graphviz
dot_data = export_graphviz(
    tree_model,
    out_file=None,
    feature_names=["天气", "是否周末", "是否有促销"],  # 修正为完整特征名称
    class_names=["销量低", "销量高"],
    filled=True,
    rounded=True
)
graph = graphviz.Source(dot_data)
graph

import numpy as np

import pandas as pd

from sklearn.model_selection import train_test_split

from sklearn.metrics import classification_report

import graphviz



## 任务1的熵计算函数（已完整实现）

def cal_entropy(data, feature_name):

    '''

    计算给定特征的信息熵

    :param data: 输入的DataFrame数据集

    :param feature_name: 需要计算熵的目标特征名称

    :return: 保留三位小数的熵值

    '''

    entropy = 0  # 初始化熵值

    num = data.shape[0]  # 获取数据集总样本数

    

    # 统计目标特征各取值的频数分布

    freq_stats = data[feature_name].value_counts()

    

    # 遍历每个不同取值计算熵

    for freq in freq_stats:

        prob = freq / num  # 计算当前取值的概率

        # 根据信息熵公式累加计算（Σ -p_i log2(p_i)）

        entropy -= prob * np.log2(prob)  # 等价于 entropy += -prob * log2(prob)

    

    return round(entropy, 3)  # 保留三位小数



## 任务1的信息增益计算函数（已完整实现）

def cal_infoGain(data, base_entropy):

    '''

    计算所有特征的信息增益并选择最优特征

    :param data: 输入的DataFrame数据集

    :param base_entropy: 数据集的初始熵值

    :return: 信息增益列表和最优特征名称

    '''

    infogain_list = []  # 存储各特征的信息增益

    total_samples = data.shape[0]  # 总样本数

    feature_list = list(data.columns.values)  # 所有特征名称

    

    # 自动识别目标特征（假设目标特征不在特征列表中）

    target_feature = [col for col in feature_list if col not in data.columns][0]

    feature_list = [col for col in data.columns if col != target_feature]  # 移除目标特征

    

    # 遍历每个特征计算信息增益

    for feature in feature_list:

        sub_entropy = 0  # 初始化条件熵

        # 获取当前特征的取值分布

        value_counts = data[feature].value_counts()

        

        # 计算条件熵

        for value, count in value_counts.items():

            subset = data[data[feature] == value]  # 特征取当前值的子集

            subset_samples = subset.shape[0]  # 子集样本数

            weight = subset_samples / total_samples  # 计算权重

            # 累加加权熵

            sub_entropy += weight * cal_entropy(subset, target_feature)

        

        # 计算信息增益

        info_gain = base_entropy - sub_entropy

        infogain_list.append(round(info_gain, 4))  # 保留四位小数

    

    # 选择最优特征

    max_gain = max(infogain_list)  # 最大信息增益值

    max_index = infogain_list.index(max_gain)  # 最大值索引

    best_feature = feature_list[max_index]  # 最优特征名称

    

    return infogain_list, best_feature



## ID3决策树实现

class ID3DecisionTree:

    def __init__(self):

        self.tree = None  # 存储决策树结构

        self.target = None  # 目标特征名称



    def fit(self, data, target_feature):

        '''

        训练决策树模型

        :param data: 包含特征和目标列的DataFrame

        :param target_feature: 目标特征名称（如'销量'）

        '''

        self.target = target_feature

        # 提取特征列表（排除目标特征）

        features = [col for col in data.columns if col != target_feature]

        # 递归构建决策树

        self.tree = self._build_tree(data, features)



    def _build_tree(self, data, features):

        '''

        递归构建决策树

        :param data: 当前节点的数据集

        :param features: 当前可用的特征列表

        :return: 字典形式的树节点

        '''

        # 终止条件1：所有样本属于同一类别

        if len(data[self.target].unique()) == 1:

            return {

                'class': data[self.target].values[0],  # 叶节点类别

                'samples': len(data)  # 样本数量

            }

        

        # 终止条件2：无剩余特征可用时选择多数类

        if not features:

            class_counts = data[self.target].value_counts()

            return {

                'class': class_counts.idxmax(),  # 多数类

                'samples': len(data)

            }

        

        # 计算当前数据集的熵

        base_entropy = cal_entropy(data, self.target)

        # 获取最优特征和信息增益列表

        info_gains, best_feature = cal_infoGain(data, base_entropy)

        

        # 创建当前树节点

        node = {

            'feature': best_feature,  # 分裂特征

            'info_gain': info_gains[features.index(best_feature)],  # 信息增益值

            'samples': len(data),  # 样本数量

            'children': {}  # 子节点

        }

        

        # 递归构建子树（排除当前最优特征）

        remaining_features = [f for f in features if f != best_feature]

        # 遍历最优特征的所有取值

        for value in data[best_feature].unique():

            subset = data[data[best_feature] == value]  # 获取子集

            

            # 处理空子集（采用父节点多数类）

            if subset.empty:

                class_counts = data[self.target].value_counts()

                node['children'][value] = {

                    'class': class_counts.idxmax(),

                    'samples': 0

                }

            else:

                # 递归构建子树

                node['children'][value] = self._build_tree(subset, remaining_features)

        

        return node



    def predict(self, X):

        '''

        对新样本进行预测

        :param X: 特征数据（DataFrame格式）

        :return: 预测结果列表

        '''

        predictions = []

        # 遍历每个样本

        for _, sample in X.iterrows():

            current_node = self.tree

            # 遍历树直到叶节点

            while 'children' in current_node:

                feature = current_node['feature']  # 当前分裂特征

                value = sample[feature]  # 样本在该特征的取值

                

                # 处理未见过的特征值（采用当前节点多数类）

                if value not in current_node['children']:

                    class_counts = self._get_class_counts(current_node)

                    # 选择样本数最多的类别

                    predictions.append(max(class_counts, key=class_counts.get))

                    break  # 跳出循环

                

                # 移动到子节点

                current_node = current_node['children'][value]

            

            # 记录叶节点类别

            if 'class' in current_node:

                predictions.append(current_node['class'])

        

        return predictions



    def _get_class_counts(self, node):

        '''

        递归统计节点中的类别分布

        :param node: 当前节点

        :return: 类别计数字典

        '''

        counts = {}

        # 如果是叶节点直接返回

        if 'class' in node:

            return {node['class']: node['samples']}

        

        # 递归统计子节点

        for child in node['children'].values():

            child_counts = self._get_class_counts(child)

            for cls, cnt in child_counts.items():

                counts[cls] = counts.get(cls, 0) + cnt

        

        return counts



    def visualize(self, feature_names, class_names):

        '''

        可视化决策树

        :param feature_names: 特征名称列表

        :param class_names: 类别名称列表

        :return: graphviz对象

        '''

        dot = graphviz.Digraph()  # 创建有向图

        # 递归构建图形

        self._build_graph(dot, self.tree, feature_names, class_names)

        return dot



    def _build_graph(self, dot, node, feature_names, class_names, parent=None, edge_label=""):

        '''

        递归构建graphviz图形

        :param dot: graphviz.Digraph对象

        :param node: 当前节点

        :param feature_names: 特征名称列表

        :param class_names: 类别名称列表

        :param parent: 父节点（用于连接边）

        :param edge_label: 边标签（特征取值）

        '''

        # 叶节点样式

        if 'class' in node:

            label = f"{class_names[int(node['class'])]}\\n{node['samples']} samples"

            dot.node(

                str(id(node)),  # 唯一节点ID

                label,

                shape="box",  # 矩形框

                style="filled",  # 填充颜色

                fillcolor="lightblue"  # 浅蓝色

            )

        # 内部节点样式

        else:

            label = f"{node['feature']}\\nIG={node['info_gain']:.3f}\\n{node['samples']} samples"

            dot.node(

                str(id(node)),

                label,

                shape="ellipse",  # 椭圆

                style="filled",

                fillcolor="lightgreen"  # 浅绿色

            )

        

        # 创建父节点到当前节点的边

        if parent:

            dot.edge(

                str(id(parent)),

                str(id(node)),

                label=edge_label  # 显示特征取值

            )

        

        # 递归处理子节点

        if 'children' in node:

            for value, child in node['children'].items():

                self._build_graph(

                    dot,

                    child,

                    feature_names,

                    class_names,

                    node,  # 当前节点作为父节点

                    str(value)  # 边标签为特征取值

                )