Python &引用；“未找到解决方案”；更改参数、目标函数和初始条件时使用Gekko优化套件时出错_Python_Optimization_Gekko

Python &引用；“未找到解决方案”；更改参数、目标函数和初始条件时使用Gekko优化套件时出错

python optimization

Python &引用；“未找到解决方案”；更改参数、目标函数和初始条件时使用Gekko优化套件时出错,python,optimization,gekko,Python,Optimization,Gekko,我试图用Gekko套件解决各种初始条件下的多个优化问题。分配初始条件，使用Gekko运行优化，并收集每个解决方案。当我试图更改参数、目标函数或初始条件时，Gekko经常给我“Solution Not Found error:solve raise Exception（apm_error）中的第2130行。”我在下面介绍一些案例，希望得到解决我遇到的问题的建议。我之前也有过类似的问题，但我希望这个问题更简洁明了。多谢各位案例1。运行良好，没有错误 from gekko import GEKKO

我试图用Gekko套件解决各种初始条件下的多个优化问题。分配初始条件，使用Gekko运行优化，并收集每个解决方案。当我试图更改参数、目标函数或初始条件时，Gekko经常给我“Solution Not Found error:solve raise Exception（apm_error）中的第2130行。”我在下面介绍一些案例，希望得到解决我遇到的问题的建议。我之前也有过类似的问题，但我希望这个问题更简洁明了。多谢各位

案例1。运行良好，没有错误

from gekko import GEKKO
import pandas as pd
import numpy as np

dat = {'A0': [23221, 2198, 4296, 104906, 691], 'h': [0.04, 0.25, 0.07, 0, 12.58],'emax': [23221, 2198, 4296, 104906, 691] }
dftemp = pd.DataFrame(data=dat)
na=len(dftemp)

# time points
n=51
year=50

# constants
Pa0 = 3.061 
Pe0 = 10.603 
C0 = 100 
r = 0.05 
k=50 
shift=10000000 # to make positive inside log function
ll=0.15

  
for i in range(0,na):
    # create GEKKO model
    m = GEKKO(remote=False)

    m.time = np.linspace(0,year,n)
    t=m.time
    
    A0=dftemp.loc[i][0]
    h=dftemp.loc[i][1]
    emax=dftemp.loc[i][2]    
    
    A = m.SV(value=A0, lb=0, ub=A0)
    E = m.SV(value=0, lb=0, ub=A0)

    u = m.MV(value=0, lb=-emax, ub=emax) 
    u.STATUS = 1

    t = m.Param(value=m.time)
    C = m.Var(value=C0)
    d = m.Var(value=1)
    l = m.Param(value=ll)
    
    # Equation
    m.Equation(A.dt()==-u)
    m.Equation(E.dt()==u)
    m.Equation(C.dt()==-C/k)
    m.Equation(d==m.exp(-t*r))
    # Objective (Utility)
    J = m.Var(value=0)
    
    # Final objective
    Jf = m.FV()
    Jf.STATUS = 1
    m.Connection(Jf,J,pos2='end')
    m.Equation(J.dt() == m.log((A+E*(1-l))*h*Pa0-C*u+E*Pe0+shift)*d)
    
    # maximize U
    m.Maximize(Jf)
    
    # options
    m.options.IMODE = 6  # optimal control
    m.options.NODES = 3  # collocation nodes
    m.options.SOLVER = 3 # solver (IPOPT)
    
    # solve optimization problem
    m.solve()
    
    # print profit
    print('Optimal Profit: ' + str(Jf.value[0]))

案例2。将“时间点”的数量从

n=51

更改为

n=501

发生错误

from gekko import GEKKO
import pandas as pd
import numpy as np

dat = {'A0': [23221, 2198, 4296, 104906, 691], 'h': [0.04, 0.25, 0.07, 0, 12.58],'emax': [23221, 2198, 4296, 104906, 691] }
dftemp = pd.DataFrame(data=dat)
na=len(dftemp)

# time points
n=501 
year=50

