时间戳

首页 > 解决方案 > 决策树桩的一种实现的细微错误

python - 决策树桩的一种实现的细微错误

问题描述

注意：这个问题的出现是因为实现细节而不是决策树桩 ERM 算法本身。

我正在尝试自己实现决策树桩算法并将其与正确的实现进行比较（两种实现如下所示）。

据我了解，我的实现与正确的实现基本相同，我对x,D和y一起进行排序，但正确的实现不会排序D，而是y使用curr_idx。

但是在运行以下测试代码后，在 10000 个不同的测试用例中，我得到了 6213 个不正确的测试用例。

np.random.seed(0)
cor_count = 0
err_count = 0
for iter in range(10000):
    X = np.random.randint(1, 100, size=(10, 2))
    D = np.random.rand(10)
    D /= np.sum(D)
    y = np.random.choice([-1, 1], size=(10,))
    my_res = my_decision_stump(X, D, y)
    res = decision_stump(X, D, y)
    if my_res == res:
        cor_count += 1
    else:
        err_count += 1

print("Number of correct cases {}".format(cor_count))
print("Number of error cases {}".format(err_count))

我的实现和正确的实现如下所示。

def my_decision_stump(X, D, y):
    Fs = np.inf

    optimal_j = None
    optimal_b = None
    optimal_theta = None

    m, d = X.shape
    for j in range(d):
        record = np.hstack((X[:, j].reshape(-1, 1), D.reshape(-1, 1), y.reshape(-1, 1)))
        record_sorted = record[record[:, 0].argsort()]
        x = record_sorted[:, 0]; D = record_sorted[:, 1]; y = record_sorted[:, 2]
        x = np.hstack((x, x[-1]+1))

        F_pos = np.sum(D[y == 1])
        F_neg = np.sum(D[y == -1])

        if F_pos < Fs or F_neg < Fs:
            optimal_theta = x[0] - 1; optimal_j = j
            if F_pos < F_neg:
                Fs = F_pos; optimal_b = 1
            else:
                Fs = F_neg; optimal_b = -1

        for i in range(m):
            F_pos -= y[i] * D[i]
            F_neg += y[i] * D[i]
            if (F_pos < Fs or F_neg < Fs) and x[i] != x[i+1]:
                optimal_theta = 0.5 * (x[i] + x[i+1]); optimal_j = j
                if F_pos < F_neg:
                    Fs = F_pos; optimal_b = 1              
                else:
                    Fs = F_neg; optimal_b = -1       
    return (optimal_j, optimal_b, optimal_theta)

def decision_stump(X, D, y):
    Fs = np.inf

    optimal_j = None
    optimal_b = None
    optimal_theta = None

    m, d = X.shape
    for j in range(d):
        index = np.argsort(X[:, j])
        x = np.zeros(m+1)
        x[:-1] = X[index, j]
        x[-1] = x[-2] + 1
        F_pos = np.sum(D[y == 1])
        F_neg = np.sum(D[y == -1])
        if F_pos < Fs or F_neg < Fs:
            optimal_theta = x[0] - 1; optimal_j = j
            if F_pos < F_neg:
                Fs = F_pos; optimal_b = 1                   
            else:
                Fs = F_neg; optimal_b = -1

        for i in range(m):
            curr_idx = index[i]
            F_pos -= y[curr_idx] * D[curr_idx]
            F_neg += y[curr_idx] * D[curr_idx]
            if (F_pos < Fs or F_neg < Fs) and x[i] != x[i+1]:
                optimal_theta = 0.5 * (x[i] + x[i+1]); optimal_j = j
                if F_pos < F_neg:
                    Fs = F_pos; optimal_b = 1              
                else:
                    Fs = F_neg; optimal_b = -1       
    return (optimal_j, optimal_b, optimal_theta)

我不确定我犯了什么（也许是微妙的）错误。任何人都可以帮助我，提前谢谢你。

标签： pythonmachine-learningdecision-tree

解决方案

我犯了一个愚蠢的错误...

在我的实现中，由于变量名Dand的滥用y，结果每次D和都y发生变化（即D = record_sorted[:, 1]，但在下一次迭代D中使用它，与 相同y），因为我进行了排序，但他们不应该这样做。

这个例子显示了滥用变量名的巨大危险。

推荐阅读