我一直在寻找，但找不到使用 julia 中的 DifferentialEquations 参数估计来拟合多个数据集的直接方法。因此，假设我们有一个带有两个参数的简单微分方程：

f1 = function (du,u,p,t)
  du[1] = - p[1]*p[2] * u[1]
end

我们有 u[1] 与 t 的实验数据集。每个数据集具有不同的 p[2] 值和/或不同的初始条件。p[1] 是我们要估计的参数。我可以通过在 for 循环中求解微分方程来实现此目的，该循环迭代不同的初始条件和 p[2] 值，将解存储在数组中并根据实验数据创建损失函数。我想知道是否有一种方法可以用更少的代码行来完成此操作，例如使用DiffEqBase.problem_new_parameters设置每个数据集的条件。在将模型拟合到实验数据时，这是一种非常常见的情况，但我在文档中找不到很好的示例。

先感谢您，

此致

编辑1

上面表达的情况只是一个简化的例子。为了使其成为一个实际案例，我们可以通过以下代码创建一些虚假的实验数据：

using DifferentialEquations

# ODE function
f1 = function (du,u,p,t)
  du[1] = - p[1]*p[2] * u[1]
end

# Initial conditions and parameter values.
# p1 is the parameter to be estimated.
# p2 and u0 are experimental parameters known for each dataset.
u0 = [1.,2.]
p1 = …

我有以下 Mathematica 代码，用于将图的边长度缩放为等于边权重。\n( ref )

