决策残桩一次实现的细微错误

Question

注意:这个问题的产生是因为实现细节，而不是决策终止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)

我不知道我犯了什么(也许是微妙的)错误。有人能帮我吗，谢谢。

Answer 1

我犯了个愚蠢的错误。

在我的实现中，由于变量名称D和y的滥用，结果是每次D和y更改(即D = record_sorted[:, 1]，但在下一次迭代中使用这个D，与y一样)，因为我做了排序，但它们不应该。

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