# constants
Pa0 = 3.061 
Pe0 = 10.603 
C0 = 100 
r = 0.05 
k=50 
shift=10000000 # to make positive inside log function
ll=0.15

   
for i in range(0,na):
    # create GEKKO model
    m = GEKKO(remote=False)

    m.time = np.linspace(0,year,n)
    t=m.time
    
    A0=dftemp.loc[i][0]
    h=dftemp.loc[i][1]
    emax=dftemp.loc[i][2]    
    
    A = m.SV(value=A0, lb=0, ub=A0)
    E = m.SV(value=0, lb=0, ub=A0)

    u = m.MV(value=0, lb=-emax, ub=emax) 
    u.STATUS = 1

    t = m.Param(value=m.time)
    C = m.Var(value=C0)
    d = m.Var(value=1)
    l = m.Param(value=ll)
    
    # Equation
    m.Equation(A.dt()==-u)
    m.Equation(E.dt()==u)
    m.Equation(C.dt()==-C/k)
    m.Equation(d==m.exp(-t*r))
    # Objective (Utility)
    J = m.Var(value=0)
    
    # Final objective
    Jf = m.FV()
    Jf.STATUS = 1
    m.Connection(Jf,J,pos2='end')
    m.Equation(J.dt() == m.log((A+E*(1-l))*h*Pa0-C*u+E*Pe0+shift)*d)
    
    # maximize U
    m.Maximize(Jf)
    
    # options
    m.options.IMODE = 6  # optimal control
    m.options.NODES = 3  # collocation nodes
    m.options.SOLVER = 3 # solver (IPOPT)
    
    # solve optimization problem
    m.solve()
    
    # print profit
    print('Optimal Profit: ' + str(Jf.value[0]))

from gekko import GEKKO
import pandas as pd
import numpy as np

dat = {'A0': [23221, 2198, 4296, 104906, 691], 'h': [0.04, 0.25, 0.07, 0, 12.58],'emax': [23221, 2198, 4296, 104906, 691] }
dftemp = pd.DataFrame(data=dat)
na=len(dftemp)

# time points
n=51
year=50

# constants
Pa0 = 3.061 
Pe0 = 10.603 
C0 = 100 
r = 0.05 
k=50 
shift=10000000 # to make positive inside log function
ll=0.15

    
for i in range(0,na):
    # create GEKKO model
    m = GEKKO(remote=False)

    m.time = np.linspace(0,year,n)
    t=m.time
    
    A0=dftemp.loc[i][0]
    h=dftemp.loc[i][1]
    emax=dftemp.loc[i][2]    
    
    A = m.SV(value=A0, lb=0, ub=A0)
    E = m.SV(value=0, lb=0, ub=A0)

    u = m.MV(value=0, lb=-emax, ub=emax) 
    u.STATUS = 1

    t = m.Param(value=m.time)
    C = m.Var(value=C0)
    d = m.Var(value=1)
    l = m.Param(value=ll)
    
    # Equation
    m.Equation(A.dt()==-u)
    m.Equation(E.dt()==u)
    m.Equation(C.dt()==-C/k)
    m.Equation(d==m.exp(-t*r))
    # Objective (Utility)
    J = m.Var(value=0)
    
    # Final objective
    Jf = m.FV()
    Jf.STATUS = 1
    m.Connection(Jf,J,pos2='end')
    m.Equation(J.dt() == ((A+E*(1-l))*h*Pa0-C*u+E*Pe0+shift))
    
    # maximize U
    m.Maximize(Jf)
    
    # options
    m.options.IMODE = 6  # optimal control
    m.options.NODES = 3  # collocation nodes
    m.options.SOLVER = 3 # solver (IPOPT)
    
    # solve optimization problem
    m.solve()
    
    # print profit
    print('Optimal Profit: ' + str(Jf.value[0]))

from gekko import GEKKO
import pandas as pd
import numpy as np

dat = {'A0': [23221, 2198, 4296, 104906, 691], 'h': [0.04, 0.25, 0.07, 0, 12.58],'emax': [23221, 2198, 4296, 104906, 691] }
dftemp = pd.DataFrame(data=dat)
na=len(dftemp)

# time points
n=51
year=50

# constants
Pa0 = 3.061 
Pe0 = 10.603 
C0 = 100 
r = 0.05 
k=50 
shift=0 
ll=0.15
    
