如何为numpy polyfit设置限制，避免拟合曲线超过y=100？

Absolutely, this is a super common problem when fitting percentage/proportion data—you don’t want your model predicting values outside the [0,100] range. Here are a few practical, actionable approaches you can use:

The logistic curve is perfect here because it’s naturally constrained between 0 and 100 (or 0 and 1 for proportions) by its mathematical form. It’s ideal if your data looks like it’s approaching a saturation point (getting closer to 100 as x increases).

The function looks like this:
y = 100 / (1 + exp(-(a*x + b)))
Where a controls the steepness of the curve, and b shifts it left/right.

Here’s a quick Python example using scipy:

import numpy as np
from scipy.optimize import curve_fit

# Define the logistic function
def logistic(x, a, b):
    return 100 / (1 + np.exp(-(a * x + b)))

# Your raw data (replace with your actual arrays)
x_data = np.array([1, 2, 3, 4, 5])
y_data = np.array([20, 45, 70, 85, 92])  # All values <100

# Fit the curve to your data
params, _ = curve_fit(logistic, x_data, y_data)

# Generate smooth fitted values for plotting
x_fit = np.linspace(min(x_data), max(x_data) + 2, 100)
y_fit = logistic(x_fit, *params)

No matter how far you extend x_fit, y_fit will never exceed 100 or drop below 0.

If you prefer using linear models or other standard fitting techniques, you can transform your y-values to an unbounded scale, fit the model, then transform back to stay within [0,100].

Here’s the step-by-step:

1. Convert your percentage y to a proportion: p = y / 100 (so 0 < p < 1)
2. Apply the logit transformation: z = ln(p / (1 - p)) — this maps (0,1) to (-∞, +∞)
3. Fit a model (linear, polynomial, etc.) to z vs x
4. Transform the predicted z values back to percentages: y = 100 / (1 + exp(-z_pred))

Example with linear regression:

import numpy as np
from sklearn.linear_model import LinearRegression

# Transform your data
p = y_data / 100
z = np.log(p / (1 - p))

# Fit a linear model to z and x
model = LinearRegression()
model.fit(x_data.reshape(-1, 1), z)

# Predict and convert back to percentages
x_fit = np.linspace(min(x_data), max(x_data) + 2, 100)
z_pred = model.predict(x_fit.reshape(-1, 1))
y_fit = 100 / (1 + np.exp(-z_pred))

This lets you leverage familiar models while keeping predictions bounded.

If you have a specific model in mind (like a polynomial) but need to force predictions to stay ≤100, you can use constrained optimization to minimize your loss function (e.g., mean squared error) while enforcing the bound.

Here’s an example with a quadratic polynomial using scipy.minimize:

import numpy as np
from scipy.optimize import minimize

# Define your custom polynomial model
def quadratic_model(x, params):
    a, b, c = params
    return a*x**2 + b*x + c

# Define the loss function (mean squared error)
def mse_loss(params, x, y):
    y_pred = quadratic_model(x, params)
    return np.mean((y_pred - y)**2)

# Initial guess for polynomial coefficients
initial_guess = [0.5, 10, 5]

# Add a constraint: all predicted y values must be ≤100
def constraint(params, x):
    return 100 - quadratic_model(x, params)  # ≥0 means y_pred ≤100

constraints = {'type': 'ineq', 'fun': constraint, 'args': (x_data,)}

# Run constrained minimization
result = minimize(mse_loss, initial_guess, args=(x_data, y_data), constraints=constraints)

# Generate fitted values
optimal_params = result.x
y_fit = quadratic_model(x_fit, optimal_params)

Note: Constraints might increase your fitting error slightly, so you’ll need to balance model fit and adherence to the 100% bound.

Quick Recommendation #

• If your data is trending toward saturation (approaching 100), go with the logistic function—it’s the most intuitive.
• If you want to stick with linear models, the logit transformation is a clean workaround.
• For custom models you can’t replace, constrained optimization gives you the flexibility to enforce bounds.

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