edges = {1 <-> 2, 1 <-> 3, 1 <-> 4, 2 <-> 5, 2 <-> 6, 5 <-> 6, \n   3 <-> 4, 3 <-> 7, 6 <-> 7, 7 <-> 8, 2 <-> 9};\n\nvd = {{75., 25., 0}, {115., 45., 0}, {10., 5., 0}, {45., 0, 0}, \n  {90., 60., 0}, {45., 55., 0}, {0, 25., 0}, {10., 50., 0}, {115.,  25.,0}};\n\nvl = Range[Length@vd];\n\nvcoords = MapIndexed[#2[[1]] -> # &, vd];\new = {1 …

我正在研究大规模 MILP。因此，我必须将时间限制设置为合理的值，或者必须将 MIPGap 设置为合理的水平。我已经知道 gurobi 的文档了。

MIPGap：https://www.gurobi.com/documentation/6.5/refman/mipgap.html

时间限制：https://www.gurobi.com/documentation/8.0/refman/timelimit.html#parameter :TimeLimit

当 MIPGap Gurobi 在最佳百分比范围内找到解决方案时，它将停止

TimeLimit Gurobi 将在一定时间后停止。

但是您能否给我发送一个示例，其中将时间限制设置为 5 分钟或将 MIPGap 设置为 5%？

我不知道如何具体实现这些角色？

请帮助我，我对 python 很陌生

我尝试过，但这不起作用

    model.Params.TimeLimit = 5
    model.setParam("MIPGap", mipgap)

这是我的模型的简短版本

from gurobipy import *  
import csv
import geopandas as gpd
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import matplotlib.patches as mpatches
from pandas.core.common import flatten
import math

################################# SOLVE function START ###################################################################
def solve(
      
       vpmaint, wpunit, wuunit, vumaint,
       kfuel, koil, …

我想用cyipopt解决以下（宽松的，即 v(t) \xe2\x88\x88 [0, 1]）最优控制问题：

这是迄今为止我解决离散问题的方法：

import numpy as np\nimport matplotlib.pyplot as plt\nfrom cyipopt import minimize_ipopt\nfrom scipy.optimize._numdiff import approx_derivative\n\n# z = (x1(t0) .... x1(tN) x2(t0) .... x2(tN) v(t0) .... v(tN))^T\n\ndef objective(z, time):\n    x0, x1, v = np.split(z, 3)\n    res = 0.0\n    for i in range(time.size-1):\n        h = time[i+1] - time[i]\n        res += h*((x0[i]-1)**2 + (x1[i]-1)**2)\n    return res\n\n\ndef ode_rhs(t, x, v):\n    x0, x1 = x\n    xdot1 = x0 - x0*x1 - 0.4*x0*v\n    xdot2 = -x1 + x0*x1 …

我读到 scipy 中的 linprog 返回最小解决方案，并且可以通过将目标函数乘以 -1 来获得最佳解决方案。

我在这里读到它： https: //realpython.com/linear-programming-python/ 我已经测试了他们提供的示例，看看我是否也能得到最小的解决方案——我可以。


关于我试图解决的问题，我希望解决方案是：

opt_sol1.x = [0.61538462 0.38461538]
opt_sol2.x = [0.0, 1.0]

但在两种情况下我都得到相同的结果 [0.61538462 0.38461538] 为什么？-- 我的猜测是它与我的目标函数中的值相互接近有关，但只是猜测有没有一种方法可以得到我正在寻找的第二个解决方案？

from scipy.optimize import linprog

obj_fct1 = [0.5, 0.5]
obj_fct2 = [-0.5, -0.5]
lhs_ineq = [[1.5, 0.2]]
rhs_ineq = [1]
lhs_eq = [[1,1]]
rhs_eq = [1]
bnds = [(0, 1),
          (0, 1)]

opt_sol1 = linprog(c=obj_fct1,
                  A_ub=lhs_ineq,
                  b_ub=rhs_ineq,
                  A_eq=lhs_eq,
                  b_eq=rhs_eq,
                  bounds=bnds)
print(opt_sol1.x)
print("------------------------------------------")
opt_sol2 = linprog(c=obj_fct2,
                  A_ub=lhs_ineq,
                  b_ub=rhs_ineq,
                  A_eq=lhs_eq,
                  b_eq=rhs_eq,
                  bounds=bnds)
print(opt_sol2.x)


>>> [0.61538462 0.38461538]
>>> ------------------------------------------ …

我正在尝试构建一个应用程序来检测来自网页的广告图像.一旦我发现了那些,我就不会允许那些在客户端显示.

基本上我使用反向传播算法来训练神经网络使用这里给出的数据集:http://archive.ics.uci.edu/ml/datasets/Internet+Advertisements.

但是在那个数据集中没有.属性非常高.事实上,该项目的一位导师告诉我,如果你训练具有许多属性的神经网络,那么需要花费大量的时间来接受训练.那么有没有办法优化输入数据集？或者我只需要使用那么多属性？

我目前正在编写一段代码,它只是简单地使用布尔值来查看屏幕是否垂直翻转.这完成了:

glOrtho(0.0f, _width, flip ? 0.0f : _height, flip ? _height : 0.0f, -1.0f, 1.0f);

我想知道是否会有更优化的方法来做到这一点,例如:

glOrtho(0.0f, _width, !flip * _height, flip * _height, -1.0f, 1.0f);

或者按位操作会有效吗？

感谢您的任何反馈!

我用c ++编写代码并调用CPLEX来解决它.它很快找到了一个非常好的解决方案,但需要很长时间才能改进它.所以我想将间隙设置为更大的值来终止代码,这就是我使用的:

    cplex_model.setParam(EpGap, 0.01);

但编译器给我一个错误,说EpGap是一个未声明的标识符.相对差距的默认名称是什么？

我知道每个粒子都是特定功能的解决方案,每个粒子和群体都在不断寻找最佳解决方案.如果在第一次迭代后发现全局最佳,并且没有新的粒子被添加到混合中,那么循环是否应该退出并且第一个全局最佳找到的是最合适的解决方案？如果是这种情况,那么PSO比仅仅迭代列表更好.

我打算做一个简单的线性拟合具有两个numpy的阵列y1和y2长度54各自的。该函数定义如下：

def f(x,b):
    return b*x

数据绘制在这里：

然后我尝试通过以下方式拟合：

popt, pcov = scop.curve_fit(f,y2,y1)  # yes y1 and y2 are in right order

结果： popt = 1., pcov = inf

我尝试过p0 = -833，结果差不多是多少，但这给了我popt = -833, pcov = inf。

我使用示例函数尝试了一些示例数据：

x = np.array(range(10))
y = x**2 + 3
def fu(x,b):
    return x**2 + b
po, pc = scop.curve_fit(fu,x,y)
print po, pc

结果很好：3和2e-33

有人对第一次审判出了什么问题有想法吗？我还没有发现任何有用的东西或与我的问题有关的信息...