优化SciPy优化函数输入：解决矩阵维度不匹配与提升代码效率

import numpy as np
from scipy import optimize
import math

# 定义矩阵维度
rows, cols = 4, 4

# 示例数据
guess = np.array([
    [1, -1, 2, 0],
    [0,  2, 0, 0],
    [1,  0, 0, 1],
    [0,  1, 2, 0]
])
inputArray = np.array([
    [2, 4, 6, 9],
    [2, 3, 1, 0],
    [7, 2, 6, 4],
    [1, 5, 2, 1]
])
goalArray = np.array([
    [14, 5, 17, 17],
    [4,  6, 2,   0],
    [3,  9, 8,  10],
    [16, 7, 13,  8]
])

# 修正后的目标函数
def objfunc(guess_flat, inputArray, goalArray):
    # 核心修正：将展平的guess_flat重塑回原始矩阵形状
    guess = guess_flat.reshape((rows, cols))

    model = guess @ inputArray # 矩阵乘法

    # 计算误差：使用NumPy向量化操作替代循环
    # 原始问题中是求差的绝对值之和，等同于L1范数
    # sum_error = np.sum(np.abs(goalArray - model))
    # 如果是欧几里得距离（L2范数），则使用：
    sum_error = np.linalg.norm(goalArray - model, ord='fro') # Frobenius范数等同于展平后的L2范数

    return sum_error

# 验证修正后的目标函数
print(f"Initial guess shape: {guess.shape}")
print(f"Input array shape: {inputArray.shape}")
print(f"Initial objective function value: {objfunc(guess.ravel(), inputArray, goalArray):.4f}")

# 调用optimize.fmin进行优化
# 注意：fmin的x0参数应为一维数组，因此需要对guess进行ravel()操作
minimum_fmin = optimize.fmin(objfunc, guess.ravel(), args=(inputArray, goalArray))

print("\n--- Results from optimize.fmin ---")
print(f"Optimized flat array: {minimum_fmin}")
print(f"Reshaped optimized matrix:\n{minimum_fmin.reshape((rows, cols))}")

    sum = 0
    for i in range(rows):
        for j in range(cols):
            sum = sum + math.sqrt((goalArray[i][j] - model[i][j]) ** 2)

# 使用optimize.minimize进行优化
# x0 参数必须是展平的一维数组
minimum_result = optimize.minimize(objfunc, guess.ravel(), args=(inputArray, goalArray), method='BFGS')

print("\n--- Results from optimize.minimize (BFGS) ---")
print(f"Optimization successful: {minimum_result.success}")
print(f"Message: {minimum_result.message}")
print(f"Final objective function value: {minimum_result.fun:.4f}")
print(f"Optimized flat array: {minimum_result.x}")
print(f"Reshaped optimized matrix:\n{minimum_result.x.reshape((rows, cols))}")

# 尝试不同的优化方法，例如'Nelder-Mead' (fmin的默认方法)
minimum_result_nm = optimize.minimize(objfunc, guess.ravel(), args=(inputArray, goalArray), method='Nelder-Mead')
print("\n--- Results from optimize.minimize (Nelder-Mead) ---")
print(f"Optimization successful: {minimum_result_nm.success}")
print(f"Message: {minimum_result_nm.message}")
print(f"Final objective function value: {minimum_result_nm.fun:.4f}")
print(f"Reshaped optimized matrix:\n{minimum_result_nm.x.reshape((rows, cols))}")

# 检查inputArray是否可逆
if np.linalg.det(inputArray) != 0:
    # 使用线性代数直接求解
    solution_linalg = np.linalg.solve(inputArray.T, goalArray.T).T
    print("\n--- Solution using Linear Algebra (np.linalg.solve) ---")
    print(f"Directly calculated transformation matrix:\n{solution_linalg}")
    # 验证解的准确性
    calculated_goal = solution_linalg @ inputArray
    print(f"Verifying result (solution_linalg @ inputArray):\n{calculated_goal}")
    print(f"Difference from goalArray (should be close to zero):\n{np.abs(goalArray - calculated_goal).sum():.4f}")
else:
    print("\ninputArray is singular, cannot solve directly using linear algebra.")