Scipy optimize fmin报错ValueError：用序列设置数组元素求助

Hey there! Let's work through this ValueError you're stuck on with Scipy's optimize.fmin. I’ve helped troubleshoot similar issues for new Python/Scipy folks before, so let’s break this down step by step.

First, let’s get to the root of that error: it almost always means Scipy’s optimizer is expecting a single scalar value (like a float) from your cost function, but you’re returning a sequence/array instead. Or, if you’re passing a gradient, the gradient’s shape doesn’t match the input parameter vector’s shape. Even though you tried grabbing J[0,0] or J[0], there might be other hidden issues here.

Here are the key troubleshooting steps to try:

1. Double-check which optimizer you’re using #

Wait a second—scipy.optimize.fmin (the simplex method) doesn’t support passing gradient information at all. If you’re trying to return both the cost J and gradient grad from your function, you’re using the wrong optimizer! You should be using fmin_bfgs instead if you want to supply a gradient.

If you are using fmin_bfgs, make sure you’re either:

• Passing the gradient as a separate fprime function, or
• Having your cost function return a tuple (J, grad) and setting fprime=None in the optimizer call.

If you were accidentally using plain fmin while returning two values, that’s definitely triggering the error.

2. Verify your cost return is a true scalar #

Even if you’re grabbing J[0,0] or J[0], make sure that value is a float, not a 0-dimensional numpy array. Add a quick print statement right before returning to check:

print(type(J), J.shape)  # Should output <class 'float'> or () for scalar array

If it’s still an array, wrap it in float(J) to force it to a scalar.

3. Make sure your gradient matches the parameter shape #

If you’re supplying a gradient, its shape must exactly match the shape of your parameter vector (e.g., if your theta is a (n,) 1D array, the gradient must also be (n,)). Common mistakes here:

• Your gradient is a column vector (n,1) or row vector (1,n) instead of 1D. Fix this with grad.flatten() or grad.reshape(-1).
• The regularization term in your gradient has a dimension mismatch (e.g., you’re adding a 2D array to a 1D array).

4. Audit your regularized logistic regression code #

Let’s walk through common pitfalls in this specific cost function:

• Regularization term: Make sure you’re not applying regularization to the intercept term (theta[0]). If you’re including theta[0] in the sum, that’s okay, but double-check the math returns a scalar.
• Sigmoid output: Ensure your sigmoid function isn’t returning a 2D array when it should be 1D—this can cascade into cost/gradient shape issues.
• Matrix multiplication: If you’re using @ or dot, confirm the dimensions of X, theta, and y align correctly. For example, X should be (m, n), theta (n,), y (m,).

Here’s a quick example of a correctly structured regularized logistic regression cost function that plays nice with fmin_bfgs:

import numpy as np
from scipy.optimize import fmin_bfgs

def sigmoid(z):
    return 1 / (1 + np.exp(-z))

def reg_logistic_cost(theta, X, y, lambda_):
    m = len(y)
    h = sigmoid(X @ theta)
    
    # Calculate cost (ensure scalar output)
    term1 = -y @ np.log(h)
    term2 = -(1 - y) @ np.log(1 - h)
    reg_term = (lambda_ / (2 * m)) * np.sum(theta[1:] ** 2)
    J = (term1 + term2) / m + reg_term
    
    # Calculate gradient (match theta's shape)
    error = h - y
    grad = (X.T @ error) / m
    grad[1:] += (lambda_ / m) * theta[1:]  # Skip regularization for intercept
    
    return float(J), grad.flatten()  # Force scalar J, 1D grad

# Example usage
X = np.hstack((np.ones((100,1)), np.random.rand(100,2)))  # Add intercept column
y = np.random.randint(0, 2, 100)
initial_theta = np.zeros(3)

result = fmin_bfgs(reg_logistic_cost, initial_theta, args=(X, y, 0.5), fprime=None)

5. Use the error stack trace to pinpoint the issue #

Look at the line numbers in your error stack—does the error originate inside your cost function, or inside Scipy’s optimizer code?

• If it’s in your code: Check the line where you calculate J or grad for dimension mismatches.
• If it’s in Scipy’s code: The problem is almost certainly that your return values (J or grad) have the wrong shape.

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