for i in range(0,na):
    # create GEKKO model
    m = GEKKO(remote=False)

    m.time = np.linspace(0,year,n)
    t=m.time
    
    A0=dftemp.loc[i][0]
    h=dftemp.loc[i][1]
    emax=dftemp.loc[i][2]    
    
    A = m.SV(value=A0, lb=0, ub=A0)
    E = m.SV(value=0, lb=0, ub=A0)

    u = m.MV(value=0, lb=-emax, ub=emax) 
    u.STATUS = 1

    t = m.Param(value=m.time)
    C = m.Var(value=C0)
    d = m.Var(value=1)
    l = m.Param(value=ll)
    
    # Equation
    m.Equation(A.dt()==-u)
    m.Equation(E.dt()==u)
    m.Equation(C.dt()==-C/k)
    m.Equation(d==m.exp(-t*r))
    # Objective (Utility)
    J = m.Var(value=0)
    
    # Final objective
    Jf = m.FV()
    Jf.STATUS = 1
    m.Connection(Jf,J,pos2='end')
    m.Equation(J.dt() == ((A+E*(1-l))*h*Pa0-C*u+E*Pe0+shift)*d)
    
    # maximize U
    m.Maximize(Jf)
    
    # options
    m.options.IMODE = 6  # optimal control
    m.options.NODES = 3  # collocation nodes
    m.options.SOLVER = 3 # solver (IPOPT)
    
    # solve optimization problem
    m.solve()
    
    # print profit
    print('Optimal Profit: ' + str(Jf.value[0]))

案例3。将目标函数从

m.log

更改为简单线性和。效果很好

from gekko import GEKKO
import pandas as pd
import numpy as np

dat = {'A0': [23221, 2198, 4296, 104906, 691], 'h': [0.04, 0.25, 0.07, 0, 12.58],'emax': [23221, 2198, 4296, 104906, 691] }
dftemp = pd.DataFrame(data=dat)
na=len(dftemp)

# time points
n=51
year=50

# constants
Pa0 = 3.061 
Pe0 = 10.603 
C0 = 100 
r = 0.05 
k=50 
shift=10000000 # to make positive inside log function
ll=0.15
    
for i in range(0,na):
    # create GEKKO model
    m = GEKKO(remote=False)

    m.time = np.linspace(0,year,n)
    t=m.time
    
    A0=dftemp.loc[i][0]
    h=dftemp.loc[i][1]
    emax=dftemp.loc[i][2]    
    
    A = m.SV(value=A0, lb=0, ub=A0)
    E = m.SV(value=0, lb=0, ub=A0)

    u = m.MV(value=0, lb=-emax, ub=emax) 
    u.STATUS = 1

    t = m.Param(value=m.time)
    C = m.Var(value=C0)
    d = m.Var(value=1)
    l = m.Param(value=ll)
    
    # Equation
    m.Equation(A.dt()==-u)
    m.Equation(E.dt()==u)
    m.Equation(C.dt()==-C/k)
    m.Equation(d==m.exp(-t*r))
    # Objective (Utility)
    J = m.Var(value=0)
    
    # Final objective
    Jf = m.FV()
    Jf.STATUS = 1
    m.Connection(Jf,J,pos2='end')
    m.Equation(J.dt() == ((A+E*(1-l))*h*Pa0-C*u+E*Pe0+shift)*d)
    
    # maximize U
    m.Maximize(Jf)
    
    # options
    m.options.IMODE = 6  # optimal control
    m.options.NODES = 3  # collocation nodes
    m.options.SOLVER = 3 # solver (IPOPT)
    
    # solve optimization problem
    m.solve()
    
    # print profit
    print('Optimal Profit: ' + str(Jf.value[0]))

案例4。将目标函数从

m.log

更改为简单求和，并从目标函数中删除“变量”

。发生错误

from gekko import GEKKO
import pandas as pd
import numpy as np

dat = {'A0': [23221, 2198, 4296, 104906, 691], 'h': [0.04, 0.25, 0.07, 0, 12.58],'emax': [23221, 2198, 4296, 104906, 691] }
dftemp = pd.DataFrame(data=dat)
na=len(dftemp)

# time points
n=501 
year=50

