JModelica和Concurrent Futures

时间:2015-08-13 05:57:02

标签: python concurrency modelica jmodelica

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

我想并行运行许多优化。目前我在做 这使用多处理模块。

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

#!/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;

这样安全吗?

2 个答案:

答案 0 :(得分:1)

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

答案 1 :(得分:0)

不。从02015-11-09开始它似乎不安全。

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

有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函数中随机数生成错误的结果,但与此相关的错误是resolved on 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)