Python 我收到此错误消息：无法根据规则将数组数据从dtype（'；O'；）强制转换为dtype（'；float64'；）；安全'；

这是我的密码

import numpy as np
from scipy.optimize import minimize
import sympy as sp
sp.init_printing()
from sympy import *
from sympy import Symbol, Matrix

rom sympy import *
def make_Aij(m, n, a='a') :
    from sympy import Symbol, Matrix # just in case they aren't already loaded
    A = zeros(m, n)
    for i in range(0, m) :
        for j in range(0, n) :
            s = a+'_'+str(i)+str(j)
            exec  (s + "= Symbol('" + s + "')") # go look up what "exec" does!
            exec ("A[i, j] = " + s)
    return A
C = make_Aij(1, 2, 'c')
C

z = C[0,0]
g = C[0,0]**2-C[0,1]**2
g
h = C[0,0]
h

#Function defined
def function(h):
    return g
g

#Jacobian working with sympy
q = diff(g,C[0,0])
q

#Jacobian final
def jacobian(h):
    return q
q

Hf = diff(q,C[0,0])
Hf

#Hessianf
def Hessianf(h):
    return Hf
Hf

from scipy.optimize import Bounds
bounds = Bounds(-1, 1)

h0 = (0*C[0,1])

res = minimize(function, h0, method='trust-constr', jac=jacobian, hess=Hessianf,
               
               options={'verbose': 1}, bounds=bounds)

错误消息： ---------------------------------------------------------------------------

TypeError                                 Traceback (most recent call last)
<ipython-input-41-94c28f7f32b2> in <module>
----> 1 res = minimize(function, h0, method='trust-constr', jac=jacobian, hess=Hessianf,
      2 
      3                options={'verbose': 1}, bounds=bounds)

~\anaconda3\lib\site-packages\scipy\optimize\_minimize.py in minimize(fun, x0, args, method, jac, hess, hessp, bounds, constraints, tol, callback, options)
    626                                constraints, callback=callback, **options)
    627     elif meth == 'trust-constr':
--> 628         return _minimize_trustregion_constr(fun, x0, args, jac, hess, hessp,
    629                                             bounds, constraints,
    630                                             callback=callback, **options)

~\anaconda3\lib\site-packages\scipy\optimize\_trustregion_constr\minimize_trustregion_constr.py in _minimize_trustregion_constr(fun, x0, args, grad, hess, hessp, bounds, constraints, xtol, gtol, barrier_tol, sparse_jacobian, callback, maxiter, verbose, finite_diff_rel_step, initial_constr_penalty, initial_tr_radius, initial_barrier_parameter, initial_barrier_tolerance, factorization_method, disp)
    507 
    508     elif method == 'tr_interior_point':