# constants
Pa0 = 3.061 
Pe0 = 10.603 
C0 = 100 
r = 0.05 
k=50 
shift=10000000 # to make positive inside log function
ll=0.15

   
for i in range(0,na):
    # create GEKKO model
    m = GEKKO(remote=False)

    m.time = np.linspace(0,year,n)
    t=m.time
    
    A0=dftemp.loc[i][0]
    h=dftemp.loc[i][1]
    emax=dftemp.loc[i][2]    
    
    A = m.SV(value=A0, lb=0, ub=A0)
    E = m.SV(value=0, lb=0, ub=A0)

    u = m.MV(value=0, lb=-emax, ub=emax) 
    u.STATUS = 1

    t = m.Param(value=m.time)
    C = m.Var(value=C0)
    d = m.Var(value=1)
    l = m.Param(value=ll)
    
    # Equation
    m.Equation(A.dt()==-u)
    m.Equation(E.dt()==u)
    m.Equation(C.dt()==-C/k)
    m.Equation(d==m.exp(-t*r))
    # Objective (Utility)
    J = m.Var(value=0)
    
    # Final objective
    Jf = m.FV()
    Jf.STATUS = 1
    m.Connection(Jf,J,pos2='end')
    m.Equation(J.dt() == m.log((A+E*(1-l))*h*Pa0-C*u+E*Pe0+shift)*d)
    
    # maximize U
    m.Maximize(Jf)
    
    # options
    m.options.IMODE = 6  # optimal control
    m.options.NODES = 3  # collocation nodes
    m.options.SOLVER = 3 # solver (IPOPT)
    
    # solve optimization problem
    m.solve()
    
    # print profit
    print('Optimal Profit: ' + str(Jf.value[0]))

from gekko import GEKKO
import pandas as pd
import numpy as np

dat = {'A0': [23221, 2198, 4296, 104906, 691], 'h': [0.04, 0.25, 0.07, 0, 12.58],'emax': [23221, 2198, 4296, 104906, 691] }
dftemp = pd.DataFrame(data=dat)
na=len(dftemp)

# time points
n=51
year=50

# constants
Pa0 = 3.061 
Pe0 = 10.603 
C0 = 100 
r = 0.05 
k=50 
shift=10000000 # to make positive inside log function
ll=0.15

    
for i in range(0,na):
    # create GEKKO model
    m = GEKKO(remote=False)

    m.time = np.linspace(0,year,n)
    t=m.time
    
    A0=dftemp.loc[i][0]
    h=dftemp.loc[i][1]
    emax=dftemp.loc[i][2]    
    
    A = m.SV(value=A0, lb=0, ub=A0)
    E = m.SV(value=0, lb=0, ub=A0)

    u = m.MV(value=0, lb=-emax, ub=emax) 
    u.STATUS = 1

    t = m.Param(value=m.time)
    C = m.Var(value=C0)
    d = m.Var(value=1)
    l = m.Param(value=ll)
    
    # Equation
    m.Equation(A.dt()==-u)
    m.Equation(E.dt()==u)
    m.Equation(C.dt()==-C/k)
    m.Equation(d==m.exp(-t*r))
    # Objective (Utility)
    J = m.Var(value=0)
    
    # Final objective
    Jf = m.FV()
    Jf.STATUS = 1
    m.Connection(Jf,J,pos2='end')
    m.Equation(J.dt() == ((A+E*(1-l))*h*Pa0-C*u+E*Pe0+shift))
    
    # maximize U
    m.Maximize(Jf)
    
    # options
    m.options.IMODE = 6  # optimal control
    m.options.NODES = 3  # collocation nodes
    m.options.SOLVER = 3 # solver (IPOPT)
    
    # solve optimization problem
    m.solve()
    
    # print profit
    print('Optimal Profit: ' + str(Jf.value[0]))

from gekko import GEKKO
import pandas as pd
import numpy as np

dat = {'A0': [23221, 2198, 4296, 104906, 691], 'h': [0.04, 0.25, 0.07, 0, 12.58],'emax': [23221, 2198, 4296, 104906, 691] }
dftemp = pd.DataFrame(data=dat)
na=len(dftemp)

# time points
n=51
year=50

# constants
Pa0 = 3.061 
Pe0 = 10.603 
C0 = 100 
r = 0.05 
k=50 
shift=0 
ll=0.15
    
