如何在逻辑回归中实现二进制系数（{0,1}或{0,1,-1}）约束？

你遇到的问题本质是要找一个**稀疏且系数仅取{-1, 0, 1}（或{0,1}）**的线性分类器，既要保留L1正则带来的稀疏性，又要让所有有效特征的贡献度一致。不用修改liblinear或saga的底层代码，有几个实用的思路，按实现复杂度和效率排序如下：

1. 快速离散化+可选微调（优先推荐） #

既然你已经用L1正则的LogisticRegression得到了性能优异的稀疏系数，最简单的方法就是直接对这些系数做离散化处理——因为Logistic回归的决策边界对系数的缩放并不敏感（sigmoid是单调函数，系数缩放等价于调整分类阈值），离散化后的模型性能通常不会有明显下降。

步骤： #

• 先用你现有的LogisticRegression(penalty='l1', C=0.5, solver='liblinear')拟合得到稀疏系数。
• 将正系数设为1，负系数设为-1，零系数保持为0（如果只需要{0,1}，就把负系数也设为0）。
• 如果离散化后性能略有下降，可以用少量梯度下降步做微调，每次更新后把系数重新投影到{-1,0,1}集合。

代码示例： #

from sklearn.linear_model import LogisticRegression
import numpy as np

# 假设X是csr_matrix，y是标签数组
clf_l1 = LogisticRegression(penalty='l1', C=0.5, solver='liblinear')
clf_l1.fit(X, y)

# 离散化系数：正→1，负→-1，零→0
w_discrete = np.where(clf_l1.coef_[0] > 0, 1, 
                      np.where(clf_l1.coef_[0] < 0, -1, 0))
b_discrete = clf_l1.intercept_[0]

# 自定义预测函数
def predict_discrete(X, weights, bias):
    scores = X.dot(weights) + bias
    return np.where(scores >= 0, 1, 0)

# 测试离散化模型
y_pred = predict_discrete(X, w_discrete, b_discrete)

如果需要微调，用SGD做少量迭代（warm start复用初始离散系数，每次更新后投影）：

from sklearn.linear_model import SGDClassifier
from sklearn.preprocessing import StandardScaler

# 稀疏矩阵不能中心化，仅做标准化
scaler = StandardScaler(with_mean=False)
X_scaled = scaler.fit_transform(X)

# 初始化SGD模型，用log损失+L1正则，alpha对应1/(C*n_samples)
sgd_clf = SGDClassifier(loss='log_loss', penalty='l1', 
                        alpha=1/(0.5 * X.shape[0]), warm_start=True)
# 加载离散化的初始系数
sgd_clf.coef_ = w_discrete.reshape(1, -1)
sgd_clf.intercept_ = b_discrete.reshape(1,)

# 投影函数：强制系数回到{-1,0,1}
def project_weights(coef):
    return np.where(coef > 0, 1, np.where(coef < 0, -1, 0))

# 仅做10-20步微调，避免破坏稀疏性和离散约束
for _ in range(15):
    sgd_clf.partial_fit(X_scaled, y, classes=np.unique(y))
    sgd_clf.coef_ = project_weights(sgd_clf.coef_)

# 微调后的预测
y_pred_tuned = sgd_clf.predict(X_scaled)

2. 用L∞正则近似约束（非严格但高效） #

如果你不需要系数严格等于±1，只是希望所有有效特征的贡献度尽可能一致，可以用L1+L∞组合正则。L∞正则会惩罚系数的最大绝对值，迫使非零系数趋近于相同的绝对值，结合L1的稀疏性，能得到近似满足你需求的系数。

在scikit-learn中，你可以用SGDClassifier自定义正则项，或者直接在梯度更新后对系数做L∞归一化：

# 每次SGD更新后，将非零系数的绝对值缩放到1
def normalize_linfty(coef):
    non_zero = np.abs(coef) > 1e-8
    if np.any(non_zero):
        max_abs = np.max(np.abs(coef[non_zero]))
        coef[non_zero] /= max_abs
    return coef

# 用法和之前的SGD微调类似，把project_weights换成normalize_linfty即可

这种方法完全复用SGD的高效求解，适合大规模数据，只是结果是近似的。

3. 混合整数规划（严格满足约束，适合小规模数据） #

如果必须严格要求系数为{-1,0,1}，可以将问题转化为混合整数线性规划（MILP），用优化工具如cvxpy定义问题并求解。不过这种方法速度较慢，适合特征数量经过L1筛选后较少的场景。

核心思路： #

将每个系数w_i表示为两个二进制变量的差：w_i = x_i - y_i，其中x_i, y_i ∈ {0,1}且x_i * y_i = 0（保证每个特征不能同时为正和负）。目标函数是Logistic损失加上L1正则（即sum(x_i + y_i)，对应稀疏性）。

代码示例（简化版）： #

import cvxpy as cp
import numpy as np

n_samples, n_features = X.shape
X_dense = X.toarray()  # 需要转为 dense 矩阵，cvxpy对稀疏矩阵支持有限

# 定义变量
x = cp.Variable(n_features, boolean=True)
y = cp.Variable(n_features, boolean=True)
b = cp.Variable()

# 约束：每个特征不能同时为正和负
constraints = [x[i] + y[i] <= 1 for i in range(n_features)]
# 系数w = x - y
w = x - y

# 目标函数：Logistic损失 + L1正则（lambda调整稀疏性）
log_loss = cp.sum(cp.logistic(-cp.multiply(y.reshape(-1,1), X_dense @ w + b)))
l1_reg = 0.5 * cp.sum(x + y)  # 0.5对应你的C=0.5
objective = cp.Minimize(log_loss + l1_reg)

# 求解
prob = cp.Problem(objective, constraints)
prob.solve(solver=cp.ECOS_BB)  # ECOS_BB支持混合整数规划

# 得到离散系数
w_discrete = np.round(x.value - y.value).astype(int)
b_discrete = b.value

总结 #

• 优先用方法1：快速、简单，复用你现有的高效L1模型，性能损失极小。
• 如果需要近似的等贡献度，用方法2：高效且无需修改底层。
• 如果必须严格满足离散约束且数据规模小，用方法3。

内容的提问来源于stack exchange，提问作者Damien Lancry