1

我正在使用 JModelica 在后台使用 IPOPT 优化模型。

我想并行运行许多优化。目前我正在使用多处理模块执行此操作。

现在，代码如下。它对变量执行参数扫描，T并将So结果写入为这些参数命名的输出文件。输出文件还包含模型中使用的参数列表以及运行结果。

#!/usr/local/jmodelica/bin/jm_python.sh
import itertools
import multiprocessing
import numpy as np
import time
import sys
import signal
import traceback
import StringIO
import random
import cPickle as pickle

def PrintResToFile(filename,result):
  def StripMX(x):
    return str(x).replace('MX(','').replace(')','')

  varstr = '#Variable Name={name: <10}, Unit={unit: <7}, Val={val: <10}, Col={col:< 5}, Comment="{comment}"\n'

  with open(filename,'w') as fout:
    #Print all variables at the top of the file, along with relevant information
    #about them.
    for var in result.model.getAllVariables():
      if not result.is_variable(var.getName()):
        val = result.initial(var.getName())
        col = -1
      else:
        val = "Varies"
        col = result.get_column(var.getName())

      unit = StripMX(var.getUnit())
      if not unit:
        unit = "X"

      fout.write(varstr.format(
        name    = var.getName(),
        unit    = unit,
        val     = val,
        col     = col,
        comment = StripMX(var.getAttribute('comment'))
      ))

    #Ensure that time variable is printed
    fout.write(varstr.format(
      name    = 'time',
      unit    = 's',
      val     = 'Varies',
      col     = 0,
      comment = 'None'
    ))

    #The data matrix contains only time-varying variables. So fetch all of
    #these, couple them in tuples with their column number, sort by column
    #number, and then extract the name of the variable again. This results in a
    #list of variable names which are guaranteed to be in the same order as the
    #data matrix.
    vkeys_in_order = [(result.get_column(x),x) for x in result.keys() if result.is_variable(x)]
    vkeys_in_order = map(lambda x: x[1], sorted(vkeys_in_order))

    for vk in vkeys_in_order:
      fout.write("{0:>13},".format(vk))
    fout.write("\n")

    sio = StringIO.StringIO()
    np.savetxt(sio, result.data_matrix, delimiter=',', fmt='%13.5f')
    fout.write(sio.getvalue())




def RunModel(params):
  T  = params[0]
  So = params[1]

  try:
    import pyjmi
    signal.signal(signal.SIGINT, signal.SIG_IGN)

    #For testing what happens if an error occurs
    # import random
    # if random.randint(0,100)<50:
      # raise "Test Exception"

    op = pyjmi.transfer_optimization_problem("ModelClass", "model.mop")
    op.set('a',        0.20)
    op.set('b',        1.00)
    op.set('f',        0.05)
    op.set('h',        0.05)
    op.set('S0',         So)
    op.set('finalTime',   T)

    # Set options, see: http://www.jmodelica.org/api-docs/usersguide/1.13.0/ch07s06.html
    opt_opts                                   = op.optimize_options()
    opt_opts['n_e']                            = 40
    opt_opts['IPOPT_options']['tol']           = 1e-10
    opt_opts['IPOPT_options']['output_file']   = '/z/err_'+str(T)+'_'+str(So)+'_info.dat'
    opt_opts['IPOPT_options']['linear_solver'] = 'ma27' #See: http://www.coin-or.org/Ipopt/documentation/node50.html

    res = op.optimize(options=opt_opts)

    result_file_name = 'out_'+str(T)+'_'+str(So)+'.dat'
    PrintResToFile(result_file_name, res)

    return (True,(T,So))
  except:
    ex_type, ex, tb = sys.exc_info()
    return (False,(T,So),traceback.extract_tb(tb))

try:
  fstatus = open('status','w')
except:
  print("Could not open status file!")
  sys.exit(-1)

T       = map(float,[10,20,30,40,50,60,70,80,90,100,110,120,130,140])
So      = np.arange(0.1,30.1,0.1)
tspairs = list(itertools.product(T,So))
random.shuffle(tspairs)

pool  = multiprocessing.Pool()
mapit = pool.imap_unordered(RunModel,tspairs)
pool.close()

completed = 0

while True:
  try:
    res = mapit.next(timeout=2)
    pickle.dump(res,fstatus)
    fstatus.flush()
    completed += 1
    print(res)
    print "{0: >4} of {1: >4} ({2: >4} left)".format(completed,len(tspairs),len(tspairs)-completed)
  except KeyboardInterrupt:
    pool.terminate()
    pool.join()
    sys.exit(0)
  except multiprocessing.TimeoutError:
    print "{0: >4} of {1: >4} ({2: >4} left)".format(completed,len(tspairs),len(tspairs)-completed)
  except StopIteration:
    break

使用模型：

optimization ModelClass(objective=-S(finalTime), startTime=0, finalTime=100)
  parameter Real S0 = 2;
  parameter Real F0 = 0;

  parameter Real a = 0.2;
  parameter Real b = 1;
  parameter Real f = 0.05;
  parameter Real h = 0.05;

  output Real F(start=F0, fixed=true, min=0, max=100, unit="kg");
  output Real S(start=S0, fixed=true, min=0, max=100, unit="kg");

  input Real u(min=0, max=1);
equation
  der(F) = u*(a*F+b);
  der(S) = f*F/(1+h*F)-u*(a*F+b);
end ModelClass;

这安全吗？

4

2 回答 2

1

不，这不安全。op.optimize()将使用从模型名称派生的文件名存储优化结果，然后加载结果以返回数据，因此当您尝试一次运行多个优化时，您将获得竞争条件。为了避免这种情况，您可以在opt_opts['result_file_name'].

于 2015-11-10T08:34:42.917 回答
0

不。截至 02015 年 11 月 9 日，它似乎并不安全。

上面的代码根据输入参数命名输出文件。输出文件还包含用于运行模型的输入参数。

对于 4 核，会出现两种情况：

  • 有时Inconsistent number of lines in the result data.会在文件中引发错误/usr/local/jmodelica/Python/pyjmi/common/io.py。
  • 输出文件在内部显示一组参数，但以一组不同的参数命名，这表明脚本认为它正在处理的参数与实际正在处理的参数之间存在分歧。

24核：

  • 该错误The result does not seem to be of a supported format.由 反复引发/usr/local/jmodelica/Python/pyjmi/common/io.py。

总之，这些信息表明 JModelica 正在使用中间文件，但中间文件的名称存在重叠，在最好的情况下会导致错误，在最坏的情况下会导致错误的结果。

有人可能会假设这是tempfile某处函数中随机数生成错误的结果，但与此相关的错误已在 02011-11-25 解决。也许 PRNG 是根据系统时钟或常数播种的，因此同步进行？

但是，情况似乎并非如此，因为以下不会产生冲突：

#!/usr/bin/env python
import time
import tempfile
import os
import collections

from multiprocessing import Pool

def f(x):
  tf = tempfile.NamedTemporaryFile(delete=False)
  print(tf.name)
  return tf.name

p      = Pool(24)
ret    = p.map(f, range(2000))
counts = collections.Counter(ret)
print(counts)
于 2015-11-09T22:28:55.037 回答