for i in range(0,na):
    # create GEKKO model
    m = GEKKO(remote=False)

    m.time = np.linspace(0,year,n)
    t=m.time
    
    A0=dftemp.loc[i][0]
    h=dftemp.loc[i][1]
    emax=dftemp.loc[i][2]    
    
    A = m.SV(value=A0, lb=0, ub=A0)
    E = m.SV(value=0, lb=0, ub=A0)

    u = m.MV(value=0, lb=-emax, ub=emax) 
    u.STATUS = 1

    t = m.Param(value=m.time)
    C = m.Var(value=C0)
    d = m.Var(value=1)
    l = m.Param(value=ll)
    
    # Equation
    m.Equation(A.dt()==-u)
    m.Equation(E.dt()==u)
    m.Equation(C.dt()==-C/k)
    m.Equation(d==m.exp(-t*r))
    # Objective (Utility)
    J = m.Var(value=0)
    
    # Final objective
    Jf = m.FV()
    Jf.STATUS = 1
    m.Connection(Jf,J,pos2='end')
    m.Equation(J.dt() == ((A+E*(1-l))*h*Pa0-C*u+E*Pe0+shift)*d)
    
    # maximize U
    m.Maximize(Jf)
    
    # options
    m.options.IMODE = 6  # optimal control
    m.options.NODES = 3  # collocation nodes
    m.options.SOLVER = 3 # solver (IPOPT)
    
    # solve optimization problem
    m.solve()
    
    # print profit
    print('Optimal Profit: ' + str(Jf.value[0]))

案例5。将目标函数从

m.log

更改为简单线性和，并将

shift

更改为0。发生错误

from gekko import GEKKO
import pandas as pd
import numpy as np

dat = {'A0': [23221, 2198, 4296, 104906, 691], 'h': [0.04, 0.25, 0.07, 0, 12.58],'emax': [23221, 2198, 4296, 104906, 691] }
dftemp = pd.DataFrame(data=dat)
na=len(dftemp)

# time points
n=501 
year=50

# constants
Pa0 = 3.061 
Pe0 = 10.603 
C0 = 100 
r = 0.05 
k=50 
shift=10000000 # to make positive inside log function
ll=0.15

   
for i in range(0,na):
    # create GEKKO model
    m = GEKKO(remote=False)

    m.time = np.linspace(0,year,n)
    t=m.time
    
    A0=dftemp.loc[i][0]
    h=dftemp.loc[i][1]
    emax=dftemp.loc[i][2]    
    
    A = m.SV(value=A0, lb=0, ub=A0)
    E = m.SV(value=0, lb=0, ub=A0)

    u = m.MV(value=0, lb=-emax, ub=emax) 
    u.STATUS = 1

    t = m.Param(value=m.time)
    C = m.Var(value=C0)
    d = m.Var(value=1)
    l = m.Param(value=ll)
    
    # Equation
    m.Equation(A.dt()==-u)
    m.Equation(E.dt()==u)
    m.Equation(C.dt()==-C/k)
    m.Equation(d==m.exp(-t*r))
    # Objective (Utility)
    J = m.Var(value=0)
    
    # Final objective
    Jf = m.FV()
    Jf.STATUS = 1
    m.Connection(Jf,J,pos2='end')
    m.Equation(J.dt() == m.log((A+E*(1-l))*h*Pa0-C*u+E*Pe0+shift)*d)
    
    # maximize U
    m.Maximize(Jf)
    
    # options
    m.options.IMODE = 6  # optimal control
    m.options.NODES = 3  # collocation nodes
    m.options.SOLVER = 3 # solver (IPOPT)
    
    # solve optimization problem
    m.solve()
    
    # print profit
    print('Optimal Profit: ' + str(Jf.value[0]))

from gekko import GEKKO
import pandas as pd
import numpy as np

dat = {'A0': [23221, 2198, 4296, 104906, 691], 'h': [0.04, 0.25, 0.07, 0, 12.58],'emax': [23221, 2198, 4296, 104906, 691] }
dftemp = pd.DataFrame(data=dat)
na=len(dftemp)

# time points
n=51
year=50