--> 509         _, result = tr_interior_point(
    510             objective.fun, objective.grad, lagrangian_hess,
    511             n_vars, canonical.n_ineq, canonical.n_eq,

~\anaconda3\lib\site-packages\scipy\optimize\_trustregion_constr\tr_interior_point.py in tr_interior_point(fun, grad, lagr_hess, n_vars, n_ineq, n_eq, constr, jac, x0, fun0, grad0, constr_ineq0, jac_ineq0, constr_eq0, jac_eq0, stop_criteria, enforce_feasibility, xtol, state, initial_barrier_parameter, initial_tolerance, initial_penalty, initial_trust_radius, factorization_method)
    319     while True:
    320         # Solve SQP subproblem
--> 321         z, state = equality_constrained_sqp(
    322             subprob.function_and_constraints,
    323             subprob.gradient_and_jacobian,

~\anaconda3\lib\site-packages\scipy\optimize\_trustregion_constr\equality_constrained_sqp.py in equality_constrained_sqp(fun_and_constr, grad_and_jac, lagr_hess, x0, fun0, grad0, constr0, jac0, stop_criteria, state, initial_penalty, initial_trust_radius, factorization_method, trust_lb, trust_ub, scaling)
     80     Z, LS, Y = projections(A, factorization_method)
     81     # Compute least-square lagrange multipliers
---> 82     v = -LS.dot(c)
     83     # Compute Hessian
     84     H = lagr_hess(x, v)

~\anaconda3\lib\site-packages\scipy\sparse\linalg\interface.py in dot(self, x)
    416 
    417             if x.ndim == 1 or x.ndim == 2 and x.shape[1] == 1:
--> 418                 return self.matvec(x)
    419             elif x.ndim == 2:
    420                 return self.matmat(x)

~\anaconda3\lib\site-packages\scipy\sparse\linalg\interface.py in matvec(self, x)
    230             raise ValueError('dimension mismatch')
    231 
--> 232         y = self._matvec(x)
    233 
    234         if isinstance(x, np.matrix):

~\anaconda3\lib\site-packages\scipy\sparse\linalg\interface.py in _matvec(self, x)
    528 
    529     def _matvec(self, x):
--> 530         return self.__matvec_impl(x)
    531 
    532     def _rmatvec(self, x):

~\anaconda3\lib\site-packages\scipy\optimize\_trustregion_constr\projections.py in least_squares(x)
    151         # lu_sol = [aux]
    152         #          [ z ]
--> 153         lu_sol = solve(v)
    154         # return z = inv(A A.T) A x
    155         return lu_sol[n:m+n]

TypeError: Cannot cast array data from dtype('O') to dtype('float64') according to the rule 'safe'

TypeError回溯（最近一次调用）
在里面
---->1 res=最小化（函数，h0，方法='trust-constr'，jac=雅可比矩阵，hess=Hessianf，
2.
3选项={'verbose'：1}，界限=界限）
最小化中的~\anaconda3\lib\site packages\scipy\optimize\\u minimize.py（fun、x0、args、method、jac、hess、hessp、bounds、constraints、tol、callback、options）
626约束，回调=回调，**选项）
627 elif meth=='trust Const'：
-->628返回最小信任区域（fun、x0、args、jac、hess、hessp、，
629边界、约束条件，
630回调=回调，**选项）
~\anaconda3\lib\site packages\scipy\optimize\\u trustregion\u constr\minimize\u trustregion\u constr.py in\u minimize\u trustregion\u constr（fun、x0、args、grad、hess、hessp、bounds、constraints、xtol、gtol、barrier、sparse\u jacobian、回调、maxiter、verbose、有限差分相关步长、初始构造惩罚、初始tr\u半径、初始barrier\u参数、初始barrier\u容差、因子分解法、disp）
507
508 elif方法=='tr_内部_点'：
-->509，结果=tr_内部点(
510 objective.fun，objective.grad，lagrangian_hess，
511 n_变量，canonical.n_ineq，canonical.n_eq，
~\anaconda3\lib\site packages\scipy\optimize\\u trustregion\u constr\tr\u interior\u point.py in tr\u interior\u point（fun、grad、lagr_hess、n_vars、n_ineq、n_eq、constr、jac、x0、fun0、grad0、constru ineq0、jac_ineq0、constru eq0、jac_eq0、stop_标准、强制执行可行性、xtol、状态、初始障碍参数、初始公差、初始惩罚、初始信任半径、因子分解法）
319虽然正确：
320#求解SQP子问题
-->321 z，状态=相等\u约束\u sqp(
322子B.函数和约束，
323 b.梯度和雅可比矩阵，
~\anaconda3\lib\site packages\scipy\optimize\\信任区\约束\约束\约束\约束\约束\约束\约束\约束\约束\约束\约束\约束\约束\约束\约束（乐趣\约束、梯度\约束、拉格\赫斯、x0、fun0、梯度\约束、约束\约束\约束\约束\约束\约束\约束\约束\约束\约束\约束\约束\约束\约束\约束\约束\约束\约束\约束\约束\约束\约束\约束\约束\约束\约束\约束\约束\约束\约束\约束\约束\约束\约束\约束\约束\约束\约束\约束\约束\约束\约束\约束\约束\约束\
80 Z，LS，Y=投影（A，因式分解法）
81#计算最小二乘拉格朗日乘数
--->82 v=-LS.dot（c）
83#计算Hessian
84 H=lagr_hess（x，v）
~\anaconda3\lib\site packages\scipy\sparse\linalg\interface.py点（self，x）格式
416
417如果x.ndim==1或x.ndim==2且x.shape[1]==1：
-->418返回自我matvec（x）
419 elif x.ndim==2：
420返回自组装材料（x）
matvec中的~\anaconda3\lib\site packages\scipy\sparse\linalg\interface.py（self，x）
230提升值错误（“维度不匹配”）
231
-->232 y=self.\u matvec（x）
233
234如果存在（x，np.矩阵）：
matvec（self，x）中的~\anaconda3\lib\site packages\scipy\sparse\linalg\interface.py
528
529 def_matvec（自我，x）：
-->530返回自我。\uuu matvec\u impl（x）
531
532定义向量（自身，x）：
~\anaconda3\lib\site packages\scipy\optimize\\u trustregion\u constr\projections.py最小二乘法（x）
151#lu#u sol=[aux]
152#[z]
-->153 lu_sol=求解（v）
154#返回z=inv（A.T）A x
155返回lu_sol[n:m+n]
TypeError:无法根据规则“safe”将数组数据从dtype（'O'）强制转换为dtype（'float64'）

我只想计算2变量函数f（c00，c01）沿c00轴的最小值，有一些界限。因此，我应该得到c00作为c01的函数（这里c01是一个参数）。我认为问题来自与scipy.optimize相关的symphy函数

---

提前感谢。

符号的

symphy

与数字的

scipy

和

numpy

不兼容。数字函数不理解

symphy

的符号

要使这些功能协同工作，所有符号函数都需要转换为numpy等价物。

symphy

的

lambdify

可以将symphy表达式转换为numpy函数。在代码中，可以按如下方式使用它：

np_函数=sp.lambdify（h，函数（h））
np_雅可比矩阵=sp.lambdify（h，雅可比矩阵（h））
np_hessian=sp.lambdify（h，Hessianf（h））
res=最小化（np_函数，h0，方法='trust-constr'，jac=np_雅可比，hess=np_hessian，
选项={'verbose'：1}，界限=界限）

scipy

解算器使用数值

numpy

数组。如果存在

sympy

对象（符号、表达式等），它们将生成对象

dtype

数组，而

scipy

代码无法处理这些数组（即无法将符号转换为浮点数）。将

symphy

与

scipy

一起使用的唯一方法是首先将表达式转换为

numpy

函数，与

symphy.lambdify

一起使用。效果很好，非常感谢您迟到。很抱歉，我忽略了您的答案，是的，效果很好，非常感谢！