如何手动构建Sklearn LogisticRegression模型并解决单类别数据拟合问题

Let's break down your questions step by step—working with single-class data and manually configuring LogisticRegression in scikit-learn has some quirks, but there are straightforward workarounds.

1. Manually Setting coef_ and intercept_ #

You can directly assign these attributes to an instantiated LogisticRegression object, but you need to match the correct dimensions and set critical metadata to avoid downstream errors:

from sklearn.linear_model import LogisticRegression
import numpy as np

# Initialize the model instance
m = LogisticRegression()

# Assume 3 input features for a binary classification setup
n_features = 3
m.coef_ = np.array([[0.1, -0.2, 0.3]])  # Shape: (1, n_features) for binary tasks
m.intercept_ = np.array([-0.5])          # Shape: (1,) for binary tasks

# Critical: Set class metadata (required for predict_proba to work)
m.classes_ = np.array([0, 1])  # Even for single-class use, this avoids missing attribute errors
m.n_classes_ = 2

Now m.predict(X_test) will work as expected. For single-class scenarios, we'll adjust this setup later to fix predict_proba.

2. Why m.fit(X,y) Fails with Single-Class Data? #

scikit-learn's LogisticRegression is built to learn a decision boundary between at least two classes. When your target y only contains one unique value (like all 0s), the fit method throws a ValueError—there's no class separation to optimize, since logistic regression's loss function relies on comparing two classes.

3. Fixing predict_proba Errors After Manual Parameter Setup #

The error occurs because the model expects multi-class metadata or the default probability calculation isn't designed for single-class cases. Here are two reliable fixes:

Fix A: Custom predict_proba for Single-Class #

If you only need to predict class 0, rewrite the predict_proba method to return 1.0 for that class:

def custom_predict_proba(self, X):
    # Return shape (n_samples, 1) with all probabilities = 1.0 for class 0
    return np.ones((X.shape[0], 1))

# Attach the custom method to your model instance
m.predict_proba = custom_predict_proba.__get__(m, LogisticRegression)

# Test it
X_test = np.array([[1, 2, 3]])
print(m.predict_proba(X_test))  # Output: [[1.]]

Fix B: Align Metadata with Single-Class #

If you want to stick closer to scikit-learn's structure, update the model's class attributes to reflect only one class:

m.classes_ = np.array([0])
m.n_classes_ = 1

# Note: scikit-learn's default predict_proba isn't built for single-class, so overriding it is still safer

4. Making m.fit(X,y) Work with Single-Class Data #

scikit-learn doesn't support this natively, but you have two practical workarounds:

Workaround 1: Add a Temporary Dummy Class #

Insert one fake sample of the missing class, fit the model, then adjust parameters to ignore the dummy's impact:

# Original single-class data (all 0s)
X = np.random.rand(100, 3)
y = np.zeros(100)

# Add a dummy positive-class sample (use feature mean to minimize impact)
X_temp = np.vstack([X, np.mean(X, axis=0).reshape(1, -1)])
y_temp = np.hstack([y, np.array([1])])

# Fit the model normally
m = LogisticRegression()
m.fit(X_temp, y_temp)

# Adjust parameters to always predict class 0
m.coef_ = np.zeros_like(m.coef_)
m.intercept_ = np.array([-10.0])  # Sigmoid of this is ~0, so model predicts 0

Workaround 2: Custom Single-Class Logistic Regression #

Create a subclass that handles single-class cases automatically:

class SingleClassLogisticRegression(LogisticRegression):
    def fit(self, X, y, sample_weight=None):
        unique_classes = np.unique(y)
        if len(unique_classes) == 1:
            # Configure model to always predict the single class
            self.classes_ = unique_classes
            self.n_classes_ = 1
            self.coef_ = np.zeros((1, X.shape[1]))
            # Set intercept to ensure predictions stay on the target class
            self.intercept_ = np.array([-10.0]) if unique_classes[0] == 0 else np.array([10.0])
            return self
        # Fallback to normal fit for multi-class data
        return super().fit(X, y, sample_weight)
    
    def predict_proba(self, X):
        if self.n_classes_ == 1:
            return np.ones((X.shape[0], 1))
        return super().predict_proba(X)

# Usage example
m = SingleClassLogisticRegression()
m.fit(X, y)  # No error now!
print(m.predict(X))       # Output: all 0s
print(m.predict_proba(X)) # Output: all [[1.]]

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