# constants
Pa0 = 3.061 
Pe0 = 10.603 
C0 = 100 
r = 0.05 
k=50 
shift=10000000 # to make positive inside log function
ll=0.15

    
for i in range(0,na):
    # create GEKKO model
    m = GEKKO(remote=False)

    m.time = np.linspace(0,year,n)
    t=m.time
    
    A0=dftemp.loc[i][0]
    h=dftemp.loc[i][1]
    emax=dftemp.loc[i][2]    
    
    A = m.SV(value=A0, lb=0, ub=A0)
    E = m.SV(value=0, lb=0, ub=A0)

    u = m.MV(value=0, lb=-emax, ub=emax) 
    u.STATUS = 1

    t = m.Param(value=m.time)
    C = m.Var(value=C0)
    d = m.Var(value=1)
    l = m.Param(value=ll)
    
    # Equation
    m.Equation(A.dt()==-u)
    m.Equation(E.dt()==u)
    m.Equation(C.dt()==-C/k)
    m.Equation(d==m.exp(-t*r))
    # Objective (Utility)
    J = m.Var(value=0)
    
    # Final objective
    Jf = m.FV()
    Jf.STATUS = 1
    m.Connection(Jf,J,pos2='end')
    m.Equation(J.dt() == ((A+E*(1-l))*h*Pa0-C*u+E*Pe0+shift))
    
    # maximize U
    m.Maximize(Jf)
    
    # options
    m.options.IMODE = 6  # optimal control
    m.options.NODES = 3  # collocation nodes
    m.options.SOLVER = 3 # solver (IPOPT)
    
    # solve optimization problem
    m.solve()
    
    # print profit
    print('Optimal Profit: ' + str(Jf.value[0]))

from gekko import GEKKO
import pandas as pd
import numpy as np

dat = {'A0': [23221, 2198, 4296, 104906, 691], 'h': [0.04, 0.25, 0.07, 0, 12.58],'emax': [23221, 2198, 4296, 104906, 691] }
dftemp = pd.DataFrame(data=dat)
na=len(dftemp)

# time points
n=51
year=50

# constants
Pa0 = 3.061 
Pe0 = 10.603 
C0 = 100 
r = 0.05 
k=50 
shift=0 
ll=0.15
    
for i in range(0,na):
    # create GEKKO model
    m = GEKKO(remote=False)

    m.time = np.linspace(0,year,n)
    t=m.time
    
    A0=dftemp.loc[i][0]
    h=dftemp.loc[i][1]
    emax=dftemp.loc[i][2]    
    
    A = m.SV(value=A0, lb=0, ub=A0)
    E = m.SV(value=0, lb=0, ub=A0)

    u = m.MV(value=0, lb=-emax, ub=emax) 
    u.STATUS = 1

    t = m.Param(value=m.time)
    C = m.Var(value=C0)
    d = m.Var(value=1)
    l = m.Param(value=ll)
    
    # Equation
    m.Equation(A.dt()==-u)
    m.Equation(E.dt()==u)
    m.Equation(C.dt()==-C/k)
    m.Equation(d==m.exp(-t*r))
    # Objective (Utility)
    J = m.Var(value=0)
    
    # Final objective
    Jf = m.FV()
    Jf.STATUS = 1
    m.Connection(Jf,J,pos2='end')
    m.Equation(J.dt() == ((A+E*(1-l))*h*Pa0-C*u+E*Pe0+shift)*d)
    
    # maximize U
    m.Maximize(Jf)
    
    # options
    m.options.IMODE = 6  # optimal control
    m.options.NODES = 3  # collocation nodes
    m.options.SOLVER = 3 # solver (IPOPT)
    
    # solve optimization problem
    m.solve()
    
    # print profit
    print('Optimal Profit: ' + str(Jf.value[0]))

对于其中的许多情况，它可以帮助进行一些更改，例如：

重新格式化以避免
```
m.log（）
```
带有负数。中间变量也有帮助

#目标（实用程序）
J=m.Var（值=0）
rhs=m.中间（（A+E*（1-l））*h*Pa0-C*u+E*Pe0+shift）
m、 方程（m.exp（J.dt（）/d）=rhs）

在优化之前初始化。
```
APOPT
```
解算器在初始化方面做得更好，
```
IPOPT
```
使用
```
APOPT
```
中的初始化解决方案做得更好。初始化策略见：Safdarnejad，S.M.，Hedengren，J.D.，Lewis，N.R.，Haseltine，E.，动态系统优化初始化策略，计算机和化学工程，2015年，第78卷，第39-50页，DOI:10.1016/J.compchemeng.2015.04.016

#解决优化问题
m、 options.NODES=3个#配置节点
m、 options.SOLVER=1#SOLVER（APOPT）
m、 选项。IMODE=4
m、 解决（）
#求解优化问题
m、 选项。时间\u移位=0
m、 options.SOLVER=3#SOLVER（IPOPT）
m、 选项。IMODE=6
m、 解决（）

