def init_julia(self, imports=["REISE"]):
"""Initialize a Julia session in the specified environment and import.
:param list imports: julia packages to import.
:return: (*tuple*) -- imported names.
"""
api = LibJulia.load()
julia_command_line_options = ["--compiled-modules=no"]
if self.julia_env is not None:
julia_command_line_options += [f"--project={self.julia_env}"]
api.init_julia(julia_command_line_options)
return tuple([importlib.import_module(f"julia.{i}") for i in imports])
def Lp(A, b, p):
if p >= 2: # pIRLS implementation (NIPS 2019)
# uncomment to compare with vanilla implementation
#if p < 3: # vanilla does not converge for p >= 3
# cons, _, _ = IRLS(A, b, p)
# print_consensus(cons)
from julia.api import LibJulia
api = LibJulia.load()
api.sysimage = os.path.dirname(os.path.realpath(__file__)) + '/sys.so'
api.init_julia()
from julia import Main
Main.include(
os.path.dirname(os.path.realpath(__file__)) + '/IRLS-pNorm.jl')
# constraints needed for pIRLS (empty)
C = np.zeros_like(A)
d = np.zeros_like(b)
epsilon = 1e-10
cons, it = Main.pNorm(epsilon, A, b.reshape(-1, 1), p, C,
d.reshape(-1, 1))
r = np.abs(A @ cons - b)
return cons, r, np.linalg.norm(r, p)
else: # vanilla IRLS implementation
return IRLS(A, b, p)
""" Created: Tue Jul 30 07:56:52 2019 @author: Christopher Albert <*****@*****.**> """ import os import site from julia.api import LibJulia, Julia api = LibJulia.load(julia=os.path.join(site.USER_BASE, 'bin', 'julia-py')) api.sysimage = 'julia_sysimage.so' api.init_julia() #%% ret = api.jl_eval_string(b"sin(pi)") print(float(api.jl_unbox_float64(ret)))
def run_jump_model(self, dfm, data, run_uuid, bau=False):
profiler = Profiler()
time_dict = dict()
name = 'reopt' if not bau else 'reopt_bau'
reopt_inputs = dfm['reopt_inputs'] if not bau else dfm['reopt_inputs_bau']
self.data = data
self.run_uuid = data['outputs']['Scenario']['run_uuid']
self.user_uuid = data['outputs']['Scenario'].get('user_uuid')
if platform.system() == "Darwin":
ext = ".dylib"
elif platform.system() == "Windows":
ext = ".dll"
else:
ext = ".so" # if platform.system() == "Linux":
julia_img_file = os.path.join("julia_envs", "Xpress",
"JuliaXpressSysimage" + ext)
logger.info("Running JuMP model ...")
try:
if os.path.isfile(julia_img_file):
# TODO: clean up this try/except block
logger.info("Found Julia image file {}.".format(julia_img_file))
t_start = time.time()
api = LibJulia.load()
api.sysimage = julia_img_file
api.init_julia()
from julia import Main
time_dict["pyjulia_start_seconds"] = time.time() - t_start
else:
t_start = time.time()
j = julia.Julia()
from julia import Main
time_dict["pyjulia_start_seconds"] = time.time() - t_start
t_start = time.time()
Main.using("Pkg")
from julia import Pkg
time_dict["pyjulia_pkg_seconds"] = time.time() - t_start
if os.environ.get("SOLVER") == "xpress":
t_start = time.time()
Pkg.activate("./julia_envs/Xpress/")
time_dict["pyjulia_activate_seconds"] = time.time() - t_start
try:
t_start = time.time()
Main.include("reo/src/reopt_xpress_model.jl")
time_dict["pyjulia_include_model_seconds"] = time.time(
) - t_start
except ImportError:
# should only need to instantiate once
Pkg.instantiate()
Main.include("reo/src/reopt_xpress_model.jl")
t_start = time.time()
if bau:
model = Main.reopt_model(
float(data["inputs"]["Scenario"]["timeout_seconds"]),
float(data["inputs"]["Scenario"]
["optimality_tolerance_bau"]))
else:
model = Main.reopt_model(
float(data["inputs"]["Scenario"]["timeout_seconds"]),
float(data["inputs"]["Scenario"]
["optimality_tolerance_techs"]))
time_dict["pyjulia_make_model_seconds"] = time.time() - t_start
elif os.environ.get("SOLVER") == "cbc":
t_start = time.time()
Pkg.activate("./julia_envs/Cbc/")
time_dict["pyjulia_activate_seconds"] = time.time() - t_start
t_start = time.time()
Main.include("reo/src/reopt_cbc_model.jl")
time_dict["pyjulia_include_model_seconds"] = time.time() - t_start
t_start = time.time()
model = Main.reopt_model(
float(data["inputs"]["Scenario"]["timeout_seconds"]),
float(data["inputs"]["Scenario"]["optimality_tolerance_bau"]))
time_dict["pyjulia_make_model_seconds"] = time.time() - t_start
elif os.environ.get("SOLVER") == "scip":
t_start = time.time()
Pkg.activate("./julia_envs/SCIP/")
time_dict["pyjulia_activate_seconds"] = time.time() - t_start
t_start = time.time()
Main.include("reo/src/reopt_scip_model.jl")
time_dict["pyjulia_include_model_seconds"] = time.time() - t_start
t_start = time.time()
model = Main.reopt_model(
float(data["inputs"]["Scenario"]["timeout_seconds"]),
float(data["inputs"]["Scenario"]["optimality_tolerance_bau"]))
time_dict["pyjulia_make_model_seconds"] = time.time() - t_start
else:
raise REoptFailedToStartError(
message=
"The environment variable SOLVER must be set to one of [xpress, cbc, scip].",
run_uuid=self.run_uuid,
user_uuid=self.user_uuid)
if bau or not data["inputs"]["Scenario"]["use_decomposition_model"]:
t_start = time.time()
Main.include("reo/src/reopt.jl")
time_dict["pyjulia_include_reopt_seconds"] = time.time() - t_start
t_start = time.time()
results = Main.reopt(model, reopt_inputs)
time_dict["pyjulia_run_reopt_seconds"] = time.time() - t_start
else:
t_start = time.time()
Main.include("reo/src/reopt_decomposed.jl")
time_dict["pyjulia_include_reopt_seconds"] = time.time() - t_start
t_start = time.time()
results = run_decomposed_model(data, model, reopt_inputs)
time_dict["pyjulia_run_reopt_seconds"] = time.time() - t_start
results = scrub_numpy_arrays_from_dict(results)
results.update(time_dict)
except Exception as e:
if isinstance(e, REoptFailedToStartError):
raise e
elif "DimensionMismatch" in e.args[
0]: # JuMP may mishandle a timeout when no feasible solution is returned
msg = "Optimization exceeded timeout: {} seconds.".format(
data["inputs"]["Scenario"]["timeout_seconds"])
logger.info(msg)
raise OptimizationTimeout(task=name,
message=msg,
run_uuid=self.run_uuid,
user_uuid=self.user_uuid)
exc_type, exc_value, exc_traceback = sys.exc_info()
print(exc_type)
print(exc_value)
print(exc_traceback)
logger.error("REopt.py raise unexpected error: UUID: " +
str(self.run_uuid))
raise UnexpectedError(exc_type,
exc_value,
traceback.format_tb(exc_traceback),
task=name,
run_uuid=self.run_uuid,
user_uuid=self.user_uuid)
else:
status = results["status"]
logger.info("REopt run successful. Status {}".format(status))
if bau:
dfm['results_bau'] = results # will be flat dict
else:
dfm['results'] = results
if status.strip().lower() == 'timed-out':
msg = "Optimization exceeded timeout: {} seconds.".format(
data["inputs"]["Scenario"]["timeout_seconds"])
logger.info(msg)
raise OptimizationTimeout(task=name,
message=msg,
run_uuid=self.run_uuid,
user_uuid=self.user_uuid)
elif status.strip().lower() != 'optimal':
logger.error(
"REopt status not optimal. Raising NotOptimal Exception.")
raise NotOptimal(task=name,
run_uuid=self.run_uuid,
status=status.strip(),
user_uuid=self.user_uuid)
profiler.profileEnd()
ModelManager.updateModel('ProfileModel',
{name + '_seconds': profiler.getDuration()},
run_uuid)
# reduce the amount data being transferred between tasks
if bau:
del dfm['reopt_inputs_bau']
else:
del dfm['reopt_inputs']
return dfm
import os
import time
from typing import List
# from numba import typed, types, float64
from julia.api import LibJulia # noqa: autoimport
api = LibJulia.load() # noqa: autoimport
api.init_julia(["--project=.", "--optimize=3", f"--threads={os.cpu_count()}"]) # noqa: autoimport
from julia import Main as list_julia
import list_cy_annotations
import list_cy_annotations_c
import list_py
import list_py_annotations
import list_py_annotations_c
import list_py_c
import simple_list
import list_cy
import list_rust
import numpy as np
# import list_numba
list_julia.eval('include("list_julia.jl")')
list_julia.eval('include("list_julia_threads.jl")')
_a_list: List[List[float]]
# _nb_a_list = typed.List(typed.List(float64))
# ttt = time.time()
# _nb_a_list = list_numba.make_list(_nb_a_list)
# list_numba.iterate_list_par(_nb_a_list)
required=True,
help="activate/deactivate bias in GraphSAGE")
parser.add_argument('--nworkers',
type=int,
required=True,
help="number of parallel workers to use")
args = parser.parse_args()
## Set up Julia
# This can be simplified once https://github.com/JuliaPy/pyjulia/issues/310 is fixed
with open("/etc/hostname") as f:
hostname = f.readline().strip()
from julia.api import LibJulia
api = LibJulia.load()
api.sysimage = "julia/sys-{}.so".format(hostname)
api.init_julia()
from julia import Main
Main.eval('include("julia/dataset.jl")')
## Settings
testtype = args.testtype
assert testtype in ['edges', 'nodes']
testprop = args.testprop
bias = args.bias
layer_sizes = [args.diml1enc, args.dimxiadj]
nworkers = args.nworkers
number_of_walks = 1
length_of_walks = 5