案例2:n=501的成功解决方案

从gekko导入gekko 作为pd进口熊猫将numpy作为np导入 dat={'A0'：[2322121984296104906691]\ ‘h’：[0.04,0.25,0.07,0,12.58]\ 'emax'：[2322121984296104906691]} dftemp=pd.DataFrame（数据=dat） na=len（dftemp） #时点 n=501 年份=50 #常数 Pa0=3.061 Pe0=10.603 C0=100 r=0.05 k=50 shift=10000000#使内部日志函数为正值 ll=0.15 对于范围（0，na）内的i： #创建GEKKO模型 m=GEKKO（远程=True） m、时间=np.linspace（0，年，n） t=m时间 A0=dftemp.loc[i][0] h=dftemp.loc[i][1] emax=dftemp.loc[i][2] A=m.SV（值=A0，磅=0，磅=A0） E=m.SV（值=0，磅=0，磅=A0） u=m.MV（值=0，磅=emax，ub=emax） u、状态=1 t=m.Param（值=m.time） C=m.Var（值=C0） d=m.Var（值=1） l=m.Param（值=ll） #方程式 m、方程（A.dt（）=-u） m、方程（E.dt（）==u） m、方程（C.dt（）==-C/k） m、方程（d==m.exp（-t*r）） #目标（效用） J=m.Var（值=0） rhs=m.中间（（A+E*（1-l））*h*Pa0-C*u+E*Pe0+shift） m、方程（m.exp（J.dt（）/d）=rhs） #最终目标 final=np.类零（m.时间）最终[-1]=1 最终=m.Param（最终） #最大化U m、最大化（最终*J） #求解优化问题 m、 options.NODES=3个#配置节点 m、 options.SOLVER=1#SOLVER（APOPT） m、选项。IMODE=4 打印（'\n\n使用APOPT'初始化） m、求解（disp=False） #求解优化问题 m、选项。时间\u移位=0 m、 options.SOLVER=3#SOLVER（IPOPT） m、选项。IMODE=6 m、解决（） #印刷利润打印（'最佳利润：'+str（J.值[-1]））
请在其他情况下也尝试这种方法。通常最好使用
m.sum（）
而不是
sum
，因为Gekko将求和构造为内置对象而不是长字符串
编辑：更新的解决方案这是一个具有正确初始条件的更新解决方案。
IMODE=4
的初始条件不会转移到
IMODE=6
。另一种方法是将
IMODE=6
与等效的
COLDSTART=1
一起使用

从gekko导入gekko 作为pd进口熊猫将numpy作为np导入将matplotlib.pyplot作为plt导入 dat={'A0'：[2322121984296104906691]\ ‘h’：[0.04,0.25,0.07,0,12.58]\ 'emax'：[2322121984296104906691]} dftemp=pd.DataFrame（数据=dat） na=len（dftemp） #时点 n=101 年份=50 #常数 Pa0=3.061 Pe0=10.603 C0=100 r=0.05 k=50 shift=10000000#使内部日志函数为正值 ll=0.15 plt.图（figsize=（10,5））对于范围（0，na）内的i： #创建GEKKO模型 m=GEKKO（远程=True） m、时间=np.linspace（0，年，n） t=m时间 A0=dftemp.loc[i][0] h=dftemp.loc[i][1] emax=dftemp.loc[i][2] 打印（'A（首字母）：'+str（A0）） A=m.Var（值=A0，磅=0，磅=A0） E=m.Var（值=0，磅=0，磅=A0） u=m.MV（值=0，磅=emax，ub=emax） u、状态=1 t=m.Param（值=m.time） C=m.Var（值=C0） d=m.Var（值=1） l=m.Param（值=ll） #方程式 m、方程（A.dt（）=-u） m、方程（E.dt（）==u） m、方程（C.dt（）==-C/k） m、方程（d==m.exp（-t*r）） #目标（效用） J=m.Var（值=0） rhs=m.中间（（A+E*（1-l））*h*Pa0-C*u+E*Pe0+shift） m、方程（m.exp（J.dt（）/d）=rhs） #最终目标 final=np.类零（m.时间）最终[-1]=1 最终=m.Param（fi