From 41d359589c6a3b6c7cb86dce5819006aee5b15a9 Mon Sep 17 00:00:00 2001 From: YigitElma Date: Wed, 25 Dec 2024 15:13:00 -0500 Subject: [PATCH 01/75] add multiple gpu support to backend --- desc/__init__.py | 52 ++++++++++++++++++++++++++++++++++++++++++++++-- desc/backend.py | 17 ++++++++++++---- 2 files changed, 63 insertions(+), 6 deletions(-) diff --git a/desc/__init__.py b/desc/__init__.py index 840b9985b9..9951062d56 100644 --- a/desc/__init__.py +++ b/desc/__init__.py @@ -61,7 +61,7 @@ def __getattr__(name): config = {"device": None, "avail_mem": None, "kind": None} -def set_device(kind="cpu"): +def set_device(kind="cpu", multigpu=False): # noqa: C901 """Sets the device to use for computation. If kind==``'gpu'``, checks available GPUs and selects the one with the most @@ -73,6 +73,8 @@ def set_device(kind="cpu"): ---------- kind : {``'cpu'``, ``'gpu'``} whether to use CPU or GPU. + multigpu : bool + whether to use multiple GPUs or not. Default is False. """ config["kind"] = kind @@ -85,7 +87,7 @@ def set_device(kind="cpu"): config["device"] = "CPU" config["avail_mem"] = cpu_mem - if kind == "gpu": + if kind == "gpu" and not multigpu: # Set CUDA_DEVICE_ORDER so the IDs assigned by CUDA match those from nvidia-smi os.environ["CUDA_DEVICE_ORDER"] = "PCI_BUS_ID" import nvgpu @@ -139,3 +141,49 @@ def set_device(kind="cpu"): selected_gpu["mem_total"] - selected_gpu["mem_used"] ) / 1024 # in GB os.environ["CUDA_VISIBLE_DEVICES"] = str(selected_gpu["index"]) + + if kind == "gpu" and multigpu: + # Set CUDA_DEVICE_ORDER so the IDs assigned by CUDA match those from nvidia-smi + os.environ["CUDA_DEVICE_ORDER"] = "PCI_BUS_ID" + import nvgpu + + try: + devices = nvgpu.gpu_info() + except FileNotFoundError: + devices = [] + if len(devices) == 0: + warnings.warn(colored("No GPU found, falling back to CPU", "yellow")) + set_device(kind="cpu") + return + + gpu_ids = [dev["index"] for dev in devices] + if len(gpu_ids) == 0: + # cuda visible devices = '' -> don't use any gpu + warnings.warn( + colored( + ( + "CUDA_VISIBLE_DEVICES={} ".format( + os.environ["CUDA_VISIBLE_DEVICES"] + ) + + "did not match any physical GPU " + + "(id={}), falling back to CPU".format( + [dev["index"] for dev in devices] + ) + ), + "yellow", + ) + ) + set_device(kind="cpu") + return + + devices = [dev for dev in devices if dev["index"] in gpu_ids] + memories = {} + for dev in devices: + mem = dev["mem_total"] - dev["mem_used"] + memories[dev["index"]] = mem + config["devices"] = [ + dev["type"] + " (id={})".format(dev["index"]) for dev in devices + ] + config["avail_mems"] = [ + memories[dev["index"]] / 1024 for dev in devices + ] # in GB diff --git a/desc/backend.py b/desc/backend.py index 3704cb0bb1..44bc90dd25 100644 --- a/desc/backend.py +++ b/desc/backend.py @@ -59,11 +59,20 @@ desc.__version__, np.__version__, y.dtype ) ) -print( - "Using device: {}, with {:.2f} GB available memory".format( - desc_config.get("device"), desc_config.get("avail_mem") + +if hasattr(desc_config, "device"): + print( + "Using device: {}, with {:.2f} GB available memory".format( + desc_config.get("device"), desc_config.get("avail_mem") + ) ) -) +elif hasattr(desc_config, "devices"): + print(f"Using {len(desc_config["devices"])} devices:") + for i, dev in enumerate(desc_config["devices"]): + print( + f"\t Device {i}: {dev} with {desc_config["avail_mems"][i]:.2f} " + "GB available memory" + ) if use_jax: # noqa: C901 from jax import custom_jvp, jit, vmap From 860b1ff2e762460fef8cede498db7137c4847aee Mon Sep 17 00:00:00 2001 From: YigitElma Date: Wed, 25 Dec 2024 15:29:35 -0500 Subject: [PATCH 02/75] fix if statement --- desc/backend.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/desc/backend.py b/desc/backend.py index 44bc90dd25..6ed2ac3348 100644 --- a/desc/backend.py +++ b/desc/backend.py @@ -60,13 +60,13 @@ ) ) -if hasattr(desc_config, "device"): +if "device" in desc_config.keys(): print( "Using device: {}, with {:.2f} GB available memory".format( desc_config.get("device"), desc_config.get("avail_mem") ) ) -elif hasattr(desc_config, "devices"): +elif "devices" in desc_config.keys(): print(f"Using {len(desc_config["devices"])} devices:") for i, dev in enumerate(desc_config["devices"]): print( From 003eca90aca86d6d99c4cec2224f66ef195002c1 Mon Sep 17 00:00:00 2001 From: YigitElma Date: Wed, 25 Dec 2024 15:45:19 -0500 Subject: [PATCH 03/75] fix stuff --- desc/__init__.py | 6 ++++++ desc/backend.py | 4 ++-- 2 files changed, 8 insertions(+), 2 deletions(-) diff --git a/desc/__init__.py b/desc/__init__.py index 9951062d56..37a7755a22 100644 --- a/desc/__init__.py +++ b/desc/__init__.py @@ -157,6 +157,12 @@ def set_device(kind="cpu", multigpu=False): # noqa: C901 return gpu_ids = [dev["index"] for dev in devices] + if "CUDA_VISIBLE_DEVICES" in os.environ: + cuda_ids = [ + s for s in re.findall(r"\b\d+\b", os.environ["CUDA_VISIBLE_DEVICES"]) + ] + # check that the visible devices actually exist and are gpus + gpu_ids = [i for i in cuda_ids if i in gpu_ids] if len(gpu_ids) == 0: # cuda visible devices = '' -> don't use any gpu warnings.warn( diff --git a/desc/backend.py b/desc/backend.py index 6ed2ac3348..7aa8b0e69c 100644 --- a/desc/backend.py +++ b/desc/backend.py @@ -60,13 +60,13 @@ ) ) -if "device" in desc_config.keys(): +if "devices" not in desc_config.keys(): print( "Using device: {}, with {:.2f} GB available memory".format( desc_config.get("device"), desc_config.get("avail_mem") ) ) -elif "devices" in desc_config.keys(): +else: print(f"Using {len(desc_config["devices"])} devices:") for i, dev in enumerate(desc_config["devices"]): print( From 74f5f3d4f2b0c6aab2560543170f5cdfaebdfbca Mon Sep 17 00:00:00 2001 From: YigitElma Date: Wed, 25 Dec 2024 15:47:06 -0500 Subject: [PATCH 04/75] try --- desc/__init__.py | 2 -- 1 file changed, 2 deletions(-) diff --git a/desc/__init__.py b/desc/__init__.py index 37a7755a22..6af645128a 100644 --- a/desc/__init__.py +++ b/desc/__init__.py @@ -143,8 +143,6 @@ def set_device(kind="cpu", multigpu=False): # noqa: C901 os.environ["CUDA_VISIBLE_DEVICES"] = str(selected_gpu["index"]) if kind == "gpu" and multigpu: - # Set CUDA_DEVICE_ORDER so the IDs assigned by CUDA match those from nvidia-smi - os.environ["CUDA_DEVICE_ORDER"] = "PCI_BUS_ID" import nvgpu try: From eed3f6d02da415c96c95d5a9ff82028054e36c14 Mon Sep 17 00:00:00 2001 From: YigitElma Date: Wed, 25 Dec 2024 15:58:20 -0500 Subject: [PATCH 05/75] fix issue --- desc/__init__.py | 2 ++ 1 file changed, 2 insertions(+) diff --git a/desc/__init__.py b/desc/__init__.py index 6af645128a..3097d9bc2f 100644 --- a/desc/__init__.py +++ b/desc/__init__.py @@ -185,6 +185,8 @@ def set_device(kind="cpu", multigpu=False): # noqa: C901 for dev in devices: mem = dev["mem_total"] - dev["mem_used"] memories[dev["index"]] = mem + + config["device"] = "gpu" config["devices"] = [ dev["type"] + " (id={})".format(dev["index"]) for dev in devices ] From b7e9435b442f0b83d5514619074d18e0a52cf344 Mon Sep 17 00:00:00 2001 From: YigitElma Date: Wed, 25 Dec 2024 16:11:32 -0500 Subject: [PATCH 06/75] update jac_chunk_size assignment --- desc/objectives/objective_funs.py | 9 ++++++--- 1 file changed, 6 insertions(+), 3 deletions(-) diff --git a/desc/objectives/objective_funs.py b/desc/objectives/objective_funs.py index 3e3af89836..1f69ccd047 100644 --- a/desc/objectives/objective_funs.py +++ b/desc/objectives/objective_funs.py @@ -350,10 +350,13 @@ def build(self, use_jit=None, verbose=1): # Heuristic estimates of fwd mode Jacobian memory usage, # slightly conservative, based on using ForceBalance as the objective estimated_memory_usage = 2.4e-7 * self.dim_f * self.dim_x + 1 # in GB + mem_avail = ( + desc_config.get("avail_mem") + if desc_config.get("avail_mem") is not None + else sum(desc_config["avail_mems"]) + ) max_chunk_size = round( - (desc_config.get("avail_mem") / estimated_memory_usage - 0.22) - / 0.85 - * self.dim_x + (mem_avail / estimated_memory_usage - 0.22) / 0.85 * self.dim_x ) self._jac_chunk_size = max([1, max_chunk_size]) if self._deriv_mode == "blocked": From ab7402ea4eb767c404225543d3a5d55d924b0fa0 Mon Sep 17 00:00:00 2001 From: YigitElma Date: Wed, 25 Dec 2024 16:48:16 -0500 Subject: [PATCH 07/75] try putting the grid accross devices --- desc/grid.py | 6 +++--- desc/objectives/objective_funs.py | 18 ++++++++++++++++++ 2 files changed, 21 insertions(+), 3 deletions(-) diff --git a/desc/grid.py b/desc/grid.py index e6ebbb6831..d86aead70c 100644 --- a/desc/grid.py +++ b/desc/grid.py @@ -1211,7 +1211,7 @@ def _create_nodes( # noqa: C901 nodes = np.column_stack([r, t, z]) spacing = np.column_stack([dr, dt, dz]) - return nodes, spacing + return jnp.asarray(nodes), jnp.asarray(spacing) def change_resolution(self, L, M, N, NFP=None): """Change the resolution of the grid. @@ -1349,7 +1349,7 @@ def _create_nodes(self, L=1, M=1, N=1, NFP=1): nodes = np.column_stack([r, t, z]) spacing = np.column_stack([dr, dt, dz]) - return nodes, spacing + return jnp.asarray(nodes), jnp.asarray(spacing) def change_resolution(self, L, M, N, NFP=None): """Change the resolution of the grid. @@ -1551,7 +1551,7 @@ def ocs(L): nodes = np.column_stack([r, t, z]) spacing = np.column_stack([dr, dt, dz]) - return nodes, spacing + return jnp.asarray(nodes), jnp.asarray(spacing) def change_resolution(self, L, M, N, NFP=None): """Change the resolution of the grid. diff --git a/desc/objectives/objective_funs.py b/desc/objectives/objective_funs.py index 1f69ccd047..04260417b6 100644 --- a/desc/objectives/objective_funs.py +++ b/desc/objectives/objective_funs.py @@ -8,6 +8,7 @@ from desc.backend import ( desc_config, execute_on_cpu, + jax, jit, jnp, tree_flatten, @@ -1143,6 +1144,23 @@ def build(self, use_jit=True, verbose=1): self._check_dimensions() self._set_derivatives() + if "avail_mems" in desc_config.keys(): + grid = self._constants["transforms"]["grid"] + num_gpu = len(desc_config["avail_mems"]) + mesh = jax.make_mesh((num_gpu,), ("grid")) + grid._nodes = jax.device_put( + grid.nodes, + jax.sharding.NamedSharding(mesh, jax.sharding.PartitionSpec("grid")), + ) + grid._spacing = jax.device_put( + grid.spacing, + jax.sharding.NamedSharding(mesh, jax.sharding.PartitionSpec("grid")), + ) + grid._weights = jax.device_put( + grid.weights, + jax.sharding.NamedSharding(mesh, jax.sharding.PartitionSpec("grid")), + ) + # set quadrature weights if they haven't been if hasattr(self, "_constants") and ("quad_weights" not in self._constants): grid = self._constants["transforms"]["grid"] From 2a7ab0debc4df41148eb06e9f2b8c6e84caa975b Mon Sep 17 00:00:00 2001 From: YigitElma Date: Wed, 25 Dec 2024 16:50:11 -0500 Subject: [PATCH 08/75] fix issue with none constants --- desc/objectives/objective_funs.py | 37 ++++++++++++++++++------------- 1 file changed, 22 insertions(+), 15 deletions(-) diff --git a/desc/objectives/objective_funs.py b/desc/objectives/objective_funs.py index 04260417b6..81c54025f5 100644 --- a/desc/objectives/objective_funs.py +++ b/desc/objectives/objective_funs.py @@ -1145,21 +1145,28 @@ def build(self, use_jit=True, verbose=1): self._set_derivatives() if "avail_mems" in desc_config.keys(): - grid = self._constants["transforms"]["grid"] - num_gpu = len(desc_config["avail_mems"]) - mesh = jax.make_mesh((num_gpu,), ("grid")) - grid._nodes = jax.device_put( - grid.nodes, - jax.sharding.NamedSharding(mesh, jax.sharding.PartitionSpec("grid")), - ) - grid._spacing = jax.device_put( - grid.spacing, - jax.sharding.NamedSharding(mesh, jax.sharding.PartitionSpec("grid")), - ) - grid._weights = jax.device_put( - grid.weights, - jax.sharding.NamedSharding(mesh, jax.sharding.PartitionSpec("grid")), - ) + if hasattr(self, "_constants"): + grid = self._constants["transforms"]["grid"] + num_gpu = len(desc_config["avail_mems"]) + mesh = jax.make_mesh((num_gpu,), ("grid")) + grid._nodes = jax.device_put( + grid.nodes, + jax.sharding.NamedSharding( + mesh, jax.sharding.PartitionSpec("grid") + ), + ) + grid._spacing = jax.device_put( + grid.spacing, + jax.sharding.NamedSharding( + mesh, jax.sharding.PartitionSpec("grid") + ), + ) + grid._weights = jax.device_put( + grid.weights, + jax.sharding.NamedSharding( + mesh, jax.sharding.PartitionSpec("grid") + ), + ) # set quadrature weights if they haven't been if hasattr(self, "_constants") and ("quad_weights" not in self._constants): From afa349cb2d4fde702139326bc9bb299677976e69 Mon Sep 17 00:00:00 2001 From: YigitElma Date: Wed, 25 Dec 2024 16:53:23 -0500 Subject: [PATCH 09/75] revert jnp.asarrays in grid --- desc/grid.py | 22 ++++++++++------------ desc/objectives/objective_funs.py | 6 +++--- 2 files changed, 13 insertions(+), 15 deletions(-) diff --git a/desc/grid.py b/desc/grid.py index d86aead70c..b3757ea376 100644 --- a/desc/grid.py +++ b/desc/grid.py @@ -706,8 +706,8 @@ class Grid(_Grid): nodes.reshape((num_poloidal, num_radial, num_toroidal, 3), order="F"). jitable : bool Whether to skip certain checks and conditionals that don't work under jit. - Allows grid to be created on the fly with custom nodes, but weights, - symmetry etc. may be wrong if grid contains duplicate nodes. + Allows grid to be created on the fly with custom nodes, but weights, symmetry + etc. may be wrong if grid contains duplicate nodes. """ def __init__( @@ -793,7 +793,6 @@ def create_meshgrid( coordinates="rtz", period=(np.inf, 2 * np.pi, 2 * np.pi), NFP=1, - jitable=True, **kwargs, ): """Create a tensor-product grid from the given coordinates in a jitable manner. @@ -820,10 +819,6 @@ def create_meshgrid( Only makes sense to change from 1 if last coordinate is periodic with some constant divided by ``NFP`` and the nodes are placed within one field period. - jitable : bool - Whether to skip certain checks and conditionals that don't work under jit. - Allows grid to be created on the fly with custom nodes, but weights, - symmetry etc. may be wrong if grid contains duplicate nodes. Returns ------- @@ -866,7 +861,10 @@ def create_meshgrid( repeat(unique_a_idx // b.size, b.size, total_repeat_length=a.size * b.size), c.size, ) - inverse_b_idx = jnp.tile(unique_b_idx, a.size * c.size) + inverse_b_idx = jnp.tile( + unique_b_idx, + a.size * c.size, + ) inverse_c_idx = repeat(unique_c_idx // (a.size * b.size), (a.size * b.size)) return Grid( nodes=nodes, @@ -877,7 +875,7 @@ def create_meshgrid( NFP=NFP, sort=False, is_meshgrid=True, - jitable=jitable, + jitable=True, _unique_rho_idx=unique_a_idx, _unique_poloidal_idx=unique_b_idx, _unique_zeta_idx=unique_c_idx, @@ -1211,7 +1209,7 @@ def _create_nodes( # noqa: C901 nodes = np.column_stack([r, t, z]) spacing = np.column_stack([dr, dt, dz]) - return jnp.asarray(nodes), jnp.asarray(spacing) + return nodes, spacing def change_resolution(self, L, M, N, NFP=None): """Change the resolution of the grid. @@ -1349,7 +1347,7 @@ def _create_nodes(self, L=1, M=1, N=1, NFP=1): nodes = np.column_stack([r, t, z]) spacing = np.column_stack([dr, dt, dz]) - return jnp.asarray(nodes), jnp.asarray(spacing) + return nodes, spacing def change_resolution(self, L, M, N, NFP=None): """Change the resolution of the grid. @@ -1551,7 +1549,7 @@ def ocs(L): nodes = np.column_stack([r, t, z]) spacing = np.column_stack([dr, dt, dz]) - return jnp.asarray(nodes), jnp.asarray(spacing) + return nodes, spacing def change_resolution(self, L, M, N, NFP=None): """Change the resolution of the grid. diff --git a/desc/objectives/objective_funs.py b/desc/objectives/objective_funs.py index 81c54025f5..df18031f31 100644 --- a/desc/objectives/objective_funs.py +++ b/desc/objectives/objective_funs.py @@ -1150,19 +1150,19 @@ def build(self, use_jit=True, verbose=1): num_gpu = len(desc_config["avail_mems"]) mesh = jax.make_mesh((num_gpu,), ("grid")) grid._nodes = jax.device_put( - grid.nodes, + jnp.asarray(grid.nodes), jax.sharding.NamedSharding( mesh, jax.sharding.PartitionSpec("grid") ), ) grid._spacing = jax.device_put( - grid.spacing, + jnp.asarray(grid.spacing), jax.sharding.NamedSharding( mesh, jax.sharding.PartitionSpec("grid") ), ) grid._weights = jax.device_put( - grid.weights, + jnp.asarray(grid.weights), jax.sharding.NamedSharding( mesh, jax.sharding.PartitionSpec("grid") ), From 04af924d4fce14d88e75a3f2f450bb051cc88cef Mon Sep 17 00:00:00 2001 From: YigitElma Date: Wed, 25 Dec 2024 17:02:11 -0500 Subject: [PATCH 10/75] replicate state vector on all deviecs --- desc/optimize/_constraint_wrappers.py | 13 +++++++++++-- 1 file changed, 11 insertions(+), 2 deletions(-) diff --git a/desc/optimize/_constraint_wrappers.py b/desc/optimize/_constraint_wrappers.py index 7695a671b4..e2c5c59ce7 100644 --- a/desc/optimize/_constraint_wrappers.py +++ b/desc/optimize/_constraint_wrappers.py @@ -4,7 +4,7 @@ import numpy as np -from desc.backend import jit, jnp +from desc.backend import desc_config, jax, jit, jnp from desc.batching import batched_vectorize from desc.objectives import ( BoundaryRSelfConsistency, @@ -129,7 +129,16 @@ def project(self, x): def recover(self, x_reduced): """Recover the full state vector from the reduced optimization vector.""" - return self._recover(x_reduced) + x_full = self._recover(x_reduced) + if "avail_mems" in desc_config.keys(): + if hasattr(self, "_constants"): + num_gpu = len(desc_config["avail_mems"]) + mesh = jax.make_mesh((num_gpu,), ("grid")) + x_full = jax.device_put( + x_full, + jax.sharding.NamedSharding(mesh, jax.sharding.PartitionSpec()), + ) + return x_full def x(self, *things): """Return the reduced state vector from the Equilibrium eq.""" From aa4f9aa0981664cc13de9e81b3240ee179ebc209 Mon Sep 17 00:00:00 2001 From: YigitElma Date: Wed, 25 Dec 2024 17:51:28 -0500 Subject: [PATCH 11/75] allow variable number of gpus, copy some data to every device --- desc/__init__.py | 54 ++++++++++++++++++++------- desc/objectives/objective_funs.py | 15 ++++++-- desc/optimize/_constraint_wrappers.py | 18 +++++---- 3 files changed, 63 insertions(+), 24 deletions(-) diff --git a/desc/__init__.py b/desc/__init__.py index 3097d9bc2f..32410f8af7 100644 --- a/desc/__init__.py +++ b/desc/__init__.py @@ -58,10 +58,10 @@ def __getattr__(name): BANNER = colored(_BANNER, "magenta") -config = {"device": None, "avail_mem": None, "kind": None} +config = {"device": None, "avail_mem": None, "kind": None, "num_device": 1} -def set_device(kind="cpu", multigpu=False): # noqa: C901 +def set_device(kind="cpu", num_device=None): # noqa: C901 """Sets the device to use for computation. If kind==``'gpu'``, checks available GPUs and selects the one with the most @@ -73,8 +73,8 @@ def set_device(kind="cpu", multigpu=False): # noqa: C901 ---------- kind : {``'cpu'``, ``'gpu'``} whether to use CPU or GPU. - multigpu : bool - whether to use multiple GPUs or not. Default is False. + num_device : int + number of devices to use. If None, uses only one device. """ config["kind"] = kind @@ -87,7 +87,7 @@ def set_device(kind="cpu", multigpu=False): # noqa: C901 config["device"] = "CPU" config["avail_mem"] = cpu_mem - if kind == "gpu" and not multigpu: + if kind == "gpu" and num_device is None: # Set CUDA_DEVICE_ORDER so the IDs assigned by CUDA match those from nvidia-smi os.environ["CUDA_DEVICE_ORDER"] = "PCI_BUS_ID" import nvgpu @@ -142,7 +142,7 @@ def set_device(kind="cpu", multigpu=False): # noqa: C901 ) / 1024 # in GB os.environ["CUDA_VISIBLE_DEVICES"] = str(selected_gpu["index"]) - if kind == "gpu" and multigpu: + if kind == "gpu" and num_device is not None and num_device > 1: import nvgpu try: @@ -186,10 +186,38 @@ def set_device(kind="cpu", multigpu=False): # noqa: C901 mem = dev["mem_total"] - dev["mem_used"] memories[dev["index"]] = mem - config["device"] = "gpu" - config["devices"] = [ - dev["type"] + " (id={})".format(dev["index"]) for dev in devices - ] - config["avail_mems"] = [ - memories[dev["index"]] / 1024 for dev in devices - ] # in GB + if num_device > len(devices): + warnings.warn( + colored( + "Requested {} GPUs, but only {} available".format( + num_device, len(devices) + ), + "yellow", + ) + ) + return + elif num_device < len(devices): + config["device"] = "gpu" + config["devices"] = [ + dev["type"] + " (id={})".format(dev["index"]) + for dev in devices[:num_device] + ] + config["avail_mems"] = [ + memories[dev["index"]] / 1024 for dev in devices[:num_device] + ] # in GB + config["num_device"] = num_device + # make the other gpu's invisible + visible_devices = "0" + for i in range(1, num_device): + visible_devices += f",{i}" + os.environ["CUDA_VISIBLE_DEVICES"] = visible_devices + else: + config["device"] = "gpu" + config["devices"] = [ + dev["type"] + " (id={})".format(dev["index"]) for dev in devices + ] + config["avail_mems"] = [ + memories[dev["index"]] / 1024 for dev in devices + ] # in GB + config["num_device"] = num_device + # by default all gpus are already visible diff --git a/desc/objectives/objective_funs.py b/desc/objectives/objective_funs.py index df18031f31..b7b434b6f7 100644 --- a/desc/objectives/objective_funs.py +++ b/desc/objectives/objective_funs.py @@ -1144,11 +1144,11 @@ def build(self, use_jit=True, verbose=1): self._check_dimensions() self._set_derivatives() - if "avail_mems" in desc_config.keys(): + if desc_config["num_device"] != 1: if hasattr(self, "_constants"): grid = self._constants["transforms"]["grid"] - num_gpu = len(desc_config["avail_mems"]) - mesh = jax.make_mesh((num_gpu,), ("grid")) + mesh = jax.make_mesh((desc_config["num_device"],), ("grid")) + # shard nodes, spacing, and weights across devices grid._nodes = jax.device_put( jnp.asarray(grid.nodes), jax.sharding.NamedSharding( @@ -1168,6 +1168,15 @@ def build(self, use_jit=True, verbose=1): ), ) + # replicate profiles across devices + # TODO: profiles are dict of arrays, need to shard each array + if False: + profiles = self._constants["profiles"] + profiles = jax.device_put( + profiles, + jax.sharding.NamedSharding(mesh, jax.sharding.PartitionSpec()), + ) + # set quadrature weights if they haven't been if hasattr(self, "_constants") and ("quad_weights" not in self._constants): grid = self._constants["transforms"]["grid"] diff --git a/desc/optimize/_constraint_wrappers.py b/desc/optimize/_constraint_wrappers.py index e2c5c59ce7..af9107ed1f 100644 --- a/desc/optimize/_constraint_wrappers.py +++ b/desc/optimize/_constraint_wrappers.py @@ -130,14 +130,12 @@ def project(self, x): def recover(self, x_reduced): """Recover the full state vector from the reduced optimization vector.""" x_full = self._recover(x_reduced) - if "avail_mems" in desc_config.keys(): - if hasattr(self, "_constants"): - num_gpu = len(desc_config["avail_mems"]) - mesh = jax.make_mesh((num_gpu,), ("grid")) - x_full = jax.device_put( - x_full, - jax.sharding.NamedSharding(mesh, jax.sharding.PartitionSpec()), - ) + if desc_config["num_device"] != 1: + mesh = jax.make_mesh((desc_config["num_device"],), ("grid")) + x_full = jax.device_put( + x_full, + jax.sharding.NamedSharding(mesh, jax.sharding.PartitionSpec()), + ) return x_full def x(self, *things): @@ -300,6 +298,8 @@ def _jac(self, x_reduced, constants=None, op="scaled"): x = self.recover(x_reduced) v = self._unfixed_idx_mat df = getattr(self._objective, "jvp_" + op)(v.T, x, constants) + if desc_config["num_device"] != 1: + df = jax.device_put(df, jax.devices("gpu")[0]) return df.T def jac_scaled(self, x_reduced, constants=None): @@ -360,6 +360,8 @@ def _jvp(self, v, x_reduced, constants=None, op="jvp_scaled"): x = self.recover(x_reduced) v = self._unfixed_idx_mat @ v df = getattr(self._objective, op)(v, x, constants) + if desc_config["num_device"] != 1: + df = jax.device_put(df, jax.devices("gpu")[0]) return df def jvp_scaled(self, v, x_reduced, constants=None): From d67688815cd0e42bac4ea13f8aba4ece793785d6 Mon Sep 17 00:00:00 2001 From: YigitElma Date: Wed, 25 Dec 2024 17:55:00 -0500 Subject: [PATCH 12/75] not put back to one device for testing --- desc/optimize/_constraint_wrappers.py | 4 ---- 1 file changed, 4 deletions(-) diff --git a/desc/optimize/_constraint_wrappers.py b/desc/optimize/_constraint_wrappers.py index af9107ed1f..61c5e36e2d 100644 --- a/desc/optimize/_constraint_wrappers.py +++ b/desc/optimize/_constraint_wrappers.py @@ -298,8 +298,6 @@ def _jac(self, x_reduced, constants=None, op="scaled"): x = self.recover(x_reduced) v = self._unfixed_idx_mat df = getattr(self._objective, "jvp_" + op)(v.T, x, constants) - if desc_config["num_device"] != 1: - df = jax.device_put(df, jax.devices("gpu")[0]) return df.T def jac_scaled(self, x_reduced, constants=None): @@ -360,8 +358,6 @@ def _jvp(self, v, x_reduced, constants=None, op="jvp_scaled"): x = self.recover(x_reduced) v = self._unfixed_idx_mat @ v df = getattr(self._objective, op)(v, x, constants) - if desc_config["num_device"] != 1: - df = jax.device_put(df, jax.devices("gpu")[0]) return df def jvp_scaled(self, v, x_reduced, constants=None): From d3d266359f8b485bc10bc30eb109a544e40a50d3 Mon Sep 17 00:00:00 2001 From: YigitElma Date: Wed, 25 Dec 2024 17:58:16 -0500 Subject: [PATCH 13/75] handle num_device=1 case --- desc/__init__.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/desc/__init__.py b/desc/__init__.py index 32410f8af7..94f966a8ce 100644 --- a/desc/__init__.py +++ b/desc/__init__.py @@ -87,7 +87,7 @@ def set_device(kind="cpu", num_device=None): # noqa: C901 config["device"] = "CPU" config["avail_mem"] = cpu_mem - if kind == "gpu" and num_device is None: + if kind == "gpu" and (num_device is None or num_device == 1): # Set CUDA_DEVICE_ORDER so the IDs assigned by CUDA match those from nvidia-smi os.environ["CUDA_DEVICE_ORDER"] = "PCI_BUS_ID" import nvgpu From ec05139fd46af4e2addbe112fd4aee7f3b1c6fb6 Mon Sep 17 00:00:00 2001 From: YigitElma Date: Wed, 25 Dec 2024 18:19:03 -0500 Subject: [PATCH 14/75] update --- desc/__init__.py | 7 ++++--- desc/backend.py | 2 +- 2 files changed, 5 insertions(+), 4 deletions(-) diff --git a/desc/__init__.py b/desc/__init__.py index 94f966a8ce..9a7227098c 100644 --- a/desc/__init__.py +++ b/desc/__init__.py @@ -61,7 +61,7 @@ def __getattr__(name): config = {"device": None, "avail_mem": None, "kind": None, "num_device": 1} -def set_device(kind="cpu", num_device=None): # noqa: C901 +def set_device(kind="cpu", num_device=1): # noqa: C901 """Sets the device to use for computation. If kind==``'gpu'``, checks available GPUs and selects the one with the most @@ -87,7 +87,7 @@ def set_device(kind="cpu", num_device=None): # noqa: C901 config["device"] = "CPU" config["avail_mem"] = cpu_mem - if kind == "gpu" and (num_device is None or num_device == 1): + if kind == "gpu" and num_device == 1: # Set CUDA_DEVICE_ORDER so the IDs assigned by CUDA match those from nvidia-smi os.environ["CUDA_DEVICE_ORDER"] = "PCI_BUS_ID" import nvgpu @@ -142,7 +142,8 @@ def set_device(kind="cpu", num_device=None): # noqa: C901 ) / 1024 # in GB os.environ["CUDA_VISIBLE_DEVICES"] = str(selected_gpu["index"]) - if kind == "gpu" and num_device is not None and num_device > 1: + # TODO: merge the "gpu" and "num_device" cases in single if block + if kind == "gpu" and num_device > 1: import nvgpu try: diff --git a/desc/backend.py b/desc/backend.py index 7aa8b0e69c..658d51b1ab 100644 --- a/desc/backend.py +++ b/desc/backend.py @@ -60,7 +60,7 @@ ) ) -if "devices" not in desc_config.keys(): +if desc_config["num_devices"] == 1: print( "Using device: {}, with {:.2f} GB available memory".format( desc_config.get("device"), desc_config.get("avail_mem") From ea0b5849f0f9fa9f55ced1aeab7059f77a90ac49 Mon Sep 17 00:00:00 2001 From: YigitElma Date: Wed, 25 Dec 2024 18:20:07 -0500 Subject: [PATCH 15/75] fix typo --- desc/backend.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/desc/backend.py b/desc/backend.py index 658d51b1ab..29231354f5 100644 --- a/desc/backend.py +++ b/desc/backend.py @@ -60,14 +60,14 @@ ) ) -if desc_config["num_devices"] == 1: +if desc_config["num_device"] == 1: print( "Using device: {}, with {:.2f} GB available memory".format( desc_config.get("device"), desc_config.get("avail_mem") ) ) else: - print(f"Using {len(desc_config["devices"])} devices:") + print(f"Using {desc_config["num_device"]} devices:") for i, dev in enumerate(desc_config["devices"]): print( f"\t Device {i}: {dev} with {desc_config["avail_mems"][i]:.2f} " From f353649c7bd3937cb390f4715172b6b5769e4727 Mon Sep 17 00:00:00 2001 From: YigitElma Date: Wed, 25 Dec 2024 18:25:06 -0500 Subject: [PATCH 16/75] fix issue --- desc/__init__.py | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/desc/__init__.py b/desc/__init__.py index 9a7227098c..935d55447f 100644 --- a/desc/__init__.py +++ b/desc/__init__.py @@ -58,7 +58,7 @@ def __getattr__(name): BANNER = colored(_BANNER, "magenta") -config = {"device": None, "avail_mem": None, "kind": None, "num_device": 1} +config = {"device": None, "avail_mem": None, "kind": None, "num_device": None} def set_device(kind="cpu", num_device=1): # noqa: C901 @@ -86,6 +86,7 @@ def set_device(kind="cpu", num_device=1): # noqa: C901 cpu_mem = psutil.virtual_memory().available / 1024**3 # RAM in GB config["device"] = "CPU" config["avail_mem"] = cpu_mem + config["num_device"] = 1 if kind == "gpu" and num_device == 1: # Set CUDA_DEVICE_ORDER so the IDs assigned by CUDA match those from nvidia-smi @@ -140,6 +141,7 @@ def set_device(kind="cpu", num_device=1): # noqa: C901 config["avail_mem"] = ( selected_gpu["mem_total"] - selected_gpu["mem_used"] ) / 1024 # in GB + config["num_device"] = 1 os.environ["CUDA_VISIBLE_DEVICES"] = str(selected_gpu["index"]) # TODO: merge the "gpu" and "num_device" cases in single if block From a7847df0034ef803f51313ccf0e7c73f74442e1b Mon Sep 17 00:00:00 2001 From: YigitElma Date: Wed, 25 Dec 2024 18:27:23 -0500 Subject: [PATCH 17/75] it was a stupid mistake --- desc/backend.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/desc/backend.py b/desc/backend.py index 29231354f5..1fa5ae0cb1 100644 --- a/desc/backend.py +++ b/desc/backend.py @@ -67,10 +67,10 @@ ) ) else: - print(f"Using {desc_config["num_device"]} devices:") + print(f"Using {desc_config['num_device']} devices:") for i, dev in enumerate(desc_config["devices"]): print( - f"\t Device {i}: {dev} with {desc_config["avail_mems"][i]:.2f} " + f"\t Device {i}: {dev} with {desc_config['avail_mems'][i]:.2f} " "GB available memory" ) From 5c0f8116ed0f2afb1c8a606375bbbb6bd3053f00 Mon Sep 17 00:00:00 2001 From: YigitElma Date: Wed, 25 Dec 2024 18:41:53 -0500 Subject: [PATCH 18/75] I don't know why this was changed --- desc/grid.py | 16 +++++++++------- 1 file changed, 9 insertions(+), 7 deletions(-) diff --git a/desc/grid.py b/desc/grid.py index b3757ea376..e6ebbb6831 100644 --- a/desc/grid.py +++ b/desc/grid.py @@ -706,8 +706,8 @@ class Grid(_Grid): nodes.reshape((num_poloidal, num_radial, num_toroidal, 3), order="F"). jitable : bool Whether to skip certain checks and conditionals that don't work under jit. - Allows grid to be created on the fly with custom nodes, but weights, symmetry - etc. may be wrong if grid contains duplicate nodes. + Allows grid to be created on the fly with custom nodes, but weights, + symmetry etc. may be wrong if grid contains duplicate nodes. """ def __init__( @@ -793,6 +793,7 @@ def create_meshgrid( coordinates="rtz", period=(np.inf, 2 * np.pi, 2 * np.pi), NFP=1, + jitable=True, **kwargs, ): """Create a tensor-product grid from the given coordinates in a jitable manner. @@ -819,6 +820,10 @@ def create_meshgrid( Only makes sense to change from 1 if last coordinate is periodic with some constant divided by ``NFP`` and the nodes are placed within one field period. + jitable : bool + Whether to skip certain checks and conditionals that don't work under jit. + Allows grid to be created on the fly with custom nodes, but weights, + symmetry etc. may be wrong if grid contains duplicate nodes. Returns ------- @@ -861,10 +866,7 @@ def create_meshgrid( repeat(unique_a_idx // b.size, b.size, total_repeat_length=a.size * b.size), c.size, ) - inverse_b_idx = jnp.tile( - unique_b_idx, - a.size * c.size, - ) + inverse_b_idx = jnp.tile(unique_b_idx, a.size * c.size) inverse_c_idx = repeat(unique_c_idx // (a.size * b.size), (a.size * b.size)) return Grid( nodes=nodes, @@ -875,7 +877,7 @@ def create_meshgrid( NFP=NFP, sort=False, is_meshgrid=True, - jitable=True, + jitable=jitable, _unique_rho_idx=unique_a_idx, _unique_poloidal_idx=unique_b_idx, _unique_zeta_idx=unique_c_idx, From c97608864b8c58b2039f6e5906d73e2cc23559e8 Mon Sep 17 00:00:00 2001 From: YigitElma Date: Wed, 25 Dec 2024 19:01:13 -0500 Subject: [PATCH 19/75] put the copying inside the jitted part --- desc/objectives/utils.py | 8 +++++++- desc/optimize/_constraint_wrappers.py | 11 ++--------- 2 files changed, 9 insertions(+), 10 deletions(-) diff --git a/desc/objectives/utils.py b/desc/objectives/utils.py index 8e0d6c5f34..2258f1acee 100644 --- a/desc/objectives/utils.py +++ b/desc/objectives/utils.py @@ -5,7 +5,7 @@ import numpy as np -from desc.backend import jit, jnp, put, softargmax +from desc.backend import desc_config, jax, jit, jnp, put, softargmax from desc.io import IOAble from desc.utils import Index, errorif, flatten_list, svd_inv_null, unique_list, warnif @@ -264,6 +264,12 @@ def __call__(self, x_reduced): """Recover the full state vector from the reduced optimization vector.""" dx = put(jnp.zeros(self.dim_x), self.unfixed_idx, self.Z @ x_reduced) x_full = self.D * (self.xp + dx) + if desc_config["num_device"] != 1: + mesh = jax.make_mesh((desc_config["num_device"],), ("grid")) + x_full = jax.device_put( + x_full, + jax.sharding.NamedSharding(mesh, jax.sharding.PartitionSpec()), + ) return jnp.atleast_1d(jnp.squeeze(x_full)) diff --git a/desc/optimize/_constraint_wrappers.py b/desc/optimize/_constraint_wrappers.py index 61c5e36e2d..7695a671b4 100644 --- a/desc/optimize/_constraint_wrappers.py +++ b/desc/optimize/_constraint_wrappers.py @@ -4,7 +4,7 @@ import numpy as np -from desc.backend import desc_config, jax, jit, jnp +from desc.backend import jit, jnp from desc.batching import batched_vectorize from desc.objectives import ( BoundaryRSelfConsistency, @@ -129,14 +129,7 @@ def project(self, x): def recover(self, x_reduced): """Recover the full state vector from the reduced optimization vector.""" - x_full = self._recover(x_reduced) - if desc_config["num_device"] != 1: - mesh = jax.make_mesh((desc_config["num_device"],), ("grid")) - x_full = jax.device_put( - x_full, - jax.sharding.NamedSharding(mesh, jax.sharding.PartitionSpec()), - ) - return x_full + return self._recover(x_reduced) def x(self, *things): """Return the reduced state vector from the Equilibrium eq.""" From e15f7b2e090df7556d92efe623f416bcdb4b1e12 Mon Sep 17 00:00:00 2001 From: YigitElma Date: Wed, 25 Dec 2024 19:20:14 -0500 Subject: [PATCH 20/75] shard A, Z and D too --- desc/objectives/utils.py | 15 +++++++++++++++ 1 file changed, 15 insertions(+) diff --git a/desc/objectives/utils.py b/desc/objectives/utils.py index 2258f1acee..11c5529ee1 100644 --- a/desc/objectives/utils.py +++ b/desc/objectives/utils.py @@ -183,6 +183,21 @@ def factorize_linear_constraints(objective, constraint, x_scale="auto"): # noqa Z = jnp.asarray(Z) D = jnp.asarray(D) + if desc_config["num_device"] != 1: + mesh = jax.make_mesh((desc_config["num_device"],), ("grid")) + Z = jax.device_put( + Z, + jax.sharding.NamedSharding(mesh, jax.sharding.PartitionSpec("grid")), + ) + D = jax.device_put( + D, + jax.sharding.NamedSharding(mesh, jax.sharding.PartitionSpec("grid")), + ) + A = jax.device_put( + A, + jax.sharding.NamedSharding(mesh, jax.sharding.PartitionSpec("grid")), + ) + project = _Project(Z, D, xp, unfixed_idx) recover = _Recover(Z, D, xp, unfixed_idx, objective.dim_x) From 36cd4e1a597891b2aca539c98257375f08999c65 Mon Sep 17 00:00:00 2001 From: YigitElma Date: Wed, 25 Dec 2024 19:23:15 -0500 Subject: [PATCH 21/75] fix --- desc/objectives/utils.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/desc/objectives/utils.py b/desc/objectives/utils.py index 11c5529ee1..9de7b6bad5 100644 --- a/desc/objectives/utils.py +++ b/desc/objectives/utils.py @@ -185,9 +185,10 @@ def factorize_linear_constraints(objective, constraint, x_scale="auto"): # noqa if desc_config["num_device"] != 1: mesh = jax.make_mesh((desc_config["num_device"],), ("grid")) + mesh2 = jax.make_mesh((1, desc_config["num_device"]), ("grid")) Z = jax.device_put( Z, - jax.sharding.NamedSharding(mesh, jax.sharding.PartitionSpec("grid")), + jax.sharding.NamedSharding(mesh2, jax.sharding.PartitionSpec("grid")), ) D = jax.device_put( D, From 7e82f6d7bf5b1ed2bac68814e7f766ea5d01f06f Mon Sep 17 00:00:00 2001 From: YigitElma Date: Wed, 25 Dec 2024 19:25:58 -0500 Subject: [PATCH 22/75] fix --- desc/objectives/utils.py | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/desc/objectives/utils.py b/desc/objectives/utils.py index 9de7b6bad5..29070916b6 100644 --- a/desc/objectives/utils.py +++ b/desc/objectives/utils.py @@ -185,10 +185,12 @@ def factorize_linear_constraints(objective, constraint, x_scale="auto"): # noqa if desc_config["num_device"] != 1: mesh = jax.make_mesh((desc_config["num_device"],), ("grid")) - mesh2 = jax.make_mesh((1, desc_config["num_device"]), ("grid")) + mesh2 = jax.make_mesh((1, desc_config["num_device"]), ("vert", "horz")) Z = jax.device_put( Z, - jax.sharding.NamedSharding(mesh2, jax.sharding.PartitionSpec("grid")), + jax.sharding.NamedSharding( + mesh2, jax.sharding.PartitionSpec("vert", "horz") + ), ) D = jax.device_put( D, From c963c1a9666d13ec8bec850167973d3a551d344b Mon Sep 17 00:00:00 2001 From: YigitElma Date: Wed, 25 Dec 2024 19:26:58 -0500 Subject: [PATCH 23/75] don't shard A --- desc/objectives/utils.py | 4 ---- 1 file changed, 4 deletions(-) diff --git a/desc/objectives/utils.py b/desc/objectives/utils.py index 29070916b6..cbe8f7466b 100644 --- a/desc/objectives/utils.py +++ b/desc/objectives/utils.py @@ -196,10 +196,6 @@ def factorize_linear_constraints(objective, constraint, x_scale="auto"): # noqa D, jax.sharding.NamedSharding(mesh, jax.sharding.PartitionSpec("grid")), ) - A = jax.device_put( - A, - jax.sharding.NamedSharding(mesh, jax.sharding.PartitionSpec("grid")), - ) project = _Project(Z, D, xp, unfixed_idx) recover = _Recover(Z, D, xp, unfixed_idx, objective.dim_x) From ebd8dd1f6887e0621b034c662b55dfd99736b7fb Mon Sep 17 00:00:00 2001 From: YigitElma Date: Wed, 25 Dec 2024 19:39:09 -0500 Subject: [PATCH 24/75] clean up --- desc/backend.py | 8 ++++++++ desc/objectives/objective_funs.py | 15 ++++----------- desc/objectives/utils.py | 21 ++------------------- 3 files changed, 14 insertions(+), 30 deletions(-) diff --git a/desc/backend.py b/desc/backend.py index 1fa5ae0cb1..c8f3152f54 100644 --- a/desc/backend.py +++ b/desc/backend.py @@ -32,6 +32,14 @@ from jax import config as jax_config jax_config.update("jax_enable_x64", True) + if desc_config["num_device"] != 1: + mesh = jax.make_mesh((desc_config["num_device"],), ("grid")) + desc_config["sharding"] = jax.sharding.NamedSharding( + mesh, jax.sharding.PartitionSpec("grid") + ) + desc_config["sharding_replicated"] = jax.sharding.NamedSharding( + mesh, jax.sharding.PartitionSpec() + ) if desc_config.get("kind") == "gpu" and len(jax.devices("gpu")) == 0: warnings.warn( "JAX failed to detect GPU, are you sure you " diff --git a/desc/objectives/objective_funs.py b/desc/objectives/objective_funs.py index b7b434b6f7..93012584e9 100644 --- a/desc/objectives/objective_funs.py +++ b/desc/objectives/objective_funs.py @@ -1147,25 +1147,18 @@ def build(self, use_jit=True, verbose=1): if desc_config["num_device"] != 1: if hasattr(self, "_constants"): grid = self._constants["transforms"]["grid"] - mesh = jax.make_mesh((desc_config["num_device"],), ("grid")) # shard nodes, spacing, and weights across devices grid._nodes = jax.device_put( jnp.asarray(grid.nodes), - jax.sharding.NamedSharding( - mesh, jax.sharding.PartitionSpec("grid") - ), + desc_config["sharding"], ) grid._spacing = jax.device_put( jnp.asarray(grid.spacing), - jax.sharding.NamedSharding( - mesh, jax.sharding.PartitionSpec("grid") - ), + desc_config["sharding"], ) grid._weights = jax.device_put( jnp.asarray(grid.weights), - jax.sharding.NamedSharding( - mesh, jax.sharding.PartitionSpec("grid") - ), + desc_config["sharding"], ) # replicate profiles across devices @@ -1174,7 +1167,7 @@ def build(self, use_jit=True, verbose=1): profiles = self._constants["profiles"] profiles = jax.device_put( profiles, - jax.sharding.NamedSharding(mesh, jax.sharding.PartitionSpec()), + desc_config["sharding"], ) # set quadrature weights if they haven't been diff --git a/desc/objectives/utils.py b/desc/objectives/utils.py index cbe8f7466b..b47ac2afcf 100644 --- a/desc/objectives/utils.py +++ b/desc/objectives/utils.py @@ -177,26 +177,13 @@ def factorize_linear_constraints(objective, constraint, x_scale="auto"): # noqa xp = put(xp, unfixed_idx, A_inv @ b) xp = put(xp, fixed_idx, ((1 / D) * xp)[fixed_idx]) # cast to jnp arrays + # TODO: might consider sharding these too xp = jnp.asarray(xp) A = jnp.asarray(A) b = jnp.asarray(b) Z = jnp.asarray(Z) D = jnp.asarray(D) - if desc_config["num_device"] != 1: - mesh = jax.make_mesh((desc_config["num_device"],), ("grid")) - mesh2 = jax.make_mesh((1, desc_config["num_device"]), ("vert", "horz")) - Z = jax.device_put( - Z, - jax.sharding.NamedSharding( - mesh2, jax.sharding.PartitionSpec("vert", "horz") - ), - ) - D = jax.device_put( - D, - jax.sharding.NamedSharding(mesh, jax.sharding.PartitionSpec("grid")), - ) - project = _Project(Z, D, xp, unfixed_idx) recover = _Recover(Z, D, xp, unfixed_idx, objective.dim_x) @@ -279,11 +266,7 @@ def __call__(self, x_reduced): dx = put(jnp.zeros(self.dim_x), self.unfixed_idx, self.Z @ x_reduced) x_full = self.D * (self.xp + dx) if desc_config["num_device"] != 1: - mesh = jax.make_mesh((desc_config["num_device"],), ("grid")) - x_full = jax.device_put( - x_full, - jax.sharding.NamedSharding(mesh, jax.sharding.PartitionSpec()), - ) + x_full = jax.device_put(x_full, desc_config["sharding_replicated"]) return jnp.atleast_1d(jnp.squeeze(x_full)) From 172d2119a3134d195e19fb072431496b88cda3c8 Mon Sep 17 00:00:00 2001 From: YigitElma Date: Thu, 26 Dec 2024 01:34:40 -0500 Subject: [PATCH 25/75] shard tangents too --- desc/optimize/_constraint_wrappers.py | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-) diff --git a/desc/optimize/_constraint_wrappers.py b/desc/optimize/_constraint_wrappers.py index 7695a671b4..3128e07297 100644 --- a/desc/optimize/_constraint_wrappers.py +++ b/desc/optimize/_constraint_wrappers.py @@ -4,7 +4,7 @@ import numpy as np -from desc.backend import jit, jnp +from desc.backend import desc_config, jax, jit, jnp from desc.batching import batched_vectorize from desc.objectives import ( BoundaryRSelfConsistency, @@ -289,8 +289,10 @@ def hess(self, x_reduced, constants=None): def _jac(self, x_reduced, constants=None, op="scaled"): x = self.recover(x_reduced) - v = self._unfixed_idx_mat - df = getattr(self._objective, "jvp_" + op)(v.T, x, constants) + vT = self._unfixed_idx_mat.T + if desc_config["num_device"] != 1: + vT = jax.device_put(vT, desc_config["sharding"]) + df = getattr(self._objective, "jvp_" + op)(vT, x, constants) return df.T def jac_scaled(self, x_reduced, constants=None): From bd986bef6124929073a04bdcfc947cef66b0b1c5 Mon Sep 17 00:00:00 2001 From: YigitElma Date: Thu, 26 Dec 2024 01:55:49 -0500 Subject: [PATCH 26/75] shard v in different way --- desc/optimize/_constraint_wrappers.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/desc/optimize/_constraint_wrappers.py b/desc/optimize/_constraint_wrappers.py index 3128e07297..4f8f86ee9c 100644 --- a/desc/optimize/_constraint_wrappers.py +++ b/desc/optimize/_constraint_wrappers.py @@ -289,10 +289,10 @@ def hess(self, x_reduced, constants=None): def _jac(self, x_reduced, constants=None, op="scaled"): x = self.recover(x_reduced) - vT = self._unfixed_idx_mat.T + v = self._unfixed_idx_mat if desc_config["num_device"] != 1: - vT = jax.device_put(vT, desc_config["sharding"]) - df = getattr(self._objective, "jvp_" + op)(vT, x, constants) + v = jax.device_put(v, desc_config["sharding"]) + df = getattr(self._objective, "jvp_" + op)(v.T, x, constants) return df.T def jac_scaled(self, x_reduced, constants=None): From 163801ec05fb8c1eb2487cee5092b0aab3d7c662 Mon Sep 17 00:00:00 2001 From: YigitElma Date: Thu, 26 Dec 2024 02:18:20 -0500 Subject: [PATCH 27/75] don't cover set_device for coverage --- setup.cfg | 2 ++ 1 file changed, 2 insertions(+) diff --git a/setup.cfg b/setup.cfg index ec603ef1f1..72b9a5775a 100644 --- a/setup.cfg +++ b/setup.cfg @@ -20,8 +20,10 @@ source = desc/ # _version.py is generated code, no need to count it +# __init__.py deals with device selection that CI cannot test omit = desc/_version.py + desc/__init__.py desc/examples/precise_QH.py desc/examples/precise_QA.py desc/examples/regenerate_all_equilibria.py From 33b7c0b9840fe7f919de212eb1afd62ed741c8cf Mon Sep 17 00:00:00 2001 From: YigitElma Date: Wed, 29 Jan 2025 17:03:16 -0500 Subject: [PATCH 28/75] add getter for parallel force objective --- desc/objectives/getters.py | 49 +++++++++++++++++++++++++++++++ desc/objectives/objective_funs.py | 2 +- 2 files changed, 50 insertions(+), 1 deletion(-) diff --git a/desc/objectives/getters.py b/desc/objectives/getters.py index 03e1b75631..2dcddc636b 100644 --- a/desc/objectives/getters.py +++ b/desc/objectives/getters.py @@ -337,3 +337,52 @@ def maybe_add_self_consistency(thing, constraints): constraints += (FixCurveRotation(curve=thing),) return constraints + + +def get_parallel_forcebalance(eq, num_device, check_device=True): + """Get a list of ForceBalance objectives for parallel computing. + + Parameters + ---------- + eq : Equilibrium + Equilibrium to constrain. + num_device : int + Number of devices to use for parallel computing. + + Returns + ------- + objs : tuple of ForceBalance + A list of the linear constraints used in fixed-boundary problems. + """ + from desc.backend import desc_config, jnp + from desc.grid import LinearGrid + + if desc_config["num_device"] != num_device and check_device: + raise ValueError( + f"Number of devices in desc_config ({desc_config['num_device']}) " + f"does not match the number of devices in input ({num_device})." + ) + if eq.L_grid % num_device == 0: + k = eq.L_grid // num_device + L = eq.L_grid + else: + k = eq.L_grid // num_device + 1 + L = k * num_device + + rhos = jnp.linspace(0.01, 1.0, L) + objs = () + for i in range(num_device): + obj = ForceBalance( + eq, + grid=LinearGrid( + rho=rhos[i * k : (i + 1) * k], + # kind of experimental way of set giving + # less grid points to inner part, but seems + # to make transforms way slower + M=int(eq.M_grid * i / num_device), + N=eq.N_grid, + NFP=eq.NFP, + ), + ) + objs += (obj,) + return objs diff --git a/desc/objectives/objective_funs.py b/desc/objectives/objective_funs.py index 659d3d5baa..ac6c10dea9 100644 --- a/desc/objectives/objective_funs.py +++ b/desc/objectives/objective_funs.py @@ -1148,7 +1148,7 @@ def build(self, use_jit=True, verbose=1): self._check_dimensions() self._set_derivatives() - if desc_config["num_device"] != 1: + if desc_config["num_device"] != 1 and False: # temporarly disable sharding if hasattr(self, "_constants"): grid = self._constants["transforms"]["grid"] # shard nodes, spacing, and weights across devices From 35dd7b037e062588df4ac9e9ae4f9491c01bb297 Mon Sep 17 00:00:00 2001 From: YigitElma Date: Wed, 29 Jan 2025 17:11:29 -0500 Subject: [PATCH 29/75] add notebook for testing --- docs/notebooks/tutorials/multi_device.ipynb | 108 ++++++++++++++++++++ 1 file changed, 108 insertions(+) create mode 100644 docs/notebooks/tutorials/multi_device.ipynb diff --git a/docs/notebooks/tutorials/multi_device.ipynb b/docs/notebooks/tutorials/multi_device.ipynb new file mode 100644 index 0000000000..0540b82026 --- /dev/null +++ b/docs/notebooks/tutorials/multi_device.ipynb @@ -0,0 +1,108 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "vscode": { + "languageId": "plaintext" + } + }, + "source": [ + "# Multi-Gpu Equilibrium Solve" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "import sys\n", + "import os\n", + "\n", + "sys.path.insert(0, os.path.abspath(\".\"))\n", + "sys.path.append(os.path.abspath(\"../../../\"))" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "# from desc import set_device\n", + "# set_device(\"gpu\", num_device=4)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "DESC version 0.13.0+1107.g33b7c0b98,using JAX backend, jax version=0.4.37, jaxlib version=0.4.36, dtype=float64\n", + "Using device: CPU, with 7.82 GB available memory\n" + ] + } + ], + "source": [ + "from desc.examples import get\n", + "from desc.objectives import *\n", + "from desc.objectives.getters import *" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "eq = get(\"HELIOTRON\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "objs = get_parallel_forcebalance(eq, num_device=4, check_device=False)\n", + "obj = ObjectiveFunction(objs)\n", + "cons = get_fixed_boundary_constraints(eq)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "eq.solve(objective=obj, constraints=cons, maxiter=2, ftol=0, gtol=0, xtol=0, verbose=3)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "desc-env", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.7" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} From e9c6e637773f518b31547fd2f46a643090470f0d Mon Sep 17 00:00:00 2001 From: YigitElma Date: Wed, 29 Jan 2025 17:18:14 -0500 Subject: [PATCH 30/75] build and distribute objectives in getter --- desc/objectives/getters.py | 26 ++++++++++++++------------ 1 file changed, 14 insertions(+), 12 deletions(-) diff --git a/desc/objectives/getters.py b/desc/objectives/getters.py index 2dcddc636b..3bfe69661b 100644 --- a/desc/objectives/getters.py +++ b/desc/objectives/getters.py @@ -354,7 +354,7 @@ def get_parallel_forcebalance(eq, num_device, check_device=True): objs : tuple of ForceBalance A list of the linear constraints used in fixed-boundary problems. """ - from desc.backend import desc_config, jnp + from desc.backend import desc_config, jax, jnp from desc.grid import LinearGrid if desc_config["num_device"] != num_device and check_device: @@ -372,17 +372,19 @@ def get_parallel_forcebalance(eq, num_device, check_device=True): rhos = jnp.linspace(0.01, 1.0, L) objs = () for i in range(num_device): - obj = ForceBalance( - eq, - grid=LinearGrid( - rho=rhos[i * k : (i + 1) * k], - # kind of experimental way of set giving - # less grid points to inner part, but seems - # to make transforms way slower - M=int(eq.M_grid * i / num_device), - N=eq.N_grid, - NFP=eq.NFP, - ), + grid = LinearGrid( + rho=rhos[i * k : (i + 1) * k], + # kind of experimental way of set giving + # less grid points to inner part, but seems + # to make transforms way slower + M=int(eq.M_grid * i / num_device), + N=eq.N_grid, + NFP=eq.NFP, ) + grid._nodes = jax.device_put(grid._nodes, jax.devices("gpu")[i]) + grid._spacing = jax.device_put(grid.spacing, jax.devices("gpu")[i]) + grid._weights = jax.device_put(grid.weights, jax.devices("gpu")[i]) + obj = ForceBalance(eq, grid=grid) + obj.build() objs += (obj,) return objs From 9f1988591b1ddcd5901c3c61a7fcde7971bf23eb Mon Sep 17 00:00:00 2001 From: YigitElma Date: Wed, 29 Jan 2025 21:42:05 -0500 Subject: [PATCH 31/75] maybe use same grid res --- desc/objectives/getters.py | 3 +- docs/notebooks/tutorials/multi_device.ipynb | 41 +++++++++++++++------ 2 files changed, 31 insertions(+), 13 deletions(-) diff --git a/desc/objectives/getters.py b/desc/objectives/getters.py index 3bfe69661b..406070122d 100644 --- a/desc/objectives/getters.py +++ b/desc/objectives/getters.py @@ -377,7 +377,8 @@ def get_parallel_forcebalance(eq, num_device, check_device=True): # kind of experimental way of set giving # less grid points to inner part, but seems # to make transforms way slower - M=int(eq.M_grid * i / num_device), + # M=int(eq.M_grid * i / num_device), # noqa: E800 + M=eq.M_grid, N=eq.N_grid, NFP=eq.NFP, ) diff --git a/docs/notebooks/tutorials/multi_device.ipynb b/docs/notebooks/tutorials/multi_device.ipynb index 0540b82026..724699ca36 100644 --- a/docs/notebooks/tutorials/multi_device.ipynb +++ b/docs/notebooks/tutorials/multi_device.ipynb @@ -36,22 +36,16 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 7, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "DESC version 0.13.0+1107.g33b7c0b98,using JAX backend, jax version=0.4.37, jaxlib version=0.4.36, dtype=float64\n", - "Using device: CPU, with 7.82 GB available memory\n" - ] - } - ], + "outputs": [], "source": [ "from desc.examples import get\n", "from desc.objectives import *\n", - "from desc.objectives.getters import *" + "from desc.objectives.getters import *\n", + "from desc.grid import LinearGrid\n", + "from desc.backend import jnp\n", + "from desc.plotting import plot_grid" ] }, { @@ -82,6 +76,29 @@ "source": [ "eq.solve(objective=obj, constraints=cons, maxiter=2, ftol=0, gtol=0, xtol=0, verbose=3)" ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "eq = get(\"HELIOTRON\")\n", + "r_per_gpu = 2\n", + "num_device = 5\n", + "rhos = jnp.linspace(0.01, 1.0, r_per_gpu * num_device)\n", + "for i in range(num_device):\n", + " grid = LinearGrid(\n", + " rho=rhos[i * r_per_gpu : (i + 1) * r_per_gpu],\n", + " # kind of experimental way of set giving\n", + " # less grid points to inner part, but seems\n", + " # to make transforms way slower\n", + " M=int(eq.M_grid * i / num_device),\n", + " N=eq.N_grid,\n", + " NFP=eq.NFP,\n", + " )\n", + " plot_grid(grid)" + ] } ], "metadata": { From 57ab00caaadb3909ebb5d319c7e7a786816c5ca7 Mon Sep 17 00:00:00 2001 From: YigitElma Date: Wed, 29 Jan 2025 22:45:13 -0500 Subject: [PATCH 32/75] add build flag to getter --- desc/objectives/getters.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/desc/objectives/getters.py b/desc/objectives/getters.py index 406070122d..d684f09340 100644 --- a/desc/objectives/getters.py +++ b/desc/objectives/getters.py @@ -339,7 +339,7 @@ def maybe_add_self_consistency(thing, constraints): return constraints -def get_parallel_forcebalance(eq, num_device, check_device=True): +def get_parallel_forcebalance(eq, num_device, use_jit=True, check_device=True): """Get a list of ForceBalance objectives for parallel computing. Parameters @@ -386,6 +386,6 @@ def get_parallel_forcebalance(eq, num_device, check_device=True): grid._spacing = jax.device_put(grid.spacing, jax.devices("gpu")[i]) grid._weights = jax.device_put(grid.weights, jax.devices("gpu")[i]) obj = ForceBalance(eq, grid=grid) - obj.build() + obj.build(use_jit=use_jit) objs += (obj,) return objs From b28bc4e836eb6cc84eb160a099de3abd664e797f Mon Sep 17 00:00:00 2001 From: YigitElma Date: Thu, 30 Jan 2025 13:29:10 -0500 Subject: [PATCH 33/75] do not jit the ObjectiveFunction because jax doesn't allow it --- desc/objectives/getters.py | 13 +++++++++---- desc/objectives/objective_funs.py | 6 ++++-- docs/notebooks/tutorials/multi_device.ipynb | 11 +++++------ 3 files changed, 18 insertions(+), 12 deletions(-) diff --git a/desc/objectives/getters.py b/desc/objectives/getters.py index d684f09340..687b252132 100644 --- a/desc/objectives/getters.py +++ b/desc/objectives/getters.py @@ -340,7 +340,7 @@ def maybe_add_self_consistency(thing, constraints): def get_parallel_forcebalance(eq, num_device, use_jit=True, check_device=True): - """Get a list of ForceBalance objectives for parallel computing. + """Get an ObjectiveFunction for parallel computing ForceBalance. Parameters ---------- @@ -351,8 +351,11 @@ def get_parallel_forcebalance(eq, num_device, use_jit=True, check_device=True): Returns ------- - objs : tuple of ForceBalance - A list of the linear constraints used in fixed-boundary problems. + obj : ObjectiveFunction + An objective function with force balance objectives. Each objective is + computed on a separate device. The objective function is built with + `use_jit_wrapper=False` to make it compatible with JAX parallel computing. + Each objective will have a grid with same number of flux surfaces. """ from desc.backend import desc_config, jax, jnp from desc.grid import LinearGrid @@ -388,4 +391,6 @@ def get_parallel_forcebalance(eq, num_device, use_jit=True, check_device=True): obj = ForceBalance(eq, grid=grid) obj.build(use_jit=use_jit) objs += (obj,) - return objs + obj = ObjectiveFunction(objs) + obj.build(use_jit_wrapper=False) + return obj diff --git a/desc/objectives/objective_funs.py b/desc/objectives/objective_funs.py index ac6c10dea9..9b44d02dfc 100644 --- a/desc/objectives/objective_funs.py +++ b/desc/objectives/objective_funs.py @@ -293,7 +293,7 @@ def _unjit(self): pass @execute_on_cpu - def build(self, use_jit=None, verbose=1): + def build(self, use_jit=None, use_jit_wrapper=True, verbose=1): """Build the objective. Parameters @@ -306,6 +306,8 @@ def build(self, use_jit=None, verbose=1): """ if use_jit is not None: self._use_jit = use_jit + if use_jit is False: + use_jit_wrapper = False timer = Timer() timer.start("Objective build") @@ -369,7 +371,7 @@ def build(self, use_jit=None, verbose=1): if obj._jac_chunk_size is None: obj._jac_chunk_size = self._jac_chunk_size - if not self.use_jit: + if not use_jit_wrapper: self._unjit() self._built = True diff --git a/docs/notebooks/tutorials/multi_device.ipynb b/docs/notebooks/tutorials/multi_device.ipynb index 724699ca36..f2459b07be 100644 --- a/docs/notebooks/tutorials/multi_device.ipynb +++ b/docs/notebooks/tutorials/multi_device.ipynb @@ -13,7 +13,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ @@ -26,7 +26,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ @@ -36,7 +36,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -50,7 +50,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 4, "metadata": {}, "outputs": [], "source": [ @@ -63,8 +63,7 @@ "metadata": {}, "outputs": [], "source": [ - "objs = get_parallel_forcebalance(eq, num_device=4, check_device=False)\n", - "obj = ObjectiveFunction(objs)\n", + "obj = get_parallel_forcebalance(eq, num_device=1, check_device=False)\n", "cons = get_fixed_boundary_constraints(eq)" ] }, From c8f482694500fd32bf58ca129f5c9f16c0da07c3 Mon Sep 17 00:00:00 2001 From: YigitElma Date: Wed, 5 Feb 2025 18:22:56 -0500 Subject: [PATCH 34/75] move extra stuff --- desc/objectives/getters.py | 3 +++ 1 file changed, 3 insertions(+) diff --git a/desc/objectives/getters.py b/desc/objectives/getters.py index 687b252132..ce38f838c3 100644 --- a/desc/objectives/getters.py +++ b/desc/objectives/getters.py @@ -390,6 +390,9 @@ def get_parallel_forcebalance(eq, num_device, use_jit=True, check_device=True): grid._weights = jax.device_put(grid.weights, jax.devices("gpu")[i]) obj = ForceBalance(eq, grid=grid) obj.build(use_jit=use_jit) + obj._constants["quad_weights"] = jax.device_put( + obj._constants["quad_weights"], jax.devices("gpu")[i] + ) objs += (obj,) obj = ObjectiveFunction(objs) obj.build(use_jit_wrapper=False) From c3a4803848223ceff090c26f8ec3a07cd07c16ca Mon Sep 17 00:00:00 2001 From: YigitElma Date: Wed, 5 Feb 2025 18:23:48 -0500 Subject: [PATCH 35/75] move whole objective on gpu --- desc/objectives/getters.py | 7 +------ 1 file changed, 1 insertion(+), 6 deletions(-) diff --git a/desc/objectives/getters.py b/desc/objectives/getters.py index ce38f838c3..3c8b93f1e2 100644 --- a/desc/objectives/getters.py +++ b/desc/objectives/getters.py @@ -385,14 +385,9 @@ def get_parallel_forcebalance(eq, num_device, use_jit=True, check_device=True): N=eq.N_grid, NFP=eq.NFP, ) - grid._nodes = jax.device_put(grid._nodes, jax.devices("gpu")[i]) - grid._spacing = jax.device_put(grid.spacing, jax.devices("gpu")[i]) - grid._weights = jax.device_put(grid.weights, jax.devices("gpu")[i]) obj = ForceBalance(eq, grid=grid) obj.build(use_jit=use_jit) - obj._constants["quad_weights"] = jax.device_put( - obj._constants["quad_weights"], jax.devices("gpu")[i] - ) + obj = jax.device_put(obj, jax.devices("gpu")[i]) objs += (obj,) obj = ObjectiveFunction(objs) obj.build(use_jit_wrapper=False) From b599b91851eb6c989a5dfcc56695adbab6741ace Mon Sep 17 00:00:00 2001 From: YigitElma Date: Wed, 5 Feb 2025 22:09:51 -0500 Subject: [PATCH 36/75] add pconcat function normal concatenate doesn't accepts arrays from different devices --- desc/backend.py | 17 +++++++++++++++++ desc/objectives/objective_funs.py | 15 ++++++++++++--- 2 files changed, 29 insertions(+), 3 deletions(-) diff --git a/desc/backend.py b/desc/backend.py index c8f3152f54..66fe406b08 100644 --- a/desc/backend.py +++ b/desc/backend.py @@ -444,6 +444,23 @@ def tangent_solve(g, y): x = jax.lax.custom_root(res, x0, solve, tangent_solve, has_aux=False) return x + def pconcat(arrays): + """Concatenate arrays that live on different devices. + + Parameters + ---------- + arrays : list of jnp.ndarray + Arrays to concatenate. + + Returns + ------- + out : jnp.ndarray + Concatenated array that lives in the first device. + """ + return jnp.concatenate( + [jax.device_put(x, device=jax.devices("gpu")[0]) for x in arrays] + ) + # we can't really test the numpy backend stuff in automated testing, so we ignore it # for coverage purposes diff --git a/desc/objectives/objective_funs.py b/desc/objectives/objective_funs.py index 9b44d02dfc..49aae91b70 100644 --- a/desc/objectives/objective_funs.py +++ b/desc/objectives/objective_funs.py @@ -500,12 +500,21 @@ def compute_scaled_error(self, x, constants=None): if constants is None: constants = self.constants assert len(params) == len(constants) == len(self.objectives) - f = jnp.concatenate( - [ + if desc_config["num_devices"] == 1: + f = jnp.concatenate( + [ + obj.compute_scaled_error(*par, constants=const) + for par, obj, const in zip(params, self.objectives, constants) + ] + ) + else: + fs = [ obj.compute_scaled_error(*par, constants=const) for par, obj, const in zip(params, self.objectives, constants) ] - ) + from desc.backend import pconcat + + f = pconcat(fs) return f @jit From 05f705ace685b8812d368263d1d8024e2898201d Mon Sep 17 00:00:00 2001 From: YigitElma Date: Wed, 5 Feb 2025 22:18:51 -0500 Subject: [PATCH 37/75] use more pconcat --- desc/backend.py | 11 +++++++---- desc/objectives/getters.py | 14 ++++++++++---- desc/objectives/objective_funs.py | 20 ++++++-------------- 3 files changed, 23 insertions(+), 22 deletions(-) diff --git a/desc/backend.py b/desc/backend.py index 66fe406b08..f4450f953e 100644 --- a/desc/backend.py +++ b/desc/backend.py @@ -445,7 +445,7 @@ def tangent_solve(g, y): return x def pconcat(arrays): - """Concatenate arrays that live on different devices. + """Concatenate arrays that live on same/different devices. Parameters ---------- @@ -457,9 +457,12 @@ def pconcat(arrays): out : jnp.ndarray Concatenated array that lives in the first device. """ - return jnp.concatenate( - [jax.device_put(x, device=jax.devices("gpu")[0]) for x in arrays] - ) + if desc_config["num_device"] == 1: + return jnp.concatenate(arrays) + else: + return jnp.concatenate( + [jax.device_put(x, device=jax.devices("gpu")[0]) for x in arrays] + ) # we can't really test the numpy backend stuff in automated testing, so we ignore it diff --git a/desc/objectives/getters.py b/desc/objectives/getters.py index 3c8b93f1e2..222d074bf3 100644 --- a/desc/objectives/getters.py +++ b/desc/objectives/getters.py @@ -339,7 +339,9 @@ def maybe_add_self_consistency(thing, constraints): return constraints -def get_parallel_forcebalance(eq, num_device, use_jit=True, check_device=True): +def get_parallel_forcebalance( + eq, num_device, use_jit=True, use_jit_wrapper=False, check_device=True +): """Get an ObjectiveFunction for parallel computing ForceBalance. Parameters @@ -388,7 +390,11 @@ def get_parallel_forcebalance(eq, num_device, use_jit=True, check_device=True): obj = ForceBalance(eq, grid=grid) obj.build(use_jit=use_jit) obj = jax.device_put(obj, jax.devices("gpu")[i]) + # if the eq is also distrubuted across GPUs, then some internal logic that + # checks if the things are different will fail, so we need to set the eq + # to be the same manually + obj._things[0] = eq objs += (obj,) - obj = ObjectiveFunction(objs) - obj.build(use_jit_wrapper=False) - return obj + objective = ObjectiveFunction(objs) + objective.build(use_jit_wrapper=use_jit_wrapper) + return objective diff --git a/desc/objectives/objective_funs.py b/desc/objectives/objective_funs.py index 49aae91b70..434574dc7e 100644 --- a/desc/objectives/objective_funs.py +++ b/desc/objectives/objective_funs.py @@ -11,6 +11,7 @@ jax, jit, jnp, + pconcat, tree_flatten, tree_map, tree_unflatten, @@ -442,7 +443,7 @@ def compute_unscaled(self, x, constants=None): if constants is None: constants = self.constants assert len(params) == len(constants) == len(self.objectives) - f = jnp.concatenate( + f = pconcat( [ obj.compute_unscaled(*par, constants=const) for par, obj, const in zip(params, self.objectives, constants) @@ -471,7 +472,7 @@ def compute_scaled(self, x, constants=None): if constants is None: constants = self.constants assert len(params) == len(constants) == len(self.objectives) - f = jnp.concatenate( + f = pconcat( [ obj.compute_scaled(*par, constants=const) for par, obj, const in zip(params, self.objectives, constants) @@ -500,21 +501,12 @@ def compute_scaled_error(self, x, constants=None): if constants is None: constants = self.constants assert len(params) == len(constants) == len(self.objectives) - if desc_config["num_devices"] == 1: - f = jnp.concatenate( - [ - obj.compute_scaled_error(*par, constants=const) - for par, obj, const in zip(params, self.objectives, constants) - ] - ) - else: - fs = [ + f = pconcat( + [ obj.compute_scaled_error(*par, constants=const) for par, obj, const in zip(params, self.objectives, constants) ] - from desc.backend import pconcat - - f = pconcat(fs) + ) return f @jit From 7c36f3a793679ad61825094ed8d16c4578099342 Mon Sep 17 00:00:00 2001 From: YigitElma Date: Thu, 6 Feb 2025 15:41:09 -0500 Subject: [PATCH 38/75] test not passing constants --- desc/objectives/objective_funs.py | 34 ++----------------------------- 1 file changed, 2 insertions(+), 32 deletions(-) diff --git a/desc/objectives/objective_funs.py b/desc/objectives/objective_funs.py index 434574dc7e..fdc1e91a58 100644 --- a/desc/objectives/objective_funs.py +++ b/desc/objectives/objective_funs.py @@ -8,7 +8,6 @@ from desc.backend import ( desc_config, execute_on_cpu, - jax, jit, jnp, pconcat, @@ -498,13 +497,10 @@ def compute_scaled_error(self, x, constants=None): """ params = self.unpack_state(x) - if constants is None: - constants = self.constants - assert len(params) == len(constants) == len(self.objectives) f = pconcat( [ - obj.compute_scaled_error(*par, constants=const) - for par, obj, const in zip(params, self.objectives, constants) + obj.compute_scaled_error(*par) + for par, obj in zip(params, self.objectives) ] ) return f @@ -1151,32 +1147,6 @@ def build(self, use_jit=True, verbose=1): self._check_dimensions() self._set_derivatives() - if desc_config["num_device"] != 1 and False: # temporarly disable sharding - if hasattr(self, "_constants"): - grid = self._constants["transforms"]["grid"] - # shard nodes, spacing, and weights across devices - grid._nodes = jax.device_put( - jnp.asarray(grid.nodes), - desc_config["sharding"], - ) - grid._spacing = jax.device_put( - jnp.asarray(grid.spacing), - desc_config["sharding"], - ) - grid._weights = jax.device_put( - jnp.asarray(grid.weights), - desc_config["sharding"], - ) - - # replicate profiles across devices - # TODO: profiles are dict of arrays, need to shard each array - if False: - profiles = self._constants["profiles"] - profiles = jax.device_put( - profiles, - desc_config["sharding"], - ) - # set quadrature weights if they haven't been if hasattr(self, "_constants") and ("quad_weights" not in self._constants): grid = self._constants["transforms"]["grid"] From 66a4f95c6495b93c54b45a07807a347249ef319e Mon Sep 17 00:00:00 2001 From: YigitElma Date: Thu, 6 Feb 2025 16:02:44 -0500 Subject: [PATCH 39/75] try something --- desc/objectives/getters.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/desc/objectives/getters.py b/desc/objectives/getters.py index 222d074bf3..cb4bcbfc31 100644 --- a/desc/objectives/getters.py +++ b/desc/objectives/getters.py @@ -393,7 +393,7 @@ def get_parallel_forcebalance( # if the eq is also distrubuted across GPUs, then some internal logic that # checks if the things are different will fail, so we need to set the eq # to be the same manually - obj._things[0] = eq + # obj._things[0] = eq # noqa: E800 objs += (obj,) objective = ObjectiveFunction(objs) objective.build(use_jit_wrapper=use_jit_wrapper) From 293b6f0a6930c610b6256af81fe833b01f6fa0e7 Mon Sep 17 00:00:00 2001 From: YigitElma Date: Thu, 6 Feb 2025 16:04:51 -0500 Subject: [PATCH 40/75] try something --- desc/optimize/optimizer.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/desc/optimize/optimizer.py b/desc/optimize/optimizer.py index f42c4865eb..ab4a61fb4a 100644 --- a/desc/optimize/optimizer.py +++ b/desc/optimize/optimizer.py @@ -235,7 +235,7 @@ def optimize( # noqa: C901 objective, nonlinear_constraint ) assert set(objective.things) == set(nonlinear_constraint.things) - assert set(objective.things) == set(things) + # assert set(objective.things) == set(things) #noqa E800 # wrap to handle linear constraints if linear_constraint is not None: From 50883958654f2a3bdb7d1203dd04be5a7e6a8e44 Mon Sep 17 00:00:00 2001 From: YigitElma Date: Thu, 6 Feb 2025 16:11:00 -0500 Subject: [PATCH 41/75] instead replicate eq every device --- desc/objectives/getters.py | 3 ++- desc/optimize/optimizer.py | 2 +- 2 files changed, 3 insertions(+), 2 deletions(-) diff --git a/desc/objectives/getters.py b/desc/objectives/getters.py index cb4bcbfc31..f983c37849 100644 --- a/desc/objectives/getters.py +++ b/desc/objectives/getters.py @@ -362,6 +362,7 @@ def get_parallel_forcebalance( from desc.backend import desc_config, jax, jnp from desc.grid import LinearGrid + eq = jax.device_put(eq, desc_config["sharding_replicated"]) if desc_config["num_device"] != num_device and check_device: raise ValueError( f"Number of devices in desc_config ({desc_config['num_device']}) " @@ -393,7 +394,7 @@ def get_parallel_forcebalance( # if the eq is also distrubuted across GPUs, then some internal logic that # checks if the things are different will fail, so we need to set the eq # to be the same manually - # obj._things[0] = eq # noqa: E800 + obj._things[0] = eq objs += (obj,) objective = ObjectiveFunction(objs) objective.build(use_jit_wrapper=use_jit_wrapper) diff --git a/desc/optimize/optimizer.py b/desc/optimize/optimizer.py index ab4a61fb4a..f42c4865eb 100644 --- a/desc/optimize/optimizer.py +++ b/desc/optimize/optimizer.py @@ -235,7 +235,7 @@ def optimize( # noqa: C901 objective, nonlinear_constraint ) assert set(objective.things) == set(nonlinear_constraint.things) - # assert set(objective.things) == set(things) #noqa E800 + assert set(objective.things) == set(things) # wrap to handle linear constraints if linear_constraint is not None: From 2c93a6a1a08fe8fab5a6e5b0b746d9d63d134718 Mon Sep 17 00:00:00 2001 From: YigitElma Date: Thu, 6 Feb 2025 16:19:19 -0500 Subject: [PATCH 42/75] try something --- desc/optimize/optimizer.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/desc/optimize/optimizer.py b/desc/optimize/optimizer.py index f42c4865eb..64422c4b01 100644 --- a/desc/optimize/optimizer.py +++ b/desc/optimize/optimizer.py @@ -235,7 +235,7 @@ def optimize( # noqa: C901 objective, nonlinear_constraint ) assert set(objective.things) == set(nonlinear_constraint.things) - assert set(objective.things) == set(things) + # assert set(objective.things) == set(things) #noqa: E800 # wrap to handle linear constraints if linear_constraint is not None: From 84179d12b3b5db48fce615e27841d029fc8b4446 Mon Sep 17 00:00:00 2001 From: YigitElma Date: Thu, 6 Feb 2025 16:36:11 -0500 Subject: [PATCH 43/75] return replicated eq and use that otherwise outer eq and obj eq are not the same because one is the copy of the other --- desc/objectives/getters.py | 4 +++- desc/optimize/optimizer.py | 2 +- 2 files changed, 4 insertions(+), 2 deletions(-) diff --git a/desc/objectives/getters.py b/desc/objectives/getters.py index f983c37849..685abc9119 100644 --- a/desc/objectives/getters.py +++ b/desc/objectives/getters.py @@ -353,6 +353,8 @@ def get_parallel_forcebalance( Returns ------- + eq : Equilibrium + Equilibrium to constrain replicated to devices. obj : ObjectiveFunction An objective function with force balance objectives. Each objective is computed on a separate device. The objective function is built with @@ -398,4 +400,4 @@ def get_parallel_forcebalance( objs += (obj,) objective = ObjectiveFunction(objs) objective.build(use_jit_wrapper=use_jit_wrapper) - return objective + return eq, objective diff --git a/desc/optimize/optimizer.py b/desc/optimize/optimizer.py index 64422c4b01..f42c4865eb 100644 --- a/desc/optimize/optimizer.py +++ b/desc/optimize/optimizer.py @@ -235,7 +235,7 @@ def optimize( # noqa: C901 objective, nonlinear_constraint ) assert set(objective.things) == set(nonlinear_constraint.things) - # assert set(objective.things) == set(things) #noqa: E800 + assert set(objective.things) == set(things) # wrap to handle linear constraints if linear_constraint is not None: From 1ee3452af0037d4b5e91b4c44db3fc1be3f82496 Mon Sep 17 00:00:00 2001 From: YigitElma Date: Thu, 6 Feb 2025 17:04:14 -0500 Subject: [PATCH 44/75] reorder steps --- desc/objectives/getters.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/desc/objectives/getters.py b/desc/objectives/getters.py index 685abc9119..ac33b665ab 100644 --- a/desc/objectives/getters.py +++ b/desc/objectives/getters.py @@ -391,12 +391,12 @@ def get_parallel_forcebalance( NFP=eq.NFP, ) obj = ForceBalance(eq, grid=grid) - obj.build(use_jit=use_jit) obj = jax.device_put(obj, jax.devices("gpu")[i]) # if the eq is also distrubuted across GPUs, then some internal logic that # checks if the things are different will fail, so we need to set the eq # to be the same manually obj._things[0] = eq + obj.build(use_jit=use_jit) objs += (obj,) objective = ObjectiveFunction(objs) objective.build(use_jit_wrapper=use_jit_wrapper) From 088324f08dad15d6427cc8b708eeda5ae64eab54 Mon Sep 17 00:00:00 2001 From: YigitElma Date: Mon, 10 Feb 2025 18:47:13 -0500 Subject: [PATCH 45/75] copy params to device before passing to function --- desc/objectives/getters.py | 13 ++--- desc/objectives/objective_funs.py | 85 ++++++++++++++++++++++++------- 2 files changed, 70 insertions(+), 28 deletions(-) diff --git a/desc/objectives/getters.py b/desc/objectives/getters.py index ac33b665ab..8f518796e7 100644 --- a/desc/objectives/getters.py +++ b/desc/objectives/getters.py @@ -339,9 +339,7 @@ def maybe_add_self_consistency(thing, constraints): return constraints -def get_parallel_forcebalance( - eq, num_device, use_jit=True, use_jit_wrapper=False, check_device=True -): +def get_parallel_forcebalance(eq, num_device, use_jit=True, check_device=True): """Get an ObjectiveFunction for parallel computing ForceBalance. Parameters @@ -353,8 +351,6 @@ def get_parallel_forcebalance( Returns ------- - eq : Equilibrium - Equilibrium to constrain replicated to devices. obj : ObjectiveFunction An objective function with force balance objectives. Each objective is computed on a separate device. The objective function is built with @@ -364,7 +360,6 @@ def get_parallel_forcebalance( from desc.backend import desc_config, jax, jnp from desc.grid import LinearGrid - eq = jax.device_put(eq, desc_config["sharding_replicated"]) if desc_config["num_device"] != num_device and check_device: raise ValueError( f"Number of devices in desc_config ({desc_config['num_device']}) " @@ -391,13 +386,13 @@ def get_parallel_forcebalance( NFP=eq.NFP, ) obj = ForceBalance(eq, grid=grid) + obj.build(use_jit=use_jit) obj = jax.device_put(obj, jax.devices("gpu")[i]) # if the eq is also distrubuted across GPUs, then some internal logic that # checks if the things are different will fail, so we need to set the eq # to be the same manually obj._things[0] = eq - obj.build(use_jit=use_jit) objs += (obj,) objective = ObjectiveFunction(objs) - objective.build(use_jit_wrapper=use_jit_wrapper) - return eq, objective + objective.build(use_jit=use_jit) + return objective diff --git a/desc/objectives/objective_funs.py b/desc/objectives/objective_funs.py index fdc1e91a58..ee9b44621d 100644 --- a/desc/objectives/objective_funs.py +++ b/desc/objectives/objective_funs.py @@ -8,6 +8,7 @@ from desc.backend import ( desc_config, execute_on_cpu, + jax, jit, jnp, pconcat, @@ -293,13 +294,16 @@ def _unjit(self): pass @execute_on_cpu - def build(self, use_jit=None, use_jit_wrapper=True, verbose=1): + def build(self, use_jit=None, use_jit_wrapper=True, verbose=1): # noqa: C901 """Build the objective. Parameters ---------- use_jit : bool, optional Whether to just-in-time compile the objective and derivatives. + use_jit_wrapper : bool, optional + Whether to use the jit wrapper for the objective. If multiple GPUs are + used, this will be set to False. verbose : int, optional Level of output. @@ -308,6 +312,10 @@ def build(self, use_jit=None, use_jit_wrapper=True, verbose=1): self._use_jit = use_jit if use_jit is False: use_jit_wrapper = False + + if use_jit_wrapper and desc_config["num_device"] > 1: + use_jit_wrapper = False + timer = Timer() timer.start("Objective build") @@ -442,12 +450,24 @@ def compute_unscaled(self, x, constants=None): if constants is None: constants = self.constants assert len(params) == len(constants) == len(self.objectives) - f = pconcat( - [ - obj.compute_unscaled(*par, constants=const) - for par, obj, const in zip(params, self.objectives, constants) - ] - ) + if desc_config["num_device"] == 1: + f = jnp.concatenate( + [ + obj.compute_unscaled(*par, constants=const) + for par, obj, const in zip(params, self.objectives, constants) + ] + ) + else: + f = pconcat( + [ + obj.compute_unscaled( + *jax.device_put(par, jax.devices("gpu")[i]), constants=const + ) + for i, (par, obj, const) in enumerate( + zip(params, self.objectives, constants) + ) + ] + ) return f @jit @@ -471,12 +491,24 @@ def compute_scaled(self, x, constants=None): if constants is None: constants = self.constants assert len(params) == len(constants) == len(self.objectives) - f = pconcat( - [ - obj.compute_scaled(*par, constants=const) - for par, obj, const in zip(params, self.objectives, constants) - ] - ) + if desc_config["num_device"] == 1: + f = jnp.concatenate( + [ + obj.compute_scaled(*par, constants=const) + for par, obj, const in zip(params, self.objectives, constants) + ] + ) + else: + f = pconcat( + [ + obj.compute_scaled( + *jax.device_put(par, jax.devices("gpu")[i]), constants=const + ) + for i, (par, obj, const) in enumerate( + zip(params, self.objectives, constants) + ) + ] + ) return f @jit @@ -497,12 +529,27 @@ def compute_scaled_error(self, x, constants=None): """ params = self.unpack_state(x) - f = pconcat( - [ - obj.compute_scaled_error(*par) - for par, obj in zip(params, self.objectives) - ] - ) + if constants is None: + constants = self.constants + assert len(params) == len(constants) == len(self.objectives) + if desc_config["num_device"] == 1: + f = jnp.concatenate( + [ + obj.compute_scaled_error(*par, constants=const) + for par, obj, const in zip(params, self.objectives, constants) + ] + ) + else: + f = pconcat( + [ + obj.compute_scaled_error( + *jax.device_put(par, jax.devices("gpu")[i]), constants=const + ) + for i, (par, obj, const) in enumerate( + zip(params, self.objectives, constants) + ) + ] + ) return f @jit From 97c3dec59315f5da71d78564159aabb7b34fc419 Mon Sep 17 00:00:00 2001 From: YigitElma Date: Mon, 10 Feb 2025 19:08:52 -0500 Subject: [PATCH 46/75] add device_id for forcebalance --- desc/backend.py | 11 ++++------- desc/objectives/_equilibrium.py | 2 ++ desc/objectives/getters.py | 2 +- desc/objectives/objective_funs.py | 12 ++++++++---- 4 files changed, 15 insertions(+), 12 deletions(-) diff --git a/desc/backend.py b/desc/backend.py index f4450f953e..66fe406b08 100644 --- a/desc/backend.py +++ b/desc/backend.py @@ -445,7 +445,7 @@ def tangent_solve(g, y): return x def pconcat(arrays): - """Concatenate arrays that live on same/different devices. + """Concatenate arrays that live on different devices. Parameters ---------- @@ -457,12 +457,9 @@ def pconcat(arrays): out : jnp.ndarray Concatenated array that lives in the first device. """ - if desc_config["num_device"] == 1: - return jnp.concatenate(arrays) - else: - return jnp.concatenate( - [jax.device_put(x, device=jax.devices("gpu")[0]) for x in arrays] - ) + return jnp.concatenate( + [jax.device_put(x, device=jax.devices("gpu")[0]) for x in arrays] + ) # we can't really test the numpy backend stuff in automated testing, so we ignore it diff --git a/desc/objectives/_equilibrium.py b/desc/objectives/_equilibrium.py index 7be04509ea..5f1b27b149 100644 --- a/desc/objectives/_equilibrium.py +++ b/desc/objectives/_equilibrium.py @@ -61,6 +61,7 @@ def __init__( grid=None, name="force", jac_chunk_size=None, + device_id=0, ): if target is None and bounds is None: target = 0 @@ -76,6 +77,7 @@ def __init__( deriv_mode=deriv_mode, name=name, jac_chunk_size=jac_chunk_size, + device_id=device_id, ) def build(self, use_jit=True, verbose=1): diff --git a/desc/objectives/getters.py b/desc/objectives/getters.py index 8f518796e7..74393ea271 100644 --- a/desc/objectives/getters.py +++ b/desc/objectives/getters.py @@ -385,7 +385,7 @@ def get_parallel_forcebalance(eq, num_device, use_jit=True, check_device=True): N=eq.N_grid, NFP=eq.NFP, ) - obj = ForceBalance(eq, grid=grid) + obj = ForceBalance(eq, grid=grid, device_id=i) obj.build(use_jit=use_jit) obj = jax.device_put(obj, jax.devices("gpu")[i]) # if the eq is also distrubuted across GPUs, then some internal logic that diff --git a/desc/objectives/objective_funs.py b/desc/objectives/objective_funs.py index ee9b44621d..20c5f1106b 100644 --- a/desc/objectives/objective_funs.py +++ b/desc/objectives/objective_funs.py @@ -265,6 +265,8 @@ def __init__( self._built = False self._compiled = False self._name = name + device_ids = [obj._device_id for obj in objectives] + self._is_multi_device = len(set(device_ids)) > 1 def _unjit(self): """Remove jit compiled methods.""" @@ -313,7 +315,7 @@ def build(self, use_jit=None, use_jit_wrapper=True, verbose=1): # noqa: C901 if use_jit is False: use_jit_wrapper = False - if use_jit_wrapper and desc_config["num_device"] > 1: + if self._is_multi_device: use_jit_wrapper = False timer = Timer() @@ -450,7 +452,7 @@ def compute_unscaled(self, x, constants=None): if constants is None: constants = self.constants assert len(params) == len(constants) == len(self.objectives) - if desc_config["num_device"] == 1: + if not self._is_multi_device: f = jnp.concatenate( [ obj.compute_unscaled(*par, constants=const) @@ -491,7 +493,7 @@ def compute_scaled(self, x, constants=None): if constants is None: constants = self.constants assert len(params) == len(constants) == len(self.objectives) - if desc_config["num_device"] == 1: + if not self._is_multi_device: f = jnp.concatenate( [ obj.compute_scaled(*par, constants=const) @@ -532,7 +534,7 @@ def compute_scaled_error(self, x, constants=None): if constants is None: constants = self.constants assert len(params) == len(constants) == len(self.objectives) - if desc_config["num_device"] == 1: + if not self._is_multi_device: f = jnp.concatenate( [ obj.compute_scaled_error(*par, constants=const) @@ -1094,6 +1096,7 @@ def __init__( deriv_mode="auto", name=None, jac_chunk_size=None, + device_id=0, ): if self._scalar: assert self._coordinates == "" @@ -1107,6 +1110,7 @@ def __init__( assert jac_chunk_size is None or isposint(jac_chunk_size) self._jac_chunk_size = jac_chunk_size + self._device_id = device_id self._target = target self._bounds = bounds From 2b7e007b7a80d5d04ea749d3e3f71f09d7c26f78 Mon Sep 17 00:00:00 2001 From: YigitElma Date: Mon, 10 Feb 2025 19:11:18 -0500 Subject: [PATCH 47/75] update notebook --- docs/notebooks/tutorials/multi_device.ipynb | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-) diff --git a/docs/notebooks/tutorials/multi_device.ipynb b/docs/notebooks/tutorials/multi_device.ipynb index f2459b07be..107f3de1eb 100644 --- a/docs/notebooks/tutorials/multi_device.ipynb +++ b/docs/notebooks/tutorials/multi_device.ipynb @@ -26,12 +26,14 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ + "num_device = 1\n", "# from desc import set_device\n", - "# set_device(\"gpu\", num_device=4)" + "\n", + "# set_device(\"gpu\", num_device=num_device)" ] }, { @@ -63,7 +65,7 @@ "metadata": {}, "outputs": [], "source": [ - "obj = get_parallel_forcebalance(eq, num_device=1, check_device=False)\n", + "obj = get_parallel_forcebalance(eq, num_device=num_device, check_device=False)\n", "cons = get_fixed_boundary_constraints(eq)" ] }, From 856a115027e46421cc3c876efbbbc050ec51a497 Mon Sep 17 00:00:00 2001 From: YigitElma Date: Mon, 10 Feb 2025 19:15:31 -0500 Subject: [PATCH 48/75] delete old line --- desc/optimize/_constraint_wrappers.py | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) diff --git a/desc/optimize/_constraint_wrappers.py b/desc/optimize/_constraint_wrappers.py index 4f8f86ee9c..7695a671b4 100644 --- a/desc/optimize/_constraint_wrappers.py +++ b/desc/optimize/_constraint_wrappers.py @@ -4,7 +4,7 @@ import numpy as np -from desc.backend import desc_config, jax, jit, jnp +from desc.backend import jit, jnp from desc.batching import batched_vectorize from desc.objectives import ( BoundaryRSelfConsistency, @@ -290,8 +290,6 @@ def hess(self, x_reduced, constants=None): def _jac(self, x_reduced, constants=None, op="scaled"): x = self.recover(x_reduced) v = self._unfixed_idx_mat - if desc_config["num_device"] != 1: - v = jax.device_put(v, desc_config["sharding"]) df = getattr(self._objective, "jvp_" + op)(v.T, x, constants) return df.T From 27d0c73e9a1521dabd36573697fdf7d8c24ed7ed Mon Sep 17 00:00:00 2001 From: YigitElma Date: Mon, 10 Feb 2025 19:17:19 -0500 Subject: [PATCH 49/75] add testing cell --- docs/notebooks/tutorials/multi_device.ipynb | 10 ++++++++++ 1 file changed, 10 insertions(+) diff --git a/docs/notebooks/tutorials/multi_device.ipynb b/docs/notebooks/tutorials/multi_device.ipynb index 107f3de1eb..46db36a0fb 100644 --- a/docs/notebooks/tutorials/multi_device.ipynb +++ b/docs/notebooks/tutorials/multi_device.ipynb @@ -69,6 +69,16 @@ "cons = get_fixed_boundary_constraints(eq)" ] }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "print(obj.compute_scaled_error(obj.x()).shape)\n", + "print(obj.jac_scaled_error(obj.x()).shape)" + ] + }, { "cell_type": "code", "execution_count": null, From 30155452e702833af6fd7da9b125773cb28a0286 Mon Sep 17 00:00:00 2001 From: YigitElma Date: Mon, 10 Feb 2025 19:23:55 -0500 Subject: [PATCH 50/75] clean up --- desc/backend.py | 1 + desc/objectives/utils.py | 4 +--- 2 files changed, 2 insertions(+), 3 deletions(-) diff --git a/desc/backend.py b/desc/backend.py index 66fe406b08..4af60679e0 100644 --- a/desc/backend.py +++ b/desc/backend.py @@ -33,6 +33,7 @@ jax_config.update("jax_enable_x64", True) if desc_config["num_device"] != 1: + # for now, these are not used. Delete them if they are not needed. mesh = jax.make_mesh((desc_config["num_device"],), ("grid")) desc_config["sharding"] = jax.sharding.NamedSharding( mesh, jax.sharding.PartitionSpec("grid") diff --git a/desc/objectives/utils.py b/desc/objectives/utils.py index b47ac2afcf..7246a202b7 100644 --- a/desc/objectives/utils.py +++ b/desc/objectives/utils.py @@ -5,7 +5,7 @@ import numpy as np -from desc.backend import desc_config, jax, jit, jnp, put, softargmax +from desc.backend import jit, jnp, put, softargmax from desc.io import IOAble from desc.utils import Index, errorif, flatten_list, svd_inv_null, unique_list, warnif @@ -265,8 +265,6 @@ def __call__(self, x_reduced): """Recover the full state vector from the reduced optimization vector.""" dx = put(jnp.zeros(self.dim_x), self.unfixed_idx, self.Z @ x_reduced) x_full = self.D * (self.xp + dx) - if desc_config["num_device"] != 1: - x_full = jax.device_put(x_full, desc_config["sharding_replicated"]) return jnp.atleast_1d(jnp.squeeze(x_full)) From c8481e1586fe113f11e88c9f7efd6261b5976524 Mon Sep 17 00:00:00 2001 From: YigitElma Date: Mon, 10 Feb 2025 19:31:26 -0500 Subject: [PATCH 51/75] move params to device for printing too --- desc/objectives/objective_funs.py | 25 +++++++++++++++++++------ 1 file changed, 19 insertions(+), 6 deletions(-) diff --git a/desc/objectives/objective_funs.py b/desc/objectives/objective_funs.py index 20c5f1106b..38b1d4d6c7 100644 --- a/desc/objectives/objective_funs.py +++ b/desc/objectives/objective_funs.py @@ -613,13 +613,26 @@ def print_value(self, x, x0=None, constants=None): if x0 is not None: params0 = self.unpack_state(x0) assert len(params0) == len(constants) == len(self.objectives) - for par, par0, obj, const in zip( - params, params0, self.objectives, constants - ): - obj.print_value(par, par0, constants=const) + if self._is_multi_device: + for par, par0, obj, const in zip( + params, params0, self.objectives, constants + ): + par = jax.device_put(par, jax.devices("gpu")[obj._device_id]) + par0 = jax.device_put(par0, jax.devices("gpu")[obj._device_id]) + obj.print_value(par, par0, constants=const) + else: + for par, par0, obj, const in zip( + params, params0, self.objectives, constants + ): + obj.print_value(par, par0, constants=const) else: - for par, obj, const in zip(params, self.objectives, constants): - obj.print_value(par, constants=const) + if self._is_multi_device: + for par, obj, const in zip(params, self.objectives, constants): + par = jax.device_put(par, jax.devices("gpu")[obj._device_id]) + obj.print_value(par, constants=const) + else: + for par, obj, const in zip(params, self.objectives, constants): + obj.print_value(par, constants=const) return None def unpack_state(self, x, per_objective=True): From a800fd4bbb1cba426113992f074967d580de766b Mon Sep 17 00:00:00 2001 From: YigitElma Date: Mon, 10 Feb 2025 23:10:59 -0500 Subject: [PATCH 52/75] update notebook to plot grid --- docs/notebooks/tutorials/multi_device.ipynb | 17 ++--------------- 1 file changed, 2 insertions(+), 15 deletions(-) diff --git a/docs/notebooks/tutorials/multi_device.ipynb b/docs/notebooks/tutorials/multi_device.ipynb index 46db36a0fb..ae89542e17 100644 --- a/docs/notebooks/tutorials/multi_device.ipynb +++ b/docs/notebooks/tutorials/multi_device.ipynb @@ -94,21 +94,8 @@ "metadata": {}, "outputs": [], "source": [ - "eq = get(\"HELIOTRON\")\n", - "r_per_gpu = 2\n", - "num_device = 5\n", - "rhos = jnp.linspace(0.01, 1.0, r_per_gpu * num_device)\n", - "for i in range(num_device):\n", - " grid = LinearGrid(\n", - " rho=rhos[i * r_per_gpu : (i + 1) * r_per_gpu],\n", - " # kind of experimental way of set giving\n", - " # less grid points to inner part, but seems\n", - " # to make transforms way slower\n", - " M=int(eq.M_grid * i / num_device),\n", - " N=eq.N_grid,\n", - " NFP=eq.NFP,\n", - " )\n", - " plot_grid(grid)" + "for obji in obj.objectives:\n", + " plot_grid(obji.constants[\"transforms\"][\"grid\"])" ] } ], From 69161c2de84a65490901c645f552a18b34435790 Mon Sep 17 00:00:00 2001 From: Yigit Gunsur Elmacioglu Date: Tue, 11 Feb 2025 17:36:24 -0500 Subject: [PATCH 53/75] made it WORK! pass all params on given device, merge arrays on cpu or gpu depending on the size. for very big matrices we move the to cpu to be able call qr or svd. need to use blocked and for loop. --- desc/backend.py | 31 +++- desc/objectives/getters.py | 35 ++-- desc/objectives/objective_funs.py | 57 +++++-- docs/notebooks/tutorials/multi_device.ipynb | 173 ++++++++++++++++---- 4 files changed, 227 insertions(+), 69 deletions(-) diff --git a/desc/backend.py b/desc/backend.py index 4af60679e0..3f6c240377 100644 --- a/desc/backend.py +++ b/desc/backend.py @@ -445,22 +445,43 @@ def tangent_solve(g, y): x = jax.lax.custom_root(res, x0, solve, tangent_solve, has_aux=False) return x - def pconcat(arrays): + def pconcat(arrays, mode="concat"): """Concatenate arrays that live on different devices. Parameters ---------- arrays : list of jnp.ndarray Arrays to concatenate. + mode : str + "concat:, "hstack" or "vstack. Default is "concat" Returns ------- out : jnp.ndarray - Concatenated array that lives in the first device. + Concatenated array that lives on CPU. """ - return jnp.concatenate( - [jax.device_put(x, device=jax.devices("gpu")[0]) for x in arrays] - ) + # we will use either CPU or GPU[0] for the matrix decompositions, so the array + # of float64 should fit into single device + size = jnp.array([x.size for x in arrays]) + size = jnp.sum(size) + if size*8/(1024**3) > desc_config["avail_mems"][0]: + device = jax.devices("cpu")[0] + else: + device = jax.devices("gpu")[0] + + if mode == "concat": + out = jnp.concatenate( + [jax.device_put(x, device=device) for x in arrays] + ) + elif mode == "hstack": + out = jnp.hstack( + [jax.device_put(x, device=device) for x in arrays] + ) + elif mode == "vstack": + out = jnp.vstack( + [jax.device_put(x, device=device) for x in arrays] + ) + return out # we can't really test the numpy backend stuff in automated testing, so we ignore it diff --git a/desc/objectives/getters.py b/desc/objectives/getters.py index 74393ea271..75338bc0d6 100644 --- a/desc/objectives/getters.py +++ b/desc/objectives/getters.py @@ -339,7 +339,7 @@ def maybe_add_self_consistency(thing, constraints): return constraints -def get_parallel_forcebalance(eq, num_device, use_jit=True, check_device=True): +def get_parallel_forcebalance(eq, num_device, grid=None, use_jit=True, check_device=True): """Get an ObjectiveFunction for parallel computing ForceBalance. Parameters @@ -365,6 +365,12 @@ def get_parallel_forcebalance(eq, num_device, use_jit=True, check_device=True): f"Number of devices in desc_config ({desc_config['num_device']}) " f"does not match the number of devices in input ({num_device})." ) + if grid is not None: + if len(grid) != num_device: + raise ValueError( + f"Number of grids and num_device must be the same! Got " + f"{len(grid)=} and {num_device=}." + ) if eq.L_grid % num_device == 0: k = eq.L_grid // num_device L = eq.L_grid @@ -375,17 +381,20 @@ def get_parallel_forcebalance(eq, num_device, use_jit=True, check_device=True): rhos = jnp.linspace(0.01, 1.0, L) objs = () for i in range(num_device): - grid = LinearGrid( - rho=rhos[i * k : (i + 1) * k], - # kind of experimental way of set giving - # less grid points to inner part, but seems - # to make transforms way slower - # M=int(eq.M_grid * i / num_device), # noqa: E800 - M=eq.M_grid, - N=eq.N_grid, - NFP=eq.NFP, - ) - obj = ForceBalance(eq, grid=grid, device_id=i) + if grid is None: + gridi = LinearGrid( + rho=rhos[i * k : (i + 1) * k], + # kind of experimental way of set giving + # less grid points to inner part, but seems + # to make transforms way slower + # M=int(eq.M_grid * i / num_device), # noqa: E800 + M=eq.M_grid, + N=eq.N_grid, + NFP=eq.NFP, + ) + else: + gridi = grid[i] + obj = ForceBalance(eq, grid=gridi, device_id=i) obj.build(use_jit=use_jit) obj = jax.device_put(obj, jax.devices("gpu")[i]) # if the eq is also distrubuted across GPUs, then some internal logic that @@ -393,6 +402,6 @@ def get_parallel_forcebalance(eq, num_device, use_jit=True, check_device=True): # to be the same manually obj._things[0] = eq objs += (obj,) - objective = ObjectiveFunction(objs) + objective = ObjectiveFunction(objs, deriv_mode="blocked") objective.build(use_jit=use_jit) return objective diff --git a/desc/objectives/objective_funs.py b/desc/objectives/objective_funs.py index ef50d86396..19cba2ccaf 100644 --- a/desc/objectives/objective_funs.py +++ b/desc/objectives/objective_funs.py @@ -188,6 +188,21 @@ def collect_docs( return doc_params +def jit_with_dynamic_device(method): + @functools.wraps(method) + def wrapper(self, *args, **kwargs): + # Get the device using self.id + device = jax.devices("gpu")[self._device_id] + + # Compile the method with jax.jit for the specific device + jitted_method = jax.jit(method, device=device) + + # Call the jitted function + return jitted_method(self, *args, **kwargs) + + return wrapper + + class ObjectiveFunction(IOAble): """Objective function comprised of one or more Objectives. @@ -463,7 +478,7 @@ def compute_unscaled(self, x, constants=None): f = pconcat( [ obj.compute_unscaled( - *jax.device_put(par, jax.devices("gpu")[i]), constants=const + *jax.device_put(par, jax.devices("gpu")[obj._device_id]), constants=const ) for i, (par, obj, const) in enumerate( zip(params, self.objectives, constants) @@ -504,7 +519,7 @@ def compute_scaled(self, x, constants=None): f = pconcat( [ obj.compute_scaled( - *jax.device_put(par, jax.devices("gpu")[i]), constants=const + *jax.device_put(par, jax.devices("gpu")[obj._device_id]), constants=const ) for i, (par, obj, const) in enumerate( zip(params, self.objectives, constants) @@ -545,7 +560,7 @@ def compute_scaled_error(self, x, constants=None): f = pconcat( [ obj.compute_scaled_error( - *jax.device_put(par, jax.devices("gpu")[i]), constants=const + *jax.device_put(par, jax.devices("gpu")[obj._device_id]), constants=const ) for i, (par, obj, const) in enumerate( zip(params, self.objectives, constants) @@ -754,15 +769,23 @@ def _jvp_blocked(self, v, x, constants=None, op="scaled"): # one by one, and assemble into big block matrix # if objective doesn't depend on a given thing, that part is set to 0. for k, (obj, const) in enumerate(zip(self.objectives, constants)): + print(f"This should run on GPU id:{obj._device_id}") # get the xs that go to that objective thing_idx = self._things_per_objective_idx[k] xi = [xs[i] for i in thing_idx] vi = [vs[i] for i in thing_idx] + if self._is_multi_device: + xi = jax.device_put(xi, jax.devices("gpu")[obj._device_id]) + vi = jax.device_put(vi, jax.devices("gpu")[obj._device_id]) Ji_ = getattr(obj, "jvp_" + op)(vi, xi, constants=const) J += [Ji_] # this is the transpose of the jvp when v is a matrix, for consistency with # jvp_batched - J = jnp.hstack(J) + if not self._is_multi_device: + J = jnp.hstack(J) + else: + J = pconcat(J, mode="hstack") + return J def _jvp_batched(self, v, x, constants=None, op="scaled"): @@ -1252,7 +1275,7 @@ def _maybe_array_to_params(self, *args): argsout += (arg,) return argsout - @jit + @jit_with_dynamic_device def compute_unscaled(self, *args, **kwargs): """Compute the raw value of the objective.""" args = self._maybe_array_to_params(*args) @@ -1261,7 +1284,7 @@ def compute_unscaled(self, *args, **kwargs): f = self._loss_function(f) return jnp.atleast_1d(f) - @jit + @jit_with_dynamic_device def compute_scaled(self, *args, **kwargs): """Compute and apply weighting and normalization.""" args = self._maybe_array_to_params(*args) @@ -1270,7 +1293,7 @@ def compute_scaled(self, *args, **kwargs): f = self._loss_function(f) return jnp.atleast_1d(self._scale(f, **kwargs)) - @jit + @jit_with_dynamic_device def compute_scaled_error(self, *args, **kwargs): """Compute and apply the target/bounds, weighting, and normalization.""" args = self._maybe_array_to_params(*args) @@ -1313,7 +1336,7 @@ def _scale(self, f, *args, **kwargs): f_norm = jnp.atleast_1d(f) / self.normalization # normalization return f_norm * w * self.weight - @jit + @jit_with_dynamic_device def compute_scalar(self, *args, **kwargs): """Compute the scalar form of the objective.""" if self.scalar: @@ -1322,19 +1345,19 @@ def compute_scalar(self, *args, **kwargs): f = jnp.sum(self.compute_scaled_error(*args, **kwargs) ** 2) / 2 return f.squeeze() - @jit + @jit_with_dynamic_device def grad(self, *args, **kwargs): """Compute gradient vector of self.compute_scalar wrt x.""" argnums = tuple(range(len(self.things))) return Derivative(self.compute_scalar, argnums, mode="grad")(*args, **kwargs) - @jit + @jit_with_dynamic_device def hess(self, *args, **kwargs): """Compute Hessian matrix of self.compute_scalar wrt x.""" argnums = tuple(range(len(self.things))) return Derivative(self.compute_scalar, argnums, mode="hess")(*args, **kwargs) - @jit + @jit_with_dynamic_device def jac_scaled(self, *args, **kwargs): """Compute Jacobian matrix of self.compute_scaled wrt x.""" argnums = tuple(range(len(self.things))) @@ -1345,7 +1368,7 @@ def jac_scaled(self, *args, **kwargs): chunk_size=self._jac_chunk_size, )(*args, **kwargs) - @jit + @jit_with_dynamic_device def jac_scaled_error(self, *args, **kwargs): """Compute Jacobian matrix of self.compute_scaled_error wrt x.""" argnums = tuple(range(len(self.things))) @@ -1356,7 +1379,7 @@ def jac_scaled_error(self, *args, **kwargs): chunk_size=self._jac_chunk_size, )(*args, **kwargs) - @jit + @jit_with_dynamic_device def jac_unscaled(self, *args, **kwargs): """Compute Jacobian matrix of self.compute_unscaled wrt x.""" argnums = tuple(range(len(self.things))) @@ -1390,7 +1413,7 @@ def _jvp(self, v, x, constants=None, op="scaled"): # sum over different things. return jnp.sum(jnp.asarray(Jv), axis=0).T - @jit + @jit_with_dynamic_device def jvp_scaled(self, v, x, constants=None): """Compute Jacobian-vector product of self.compute_scaled. @@ -1406,7 +1429,7 @@ def jvp_scaled(self, v, x, constants=None): """ return self._jvp(v, x, constants, "scaled") - @jit + @jit_with_dynamic_device def jvp_scaled_error(self, v, x, constants=None): """Compute Jacobian-vector product of self.compute_scaled_error. @@ -1422,7 +1445,7 @@ def jvp_scaled_error(self, v, x, constants=None): """ return self._jvp(v, x, constants, "scaled_error") - @jit + @jit_with_dynamic_device def jvp_unscaled(self, v, x, constants=None): """Compute Jacobian-vector product of self.compute_unscaled. @@ -1703,3 +1726,5 @@ def __call__(self, things): assert len(flat) == self.length unique, _ = unique_list(flat) return unique + + diff --git a/docs/notebooks/tutorials/multi_device.ipynb b/docs/notebooks/tutorials/multi_device.ipynb index 46db36a0fb..cb5440e64a 100644 --- a/docs/notebooks/tutorials/multi_device.ipynb +++ b/docs/notebooks/tutorials/multi_device.ipynb @@ -26,21 +26,32 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ - "num_device = 1\n", - "# from desc import set_device\n", + "num_device = 2\n", + "from desc import set_device\n", "\n", - "# set_device(\"gpu\", num_device=num_device)" + "set_device(\"gpu\", num_device=num_device)" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 3, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "DESC version 0.13.0+1130.gc8481e158.dirty,using JAX backend, jax version=0.4.38, jaxlib version=0.4.38, dtype=float64\n", + "Using 2 devices:\n", + "\t Device 0: NVIDIA A100-PCIE-40GB (id=0) with 40.00 GB available memory\n", + "\t Device 1: NVIDIA A100-PCIE-40GB (id=1) with 40.00 GB available memory\n" + ] + } + ], "source": [ "from desc.examples import get\n", "from desc.objectives import *\n", @@ -61,9 +72,18 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 5, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Precomputing transforms\n", + "Precomputing transforms\n" + ] + } + ], "source": [ "obj = get_parallel_forcebalance(eq, num_device=num_device, check_device=False)\n", "cons = get_fixed_boundary_constraints(eq)" @@ -71,9 +91,18 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 6, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(34632,)\n", + "(34632, 1977)\n" + ] + } + ], "source": [ "print(obj.compute_scaled_error(obj.x()).shape)\n", "print(obj.jac_scaled_error(obj.x()).shape)" @@ -81,42 +110,116 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 8, + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Building objective: lcfs R\n", + "Building objective: lcfs Z\n", + "Building objective: fixed Psi\n", + "Building objective: fixed pressure\n", + "Building objective: fixed iota\n", + "Building objective: fixed sheet current\n", + "Building objective: self_consistency R\n", + "Building objective: self_consistency Z\n", + "Building objective: lambda gauge\n", + "Building objective: axis R self consistency\n", + "Building objective: axis Z self consistency\n", + "Timer: Objective build = 1.99 sec\n", + "Timer: Linear constraint projection build = 5.61 sec\n", + "Number of parameters: 1593\n", + "Number of objectives: 34632\n", + "Timer: Initializing the optimization = 7.73 sec\n", + "\n", + "Starting optimization\n", + "Using method: lsq-exact\n", + " Iteration Total nfev Cost Cost reduction Step norm Optimality \n", + " 0 1 3.654e-07 1.803e-04 \n", + " 1 6 2.102e-07 1.552e-07 1.244e-03 5.327e-05 \n", + " 2 7 2.097e-07 5.059e-10 1.883e-03 6.156e-05 \n", + "Warning: Maximum number of iterations has been exceeded.\n", + " Current function value: 2.097e-07\n", + " Total delta_x: 2.644e-03\n", + " Iterations: 2\n", + " Function evaluations: 7\n", + " Jacobian evaluations: 3\n", + "Timer: Solution time = 23.4 sec\n", + "Timer: Avg time per step = 7.83 sec\n", + "==============================================================================================================\n", + " Start --> End\n", + "Total (sum of squares): 3.654e-07 --> 2.097e-07, \n", + "Maximum absolute Force error: 1.378e+02 --> 2.537e+02 (N)\n", + "Minimum absolute Force error: 1.059e-10 --> 1.060e-10 (N)\n", + "Average absolute Force error: 2.610e+01 --> 1.938e+01 (N)\n", + "Maximum absolute Force error: 1.108e-05 --> 2.040e-05 (normalized)\n", + "Minimum absolute Force error: 8.517e-18 --> 8.529e-18 (normalized)\n", + "Average absolute Force error: 2.099e-06 --> 1.558e-06 (normalized)\n", + "Maximum absolute Force error: 8.201e+03 --> 6.247e+03 (N)\n", + "Minimum absolute Force error: 1.635e-12 --> 2.050e-12 (N)\n", + "Average absolute Force error: 8.007e+01 --> 7.093e+01 (N)\n", + "Maximum absolute Force error: 6.596e-04 --> 5.024e-04 (normalized)\n", + "Minimum absolute Force error: 1.315e-19 --> 1.649e-19 (normalized)\n", + "Average absolute Force error: 6.440e-06 --> 5.705e-06 (normalized)\n", + "R boundary error: 0.000e+00 --> 0.000e+00 (m)\n", + "Z boundary error: 0.000e+00 --> 0.000e+00 (m)\n", + "Fixed Psi error: 0.000e+00 --> 0.000e+00 (Wb)\n", + "Fixed pressure profile error: 0.000e+00 --> 0.000e+00 (Pa)\n", + "Fixed iota profile error: 0.000e+00 --> 0.000e+00 (dimensionless)\n", + "Fixed sheet current error: 0.000e+00 --> 0.000e+00 (~)\n", + "==============================================================================================================\n" + ] + } + ], "source": [ - "eq.solve(objective=obj, constraints=cons, maxiter=2, ftol=0, gtol=0, xtol=0, verbose=3)" + "eq.solve(objective=obj, constraints=cons, maxiter=2, ftol=0, gtol=0, xtol=0, verbose=3);" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 9, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ - "eq = get(\"HELIOTRON\")\n", - "r_per_gpu = 2\n", - "num_device = 5\n", - "rhos = jnp.linspace(0.01, 1.0, r_per_gpu * num_device)\n", - "for i in range(num_device):\n", - " grid = LinearGrid(\n", - " rho=rhos[i * r_per_gpu : (i + 1) * r_per_gpu],\n", - " # kind of experimental way of set giving\n", - " # less grid points to inner part, but seems\n", - " # to make transforms way slower\n", - " M=int(eq.M_grid * i / num_device),\n", - " N=eq.N_grid,\n", - " NFP=eq.NFP,\n", - " )\n", - " plot_grid(grid)" + "for obji in obj.objectives:\n", + " plot_grid(obji.constants[\"transforms\"][\"grid\"])" ] } ], "metadata": { "kernelspec": { - "display_name": "desc-env", + "display_name": "desc-env [~/.conda/envs/desc-env/]", "language": "python", - "name": "python3" + "name": "conda_desc-env" }, "language_info": { "codemirror_mode": { @@ -128,9 +231,9 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.12.7" + "version": "3.11.6" } }, "nbformat": 4, - "nbformat_minor": 2 + "nbformat_minor": 4 } From 23f66124a557050290c74dcf149d90f8537c18df Mon Sep 17 00:00:00 2001 From: YigitElma Date: Tue, 11 Feb 2025 20:52:13 -0500 Subject: [PATCH 54/75] fix formatting after cluster --- desc/__init__.py | 2 +- desc/backend.py | 18 +++++--------- desc/objectives/getters.py | 10 +++++--- desc/objectives/objective_funs.py | 27 ++++++++++++++------- docs/notebooks/tutorials/multi_device.ipynb | 10 ++++---- 5 files changed, 36 insertions(+), 31 deletions(-) diff --git a/desc/__init__.py b/desc/__init__.py index 86a919d84d..7005b3af2b 100644 --- a/desc/__init__.py +++ b/desc/__init__.py @@ -61,7 +61,7 @@ def __getattr__(name): config = {"device": None, "avail_mem": None, "kind": None, "num_device": None} -def set_device(kind="cpu", gpuid=None, num_device=1): +def set_device(kind="cpu", gpuid=None, num_device=1): # noqa : C901 """Sets the device to use for computation. If kind==``'gpu'`` and a gpuid is specified, uses the specified GPU. If diff --git a/desc/backend.py b/desc/backend.py index 3f6c240377..39f4a095e8 100644 --- a/desc/backend.py +++ b/desc/backend.py @@ -460,27 +460,21 @@ def pconcat(arrays, mode="concat"): out : jnp.ndarray Concatenated array that lives on CPU. """ - # we will use either CPU or GPU[0] for the matrix decompositions, so the array - # of float64 should fit into single device + # we will use either CPU or GPU[0] for the matrix decompositions, so the + # array of float64 should fit into single device size = jnp.array([x.size for x in arrays]) size = jnp.sum(size) - if size*8/(1024**3) > desc_config["avail_mems"][0]: + if size * 8 / (1024**3) > desc_config["avail_mems"][0]: device = jax.devices("cpu")[0] else: device = jax.devices("gpu")[0] if mode == "concat": - out = jnp.concatenate( - [jax.device_put(x, device=device) for x in arrays] - ) + out = jnp.concatenate([jax.device_put(x, device=device) for x in arrays]) elif mode == "hstack": - out = jnp.hstack( - [jax.device_put(x, device=device) for x in arrays] - ) + out = jnp.hstack([jax.device_put(x, device=device) for x in arrays]) elif mode == "vstack": - out = jnp.vstack( - [jax.device_put(x, device=device) for x in arrays] - ) + out = jnp.vstack([jax.device_put(x, device=device) for x in arrays]) return out diff --git a/desc/objectives/getters.py b/desc/objectives/getters.py index 75338bc0d6..3c8853c8af 100644 --- a/desc/objectives/getters.py +++ b/desc/objectives/getters.py @@ -339,7 +339,9 @@ def maybe_add_self_consistency(thing, constraints): return constraints -def get_parallel_forcebalance(eq, num_device, grid=None, use_jit=True, check_device=True): +def get_parallel_forcebalance( + eq, num_device, grid=None, use_jit=True, check_device=True +): """Get an ObjectiveFunction for parallel computing ForceBalance. Parameters @@ -397,9 +399,9 @@ def get_parallel_forcebalance(eq, num_device, grid=None, use_jit=True, check_dev obj = ForceBalance(eq, grid=gridi, device_id=i) obj.build(use_jit=use_jit) obj = jax.device_put(obj, jax.devices("gpu")[i]) - # if the eq is also distrubuted across GPUs, then some internal logic that - # checks if the things are different will fail, so we need to set the eq - # to be the same manually + # if the eq is also distrubuted across GPUs, then some internal logic + # that checks if the things are different will fail, so we need to + # set the eq to be the same manually obj._things[0] = eq objs += (obj,) objective = ObjectiveFunction(objs, deriv_mode="blocked") diff --git a/desc/objectives/objective_funs.py b/desc/objectives/objective_funs.py index 19cba2ccaf..9f324c6524 100644 --- a/desc/objectives/objective_funs.py +++ b/desc/objectives/objective_funs.py @@ -189,17 +189,25 @@ def collect_docs( def jit_with_dynamic_device(method): + """Just-in-time compile a decorator with a dynamic device. + + Decorates a method of a class with a dynamic device, allowing the method to be + compiled with jax.jit for the specific device. This is needed since + @functools.partial(jax.jit, device=jax.devices("gpu")[self._device_id]) is not + allowed in a class definition. + """ + @functools.wraps(method) def wrapper(self, *args, **kwargs): # Get the device using self.id device = jax.devices("gpu")[self._device_id] - + # Compile the method with jax.jit for the specific device jitted_method = jax.jit(method, device=device) - + # Call the jitted function return jitted_method(self, *args, **kwargs) - + return wrapper @@ -478,7 +486,8 @@ def compute_unscaled(self, x, constants=None): f = pconcat( [ obj.compute_unscaled( - *jax.device_put(par, jax.devices("gpu")[obj._device_id]), constants=const + *jax.device_put(par, jax.devices("gpu")[obj._device_id]), + constants=const, ) for i, (par, obj, const) in enumerate( zip(params, self.objectives, constants) @@ -519,7 +528,8 @@ def compute_scaled(self, x, constants=None): f = pconcat( [ obj.compute_scaled( - *jax.device_put(par, jax.devices("gpu")[obj._device_id]), constants=const + *jax.device_put(par, jax.devices("gpu")[obj._device_id]), + constants=const, ) for i, (par, obj, const) in enumerate( zip(params, self.objectives, constants) @@ -560,7 +570,8 @@ def compute_scaled_error(self, x, constants=None): f = pconcat( [ obj.compute_scaled_error( - *jax.device_put(par, jax.devices("gpu")[obj._device_id]), constants=const + *jax.device_put(par, jax.devices("gpu")[obj._device_id]), + constants=const, ) for i, (par, obj, const) in enumerate( zip(params, self.objectives, constants) @@ -785,7 +796,7 @@ def _jvp_blocked(self, v, x, constants=None, op="scaled"): J = jnp.hstack(J) else: J = pconcat(J, mode="hstack") - + return J def _jvp_batched(self, v, x, constants=None, op="scaled"): @@ -1726,5 +1737,3 @@ def __call__(self, things): assert len(flat) == self.length unique, _ = unique_list(flat) return unique - - diff --git a/docs/notebooks/tutorials/multi_device.ipynb b/docs/notebooks/tutorials/multi_device.ipynb index cb5440e64a..67f2fe1f58 100644 --- a/docs/notebooks/tutorials/multi_device.ipynb +++ b/docs/notebooks/tutorials/multi_device.ipynb @@ -110,7 +110,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": null, "metadata": { "editable": true, "slideshow": { @@ -180,7 +180,7 @@ } ], "source": [ - "eq.solve(objective=obj, constraints=cons, maxiter=2, ftol=0, gtol=0, xtol=0, verbose=3);" + "eq.solve(objective=obj, constraints=cons, maxiter=2, ftol=0, gtol=0, xtol=0, verbose=3)" ] }, { @@ -217,9 +217,9 @@ ], "metadata": { "kernelspec": { - "display_name": "desc-env [~/.conda/envs/desc-env/]", + "display_name": "desc-env", "language": "python", - "name": "conda_desc-env" + "name": "python3" }, "language_info": { "codemirror_mode": { @@ -231,7 +231,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.11.6" + "version": "3.12.7" } }, "nbformat": 4, From 1e1dfebdfe9cbcc5312787c480c0469524165e6d Mon Sep 17 00:00:00 2001 From: YigitElma Date: Tue, 11 Feb 2025 21:04:12 -0500 Subject: [PATCH 55/75] fix some problems for testing and docs --- desc/objectives/objective_funs.py | 7 +++++-- docs/index.rst | 1 + docs/notebooks/tutorials/multi_device.ipynb | 6 +++--- 3 files changed, 9 insertions(+), 5 deletions(-) diff --git a/desc/objectives/objective_funs.py b/desc/objectives/objective_funs.py index 9f324c6524..4de6e0a050 100644 --- a/desc/objectives/objective_funs.py +++ b/desc/objectives/objective_funs.py @@ -199,8 +199,11 @@ def jit_with_dynamic_device(method): @functools.wraps(method) def wrapper(self, *args, **kwargs): - # Get the device using self.id - device = jax.devices("gpu")[self._device_id] + # Get the device using self.id or default to CPU + if desc_config["device"] == "gpu": + device = jax.devices("gpu")[self._device_id] + else: + device = None # Compile the method with jax.jit for the specific device jitted_method = jax.jit(method, device=device) diff --git a/docs/index.rst b/docs/index.rst index 1c26bdeb58..1569e1668e 100644 --- a/docs/index.rst +++ b/docs/index.rst @@ -24,6 +24,7 @@ installation notebooks/tutorials/use_outputs.ipynb performance_tips + notebooks/tutorials/multi_device.ipynb .. toctree:: diff --git a/docs/notebooks/tutorials/multi_device.ipynb b/docs/notebooks/tutorials/multi_device.ipynb index 67f2fe1f58..c44bc260af 100644 --- a/docs/notebooks/tutorials/multi_device.ipynb +++ b/docs/notebooks/tutorials/multi_device.ipynb @@ -26,14 +26,14 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ "num_device = 2\n", - "from desc import set_device\n", + "# from desc import set_device\n", "\n", - "set_device(\"gpu\", num_device=num_device)" + "# set_device(\"gpu\", num_device=num_device)" ] }, { From fd7638b52b40f6e8db8f7fccf586ff79f76042dc Mon Sep 17 00:00:00 2001 From: YigitElma Date: Tue, 11 Feb 2025 21:33:18 -0500 Subject: [PATCH 56/75] ignore multidevice for notebook tests, add additional warnings for gpu, move jit_with_device to backend --- .github/workflows/notebook_tests.yml | 2 +- desc/backend.py | 29 ++++++++++ desc/objectives/getters.py | 5 ++ desc/objectives/objective_funs.py | 87 ++++++++-------------------- 4 files changed, 59 insertions(+), 64 deletions(-) diff --git a/.github/workflows/notebook_tests.yml b/.github/workflows/notebook_tests.yml index a437d1bbb7..3bde1e62d5 100644 --- a/.github/workflows/notebook_tests.yml +++ b/.github/workflows/notebook_tests.yml @@ -93,7 +93,7 @@ jobs: export PYTHONPATH=$(pwd) pytest -v --nbmake "./docs/notebooks" \ --nbmake-timeout=2000 \ - --ignore=./docs/notebooks/zernike_eval.ipynb \ + --ignore=./docs/notebooks/zernike_eval.ipynb ./docs/notebooks/tutorials/multi_device.ipynb \ --splits 3 \ --group ${{ matrix.group }} \ --splitting-algorithm least_duration diff --git a/desc/backend.py b/desc/backend.py index 1fcf4b3579..07393f641e 100644 --- a/desc/backend.py +++ b/desc/backend.py @@ -475,6 +475,35 @@ def pconcat(arrays, mode="concat"): out = jnp.vstack([jax.device_put(x, device=device) for x in arrays]) return out + def jit_with_device(method): + """Decorator to Just-in-time compile a class method with a dynamic device. + + Decorates a method of a class with a dynamic device, allowing the method to be + compiled with jax.jit for the specific device. This is needed since + @functools.partial(jax.jit, device=jax.devices("gpu")[self._device_id]) is not + allowed in a class definition. + + Parameters + ---------- + method : callable + Class method to decorate. If DESC is running on GPU, the class should have + a device_id attribute. + """ + + @functools.wraps(method) + def wrapper(self, *args, **kwargs): + # Get the device using self.id or default to CPU + if desc_config["device"] == "gpu" and hasattr(self, "_device_id"): + device = jax.devices("gpu")[self._device_id] + else: + device = None + + # Compile the method with jax.jit for the specific device + wrapped = jax.jit(method, device=device) + return wrapped(self, *args, **kwargs) + + return wrapper + # we can't really test the numpy backend stuff in automated testing, so we ignore it # for coverage purposes diff --git a/desc/objectives/getters.py b/desc/objectives/getters.py index 6be7132b0f..ff664816cf 100644 --- a/desc/objectives/getters.py +++ b/desc/objectives/getters.py @@ -369,6 +369,11 @@ def get_parallel_forcebalance( from desc.backend import desc_config, jax, jnp from desc.grid import LinearGrid + if desc_config["device"] != "gpu": + raise ValueError( + "Parallel computing is only supported on GPU. " + "Please use DESC with GPU device." + ) if desc_config["num_device"] != num_device and check_device: raise ValueError( f"Number of devices in desc_config ({desc_config['num_device']}) " diff --git a/desc/objectives/objective_funs.py b/desc/objectives/objective_funs.py index 4de6e0a050..d18f021854 100644 --- a/desc/objectives/objective_funs.py +++ b/desc/objectives/objective_funs.py @@ -10,6 +10,7 @@ execute_on_cpu, jax, jit, + jit_with_device, jnp, pconcat, tree_flatten, @@ -188,32 +189,6 @@ def collect_docs( return doc_params -def jit_with_dynamic_device(method): - """Just-in-time compile a decorator with a dynamic device. - - Decorates a method of a class with a dynamic device, allowing the method to be - compiled with jax.jit for the specific device. This is needed since - @functools.partial(jax.jit, device=jax.devices("gpu")[self._device_id]) is not - allowed in a class definition. - """ - - @functools.wraps(method) - def wrapper(self, *args, **kwargs): - # Get the device using self.id or default to CPU - if desc_config["device"] == "gpu": - device = jax.devices("gpu")[self._device_id] - else: - device = None - - # Compile the method with jax.jit for the specific device - jitted_method = jax.jit(method, device=device) - - # Call the jitted function - return jitted_method(self, *args, **kwargs) - - return wrapper - - class ObjectiveFunction(IOAble): """Objective function comprised of one or more Objectives. @@ -492,9 +467,7 @@ def compute_unscaled(self, x, constants=None): *jax.device_put(par, jax.devices("gpu")[obj._device_id]), constants=const, ) - for i, (par, obj, const) in enumerate( - zip(params, self.objectives, constants) - ) + for par, obj, const in zip(params, self.objectives, constants) ] ) return f @@ -534,9 +507,7 @@ def compute_scaled(self, x, constants=None): *jax.device_put(par, jax.devices("gpu")[obj._device_id]), constants=const, ) - for i, (par, obj, const) in enumerate( - zip(params, self.objectives, constants) - ) + for par, obj, const in zip(params, self.objectives, constants) ] ) return f @@ -576,9 +547,7 @@ def compute_scaled_error(self, x, constants=None): *jax.device_put(par, jax.devices("gpu")[obj._device_id]), constants=const, ) - for i, (par, obj, const) in enumerate( - zip(params, self.objectives, constants) - ) + for par, obj, const in zip(params, self.objectives, constants) ] ) return f @@ -642,26 +611,18 @@ def print_value(self, x, x0=None, constants=None): if x0 is not None: params0 = self.unpack_state(x0) assert len(params0) == len(constants) == len(self.objectives) - if self._is_multi_device: - for par, par0, obj, const in zip( - params, params0, self.objectives, constants - ): + for par, par0, obj, const in zip( + params, params0, self.objectives, constants + ): + if self._is_multi_device: par = jax.device_put(par, jax.devices("gpu")[obj._device_id]) par0 = jax.device_put(par0, jax.devices("gpu")[obj._device_id]) - obj.print_value(par, par0, constants=const) - else: - for par, par0, obj, const in zip( - params, params0, self.objectives, constants - ): - obj.print_value(par, par0, constants=const) + obj.print_value(par, par0, constants=const) else: - if self._is_multi_device: - for par, obj, const in zip(params, self.objectives, constants): + for par, obj, const in zip(params, self.objectives, constants): + if self._is_multi_device: par = jax.device_put(par, jax.devices("gpu")[obj._device_id]) - obj.print_value(par, constants=const) - else: - for par, obj, const in zip(params, self.objectives, constants): - obj.print_value(par, constants=const) + obj.print_value(par, constants=const) return None def unpack_state(self, x, per_objective=True): @@ -1289,7 +1250,7 @@ def _maybe_array_to_params(self, *args): argsout += (arg,) return argsout - @jit_with_dynamic_device + @jit_with_device def compute_unscaled(self, *args, **kwargs): """Compute the raw value of the objective.""" args = self._maybe_array_to_params(*args) @@ -1298,7 +1259,7 @@ def compute_unscaled(self, *args, **kwargs): f = self._loss_function(f) return jnp.atleast_1d(f) - @jit_with_dynamic_device + @jit_with_device def compute_scaled(self, *args, **kwargs): """Compute and apply weighting and normalization.""" args = self._maybe_array_to_params(*args) @@ -1307,7 +1268,7 @@ def compute_scaled(self, *args, **kwargs): f = self._loss_function(f) return jnp.atleast_1d(self._scale(f, **kwargs)) - @jit_with_dynamic_device + @jit_with_device def compute_scaled_error(self, *args, **kwargs): """Compute and apply the target/bounds, weighting, and normalization.""" args = self._maybe_array_to_params(*args) @@ -1350,7 +1311,7 @@ def _scale(self, f, *args, **kwargs): f_norm = jnp.atleast_1d(f) / self.normalization # normalization return f_norm * w * self.weight - @jit_with_dynamic_device + @jit_with_device def compute_scalar(self, *args, **kwargs): """Compute the scalar form of the objective.""" if self.scalar: @@ -1359,19 +1320,19 @@ def compute_scalar(self, *args, **kwargs): f = jnp.sum(self.compute_scaled_error(*args, **kwargs) ** 2) / 2 return f.squeeze() - @jit_with_dynamic_device + @jit_with_device def grad(self, *args, **kwargs): """Compute gradient vector of self.compute_scalar wrt x.""" argnums = tuple(range(len(self.things))) return Derivative(self.compute_scalar, argnums, mode="grad")(*args, **kwargs) - @jit_with_dynamic_device + @jit_with_device def hess(self, *args, **kwargs): """Compute Hessian matrix of self.compute_scalar wrt x.""" argnums = tuple(range(len(self.things))) return Derivative(self.compute_scalar, argnums, mode="hess")(*args, **kwargs) - @jit_with_dynamic_device + @jit_with_device def jac_scaled(self, *args, **kwargs): """Compute Jacobian matrix of self.compute_scaled wrt x.""" argnums = tuple(range(len(self.things))) @@ -1382,7 +1343,7 @@ def jac_scaled(self, *args, **kwargs): chunk_size=self._jac_chunk_size, )(*args, **kwargs) - @jit_with_dynamic_device + @jit_with_device def jac_scaled_error(self, *args, **kwargs): """Compute Jacobian matrix of self.compute_scaled_error wrt x.""" argnums = tuple(range(len(self.things))) @@ -1393,7 +1354,7 @@ def jac_scaled_error(self, *args, **kwargs): chunk_size=self._jac_chunk_size, )(*args, **kwargs) - @jit_with_dynamic_device + @jit_with_device def jac_unscaled(self, *args, **kwargs): """Compute Jacobian matrix of self.compute_unscaled wrt x.""" argnums = tuple(range(len(self.things))) @@ -1427,7 +1388,7 @@ def _jvp(self, v, x, constants=None, op="scaled"): # sum over different things. return jnp.sum(jnp.asarray(Jv), axis=0).T - @jit_with_dynamic_device + @jit_with_device def jvp_scaled(self, v, x, constants=None): """Compute Jacobian-vector product of self.compute_scaled. @@ -1443,7 +1404,7 @@ def jvp_scaled(self, v, x, constants=None): """ return self._jvp(v, x, constants, "scaled") - @jit_with_dynamic_device + @jit_with_device def jvp_scaled_error(self, v, x, constants=None): """Compute Jacobian-vector product of self.compute_scaled_error. @@ -1459,7 +1420,7 @@ def jvp_scaled_error(self, v, x, constants=None): """ return self._jvp(v, x, constants, "scaled_error") - @jit_with_dynamic_device + @jit_with_device def jvp_unscaled(self, v, x, constants=None): """Compute Jacobian-vector product of self.compute_unscaled. From 0a77b1abedcf639c032b24f53f6e7dee6d07a55d Mon Sep 17 00:00:00 2001 From: YigitElma Date: Wed, 12 Feb 2025 14:29:37 -0500 Subject: [PATCH 57/75] add changelog, fix notebook tests --- .github/workflows/notebook_tests.yml | 11 ++++++----- CHANGELOG.md | 5 +++-- 2 files changed, 9 insertions(+), 7 deletions(-) diff --git a/.github/workflows/notebook_tests.yml b/.github/workflows/notebook_tests.yml index 3bde1e62d5..b7e7055a0c 100644 --- a/.github/workflows/notebook_tests.yml +++ b/.github/workflows/notebook_tests.yml @@ -92,8 +92,9 @@ jobs: source .venv-${{ env.version }}/bin/activate export PYTHONPATH=$(pwd) pytest -v --nbmake "./docs/notebooks" \ - --nbmake-timeout=2000 \ - --ignore=./docs/notebooks/zernike_eval.ipynb ./docs/notebooks/tutorials/multi_device.ipynb \ - --splits 3 \ - --group ${{ matrix.group }} \ - --splitting-algorithm least_duration + --nbmake-timeout=2000 \ + --ignore=./docs/notebooks/zernike_eval.ipynb \ + --ignore=./docs/notebooks/tutorials/multi_device.ipynb \ + --splits 3 \ + --group ${{ matrix.group }} \ + --splitting-algorithm least_duration diff --git a/CHANGELOG.md b/CHANGELOG.md index ee0aa35490..fe9c8a3e17 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -24,8 +24,9 @@ New Features - Adds a new function ``desc.coils.initialize_helical_coils`` for creating an initial guess for stage 2 helical coil optimization. - Adds ``desc.vmec_utils.make_boozmn_output `` for writing boozmn.nc style output files for compatibility with other codes which expect such files from the Booz_Xform code. -- Renames compute quantity ``sqrt(g)_B`` to ``sqrt(g)_Boozer_DESC`` to more accurately reflect what the quantiy is (the jacobian from (rho,theta_B,zeta_B) to (rho,theta,zeta)), and adds a new function to compute ``sqrt(g)_Boozer`` which is the jacobian from (rho,theta_B,zeta_B) to (R,phi,Z). -- Allows specification of Nyquist spectrum maximum modenumbers when using ``VMECIO.save`` to save a DESC .h5 file as a VMEC-format wout file +- Renames compute quantity ``sqrt(g)_B`` to ``sqrt(g)_Boozer_DESC`` to more accurately reflect what the quantity is (the jacobian from (rho,theta_B,zeta_B) to (rho,theta,zeta)), and adds a new function to compute ``sqrt(g)_Boozer`` which is the jacobian from (rho,theta_B,zeta_B) to (R,phi,Z). +- Allows specification of Nyquist spectrum maximum mode-numbers when using ``VMECIO.save`` to save a DESC .h5 file as a VMEC-format wout file +- Adds initial support for multiple GPU optimization. This allows to compute derivatives on multiple GPU, and allows more memory intense objectives. Note that: at this phase, the multi-device support is for memory, not speed. Bug Fixes From 306ae44e130df16be441ccf26c519aafa83358ec Mon Sep 17 00:00:00 2001 From: YigitElma Date: Wed, 12 Feb 2025 17:13:05 -0500 Subject: [PATCH 58/75] add warning for deriv_mode blocked and moving array to CPU --- desc/backend.py | 5 +++++ desc/objectives/objective_funs.py | 12 +++++++++++- 2 files changed, 16 insertions(+), 1 deletion(-) diff --git a/desc/backend.py b/desc/backend.py index 07393f641e..7c22a48e66 100644 --- a/desc/backend.py +++ b/desc/backend.py @@ -463,6 +463,11 @@ def pconcat(arrays, mode="concat"): size = jnp.array([x.size for x in arrays]) size = jnp.sum(size) if size * 8 / (1024**3) > desc_config["avail_mems"][0]: + warnings.warn( + "The total size of the arrays exceeds the available memory of the " + "GPU[id=0]. Moving the array to CPU. This may cause performance " + "degredation." + ) device = jax.devices("cpu")[0] else: device = jax.devices("gpu")[0] diff --git a/desc/objectives/objective_funs.py b/desc/objectives/objective_funs.py index d18f021854..a830f1d895 100644 --- a/desc/objectives/objective_funs.py +++ b/desc/objectives/objective_funs.py @@ -364,6 +364,12 @@ def build(self, use_jit=None, use_jit_wrapper=True, verbose=1): # noqa: C901 else: self._deriv_mode = "blocked" + if self._is_multi_device and self._deriv_mode != "blocked": + raise ValueError( + "When using multiple GPUs, the deriv_mode must be set to 'blocked'. " + "When you are creating the ObjectiveFunction, set deriv_mode='blocked'." + ) + if self._jac_chunk_size == "auto": # Heuristic estimates of fwd mode Jacobian memory usage, # slightly conservative, based on using ForceBalance as the objective @@ -744,12 +750,16 @@ def _jvp_blocked(self, v, x, constants=None, op="scaled"): # one by one, and assemble into big block matrix # if objective doesn't depend on a given thing, that part is set to 0. for k, (obj, const) in enumerate(zip(self.objectives, constants)): - print(f"This should run on GPU id:{obj._device_id}") + # TODO: this is for debugging purposes, must be deleted before merging! + if self._is_multi_device: + print(f"This should run on GPU id:{obj._device_id}") # get the xs that go to that objective thing_idx = self._things_per_objective_idx[k] xi = [xs[i] for i in thing_idx] vi = [vs[i] for i in thing_idx] if self._is_multi_device: + # inputs to jitted functions must live on the same device. Need to + # put xi and vi on the same device as the objective xi = jax.device_put(xi, jax.devices("gpu")[obj._device_id]) vi = jax.device_put(vi, jax.devices("gpu")[obj._device_id]) Ji_ = getattr(obj, "jvp_" + op)(vi, xi, constants=const) From f5dd1fae00bdd695bed57d7d5cb896e0c7e24171 Mon Sep 17 00:00:00 2001 From: YigitElma Date: Wed, 12 Feb 2025 17:16:57 -0500 Subject: [PATCH 59/75] add option to suppress cpu warning --- desc/backend.py | 13 ++++++++----- 1 file changed, 8 insertions(+), 5 deletions(-) diff --git a/desc/backend.py b/desc/backend.py index 7c22a48e66..a7815e40b8 100644 --- a/desc/backend.py +++ b/desc/backend.py @@ -463,11 +463,14 @@ def pconcat(arrays, mode="concat"): size = jnp.array([x.size for x in arrays]) size = jnp.sum(size) if size * 8 / (1024**3) > desc_config["avail_mems"][0]: - warnings.warn( - "The total size of the arrays exceeds the available memory of the " - "GPU[id=0]. Moving the array to CPU. This may cause performance " - "degredation." - ) + if getattr(desc_config, "suppress_cpu_warning", False): + warnings.warn( + "The total size of the arrays exceeds the available memory of the " + "GPU[id=0]. Moving the array to CPU. This may cause performance " + "degredation. To suppress this warning, use " + "`from desc import config as desc_config` \n" + "`desc_config['suppress_cpu_warning'] = True`" + ) device = jax.devices("cpu")[0] else: device = jax.devices("gpu")[0] From 3326426e5f6edb19dace381abf2bcd45c85bf1e8 Mon Sep 17 00:00:00 2001 From: YigitElma Date: Wed, 12 Feb 2025 17:17:49 -0500 Subject: [PATCH 60/75] make upper case --- desc/backend.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/desc/backend.py b/desc/backend.py index a7815e40b8..7148b2896c 100644 --- a/desc/backend.py +++ b/desc/backend.py @@ -463,13 +463,13 @@ def pconcat(arrays, mode="concat"): size = jnp.array([x.size for x in arrays]) size = jnp.sum(size) if size * 8 / (1024**3) > desc_config["avail_mems"][0]: - if getattr(desc_config, "suppress_cpu_warning", False): + if getattr(desc_config, "SUPPRESS_CPU_WARNING", False): warnings.warn( "The total size of the arrays exceeds the available memory of the " "GPU[id=0]. Moving the array to CPU. This may cause performance " "degredation. To suppress this warning, use " "`from desc import config as desc_config` \n" - "`desc_config['suppress_cpu_warning'] = True`" + "`desc_config['SUPPRESS_CPU_WARNING'] = True`" ) device = jax.devices("cpu")[0] else: From fef9a90ae7b5e58c02649e258a17b0465063d2c7 Mon Sep 17 00:00:00 2001 From: YigitElma Date: Wed, 12 Feb 2025 18:13:18 -0500 Subject: [PATCH 61/75] clean up set_device --- desc/__init__.py | 173 +++++++++--------------------- desc/backend.py | 3 +- desc/objectives/objective_funs.py | 26 +++-- 3 files changed, 71 insertions(+), 131 deletions(-) diff --git a/desc/__init__.py b/desc/__init__.py index 7005b3af2b..d731607979 100644 --- a/desc/__init__.py +++ b/desc/__init__.py @@ -61,21 +61,28 @@ def __getattr__(name): config = {"device": None, "avail_mem": None, "kind": None, "num_device": None} -def set_device(kind="cpu", gpuid=None, num_device=1): # noqa : C901 +def set_device(kind="cpu", gpuid=None, num_device=1): """Sets the device to use for computation. If kind==``'gpu'`` and a gpuid is specified, uses the specified GPU. If gpuid==``None`` or a wrong GPU id is given, checks available GPUs and selects the one with the most available memory. Respects environment variable CUDA_VISIBLE_DEVICES for selecting from multiple - available GPUs + available GPUs. + + Notes + ----- + This function must be called before importing anything else from DESC or JAX, + otherwise it will have no effect. Parameters ---------- kind : {``'cpu'``, ``'gpu'``} whether to use CPU or GPU. + gpuid : int, optional + GPU id to use. Default is None. Supported only when num_device is 1. num_device : int - number of devices to use. If None, uses only one device. + number of devices to use. Default is 1. """ config["kind"] = kind @@ -89,8 +96,7 @@ def set_device(kind="cpu", gpuid=None, num_device=1): # noqa : C901 config["avail_mem"] = cpu_mem config["num_device"] = 1 - if kind == "gpu" and num_device == 1: - # Set CUDA_DEVICE_ORDER so the IDs assigned by CUDA match those from nvidia-smi + elif kind == "gpu": os.environ["CUDA_DEVICE_ORDER"] = "PCI_BUS_ID" import nvgpu @@ -103,137 +109,64 @@ def set_device(kind="cpu", gpuid=None, num_device=1): # noqa : C901 set_device(kind="cpu") return - maxmem = 0 - selected_gpu = None gpu_ids = [dev["index"] for dev in devices] if "CUDA_VISIBLE_DEVICES" in os.environ: cuda_ids = [ s for s in re.findall(r"\b\d+\b", os.environ["CUDA_VISIBLE_DEVICES"]) ] - # check that the visible devices actually exist and are gpus gpu_ids = [i for i in cuda_ids if i in gpu_ids] if len(gpu_ids) == 0: - # cuda visible devices = '' -> don't use any gpu - warnings.warn( - colored( - ( - "CUDA_VISIBLE_DEVICES={} ".format( - os.environ["CUDA_VISIBLE_DEVICES"] - ) - + "did not match any physical GPU " - + "(id={}), falling back to CPU".format( - [dev["index"] for dev in devices] - ) - ), - "yellow", - ) - ) - set_device(kind="cpu") - return - devices = [dev for dev in devices if dev["index"] in gpu_ids] - - if gpuid is not None and (str(gpuid) in gpu_ids): - selected_gpu = [dev for dev in devices if dev["index"] == str(gpuid)][0] - else: - for dev in devices: - mem = dev["mem_total"] - dev["mem_used"] - if mem > maxmem: - maxmem = mem - selected_gpu = dev - config["device"] = selected_gpu["type"] + " (id={})".format( - selected_gpu["index"] - ) - if gpuid is not None and not (str(gpuid) in gpu_ids): warnings.warn( colored( - "Specified gpuid {} not found, falling back to ".format(str(gpuid)) - + config["device"], + f"CUDA_VISIBLE_DEVICES={os.environ['CUDA_VISIBLE_DEVICES']} did " + "not match any physical GPU " + f"(id={[dev['index'] for dev in devices]}), falling back to CPU", "yellow", ) ) - config["avail_mem"] = ( - selected_gpu["mem_total"] - selected_gpu["mem_used"] - ) / 1024 # in GB - config["num_device"] = 1 - os.environ["CUDA_VISIBLE_DEVICES"] = str(selected_gpu["index"]) - - # TODO: merge the "gpu" and "num_device" cases in single if block - if kind == "gpu" and num_device > 1: - import nvgpu - - try: - devices = nvgpu.gpu_info() - except FileNotFoundError: - devices = [] - if len(devices) == 0: - warnings.warn(colored("No GPU found, falling back to CPU", "yellow")) set_device(kind="cpu") return - gpu_ids = [dev["index"] for dev in devices] - if "CUDA_VISIBLE_DEVICES" in os.environ: - cuda_ids = [ - s for s in re.findall(r"\b\d+\b", os.environ["CUDA_VISIBLE_DEVICES"]) - ] - # check that the visible devices actually exist and are gpus - gpu_ids = [i for i in cuda_ids if i in gpu_ids] - if len(gpu_ids) == 0: - # cuda visible devices = '' -> don't use any gpu - warnings.warn( - colored( - ( - "CUDA_VISIBLE_DEVICES={} ".format( - os.environ["CUDA_VISIBLE_DEVICES"] - ) - + "did not match any physical GPU " - + "(id={}), falling back to CPU".format( - [dev["index"] for dev in devices] + devices = [dev for dev in devices if dev["index"] in gpu_ids] + memories = {dev["index"]: dev["mem_total"] - dev["mem_used"] for dev in devices} + + if num_device == 1: + if gpuid is not None: + if str(gpuid) in gpu_ids: + selected_gpu = next( + dev for dev in devices if dev["index"] == str(gpuid) + ) + else: + warnings.warn( + colored( + f"Specified gpuid {gpuid} not found, selecting GPU with " + "most memory", + "yellow", ) - ), - "yellow", + ) + else: + selected_gpu = max( + devices, key=lambda dev: dev["mem_total"] - dev["mem_used"] ) - ) - set_device(kind="cpu") - return + devices = [selected_gpu] - devices = [dev for dev in devices if dev["index"] in gpu_ids] - memories = {} - for dev in devices: - mem = dev["mem_total"] - dev["mem_used"] - memories[dev["index"]] = mem - - if num_device > len(devices): - warnings.warn( - colored( - "Requested {} GPUs, but only {} available".format( - num_device, len(devices) - ), - "yellow", - ) - ) - return - elif num_device < len(devices): - config["device"] = "gpu" - config["devices"] = [ - dev["type"] + " (id={})".format(dev["index"]) - for dev in devices[:num_device] - ] - config["avail_mems"] = [ - memories[dev["index"]] / 1024 for dev in devices[:num_device] - ] # in GB - config["num_device"] = num_device - # make the other gpu's invisible - visible_devices = "0" - for i in range(1, num_device): - visible_devices += f",{i}" - os.environ["CUDA_VISIBLE_DEVICES"] = visible_devices else: - config["device"] = "gpu" - config["devices"] = [ - dev["type"] + " (id={})".format(dev["index"]) for dev in devices - ] - config["avail_mems"] = [ - memories[dev["index"]] / 1024 for dev in devices - ] # in GB - config["num_device"] = num_device - # by default all gpus are already visible + if num_device > len(devices): + raise ValueError( + f"Requested {num_device} GPUs, but only {len(devices)} available" + ) + if gpuid is not None: + # TODO: implement multiple GPU selection + raise ValueError("Cannot specify 'gpuid' when requesting multiple GPUs") + + config["avail_mems"] = [ + memories[dev["index"]] / 1024 for dev in devices[:num_device] + ] # in GB + config["devices"] = [ + f"{dev['type']} (id={dev['index']})" for dev in devices[:num_device] + ] + os.environ["CUDA_VISIBLE_DEVICES"] = ",".join( + str(dev["index"]) for dev in devices[:num_device] + ) + config["device_type"] = "gpu" + config["num_device"] = num_device diff --git a/desc/backend.py b/desc/backend.py index 7148b2896c..b1063d9d6c 100644 --- a/desc/backend.py +++ b/desc/backend.py @@ -456,7 +456,8 @@ def pconcat(arrays, mode="concat"): Returns ------- out : jnp.ndarray - Concatenated array that lives on CPU. + Concatenated array that lives on GPU[id=0]. If thre is not enough memory + the array will be stored on CPU. """ # we will use either CPU or GPU[0] for the matrix decompositions, so the # array of float64 should fit into single device diff --git a/desc/objectives/objective_funs.py b/desc/objectives/objective_funs.py index a830f1d895..192840e5e6 100644 --- a/desc/objectives/objective_funs.py +++ b/desc/objectives/objective_funs.py @@ -373,20 +373,26 @@ def build(self, use_jit=None, use_jit_wrapper=True, verbose=1): # noqa: C901 if self._jac_chunk_size == "auto": # Heuristic estimates of fwd mode Jacobian memory usage, # slightly conservative, based on using ForceBalance as the objective - estimated_memory_usage = 2.4e-7 * self.dim_f * self.dim_x + 1 # in GB - mem_avail = ( - desc_config.get("avail_mem") - if desc_config.get("avail_mem") is not None - else sum(desc_config["avail_mems"]) - ) - max_chunk_size = round( - (mem_avail / estimated_memory_usage - 0.22) / 0.85 * self.dim_x - ) + if self._deriv_mode == "batched": + estimated_memory_usage = 2.4e-7 * self.dim_f * self.dim_x + 1 # in GB + mem_avail = desc_config["avail_mems"][0] # in GB + max_chunk_size = round( + (mem_avail / estimated_memory_usage - 0.22) / 0.85 * self.dim_x + ) self._jac_chunk_size = max([1, max_chunk_size]) if self._deriv_mode == "blocked": for obj in self.objectives: if obj._jac_chunk_size is None: - obj._jac_chunk_size = self._jac_chunk_size + estimated_memory_usage = ( + 2.4e-7 * obj.dim_f * obj.dim_x + 1 + ) # in GB + mem_avail = desc_config["avail_mems"][obj._device_id] # in GB + max_chunk_size = round( + (mem_avail / estimated_memory_usage - 0.22) + / 0.85 + * obj.dim_x + ) + obj._jac_chunk_size = max([1, max_chunk_size]) if not use_jit_wrapper: self._unjit() From 7e09142acde83e6e57d35b3cc72c959edcb9aae9 Mon Sep 17 00:00:00 2001 From: YigitElma Date: Wed, 12 Feb 2025 18:43:51 -0500 Subject: [PATCH 62/75] nuch of clean up --- desc/__init__.py | 10 ++++------ desc/backend.py | 30 +++++++++++++++++------------- desc/objectives/getters.py | 10 ++++------ desc/objectives/objective_funs.py | 26 +++++++++++++------------- 4 files changed, 38 insertions(+), 38 deletions(-) diff --git a/desc/__init__.py b/desc/__init__.py index d731607979..c68e0ce56f 100644 --- a/desc/__init__.py +++ b/desc/__init__.py @@ -86,15 +86,15 @@ def set_device(kind="cpu", gpuid=None, num_device=1): """ config["kind"] = kind + config["num_device"] = num_device if kind == "cpu": os.environ["JAX_PLATFORMS"] = "cpu" os.environ["CUDA_VISIBLE_DEVICES"] = "" import psutil cpu_mem = psutil.virtual_memory().available / 1024**3 # RAM in GB - config["device"] = "CPU" - config["avail_mem"] = cpu_mem - config["num_device"] = 1 + config["devices"] = ["CPU"] + config["avail_mems"] = [cpu_mem] elif kind == "gpu": os.environ["CUDA_DEVICE_ORDER"] = "PCI_BUS_ID" @@ -157,7 +157,7 @@ def set_device(kind="cpu", gpuid=None, num_device=1): ) if gpuid is not None: # TODO: implement multiple GPU selection - raise ValueError("Cannot specify 'gpuid' when requesting multiple GPUs") + raise ValueError("Cannot specify `gpuid` when requesting multiple GPUs") config["avail_mems"] = [ memories[dev["index"]] / 1024 for dev in devices[:num_device] @@ -168,5 +168,3 @@ def set_device(kind="cpu", gpuid=None, num_device=1): os.environ["CUDA_VISIBLE_DEVICES"] = ",".join( str(dev["index"]) for dev in devices[:num_device] ) - config["device_type"] = "gpu" - config["num_device"] = num_device diff --git a/desc/backend.py b/desc/backend.py index b1063d9d6c..ef0d3c292d 100644 --- a/desc/backend.py +++ b/desc/backend.py @@ -69,19 +69,12 @@ ) ) -if desc_config["num_device"] == 1: +print(f"Using {desc_config['num_device']} device:") +for i, dev in enumerate(desc_config["devices"]): print( - "Using device: {}, with {:.2f} GB available memory".format( - desc_config.get("device"), desc_config.get("avail_mem") - ) + f"\t Device {i}: {dev} with {desc_config['avail_mems'][i]:.2f} " + "GB available memory" ) -else: - print(f"Using {desc_config['num_device']} devices:") - for i, dev in enumerate(desc_config["devices"]): - print( - f"\t Device {i}: {dev} with {desc_config['avail_mems'][i]:.2f} " - "GB available memory" - ) if use_jax: # noqa: C901 from jax import custom_jvp, jit, vmap @@ -443,7 +436,7 @@ def tangent_solve(g, y): x = jax.lax.custom_root(res, x0, solve, tangent_solve, has_aux=False) return x - def pconcat(arrays, mode="concat"): + def pconcat(arrays, mode="concat"): # pragma: no cover """Concatenate arrays that live on different devices. Parameters @@ -502,7 +495,7 @@ def jit_with_device(method): @functools.wraps(method) def wrapper(self, *args, **kwargs): # Get the device using self.id or default to CPU - if desc_config["device"] == "gpu" and hasattr(self, "_device_id"): + if desc_config["kind"] == "gpu" and hasattr(self, "_device_id"): device = jax.devices("gpu")[self._device_id] else: device = None @@ -518,6 +511,7 @@ def wrapper(self, *args, **kwargs): # for coverage purposes else: # pragma: no cover jit = lambda func, *args, **kwargs: func + jit_with_device = jit execute_on_cpu = lambda func: func import scipy.optimize from numpy.fft import ifft, irfft, irfft2, rfft, rfft2 # noqa: F401 @@ -970,3 +964,13 @@ def take( else: out = np.take(a, indices, axis, out, mode) return out + + def pconcat(arrays, mode="concat"): + """Numpy implementation of desc.backend.pconcat.""" + if mode == "concat": + out = np.concatenate(arrays) + elif mode == "hstack": + out = np.hstack(arrays) + elif mode == "vstack": + out = np.vstack(arrays) + return out diff --git a/desc/objectives/getters.py b/desc/objectives/getters.py index ff664816cf..662283dbea 100644 --- a/desc/objectives/getters.py +++ b/desc/objectives/getters.py @@ -348,7 +348,7 @@ def add_if_multiple(constraints, cls): def get_parallel_forcebalance( eq, num_device, grid=None, use_jit=True, check_device=True -): +): # pragma: no cover """Get an ObjectiveFunction for parallel computing ForceBalance. Parameters @@ -361,15 +361,13 @@ def get_parallel_forcebalance( Returns ------- obj : ObjectiveFunction - An objective function with force balance objectives. Each objective is - computed on a separate device. The objective function is built with - `use_jit_wrapper=False` to make it compatible with JAX parallel computing. - Each objective will have a grid with same number of flux surfaces. + A built objective function with force balance objectives. Each objective is + computed on a separate device. """ from desc.backend import desc_config, jax, jnp from desc.grid import LinearGrid - if desc_config["device"] != "gpu": + if desc_config["kind"] != "gpu": raise ValueError( "Parallel computing is only supported on GPU. " "Please use DESC with GPU device." diff --git a/desc/objectives/objective_funs.py b/desc/objectives/objective_funs.py index 192840e5e6..263dd6698a 100644 --- a/desc/objectives/objective_funs.py +++ b/desc/objectives/objective_funs.py @@ -297,24 +297,24 @@ def _unjit(self): pass @execute_on_cpu - def build(self, use_jit=None, use_jit_wrapper=True, verbose=1): # noqa: C901 + def build(self, use_jit=None, verbose=1): # noqa: C901 """Build the objective. Parameters ---------- use_jit : bool, optional - Whether to just-in-time compile the objective and derivatives. - use_jit_wrapper : bool, optional - Whether to use the jit wrapper for the objective. If multiple GPUs are - used, this will be set to False. + Whether to just-in-time compile the objective and derivatives. If using + multiple GPUs, instead of jitting the ObjectiveFunction, the sub-objectives + will be jitted individually, independent of the value of `use_jit`. verbose : int, optional Level of output. """ if use_jit is not None: self._use_jit = use_jit - if use_jit is False: - use_jit_wrapper = False + # use_jit_wrapper is used to determine if we jit the ObjectiveFunction + # methods. If we are using multiple GPUs, we don't want to jit them. + use_jit_wrapper = use_jit if self._is_multi_device: use_jit_wrapper = False @@ -472,7 +472,7 @@ def compute_unscaled(self, x, constants=None): for par, obj, const in zip(params, self.objectives, constants) ] ) - else: + else: # pragma: no cover f = pconcat( [ obj.compute_unscaled( @@ -512,7 +512,7 @@ def compute_scaled(self, x, constants=None): for par, obj, const in zip(params, self.objectives, constants) ] ) - else: + else: # pragma: no cover f = pconcat( [ obj.compute_scaled( @@ -552,7 +552,7 @@ def compute_scaled_error(self, x, constants=None): for par, obj, const in zip(params, self.objectives, constants) ] ) - else: + else: # pragma: no cover f = pconcat( [ obj.compute_scaled_error( @@ -626,11 +626,11 @@ def print_value(self, x, x0=None, constants=None): for par, par0, obj, const in zip( params, params0, self.objectives, constants ): - if self._is_multi_device: + if self._is_multi_device: # pragma: no cover par = jax.device_put(par, jax.devices("gpu")[obj._device_id]) par0 = jax.device_put(par0, jax.devices("gpu")[obj._device_id]) obj.print_value(par, par0, constants=const) - else: + else: # pragma: no cover for par, obj, const in zip(params, self.objectives, constants): if self._is_multi_device: par = jax.device_put(par, jax.devices("gpu")[obj._device_id]) @@ -763,7 +763,7 @@ def _jvp_blocked(self, v, x, constants=None, op="scaled"): thing_idx = self._things_per_objective_idx[k] xi = [xs[i] for i in thing_idx] vi = [vs[i] for i in thing_idx] - if self._is_multi_device: + if self._is_multi_device: # pragma: no cover # inputs to jitted functions must live on the same device. Need to # put xi and vi on the same device as the objective xi = jax.device_put(xi, jax.devices("gpu")[obj._device_id]) From c32d7b4989afdb92857257a39708ddef89ec46ec Mon Sep 17 00:00:00 2001 From: YigitElma Date: Wed, 12 Feb 2025 23:28:46 -0500 Subject: [PATCH 63/75] clean up, fix issues --- desc/__init__.py | 34 +++++++++++++++++++++++++++---- desc/backend.py | 17 ++++++++++------ desc/objectives/objective_funs.py | 16 +++++++-------- 3 files changed, 49 insertions(+), 18 deletions(-) diff --git a/desc/__init__.py b/desc/__init__.py index c68e0ce56f..7a69d4661f 100644 --- a/desc/__init__.py +++ b/desc/__init__.py @@ -2,10 +2,13 @@ import importlib import os +import platform import re +import subprocess import warnings import colorama +import psutil from termcolor import colored from ._version import get_versions @@ -61,6 +64,23 @@ def __getattr__(name): config = {"device": None, "avail_mem": None, "kind": None, "num_device": None} +def _get_processor_name(): + """Get the processor name of the current system.""" + if platform.system() == "Windows": + return platform.processor() + elif platform.system() == "Darwin": + os.environ["PATH"] = os.environ["PATH"] + os.pathsep + "/usr/sbin" + command = "sysctl -n machdep.cpu.brand_string" + return subprocess.check_output(command).strip() + elif platform.system() == "Linux": + command = "cat /proc/cpuinfo" + all_info = subprocess.check_output(command, shell=True).decode().strip() + for line in all_info.split("\n"): + if "model name" in line: + return re.sub(".*model name.*:", "", line, 1) + return "" + + def set_device(kind="cpu", gpuid=None, num_device=1): """Sets the device to use for computation. @@ -85,15 +105,21 @@ def set_device(kind="cpu", gpuid=None, num_device=1): number of devices to use. Default is 1. """ + if kind == "cpu" and num_device > 1: + # TODO: implement multi-CPU support + raise ValueError("Cannot request multiple CPUs") + config["kind"] = kind config["num_device"] = num_device + + cpu_mem = psutil.virtual_memory().available / 1024**3 # RAM in GB + cpu_info = _get_processor_name() + config["cpu_info"] = f"{cpu_info} CPU" + config["cpu_mem"] = cpu_mem if kind == "cpu": os.environ["JAX_PLATFORMS"] = "cpu" os.environ["CUDA_VISIBLE_DEVICES"] = "" - import psutil - - cpu_mem = psutil.virtual_memory().available / 1024**3 # RAM in GB - config["devices"] = ["CPU"] + config["devices"] = [f"{cpu_info} CPU"] config["avail_mems"] = [cpu_mem] elif kind == "gpu": diff --git a/desc/backend.py b/desc/backend.py index ef0d3c292d..003a070921 100644 --- a/desc/backend.py +++ b/desc/backend.py @@ -69,12 +69,17 @@ ) ) -print(f"Using {desc_config['num_device']} device:") -for i, dev in enumerate(desc_config["devices"]): - print( - f"\t Device {i}: {dev} with {desc_config['avail_mems'][i]:.2f} " - "GB available memory" - ) +print( + f"CPU Info: {desc_config['cpu_info']} with {desc_config['cpu_mem']:.2f} " + "GB available memory" +) +if desc_config["kind"] == "gpu": + print(f"Using {desc_config['num_device']} device:") + for i, dev in enumerate(desc_config["devices"]): + print( + f"\t Device {i}: {dev} with {desc_config['avail_mems'][i]:.2f} " + "GB available memory" + ) if use_jax: # noqa: C901 from jax import custom_jvp, jit, vmap diff --git a/desc/objectives/objective_funs.py b/desc/objectives/objective_funs.py index 263dd6698a..6fd5dac066 100644 --- a/desc/objectives/objective_funs.py +++ b/desc/objectives/objective_funs.py @@ -310,6 +310,7 @@ def build(self, use_jit=None, verbose=1): # noqa: C901 Level of output. """ + use_jit_wrapper = True if use_jit is not None: self._use_jit = use_jit # use_jit_wrapper is used to determine if we jit the ObjectiveFunction @@ -373,24 +374,23 @@ def build(self, use_jit=None, verbose=1): # noqa: C901 if self._jac_chunk_size == "auto": # Heuristic estimates of fwd mode Jacobian memory usage, # slightly conservative, based on using ForceBalance as the objective - if self._deriv_mode == "batched": - estimated_memory_usage = 2.4e-7 * self.dim_f * self.dim_x + 1 # in GB - mem_avail = desc_config["avail_mems"][0] # in GB - max_chunk_size = round( - (mem_avail / estimated_memory_usage - 0.22) / 0.85 * self.dim_x - ) + estimated_memory_usage = 2.4e-7 * self.dim_f * self.dim_x + 1 # in GB + mem_avail = desc_config["avail_mems"][0] # in GB + max_chunk_size = round( + (mem_avail / estimated_memory_usage - 0.22) / 0.85 * self.dim_x + ) self._jac_chunk_size = max([1, max_chunk_size]) if self._deriv_mode == "blocked": for obj in self.objectives: if obj._jac_chunk_size is None: estimated_memory_usage = ( - 2.4e-7 * obj.dim_f * obj.dim_x + 1 + 2.4e-7 * obj.dim_f * obj.things[0].dim_x + 1 ) # in GB mem_avail = desc_config["avail_mems"][obj._device_id] # in GB max_chunk_size = round( (mem_avail / estimated_memory_usage - 0.22) / 0.85 - * obj.dim_x + * obj.things[0].dim_x ) obj._jac_chunk_size = max([1, max_chunk_size]) From e2c0f7767909db35d99aae158d2c598faf424588 Mon Sep 17 00:00:00 2001 From: YigitElma Date: Wed, 12 Feb 2025 23:51:21 -0500 Subject: [PATCH 64/75] fix set_device config['device'] problem --- desc/__init__.py | 3 ++- desc/backend.py | 2 +- 2 files changed, 3 insertions(+), 2 deletions(-) diff --git a/desc/__init__.py b/desc/__init__.py index 7a69d4661f..4aa8da27e6 100644 --- a/desc/__init__.py +++ b/desc/__init__.py @@ -61,7 +61,7 @@ def __getattr__(name): BANNER = colored(_BANNER, "magenta") -config = {"device": None, "avail_mem": None, "kind": None, "num_device": None} +config = {"devices": None, "avail_mem": None, "kind": None, "num_device": None} def _get_processor_name(): @@ -116,6 +116,7 @@ def set_device(kind="cpu", gpuid=None, num_device=1): cpu_info = _get_processor_name() config["cpu_info"] = f"{cpu_info} CPU" config["cpu_mem"] = cpu_mem + if kind == "cpu": os.environ["JAX_PLATFORMS"] = "cpu" os.environ["CUDA_VISIBLE_DEVICES"] = "" diff --git a/desc/backend.py b/desc/backend.py index 003a070921..e5bb0227f5 100644 --- a/desc/backend.py +++ b/desc/backend.py @@ -21,7 +21,7 @@ ) ) else: - if desc_config.get("device") is None: + if desc_config.get("devices") is None: set_device("cpu") try: with warnings.catch_warnings(): From 20526338e69ba1dfe8290eb61359362c9fca6b7a Mon Sep 17 00:00:00 2001 From: YigitElma Date: Thu, 13 Feb 2025 00:36:39 -0500 Subject: [PATCH 65/75] update notebook and add device_id to all objectives --- desc/objectives/_bootstrap.py | 2 + desc/objectives/_coils.py | 13 + desc/objectives/_equilibrium.py | 10 + desc/objectives/_fast_ion.py | 1 + desc/objectives/_free_boundary.py | 4 + desc/objectives/_generic.py | 2 + desc/objectives/_geometry.py | 18 ++ desc/objectives/_neoclassical.py | 1 + desc/objectives/_omnigenity.py | 10 + desc/objectives/_power_balance.py | 4 + desc/objectives/_profiles.py | 8 + desc/objectives/_stability.py | 4 + desc/objectives/objective_funs.py | 7 + docs/notebooks/tutorials/multi_device.ipynb | 300 ++++++++++++++++---- 14 files changed, 325 insertions(+), 59 deletions(-) diff --git a/desc/objectives/_bootstrap.py b/desc/objectives/_bootstrap.py index 9f6850cb24..ca3fbe998f 100644 --- a/desc/objectives/_bootstrap.py +++ b/desc/objectives/_bootstrap.py @@ -64,6 +64,7 @@ def __init__( helicity=(1, 0), name="Bootstrap current self-consistency (Redl)", jac_chunk_size=None, + device_id=0, ): if target is None and bounds is None: target = 0 @@ -82,6 +83,7 @@ def __init__( deriv_mode=deriv_mode, name=name, jac_chunk_size=jac_chunk_size, + device_id=device_id, ) def build(self, use_jit=True, verbose=1): diff --git a/desc/objectives/_coils.py b/desc/objectives/_coils.py index 1a8051a529..8da36de2b9 100644 --- a/desc/objectives/_coils.py +++ b/desc/objectives/_coils.py @@ -49,6 +49,7 @@ def __init__( grid=None, name=None, jac_chunk_size=None, + device_id=0, ): self._grid = grid self._data_keys = data_keys @@ -64,6 +65,7 @@ def __init__( deriv_mode=deriv_mode, name=name, jac_chunk_size=jac_chunk_size, + device_id=device_id, ) def build(self, use_jit=True, verbose=1): # noqa:C901 @@ -226,6 +228,7 @@ def __init__( grid=None, name="coil length", jac_chunk_size=None, + device_id=0, ): if target is None and bounds is None: target = 2 * np.pi @@ -330,6 +333,7 @@ def __init__( grid=None, name="coil curvature", jac_chunk_size=None, + device_id=0, ): if target is None and bounds is None: bounds = (0, 1) @@ -429,6 +433,7 @@ def __init__( grid=None, name="coil torsion", jac_chunk_size=None, + device_id=0, ): if target is None and bounds is None: target = 0 @@ -528,6 +533,7 @@ def __init__( grid=None, name="coil current length", jac_chunk_size=None, + device_id=0, ): if target is None and bounds is None: target = 0 @@ -636,6 +642,7 @@ def __init__( grid=None, name="coil integrated curvature", jac_chunk_size=None, + device_id=0, ): if target is None and bounds is None: target = 2 * np.pi @@ -784,6 +791,7 @@ def __init__( deriv_mode=deriv_mode, name=name, jac_chunk_size=jac_chunk_size, + device_id=device_id, ) def build(self, use_jit=True, verbose=1): @@ -965,6 +973,7 @@ def __init__( deriv_mode=deriv_mode, name=name, jac_chunk_size=jac_chunk_size, + device_id=device_id, ) def build(self, use_jit=True, verbose=1): @@ -1288,6 +1297,7 @@ def __init__( vacuum=False, name="Quadratic flux", jac_chunk_size=None, + device_id=0, ): from desc.geometry import FourierRZToroidalSurface @@ -1491,6 +1501,7 @@ def __init__( name="Surface Quadratic Flux", field_fixed=False, jac_chunk_size=None, + device_id=0, ): if target is None and bounds is None: target = 0 @@ -1700,6 +1711,7 @@ def __init__( field_fixed=False, eq_fixed=False, jac_chunk_size=None, + device_id=0, ): if target is None and bounds is None: target = 1.0 if not hasattr(eq, "Psi") else eq.Psi @@ -1730,6 +1742,7 @@ def __init__( deriv_mode=deriv_mode, name=name, jac_chunk_size=jac_chunk_size, + device_id=device_id, ) def build(self, use_jit=True, verbose=1): diff --git a/desc/objectives/_equilibrium.py b/desc/objectives/_equilibrium.py index 5f1b27b149..cd2036ca72 100644 --- a/desc/objectives/_equilibrium.py +++ b/desc/objectives/_equilibrium.py @@ -218,6 +218,7 @@ def __init__( grid=None, name="force-anisotropic", jac_chunk_size=None, + device_id=0, ): if target is None and bounds is None: target = 0 @@ -233,6 +234,7 @@ def __init__( deriv_mode=deriv_mode, name=name, jac_chunk_size=jac_chunk_size, + device_id=device_id, ) def build(self, use_jit=True, verbose=1): @@ -355,6 +357,7 @@ def __init__( grid=None, name="radial force", jac_chunk_size=None, + device_id=0, ): if target is None and bounds is None: target = 0 @@ -370,6 +373,7 @@ def __init__( deriv_mode=deriv_mode, name=name, jac_chunk_size=jac_chunk_size, + device_id=device_id, ) def build(self, use_jit=True, verbose=1): @@ -492,6 +496,7 @@ def __init__( grid=None, name="helical force", jac_chunk_size=None, + device_id=0, ): if target is None and bounds is None: target = 0 @@ -507,6 +512,7 @@ def __init__( deriv_mode=deriv_mode, name=name, jac_chunk_size=jac_chunk_size, + device_id=device_id, ) def build(self, use_jit=True, verbose=1): @@ -630,6 +636,7 @@ def __init__( gamma=0, name="energy", jac_chunk_size=None, + device_id=0, ): if target is None and bounds is None: target = 0 @@ -646,6 +653,7 @@ def __init__( deriv_mode=deriv_mode, name=name, jac_chunk_size=jac_chunk_size, + device_id=device_id, ) def build(self, use_jit=True, verbose=1): @@ -773,6 +781,7 @@ def __init__( grid=None, name="current density", jac_chunk_size=None, + device_id=0, ): if target is None and bounds is None: target = 0 @@ -788,6 +797,7 @@ def __init__( deriv_mode=deriv_mode, name=name, jac_chunk_size=jac_chunk_size, + device_id=device_id, ) def build(self, use_jit=True, verbose=1): diff --git a/desc/objectives/_fast_ion.py b/desc/objectives/_fast_ion.py index 3dfff7aebf..9f13b9ffcb 100644 --- a/desc/objectives/_fast_ion.py +++ b/desc/objectives/_fast_ion.py @@ -207,6 +207,7 @@ def __init__( deriv_mode=deriv_mode, name=name, jac_chunk_size=jac_chunk_size, + device_id=device_id, ) def build(self, use_jit=True, verbose=1): diff --git a/desc/objectives/_free_boundary.py b/desc/objectives/_free_boundary.py index d83895a092..1afafed87e 100644 --- a/desc/objectives/_free_boundary.py +++ b/desc/objectives/_free_boundary.py @@ -106,6 +106,7 @@ def __init__( deriv_mode=deriv_mode, name=name, jac_chunk_size=jac_chunk_size, + device_id=device_id, ) def build(self, use_jit=True, verbose=1): @@ -459,6 +460,7 @@ def __init__( deriv_mode=deriv_mode, name=name, jac_chunk_size=jac_chunk_size, + device_id=device_id, ) def build(self, use_jit=True, verbose=1): @@ -867,6 +869,7 @@ def __init__( deriv_mode="auto", name="NESTOR Boundary", jac_chunk_size=None, + device_id=0, ): if target is None and bounds is None: target = 0 @@ -887,6 +890,7 @@ def __init__( deriv_mode=deriv_mode, name=name, jac_chunk_size=jac_chunk_size, + device_id=device_id, ) def build(self, use_jit=True, verbose=1): diff --git a/desc/objectives/_generic.py b/desc/objectives/_generic.py index 6889d2897f..58b08db31b 100644 --- a/desc/objectives/_generic.py +++ b/desc/objectives/_generic.py @@ -80,6 +80,7 @@ def __init__( deriv_mode=deriv_mode, name=name, jac_chunk_size=jac_chunk_size, + device_id=device_id, ) self._p = _parse_parameterization(thing) self._scalar = not bool(data_index[self._p][self.f]["dim"]) @@ -197,6 +198,7 @@ def __init__( normalize_target=False, name="custom linear", jac_chunk_size=None, + device_id=0, ): if target is None and bounds is None: target = 0 diff --git a/desc/objectives/_geometry.py b/desc/objectives/_geometry.py index c7393d9bf6..36839bee51 100644 --- a/desc/objectives/_geometry.py +++ b/desc/objectives/_geometry.py @@ -54,6 +54,7 @@ def __init__( grid=None, name="aspect ratio", jac_chunk_size=None, + device_id=0, ): if target is None and bounds is None: target = 2 @@ -69,6 +70,7 @@ def __init__( deriv_mode=deriv_mode, name=name, jac_chunk_size=jac_chunk_size, + device_id=device_id, ) def build(self, use_jit=True, verbose=1): @@ -197,6 +199,7 @@ def __init__( grid=None, name="elongation", jac_chunk_size=None, + device_id=0, ): if target is None and bounds is None: target = 1 @@ -212,6 +215,7 @@ def __init__( deriv_mode=deriv_mode, name=name, jac_chunk_size=jac_chunk_size, + device_id=device_id, ) def build(self, use_jit=True, verbose=1): @@ -338,6 +342,7 @@ def __init__( grid=None, name="volume", jac_chunk_size=None, + device_id=0, ): if target is None and bounds is None: target = 1 @@ -353,6 +358,7 @@ def __init__( deriv_mode=deriv_mode, name=name, jac_chunk_size=jac_chunk_size, + device_id=device_id, ) def build(self, use_jit=True, verbose=1): @@ -525,6 +531,7 @@ def __init__( name="plasma-vessel distance", use_signed_distance=False, jac_chunk_size=None, + device_id=0, **kwargs, ): if target is None and bounds is None: @@ -565,6 +572,7 @@ def __init__( deriv_mode=deriv_mode, name=name, jac_chunk_size=jac_chunk_size, + device_id=device_id, ) def build(self, use_jit=True, verbose=1): @@ -852,6 +860,7 @@ def __init__( grid=None, name="mean curvature", jac_chunk_size=None, + device_id=0, ): if target is None and bounds is None: bounds = (-np.inf, 0) @@ -867,6 +876,7 @@ def __init__( deriv_mode=deriv_mode, name=name, jac_chunk_size=jac_chunk_size, + device_id=device_id, ) def build(self, use_jit=True, verbose=1): @@ -992,6 +1002,7 @@ def __init__( grid=None, name="principal-curvature", jac_chunk_size=None, + device_id=0, ): if target is None and bounds is None: target = 1 @@ -1007,6 +1018,7 @@ def __init__( deriv_mode=deriv_mode, name=name, jac_chunk_size=jac_chunk_size, + device_id=device_id, ) def build(self, use_jit=True, verbose=1): @@ -1127,6 +1139,7 @@ def __init__( grid=None, name="B-scale-length", jac_chunk_size=None, + device_id=0, ): if target is None and bounds is None: bounds = (1, np.inf) @@ -1142,6 +1155,7 @@ def __init__( deriv_mode=deriv_mode, name=name, jac_chunk_size=jac_chunk_size, + device_id=device_id, ) def build(self, use_jit=True, verbose=1): @@ -1259,6 +1273,7 @@ def __init__( grid=None, name="coordinate goodness", jac_chunk_size=None, + device_id=0, ): if target is None and bounds is None: target = 0 @@ -1275,6 +1290,7 @@ def __init__( deriv_mode=deriv_mode, name=name, jac_chunk_size=jac_chunk_size, + device_id=device_id, ) def build(self, use_jit=True, verbose=1): @@ -1398,6 +1414,7 @@ def __init__( deriv_mode="auto", name="mirror ratio", jac_chunk_size=None, + device_id=0, ): if target is None and bounds is None: target = 0.2 @@ -1413,6 +1430,7 @@ def __init__( deriv_mode=deriv_mode, name=name, jac_chunk_size=jac_chunk_size, + device_id=device_id, ) def build(self, use_jit=True, verbose=1): diff --git a/desc/objectives/_neoclassical.py b/desc/objectives/_neoclassical.py index ad571c24b9..d02ffed2cc 100644 --- a/desc/objectives/_neoclassical.py +++ b/desc/objectives/_neoclassical.py @@ -193,6 +193,7 @@ def __init__( deriv_mode=deriv_mode, name=name, jac_chunk_size=jac_chunk_size, + device_id=device_id, ) def build(self, use_jit=True, verbose=1): diff --git a/desc/objectives/_omnigenity.py b/desc/objectives/_omnigenity.py index 2efca8e060..c897aff737 100644 --- a/desc/objectives/_omnigenity.py +++ b/desc/objectives/_omnigenity.py @@ -57,6 +57,7 @@ def __init__( N_booz=None, name="QS Boozer", jac_chunk_size=None, + device_id=0, ): if target is None and bounds is None: target = 0 @@ -75,6 +76,7 @@ def __init__( deriv_mode=deriv_mode, name=name, jac_chunk_size=jac_chunk_size, + device_id=device_id, ) self._print_value_fmt = "Quasi-symmetry ({},{}) Boozer error: ".format( @@ -247,6 +249,7 @@ def __init__( helicity=(1, 0), name="QS two-term", jac_chunk_size=None, + device_id=0, ): if target is None and bounds is None: target = 0 @@ -263,6 +266,7 @@ def __init__( deriv_mode=deriv_mode, name=name, jac_chunk_size=jac_chunk_size, + device_id=device_id, ) self._print_value_fmt = "Quasi-symmetry ({},{}) two-term error: ".format( @@ -410,6 +414,7 @@ def __init__( grid=None, name="QS triple product", jac_chunk_size=None, + device_id=0, ): if target is None and bounds is None: target = 0 @@ -425,6 +430,7 @@ def __init__( deriv_mode=deriv_mode, name=name, jac_chunk_size=jac_chunk_size, + device_id=device_id, ) def build(self, use_jit=True, verbose=1): @@ -573,6 +579,7 @@ def __init__( field_fixed=False, name="omnigenity", jac_chunk_size=None, + device_id=0, ): if target is None and bounds is None: target = 0 @@ -605,6 +612,7 @@ def __init__( deriv_mode=deriv_mode, name=name, jac_chunk_size=jac_chunk_size, + device_id=device_id, ) def build(self, use_jit=True, verbose=1): @@ -887,6 +895,7 @@ def __init__( grid=None, name="Isodynamicity", jac_chunk_size=None, + device_id=0, ): if target is None and bounds is None: target = 0 @@ -902,6 +911,7 @@ def __init__( deriv_mode=deriv_mode, name=name, jac_chunk_size=jac_chunk_size, + device_id=device_id, ) def build(self, use_jit=True, verbose=1): diff --git a/desc/objectives/_power_balance.py b/desc/objectives/_power_balance.py index bc291cb8ae..2f8594e5ec 100644 --- a/desc/objectives/_power_balance.py +++ b/desc/objectives/_power_balance.py @@ -56,6 +56,7 @@ def __init__( grid=None, name="fusion power", jac_chunk_size=None, + device_id=0, ): errorif( fuel not in ["DT"], ValueError, f"fuel must be one of ['DT'], got {fuel}." @@ -75,6 +76,7 @@ def __init__( deriv_mode=deriv_mode, name=name, jac_chunk_size=jac_chunk_size, + device_id=device_id, ) def build(self, use_jit=True, verbose=1): @@ -223,6 +225,7 @@ def __init__( grid=None, name="heating power", jac_chunk_size=None, + device_id=0, ): if target is None and bounds is None: target = 0 @@ -240,6 +243,7 @@ def __init__( deriv_mode=deriv_mode, name=name, jac_chunk_size=jac_chunk_size, + device_id=device_id, ) def build(self, use_jit=True, verbose=1): diff --git a/desc/objectives/_profiles.py b/desc/objectives/_profiles.py index 0740c6142d..29756b6454 100644 --- a/desc/objectives/_profiles.py +++ b/desc/objectives/_profiles.py @@ -62,6 +62,7 @@ def __init__( grid=None, name="pressure", jac_chunk_size=None, + device_id=0, ): if target is None and bounds is None: target = 0 @@ -77,6 +78,7 @@ def __init__( deriv_mode=deriv_mode, name=name, jac_chunk_size=jac_chunk_size, + device_id=device_id, ) def build(self, use_jit=True, verbose=1): @@ -197,6 +199,7 @@ def __init__( grid=None, name="rotational transform", jac_chunk_size=None, + device_id=0, ): if target is None and bounds is None: target = 0 @@ -212,6 +215,7 @@ def __init__( deriv_mode=deriv_mode, name=name, jac_chunk_size=jac_chunk_size, + device_id=device_id, ) def build(self, use_jit=True, verbose=1): @@ -345,6 +349,7 @@ def __init__( grid=None, name="shear", jac_chunk_size=None, + device_id=0, ): if target is None and bounds is None: bounds = (-np.inf, 0) @@ -360,6 +365,7 @@ def __init__( deriv_mode=deriv_mode, name=name, jac_chunk_size=jac_chunk_size, + device_id=device_id, ) def build(self, use_jit=True, verbose=1): @@ -485,6 +491,7 @@ def __init__( grid=None, name="toroidal current", jac_chunk_size=None, + device_id=0, ): if target is None and bounds is None: target = 0 @@ -500,6 +507,7 @@ def __init__( deriv_mode=deriv_mode, name=name, jac_chunk_size=jac_chunk_size, + device_id=device_id, ) def build(self, use_jit=True, verbose=1): diff --git a/desc/objectives/_stability.py b/desc/objectives/_stability.py index 3ef4debc82..e0b441b33d 100644 --- a/desc/objectives/_stability.py +++ b/desc/objectives/_stability.py @@ -73,6 +73,7 @@ def __init__( grid=None, name="Mercier Stability", jac_chunk_size=None, + device_id=0, ): if target is None and bounds is None: bounds = (0, np.inf) @@ -88,6 +89,7 @@ def __init__( deriv_mode=deriv_mode, name=name, jac_chunk_size=jac_chunk_size, + device_id=device_id, ) def build(self, use_jit=True, verbose=1): @@ -231,6 +233,7 @@ def __init__( grid=None, name="Magnetic Well", jac_chunk_size=None, + device_id=0, ): if target is None and bounds is None: bounds = (0, np.inf) @@ -246,6 +249,7 @@ def __init__( deriv_mode=deriv_mode, name=name, jac_chunk_size=jac_chunk_size, + device_id=device_id, ) def build(self, use_jit=True, verbose=1): diff --git a/desc/objectives/objective_funs.py b/desc/objectives/objective_funs.py index 6fd5dac066..e5ea0c7785 100644 --- a/desc/objectives/objective_funs.py +++ b/desc/objectives/objective_funs.py @@ -96,6 +96,12 @@ option will yield a larger chunk size than may be needed. It is recommended to manually choose a chunk_size if an OOM error is experienced in this case. """ +doc_device_id = """ + device_id : int, optional + Device ID to run the objective on. Defaults to 0. If different objectives + are on different devices, the ObjectiveFunction will run each sub-objective + on the device specified in the sub-objective. +""" docs = { "target": doc_target, "bounds": doc_bounds, @@ -106,6 +112,7 @@ "deriv_mode": doc_deriv_mode, "name": doc_name, "jac_chunk_size": doc_jac_chunk_size, + "device_id": doc_device_id, } diff --git a/docs/notebooks/tutorials/multi_device.ipynb b/docs/notebooks/tutorials/multi_device.ipynb index c44bc260af..b0b5e2f40d 100644 --- a/docs/notebooks/tutorials/multi_device.ipynb +++ b/docs/notebooks/tutorials/multi_device.ipynb @@ -26,14 +26,14 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ - "num_device = 2\n", - "# from desc import set_device\n", + "num_device = 3\n", + "from desc import set_device\n", "\n", - "# set_device(\"gpu\", num_device=num_device)" + "set_device(\"gpu\", num_device=num_device)" ] }, { @@ -45,10 +45,12 @@ "name": "stdout", "output_type": "stream", "text": [ - "DESC version 0.13.0+1130.gc8481e158.dirty,using JAX backend, jax version=0.4.38, jaxlib version=0.4.38, dtype=float64\n", - "Using 2 devices:\n", - "\t Device 0: NVIDIA A100-PCIE-40GB (id=0) with 40.00 GB available memory\n", - "\t Device 1: NVIDIA A100-PCIE-40GB (id=1) with 40.00 GB available memory\n" + "DESC version 0.13.0+1523.ge2c0f7767.dirty,using JAX backend, jax version=0.4.38, jaxlib version=0.4.38, dtype=float64\n", + "CPU Info: AMD EPYC 7453 28-Core Processor CPU with 978.07 GB available memory\n", + "Using 3 device:\n", + "\t Device 0: NVIDIA A100-SXM4-40GB (id=0) with 40.00 GB available memory\n", + "\t Device 1: NVIDIA A100-SXM4-40GB (id=1) with 40.00 GB available memory\n", + "\t Device 2: NVIDIA A100-SXM4-40GB (id=2) with 40.00 GB available memory\n" ] } ], @@ -79,6 +81,7 @@ "name": "stdout", "output_type": "stream", "text": [ + "Precomputing transforms\n", "Precomputing transforms\n", "Precomputing transforms\n" ] @@ -92,25 +95,6 @@ { "cell_type": "code", "execution_count": 6, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "(34632,)\n", - "(34632, 1977)\n" - ] - } - ], - "source": [ - "print(obj.compute_scaled_error(obj.x()).shape)\n", - "print(obj.jac_scaled_error(obj.x()).shape)" - ] - }, - { - "cell_type": "code", - "execution_count": null, "metadata": { "editable": true, "slideshow": { @@ -134,41 +118,52 @@ "Building objective: lambda gauge\n", "Building objective: axis R self consistency\n", "Building objective: axis Z self consistency\n", - "Timer: Objective build = 1.99 sec\n", - "Timer: Linear constraint projection build = 5.61 sec\n", + "Timer: Objective build = 1.74 sec\n", + "Timer: Linear constraint projection build = 7.48 sec\n", "Number of parameters: 1593\n", "Number of objectives: 34632\n", - "Timer: Initializing the optimization = 7.73 sec\n", + "Timer: Initializing the optimization = 9.34 sec\n", "\n", "Starting optimization\n", "Using method: lsq-exact\n", + "This should run on GPU id:0\n", + "This should run on GPU id:1\n", + "This should run on GPU id:2\n", " Iteration Total nfev Cost Cost reduction Step norm Optimality \n", - " 0 1 3.654e-07 1.803e-04 \n", - " 1 6 2.102e-07 1.552e-07 1.244e-03 5.327e-05 \n", - " 2 7 2.097e-07 5.059e-10 1.883e-03 6.156e-05 \n", + " 0 1 5.161e-07 1.557e-04 \n", + "This should run on GPU id:0\n", + "This should run on GPU id:1\n", + "This should run on GPU id:2\n", + " 1 5 2.629e-07 2.531e-07 3.371e-03 1.961e-04 \n", "Warning: Maximum number of iterations has been exceeded.\n", - " Current function value: 2.097e-07\n", - " Total delta_x: 2.644e-03\n", - " Iterations: 2\n", - " Function evaluations: 7\n", - " Jacobian evaluations: 3\n", - "Timer: Solution time = 23.4 sec\n", - "Timer: Avg time per step = 7.83 sec\n", + " Current function value: 2.629e-07\n", + " Total delta_x: 3.371e-03\n", + " Iterations: 1\n", + " Function evaluations: 5\n", + " Jacobian evaluations: 2\n", + "Timer: Solution time = 28.5 sec\n", + "Timer: Avg time per step = 14.2 sec\n", "==============================================================================================================\n", " Start --> End\n", - "Total (sum of squares): 3.654e-07 --> 2.097e-07, \n", - "Maximum absolute Force error: 1.378e+02 --> 2.537e+02 (N)\n", + "Total (sum of squares): 5.161e-07 --> 2.629e-07, \n", + "Maximum absolute Force error: 1.378e+02 --> 2.419e+02 (N)\n", "Minimum absolute Force error: 1.059e-10 --> 1.060e-10 (N)\n", - "Average absolute Force error: 2.610e+01 --> 1.938e+01 (N)\n", - "Maximum absolute Force error: 1.108e-05 --> 2.040e-05 (normalized)\n", - "Minimum absolute Force error: 8.517e-18 --> 8.529e-18 (normalized)\n", - "Average absolute Force error: 2.099e-06 --> 1.558e-06 (normalized)\n", - "Maximum absolute Force error: 8.201e+03 --> 6.247e+03 (N)\n", - "Minimum absolute Force error: 1.635e-12 --> 2.050e-12 (N)\n", - "Average absolute Force error: 8.007e+01 --> 7.093e+01 (N)\n", - "Maximum absolute Force error: 6.596e-04 --> 5.024e-04 (normalized)\n", - "Minimum absolute Force error: 1.315e-19 --> 1.649e-19 (normalized)\n", - "Average absolute Force error: 6.440e-06 --> 5.705e-06 (normalized)\n", + "Average absolute Force error: 2.932e+01 --> 1.966e+01 (N)\n", + "Maximum absolute Force error: 1.108e-05 --> 1.946e-05 (normalized)\n", + "Minimum absolute Force error: 8.517e-18 --> 8.524e-18 (normalized)\n", + "Average absolute Force error: 2.358e-06 --> 1.581e-06 (normalized)\n", + "Maximum absolute Force error: 2.276e+02 --> 3.279e+02 (N)\n", + "Minimum absolute Force error: 1.271e-10 --> 1.282e-10 (N)\n", + "Average absolute Force error: 3.359e+01 --> 2.870e+01 (N)\n", + "Maximum absolute Force error: 1.831e-05 --> 2.637e-05 (normalized)\n", + "Minimum absolute Force error: 1.022e-17 --> 1.031e-17 (normalized)\n", + "Average absolute Force error: 2.702e-06 --> 2.308e-06 (normalized)\n", + "Maximum absolute Force error: 8.201e+03 --> 6.277e+03 (N)\n", + "Minimum absolute Force error: 1.635e-12 --> 3.597e-12 (N)\n", + "Average absolute Force error: 8.964e+01 --> 7.837e+01 (N)\n", + "Maximum absolute Force error: 6.596e-04 --> 5.048e-04 (normalized)\n", + "Minimum absolute Force error: 1.315e-19 --> 2.893e-19 (normalized)\n", + "Average absolute Force error: 7.209e-06 --> 6.303e-06 (normalized)\n", "R boundary error: 0.000e+00 --> 0.000e+00 (m)\n", "Z boundary error: 0.000e+00 --> 0.000e+00 (m)\n", "Fixed Psi error: 0.000e+00 --> 0.000e+00 (Wb)\n", @@ -180,17 +175,17 @@ } ], "source": [ - "eq.solve(objective=obj, constraints=cons, maxiter=2, ftol=0, gtol=0, xtol=0, verbose=3)" + "eq.solve(objective=obj, constraints=cons, maxiter=1, ftol=0, gtol=0, xtol=0, verbose=3);" ] }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 7, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -200,7 +195,17 @@ }, { "data": { - "image/png": "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", + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", "text/plain": [ "
" ] @@ -213,13 +218,190 @@ "for obji in obj.objectives:\n", " plot_grid(obji.constants[\"transforms\"][\"grid\"])" ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Using other Objectives\n", + "Above we used the convenience function for force balance objective, but we can also other objectives with this approach. There are some extra steps you need to apply though." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "eq = get(\"HELIOTRON\")" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Precomputing transforms\n", + "Timer: Precomputing transforms = 103 ms\n", + "Precomputing transforms\n", + "Timer: Precomputing transforms = 104 ms\n", + "Precomputing transforms\n", + "Timer: Precomputing transforms = 124 ms\n", + "Timer: Objective build = 12.9 ms\n" + ] + } + ], + "source": [ + "import numpy as np\n", + "from desc.backend import jax\n", + "from desc.optimize import Optimizer\n", + "\n", + "grid1 = LinearGrid(\n", + " M=eq.M_grid, N=eq.N_grid, NFP=eq.NFP, rho=np.array([0.2, 0.4]), sym=True\n", + ")\n", + "grid2 = LinearGrid(\n", + " M=eq.M_grid, N=eq.N_grid, NFP=eq.NFP, rho=np.array([0.6, 0.8, 1.0]), sym=True\n", + ")\n", + "\n", + "obj1 = QuasisymmetryTwoTerm(eq=eq, helicity=(1, eq.NFP), grid=grid1, device_id=0)\n", + "obj2 = QuasisymmetryTwoTerm(eq=eq, helicity=(1, eq.NFP), grid=grid2, device_id=1)\n", + "obj3 = AspectRatio(eq=eq, target=8, weight=100, device_id=2)\n", + "\n", + "objs = [obj1, obj2, obj3]\n", + "for obji in objs:\n", + " obji.build(verbose=3)\n", + " obji = jax.device_put(obji, jax.devices(\"gpu\")[obji._device_id])\n", + " obji.things[0] = eq\n", + "\n", + "objective = ObjectiveFunction(objs)\n", + "objective.build(verbose=3)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "k = 1\n", + "R_modes = np.vstack(\n", + " (\n", + " [0, 0, 0],\n", + " eq.surface.R_basis.modes[\n", + " np.max(np.abs(eq.surface.R_basis.modes), 1) > k, :\n", + " ],\n", + " )\n", + ")\n", + "Z_modes = eq.surface.Z_basis.modes[\n", + " np.max(np.abs(eq.surface.Z_basis.modes), 1) > k, :\n", + "]\n", + "constraints = (\n", + " FixBoundaryR(eq=eq, modes=R_modes),\n", + " FixBoundaryZ(eq=eq, modes=Z_modes),\n", + " FixPressure(eq=eq),\n", + " FixPsi(eq=eq),\n", + ")\n", + "# TODO: implement for proximal\n", + "optimizer = Optimizer(\"lsq-exact\")" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Building objective: lcfs R\n", + "Building objective: lcfs Z\n", + "Building objective: fixed pressure\n", + "Building objective: fixed Psi\n", + "Building objective: self_consistency R\n", + "Building objective: self_consistency Z\n", + "Building objective: lambda gauge\n", + "Building objective: axis R self consistency\n", + "Building objective: axis Z self consistency\n", + "Timer: Objective build = 367 ms\n", + "Timer: Linear constraint projection build = 2.84 sec\n", + "Number of parameters: 1614\n", + "Number of objectives: 1236\n", + "Timer: Initializing the optimization = 3.32 sec\n", + "\n", + "Starting optimization\n", + "Using method: lsq-exact\n", + "This should run on GPU id:0\n", + "This should run on GPU id:1\n", + "This should run on GPU id:2\n", + " Iteration Total nfev Cost Cost reduction Step norm Optimality \n", + " 0 1 9.547e+04 3.162e+02 \n", + "This should run on GPU id:0\n", + "This should run on GPU id:1\n", + "This should run on GPU id:2\n", + " 1 6 4.883e+04 4.664e+04 5.955e+00 1.431e+02 \n", + "Warning: Maximum number of function evaluations has been exceeded.\n", + " Current function value: 4.883e+04\n", + " Total delta_x: 5.955e+00\n", + " Iterations: 1\n", + " Function evaluations: 6\n", + " Jacobian evaluations: 2\n", + "Timer: Solution time = 20.9 sec\n", + "Timer: Avg time per step = 10.4 sec\n", + "==============================================================================================================\n", + " Start --> End\n", + "Total (sum of squares): 9.547e+04 --> 4.883e+04, \n", + "Maximum absolute Quasi-symmetry (1,19) two-term error: 5.074e-01 --> 1.932e-01 (T^3)\n", + "Minimum absolute Quasi-symmetry (1,19) two-term error: 9.317e-06 --> 1.989e-05 (T^3)\n", + "Average absolute Quasi-symmetry (1,19) two-term error: 1.363e-01 --> 2.698e-02 (T^3)\n", + "Maximum absolute Quasi-symmetry (1,19) two-term error: 8.055e+00 --> 3.067e+00 (normalized)\n", + "Minimum absolute Quasi-symmetry (1,19) two-term error: 1.479e-04 --> 3.158e-04 (normalized)\n", + "Average absolute Quasi-symmetry (1,19) two-term error: 2.165e+00 --> 4.283e-01 (normalized)\n", + "Maximum absolute Quasi-symmetry (1,19) two-term error: 1.686e+00 --> 1.997e+00 (T^3)\n", + "Minimum absolute Quasi-symmetry (1,19) two-term error: 1.764e-04 --> 9.557e-05 (T^3)\n", + "Average absolute Quasi-symmetry (1,19) two-term error: 4.168e-01 --> 2.352e-01 (T^3)\n", + "Maximum absolute Quasi-symmetry (1,19) two-term error: 2.676e+01 --> 3.170e+01 (normalized)\n", + "Minimum absolute Quasi-symmetry (1,19) two-term error: 2.800e-03 --> 1.517e-03 (normalized)\n", + "Average absolute Quasi-symmetry (1,19) two-term error: 6.616e+00 --> 3.733e+00 (normalized)\n", + "Aspect ratio: 1.048e+01 --> 1.004e+01 (dimensionless)\n", + "R boundary error: 0.000e+00 --> 0.000e+00 (m)\n", + "Z boundary error: 0.000e+00 --> 0.000e+00 (m)\n", + "Fixed pressure profile error: 0.000e+00 --> 0.000e+00 (Pa)\n", + "Fixed Psi error: 0.000e+00 --> 0.000e+00 (Wb)\n", + "==============================================================================================================\n" + ] + } + ], + "source": [ + "eq.optimize(\n", + " objective=objective,\n", + " constraints=constraints,\n", + " optimizer=optimizer,\n", + " maxiter=1,\n", + " verbose=3,\n", + " options={\n", + " \"initial_trust_ratio\": 1.0,\n", + " },\n", + ");" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] } ], "metadata": { "kernelspec": { - "display_name": "desc-env", + "display_name": "desc-env [~/.conda/envs/desc-env/]", "language": "python", - "name": "python3" + "name": "conda_desc-env" }, "language_info": { "codemirror_mode": { @@ -231,7 +413,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.12.7" + "version": "3.11.6" } }, "nbformat": 4, From 0d4cc4770e2956e37364303132bd349ff1e67f21 Mon Sep 17 00:00:00 2001 From: YigitElma Date: Thu, 13 Feb 2025 00:51:49 -0500 Subject: [PATCH 66/75] fix missing docs --- desc/objectives/_coils.py | 17 +++++++++++++++++ desc/objectives/_fast_ion.py | 1 + desc/objectives/_free_boundary.py | 2 ++ desc/objectives/_generic.py | 4 ++++ desc/objectives/_neoclassical.py | 1 + desc/objectives/_stability.py | 2 ++ 6 files changed, 27 insertions(+) diff --git a/desc/objectives/_coils.py b/desc/objectives/_coils.py index 8da36de2b9..a868b34ebd 100644 --- a/desc/objectives/_coils.py +++ b/desc/objectives/_coils.py @@ -246,6 +246,7 @@ def __init__( grid=grid, name=name, jac_chunk_size=jac_chunk_size, + device_id=device_id, ) def build(self, use_jit=True, verbose=1): @@ -351,6 +352,7 @@ def __init__( grid=grid, name=name, jac_chunk_size=jac_chunk_size, + device_id=device_id, ) def build(self, use_jit=True, verbose=1): @@ -451,6 +453,7 @@ def __init__( grid=grid, name=name, jac_chunk_size=jac_chunk_size, + device_id=device_id, ) def build(self, use_jit=True, verbose=1): @@ -550,6 +553,7 @@ def __init__( grid=grid, name=name, jac_chunk_size=jac_chunk_size, + device_id=device_id, ) def build(self, use_jit=True, verbose=1): @@ -659,6 +663,7 @@ def __init__( grid=grid, name=name, jac_chunk_size=jac_chunk_size, + device_id=device_id, ) def build(self, use_jit=True, verbose=1): @@ -766,6 +771,7 @@ def __init__( use_softmin=False, softmin_alpha=1.0, dist_chunk_size=None, + device_id=0, ): from desc.coils import CoilSet @@ -944,6 +950,7 @@ def __init__( use_softmin=False, softmin_alpha=1.0, dist_chunk_size=None, + device_id=0, ): if target is None and bounds is None: bounds = (1, np.inf) @@ -1159,6 +1166,7 @@ def __init__( deriv_mode="auto", grid=None, name="coil arclength variance", + device_id=0, ): if target is None and bounds is None: target = 0 @@ -1175,6 +1183,7 @@ def __init__( deriv_mode=deriv_mode, grid=grid, name=name, + device_id=device_id, ) def build(self, use_jit=True, verbose=1): @@ -1326,6 +1335,7 @@ def __init__( normalize_target=normalize_target, name=name, jac_chunk_size=jac_chunk_size, + device_id=device_id, ) def build(self, use_jit=True, verbose=1): @@ -1523,6 +1533,7 @@ def __init__( normalize_target=normalize_target, name=name, jac_chunk_size=jac_chunk_size, + device_id=device_id, ) def build(self, use_jit=True, verbose=1): @@ -1971,6 +1982,7 @@ def __init__( deriv_mode="auto", jac_chunk_size=None, name="linking current", + device_id=0, ): if target is None and bounds is None: target = 0 @@ -1991,6 +2003,7 @@ def __init__( deriv_mode=deriv_mode, jac_chunk_size=jac_chunk_size, name=name, + device_id=device_id, ) def build(self, use_jit=True, verbose=1): @@ -2159,6 +2172,7 @@ def __init__( deriv_mode="auto", jac_chunk_size=None, name="coil-coil linking number", + device_id=0, ): from desc.coils import CoilSet @@ -2181,6 +2195,7 @@ def __init__( deriv_mode=deriv_mode, jac_chunk_size=jac_chunk_size, name=name, + device_id=device_id, ) def build(self, use_jit=True, verbose=1): @@ -2302,6 +2317,7 @@ def __init__( deriv_mode="auto", source_grid=None, name="surface-current-regularization", + device_id=0, ): from desc.magnetic_fields import ( CurrentPotentialField, @@ -2329,6 +2345,7 @@ def __init__( loss_function=loss_function, deriv_mode=deriv_mode, name=name, + device_id=device_id, ) def build(self, use_jit=True, verbose=1): diff --git a/desc/objectives/_fast_ion.py b/desc/objectives/_fast_ion.py index 9f13b9ffcb..21f7eba847 100644 --- a/desc/objectives/_fast_ion.py +++ b/desc/objectives/_fast_ion.py @@ -171,6 +171,7 @@ def __init__( surf_batch_size=1, spline=False, Nemov=True, + device_id=0, ): if target is None and bounds is None: target = 0.0 diff --git a/desc/objectives/_free_boundary.py b/desc/objectives/_free_boundary.py index 1afafed87e..67d50d4242 100644 --- a/desc/objectives/_free_boundary.py +++ b/desc/objectives/_free_boundary.py @@ -81,6 +81,7 @@ def __init__( field_fixed=False, name="Vacuum boundary error", jac_chunk_size=None, + device_id=0, **kwargs, ): eval_grid = parse_argname_change(eval_grid, kwargs, "grid", "eval_grid") @@ -426,6 +427,7 @@ def __init__( chunk_size=1, name="Boundary error", jac_chunk_size=None, + device_id=0, **kwargs, ): if target is None and bounds is None: diff --git a/desc/objectives/_generic.py b/desc/objectives/_generic.py index 58b08db31b..3e5bd0109d 100644 --- a/desc/objectives/_generic.py +++ b/desc/objectives/_generic.py @@ -56,6 +56,7 @@ def __init__( name="generic", jac_chunk_size=None, compute_kwargs=None, + device_id=0, **kwargs, ): errorif( @@ -212,6 +213,7 @@ def __init__( normalize_target=normalize_target, name=name, jac_chunk_size=jac_chunk_size, + device_id=device_id, ) def build(self, use_jit=False, verbose=1): @@ -337,6 +339,7 @@ def __init__( name="custom", jac_chunk_size=None, compute_kwargs=None, + device_id=0, **kwargs, ): errorif( @@ -361,6 +364,7 @@ def __init__( deriv_mode=deriv_mode, name=name, jac_chunk_size=jac_chunk_size, + device_id=device_id, ) self._p = _parse_parameterization(thing) diff --git a/desc/objectives/_neoclassical.py b/desc/objectives/_neoclassical.py index d02ffed2cc..6e5783cb27 100644 --- a/desc/objectives/_neoclassical.py +++ b/desc/objectives/_neoclassical.py @@ -158,6 +158,7 @@ def __init__( pitch_batch_size=None, surf_batch_size=1, spline=False, + device_id=0, ): if target is None and bounds is None: target = 0.0 diff --git a/desc/objectives/_stability.py b/desc/objectives/_stability.py index e0b441b33d..dcce2b7051 100644 --- a/desc/objectives/_stability.py +++ b/desc/objectives/_stability.py @@ -417,6 +417,7 @@ def __init__( w0=1.0, w1=10.0, name="ideal ballooning lambda", + device_id=0, ): if target is None and bounds is None: target = 0 @@ -440,6 +441,7 @@ def __init__( loss_function=loss_function, deriv_mode=deriv_mode, name=name, + device_id=device_id, ) errorif( From 12ba4db8b3aae17e1c15d73600611685d1089eb2 Mon Sep 17 00:00:00 2001 From: YigitElma Date: Thu, 13 Feb 2025 02:05:20 -0500 Subject: [PATCH 67/75] initial test for proximal --- desc/optimize/_constraint_wrappers.py | 21 +++++++++++++++++++-- 1 file changed, 19 insertions(+), 2 deletions(-) diff --git a/desc/optimize/_constraint_wrappers.py b/desc/optimize/_constraint_wrappers.py index 7695a671b4..2d521ee121 100644 --- a/desc/optimize/_constraint_wrappers.py +++ b/desc/optimize/_constraint_wrappers.py @@ -1104,7 +1104,24 @@ def __getattr__(self, name): # define these helper functions that are stateless so we can safely jit them -@functools.partial(jit, static_argnames=["op"]) +def jit_if_not_parallel(func): + """Jit a function if not in parallel mode.""" + + @functools.wraps(func) + def wrapper(*args, **kwargs): + obj = args[0] + if getattr(obj, "_is_multi_device", False): + # Apply jit if jittable + jitted_func = functools.partial(jit, static_argnames=["op"])(func) + return jitted_func(*args, **kwargs) + else: + # Run normally if not jittable + return func(*args, **kwargs) + + return wrapper + + +@jit_if_not_parallel def _proximal_jvp_f_pure(constraint, xf, constants, dc, unfixed_idx, Z, D, dxdc, op): Fx = getattr(constraint, "jac_" + op)(xf, constants) Fx_reduced = Fx @ jnp.diag(D)[:, unfixed_idx] @ Z @@ -1118,7 +1135,7 @@ def _proximal_jvp_f_pure(constraint, xf, constants, dc, unfixed_idx, Z, D, dxdc, return Fxh_inv @ Fc -@functools.partial(jit, static_argnames=["op"]) +@jit_if_not_parallel def _proximal_jvp_blocked_pure(objective, vgs, xgs, op): out = [] for k, (obj, const) in enumerate(zip(objective.objectives, objective.constants)): From f4468047def8e492aa3c85008f4131e0db5960c6 Mon Sep 17 00:00:00 2001 From: YigitElma Date: Thu, 13 Feb 2025 13:34:08 -0500 Subject: [PATCH 68/75] add obj._device attr for cleaner device_put --- desc/backend.py | 20 ++++++++++---------- desc/objectives/getters.py | 2 +- desc/objectives/objective_funs.py | 20 +++++++++----------- desc/optimize/_constraint_wrappers.py | 7 ++++++- 4 files changed, 26 insertions(+), 23 deletions(-) diff --git a/desc/backend.py b/desc/backend.py index e5bb0227f5..4665f291ce 100644 --- a/desc/backend.py +++ b/desc/backend.py @@ -461,8 +461,14 @@ def pconcat(arrays, mode="concat"): # pragma: no cover # array of float64 should fit into single device size = jnp.array([x.size for x in arrays]) size = jnp.sum(size) - if size * 8 / (1024**3) > desc_config["avail_mems"][0]: - if getattr(desc_config, "SUPPRESS_CPU_WARNING", False): + if ( + size * 8 / (1024**3) > desc_config["avail_mems"][0] + or desc_config["kind"] == "cpu" + ): + if ( + getattr(desc_config, "SUPPRESS_CPU_WARNING", False) + and desc_config["kind"] == "gpu" + ): warnings.warn( "The total size of the arrays exceeds the available memory of the " "GPU[id=0]. Moving the array to CPU. This may cause performance " @@ -487,7 +493,7 @@ def jit_with_device(method): Decorates a method of a class with a dynamic device, allowing the method to be compiled with jax.jit for the specific device. This is needed since - @functools.partial(jax.jit, device=jax.devices("gpu")[self._device_id]) is not + @functools.partial(jax.jit, device=obj._device) is not allowed in a class definition. Parameters @@ -499,14 +505,8 @@ def jit_with_device(method): @functools.wraps(method) def wrapper(self, *args, **kwargs): - # Get the device using self.id or default to CPU - if desc_config["kind"] == "gpu" and hasattr(self, "_device_id"): - device = jax.devices("gpu")[self._device_id] - else: - device = None - # Compile the method with jax.jit for the specific device - wrapped = jax.jit(method, device=device) + wrapped = jax.jit(method, device=self._device) return wrapped(self, *args, **kwargs) return wrapper diff --git a/desc/objectives/getters.py b/desc/objectives/getters.py index 662283dbea..f476de9648 100644 --- a/desc/objectives/getters.py +++ b/desc/objectives/getters.py @@ -408,7 +408,7 @@ def get_parallel_forcebalance( gridi = grid[i] obj = ForceBalance(eq, grid=gridi, device_id=i) obj.build(use_jit=use_jit) - obj = jax.device_put(obj, jax.devices("gpu")[i]) + obj = jax.device_put(obj, obj._device) # if the eq is also distrubuted across GPUs, then some internal logic # that checks if the things are different will fail, so we need to # set the eq to be the same manually diff --git a/desc/objectives/objective_funs.py b/desc/objectives/objective_funs.py index e5ea0c7785..3413acc9c4 100644 --- a/desc/objectives/objective_funs.py +++ b/desc/objectives/objective_funs.py @@ -483,8 +483,7 @@ def compute_unscaled(self, x, constants=None): f = pconcat( [ obj.compute_unscaled( - *jax.device_put(par, jax.devices("gpu")[obj._device_id]), - constants=const, + *jax.device_put(par, obj._device), constants=const ) for par, obj, const in zip(params, self.objectives, constants) ] @@ -523,8 +522,7 @@ def compute_scaled(self, x, constants=None): f = pconcat( [ obj.compute_scaled( - *jax.device_put(par, jax.devices("gpu")[obj._device_id]), - constants=const, + *jax.device_put(par, obj._device), constants=const ) for par, obj, const in zip(params, self.objectives, constants) ] @@ -563,8 +561,7 @@ def compute_scaled_error(self, x, constants=None): f = pconcat( [ obj.compute_scaled_error( - *jax.device_put(par, jax.devices("gpu")[obj._device_id]), - constants=const, + *jax.device_put(par, obj._device), constants=const ) for par, obj, const in zip(params, self.objectives, constants) ] @@ -634,13 +631,13 @@ def print_value(self, x, x0=None, constants=None): params, params0, self.objectives, constants ): if self._is_multi_device: # pragma: no cover - par = jax.device_put(par, jax.devices("gpu")[obj._device_id]) - par0 = jax.device_put(par0, jax.devices("gpu")[obj._device_id]) + par = jax.device_put(par, obj._device) + par0 = jax.device_put(par0, obj._device) obj.print_value(par, par0, constants=const) else: # pragma: no cover for par, obj, const in zip(params, self.objectives, constants): if self._is_multi_device: - par = jax.device_put(par, jax.devices("gpu")[obj._device_id]) + par = jax.device_put(par, obj._device) obj.print_value(par, constants=const) return None @@ -773,8 +770,8 @@ def _jvp_blocked(self, v, x, constants=None, op="scaled"): if self._is_multi_device: # pragma: no cover # inputs to jitted functions must live on the same device. Need to # put xi and vi on the same device as the objective - xi = jax.device_put(xi, jax.devices("gpu")[obj._device_id]) - vi = jax.device_put(vi, jax.devices("gpu")[obj._device_id]) + xi = jax.device_put(xi, obj._device) + vi = jax.device_put(vi, obj._device) Ji_ = getattr(obj, "jvp_" + op)(vi, xi, constants=const) J += [Ji_] # this is the transpose of the jvp when v is a matrix, for consistency with @@ -1145,6 +1142,7 @@ def __init__( self._jac_chunk_size = jac_chunk_size self._device_id = device_id + self._device = jax.devices(desc_config["kind"])[device_id] self._target = target self._bounds = bounds diff --git a/desc/optimize/_constraint_wrappers.py b/desc/optimize/_constraint_wrappers.py index 2d521ee121..3a2df245d6 100644 --- a/desc/optimize/_constraint_wrappers.py +++ b/desc/optimize/_constraint_wrappers.py @@ -4,7 +4,7 @@ import numpy as np -from desc.backend import jit, jnp +from desc.backend import jax, jit, jnp from desc.batching import batched_vectorize from desc.objectives import ( BoundaryRSelfConsistency, @@ -1142,6 +1142,11 @@ def _proximal_jvp_blocked_pure(objective, vgs, xgs, op): thing_idx = objective._things_per_objective_idx[k] xi = [xgs[i] for i in thing_idx] vi = [vgs[i] for i in thing_idx] + if objective._is_multi_device: # pragma: no cover + # inputs to jitted functions must live on the same device. Need to + # put xi and vi on the same device as the objective + xi = jax.device_put(xi, obj._device) + vi = jax.device_put(vi, obj._device) assert len(xi) > 0 assert len(vi) > 0 assert len(xi) == len(vi) From e5ed5cb300ddae0031a200bdac47d17a98e00e90 Mon Sep 17 00:00:00 2001 From: YigitElma Date: Thu, 13 Feb 2025 13:45:08 -0500 Subject: [PATCH 69/75] jit what you can, use pconcat --- desc/optimize/_constraint_wrappers.py | 30 +++++++++++++++++---------- 1 file changed, 19 insertions(+), 11 deletions(-) diff --git a/desc/optimize/_constraint_wrappers.py b/desc/optimize/_constraint_wrappers.py index 3a2df245d6..b33fbcf536 100644 --- a/desc/optimize/_constraint_wrappers.py +++ b/desc/optimize/_constraint_wrappers.py @@ -4,7 +4,7 @@ import numpy as np -from desc.backend import jax, jit, jnp +from desc.backend import jax, jit, jnp, pconcat from desc.batching import batched_vectorize from desc.objectives import ( BoundaryRSelfConsistency, @@ -1124,15 +1124,20 @@ def wrapper(*args, **kwargs): @jit_if_not_parallel def _proximal_jvp_f_pure(constraint, xf, constants, dc, unfixed_idx, Z, D, dxdc, op): Fx = getattr(constraint, "jac_" + op)(xf, constants) - Fx_reduced = Fx @ jnp.diag(D)[:, unfixed_idx] @ Z - Fc = Fx @ (dxdc @ dc) - Fxh = Fx_reduced - cutoff = jnp.finfo(Fxh.dtype).eps * max(Fxh.shape) - uf, sf, vtf = jnp.linalg.svd(Fxh, full_matrices=False) - sf += sf[-1] # add a tiny bit of regularization - sfi = jnp.where(sf < cutoff * sf[0], 0, 1 / sf) - Fxh_inv = vtf.T @ (sfi[..., None] * uf.T) - return Fxh_inv @ Fc + + @jit + def fun(Fx, dxdc, dc, unfixed_idx, Z, D): + # F_reduced + Fxh = Fx @ jnp.diag(D)[:, unfixed_idx] @ Z + Fc = Fx @ (dxdc @ dc) + cutoff = jnp.finfo(Fxh.dtype).eps * max(Fxh.shape) + uf, sf, vtf = jnp.linalg.svd(Fxh, full_matrices=False) + sf += sf[-1] # add a tiny bit of regularization + sfi = jnp.where(sf < cutoff * sf[0], 0, 1 / sf) + Fxh_inv = vtf.T @ (sfi[..., None] * uf.T) + return Fxh_inv @ Fc + + return fun(Fx, dxdc, dc, unfixed_idx, Z, D) @jit_if_not_parallel @@ -1160,5 +1165,8 @@ def _proximal_jvp_blocked_pure(objective, vgs, xgs, op): else: outi = getattr(obj, "jvp_" + op)([_vi for _vi in vi], xi, constants=const).T out.append(outi) - out = jnp.concatenate(out) + if objective._is_multi_device: # pragma: no cover + out = pconcat(out) + else: + out = jnp.concatenate(out) return out From 6dd7611314a869dc9d585bac7b7dc5ef7b96984f Mon Sep 17 00:00:00 2001 From: YigitElma Date: Thu, 13 Feb 2025 14:05:34 -0500 Subject: [PATCH 70/75] fix device jit issue --- desc/objectives/objective_funs.py | 2 ++ 1 file changed, 2 insertions(+) diff --git a/desc/objectives/objective_funs.py b/desc/objectives/objective_funs.py index 3413acc9c4..3c201911a7 100644 --- a/desc/objectives/objective_funs.py +++ b/desc/objectives/objective_funs.py @@ -1114,6 +1114,8 @@ class _Objective(IOAble, ABC): "_normalization", "_deriv_mode", ] + # _device is of type jax.Device() which cannot be an argument to a jitted function. + _static_attrs = ["_device"] def __init__( self, From b3e961fccd0c95b9c444c038ef3eaf7fa9e0008c Mon Sep 17 00:00:00 2001 From: YigitElma Date: Thu, 13 Feb 2025 14:33:07 -0500 Subject: [PATCH 71/75] make _device None for single device cases --- desc/objectives/objective_funs.py | 13 +++++++++++-- 1 file changed, 11 insertions(+), 2 deletions(-) diff --git a/desc/objectives/objective_funs.py b/desc/objectives/objective_funs.py index 3c201911a7..db0ed9df47 100644 --- a/desc/objectives/objective_funs.py +++ b/desc/objectives/objective_funs.py @@ -1114,7 +1114,8 @@ class _Objective(IOAble, ABC): "_normalization", "_deriv_mode", ] - # _device is of type jax.Device() which cannot be an argument to a jitted function. + # _device is of type 'jaxlib.xla_extension.Device' which cannot be an argument + # to a jitted function. _static_attrs = ["_device"] def __init__( @@ -1144,7 +1145,15 @@ def __init__( self._jac_chunk_size = jac_chunk_size self._device_id = device_id - self._device = jax.devices(desc_config["kind"])[device_id] + # if device_id is not 0, this typically means we are using multiple devices and + # we won't jit the ObjectiveFunction methods. For single device, if we set + # _device to a jaxlib.xla_extension.Device type, jit will throw error expecting + # it to be static. So we set _device to None in that case which is simpler then + # making it static. + if device_id != 0: + self._device = jax.devices(desc_config["kind"])[device_id] + else: + self._device = None self._target = target self._bounds = bounds From bfb371ce84159b16951aff8f2b5db4fd10b5feaf Mon Sep 17 00:00:00 2001 From: YigitElma Date: Thu, 13 Feb 2025 15:08:32 -0500 Subject: [PATCH 72/75] ok now it is fixed --- desc/optimize/_constraint_wrappers.py | 5 +- docs/notebooks/tutorials/multi_device.ipynb | 299 +++++++++++++++----- 2 files changed, 228 insertions(+), 76 deletions(-) diff --git a/desc/optimize/_constraint_wrappers.py b/desc/optimize/_constraint_wrappers.py index b33fbcf536..5503a39e57 100644 --- a/desc/optimize/_constraint_wrappers.py +++ b/desc/optimize/_constraint_wrappers.py @@ -1110,7 +1110,7 @@ def jit_if_not_parallel(func): @functools.wraps(func) def wrapper(*args, **kwargs): obj = args[0] - if getattr(obj, "_is_multi_device", False): + if not getattr(obj, "_is_multi_device", False): # Apply jit if jittable jitted_func = functools.partial(jit, static_argnames=["op"])(func) return jitted_func(*args, **kwargs) @@ -1144,6 +1144,9 @@ def fun(Fx, dxdc, dc, unfixed_idx, Z, D): def _proximal_jvp_blocked_pure(objective, vgs, xgs, op): out = [] for k, (obj, const) in enumerate(zip(objective.objectives, objective.constants)): + # TODO: this is for debugging purposes, must be deleted before merging! + if objective._is_multi_device: + print(f"This should run on GPU id:{obj._device_id}") thing_idx = objective._things_per_objective_idx[k] xi = [xgs[i] for i in thing_idx] vi = [vgs[i] for i in thing_idx] diff --git a/docs/notebooks/tutorials/multi_device.ipynb b/docs/notebooks/tutorials/multi_device.ipynb index b0b5e2f40d..df1bc9d14c 100644 --- a/docs/notebooks/tutorials/multi_device.ipynb +++ b/docs/notebooks/tutorials/multi_device.ipynb @@ -8,7 +8,8 @@ } }, "source": [ - "# Multi-Gpu Equilibrium Solve" + "# How to use Multiple Devices\n", + "## Solving Equilibrium" ] }, { @@ -30,7 +31,7 @@ "metadata": {}, "outputs": [], "source": [ - "num_device = 3\n", + "num_device = 2\n", "from desc import set_device\n", "\n", "set_device(\"gpu\", num_device=num_device)" @@ -45,22 +46,25 @@ "name": "stdout", "output_type": "stream", "text": [ - "DESC version 0.13.0+1523.ge2c0f7767.dirty,using JAX backend, jax version=0.4.38, jaxlib version=0.4.38, dtype=float64\n", - "CPU Info: AMD EPYC 7453 28-Core Processor CPU with 978.07 GB available memory\n", - "Using 3 device:\n", + "DESC version 0.13.0+1530.gb3e961fcc.dirty,using JAX backend, jax version=0.4.38, jaxlib version=0.4.38, dtype=float64\n", + "CPU Info: AMD EPYC 7453 28-Core Processor CPU with 968.37 GB available memory\n", + "Using 2 device:\n", "\t Device 0: NVIDIA A100-SXM4-40GB (id=0) with 40.00 GB available memory\n", - "\t Device 1: NVIDIA A100-SXM4-40GB (id=1) with 40.00 GB available memory\n", - "\t Device 2: NVIDIA A100-SXM4-40GB (id=2) with 40.00 GB available memory\n" + "\t Device 1: NVIDIA A100-SXM4-40GB (id=1) with 40.00 GB available memory\n" ] } ], "source": [ + "import numpy as np\n", + "\n", "from desc.examples import get\n", "from desc.objectives import *\n", "from desc.objectives.getters import *\n", "from desc.grid import LinearGrid\n", "from desc.backend import jnp\n", - "from desc.plotting import plot_grid" + "from desc.plotting import plot_grid\n", + "from desc.backend import jax\n", + "from desc.optimize import Optimizer" ] }, { @@ -81,7 +85,6 @@ "name": "stdout", "output_type": "stream", "text": [ - "Precomputing transforms\n", "Precomputing transforms\n", "Precomputing transforms\n" ] @@ -118,52 +121,44 @@ "Building objective: lambda gauge\n", "Building objective: axis R self consistency\n", "Building objective: axis Z self consistency\n", - "Timer: Objective build = 1.74 sec\n", - "Timer: Linear constraint projection build = 7.48 sec\n", + "Timer: Objective build = 1.87 sec\n", + "Timer: Linear constraint projection build = 7.52 sec\n", "Number of parameters: 1593\n", "Number of objectives: 34632\n", - "Timer: Initializing the optimization = 9.34 sec\n", + "Timer: Initializing the optimization = 9.51 sec\n", "\n", "Starting optimization\n", "Using method: lsq-exact\n", "This should run on GPU id:0\n", "This should run on GPU id:1\n", - "This should run on GPU id:2\n", " Iteration Total nfev Cost Cost reduction Step norm Optimality \n", - " 0 1 5.161e-07 1.557e-04 \n", + " 0 1 3.654e-07 1.803e-04 \n", "This should run on GPU id:0\n", "This should run on GPU id:1\n", - "This should run on GPU id:2\n", - " 1 5 2.629e-07 2.531e-07 3.371e-03 1.961e-04 \n", - "Warning: Maximum number of iterations has been exceeded.\n", - " Current function value: 2.629e-07\n", - " Total delta_x: 3.371e-03\n", + " 1 6 2.102e-07 1.552e-07 1.244e-03 5.327e-05 \n", + "Warning: Maximum number of function evaluations has been exceeded.\n", + " Current function value: 2.102e-07\n", + " Total delta_x: 1.244e-03\n", " Iterations: 1\n", - " Function evaluations: 5\n", + " Function evaluations: 6\n", " Jacobian evaluations: 2\n", - "Timer: Solution time = 28.5 sec\n", - "Timer: Avg time per step = 14.2 sec\n", + "Timer: Solution time = 27.0 sec\n", + "Timer: Avg time per step = 13.5 sec\n", "==============================================================================================================\n", " Start --> End\n", - "Total (sum of squares): 5.161e-07 --> 2.629e-07, \n", - "Maximum absolute Force error: 1.378e+02 --> 2.419e+02 (N)\n", - "Minimum absolute Force error: 1.059e-10 --> 1.060e-10 (N)\n", - "Average absolute Force error: 2.932e+01 --> 1.966e+01 (N)\n", - "Maximum absolute Force error: 1.108e-05 --> 1.946e-05 (normalized)\n", - "Minimum absolute Force error: 8.517e-18 --> 8.524e-18 (normalized)\n", - "Average absolute Force error: 2.358e-06 --> 1.581e-06 (normalized)\n", - "Maximum absolute Force error: 2.276e+02 --> 3.279e+02 (N)\n", - "Minimum absolute Force error: 1.271e-10 --> 1.282e-10 (N)\n", - "Average absolute Force error: 3.359e+01 --> 2.870e+01 (N)\n", - "Maximum absolute Force error: 1.831e-05 --> 2.637e-05 (normalized)\n", - "Minimum absolute Force error: 1.022e-17 --> 1.031e-17 (normalized)\n", - "Average absolute Force error: 2.702e-06 --> 2.308e-06 (normalized)\n", - "Maximum absolute Force error: 8.201e+03 --> 6.277e+03 (N)\n", - "Minimum absolute Force error: 1.635e-12 --> 3.597e-12 (N)\n", - "Average absolute Force error: 8.964e+01 --> 7.837e+01 (N)\n", - "Maximum absolute Force error: 6.596e-04 --> 5.048e-04 (normalized)\n", - "Minimum absolute Force error: 1.315e-19 --> 2.893e-19 (normalized)\n", - "Average absolute Force error: 7.209e-06 --> 6.303e-06 (normalized)\n", + "Total (sum of squares): 3.654e-07 --> 2.102e-07, \n", + "Maximum absolute Force error: 1.378e+02 --> 2.528e+02 (N)\n", + "Minimum absolute Force error: 1.059e-10 --> 1.059e-10 (N)\n", + "Average absolute Force error: 2.610e+01 --> 1.893e+01 (N)\n", + "Maximum absolute Force error: 1.108e-05 --> 2.033e-05 (normalized)\n", + "Minimum absolute Force error: 8.517e-18 --> 8.519e-18 (normalized)\n", + "Average absolute Force error: 2.099e-06 --> 1.522e-06 (normalized)\n", + "Maximum absolute Force error: 8.201e+03 --> 6.285e+03 (N)\n", + "Minimum absolute Force error: 1.635e-12 --> 2.274e-12 (N)\n", + "Average absolute Force error: 8.007e+01 --> 7.106e+01 (N)\n", + "Maximum absolute Force error: 6.596e-04 --> 5.055e-04 (normalized)\n", + "Minimum absolute Force error: 1.315e-19 --> 1.829e-19 (normalized)\n", + "Average absolute Force error: 6.440e-06 --> 5.715e-06 (normalized)\n", "R boundary error: 0.000e+00 --> 0.000e+00 (m)\n", "Z boundary error: 0.000e+00 --> 0.000e+00 (m)\n", "Fixed Psi error: 0.000e+00 --> 0.000e+00 (Wb)\n", @@ -185,17 +180,7 @@ "outputs": [ { "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -205,7 +190,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -223,7 +208,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "# Using other Objectives\n", + "## Using other Objectives\n", "Above we used the convenience function for force balance objective, but we can also other objectives with this approach. There are some extra steps you need to apply though." ] }, @@ -238,7 +223,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 9, "metadata": {}, "outputs": [ { @@ -246,20 +231,16 @@ "output_type": "stream", "text": [ "Precomputing transforms\n", - "Timer: Precomputing transforms = 103 ms\n", + "Timer: Precomputing transforms = 1.22 sec\n", "Precomputing transforms\n", - "Timer: Precomputing transforms = 104 ms\n", + "Timer: Precomputing transforms = 1.21 sec\n", "Precomputing transforms\n", - "Timer: Precomputing transforms = 124 ms\n", - "Timer: Objective build = 12.9 ms\n" + "Timer: Precomputing transforms = 1.23 sec\n", + "Timer: Objective build = 14.1 ms\n" ] } ], "source": [ - "import numpy as np\n", - "from desc.backend import jax\n", - "from desc.optimize import Optimizer\n", - "\n", "grid1 = LinearGrid(\n", " M=eq.M_grid, N=eq.N_grid, NFP=eq.NFP, rho=np.array([0.2, 0.4]), sym=True\n", ")\n", @@ -269,12 +250,12 @@ "\n", "obj1 = QuasisymmetryTwoTerm(eq=eq, helicity=(1, eq.NFP), grid=grid1, device_id=0)\n", "obj2 = QuasisymmetryTwoTerm(eq=eq, helicity=(1, eq.NFP), grid=grid2, device_id=1)\n", - "obj3 = AspectRatio(eq=eq, target=8, weight=100, device_id=2)\n", + "obj3 = AspectRatio(eq=eq, target=8, weight=100, device_id=1)\n", "\n", "objs = [obj1, obj2, obj3]\n", "for obji in objs:\n", " obji.build(verbose=3)\n", - " obji = jax.device_put(obji, jax.devices(\"gpu\")[obji._device_id])\n", + " obji = jax.device_put(obji, obji._device)\n", " obji.things[0] = eq\n", "\n", "objective = ObjectiveFunction(objs)\n", @@ -283,7 +264,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 10, "metadata": {}, "outputs": [], "source": [ @@ -305,13 +286,12 @@ " FixPressure(eq=eq),\n", " FixPsi(eq=eq),\n", ")\n", - "# TODO: implement for proximal\n", "optimizer = Optimizer(\"lsq-exact\")" ] }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 11, "metadata": {}, "outputs": [ { @@ -327,22 +307,22 @@ "Building objective: lambda gauge\n", "Building objective: axis R self consistency\n", "Building objective: axis Z self consistency\n", - "Timer: Objective build = 367 ms\n", - "Timer: Linear constraint projection build = 2.84 sec\n", + "Timer: Objective build = 385 ms\n", + "Timer: Linear constraint projection build = 3.30 sec\n", "Number of parameters: 1614\n", "Number of objectives: 1236\n", - "Timer: Initializing the optimization = 3.32 sec\n", + "Timer: Initializing the optimization = 3.80 sec\n", "\n", "Starting optimization\n", "Using method: lsq-exact\n", "This should run on GPU id:0\n", "This should run on GPU id:1\n", - "This should run on GPU id:2\n", + "This should run on GPU id:1\n", " Iteration Total nfev Cost Cost reduction Step norm Optimality \n", " 0 1 9.547e+04 3.162e+02 \n", "This should run on GPU id:0\n", "This should run on GPU id:1\n", - "This should run on GPU id:2\n", + "This should run on GPU id:1\n", " 1 6 4.883e+04 4.664e+04 5.955e+00 1.431e+02 \n", "Warning: Maximum number of function evaluations has been exceeded.\n", " Current function value: 4.883e+04\n", @@ -350,8 +330,8 @@ " Iterations: 1\n", " Function evaluations: 6\n", " Jacobian evaluations: 2\n", - "Timer: Solution time = 20.9 sec\n", - "Timer: Avg time per step = 10.4 sec\n", + "Timer: Solution time = 26.0 sec\n", + "Timer: Avg time per step = 13.0 sec\n", "==============================================================================================================\n", " Start --> End\n", "Total (sum of squares): 9.547e+04 --> 4.883e+04, \n", @@ -389,6 +369,175 @@ ");" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Optimization using Proximal Method" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [], + "source": [ + "eq = get(\"precise_QA\")\n", + "eq.change_resolution(12,12,12,24,24,24)" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Precomputing transforms\n", + "Timer: Precomputing transforms = 114 ms\n", + "Precomputing transforms\n", + "Timer: Precomputing transforms = 118 ms\n", + "Precomputing transforms\n", + "Timer: Precomputing transforms = 86.1 ms\n", + "Timer: Objective build = 10.5 ms\n" + ] + } + ], + "source": [ + "grid1 = LinearGrid(\n", + " M=eq.M_grid, N=eq.N_grid, NFP=eq.NFP, rho=jnp.linspace(0.2, 0.5, 4), sym=True\n", + ")\n", + "grid2 = LinearGrid(\n", + " M=eq.M_grid, N=eq.N_grid, NFP=eq.NFP, rho=jnp.linspace(0.6, 1.0, 6), sym=True\n", + ")\n", + "\n", + "obj1 = QuasisymmetryTwoTerm(eq=eq, helicity=(1, eq.NFP), grid=grid1, device_id=0)\n", + "obj2 = QuasisymmetryTwoTerm(eq=eq, helicity=(1, eq.NFP), grid=grid2, device_id=0)\n", + "obj3 = AspectRatio(eq=eq, target=8, weight=100, device_id=0)\n", + "\n", + "objs = [obj1, obj2, obj3]\n", + "for obji in objs:\n", + " obji.build(verbose=3)\n", + " obji = jax.device_put(obji, obji._device)\n", + " obji.things[0] = eq\n", + "\n", + "objective = ObjectiveFunction(objs)\n", + "objective.build(verbose=3)" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [], + "source": [ + "k = 12\n", + "R_modes = np.vstack(\n", + " (\n", + " [0, 0, 0],\n", + " eq.surface.R_basis.modes[\n", + " np.max(np.abs(eq.surface.R_basis.modes), 1) > k, :\n", + " ],\n", + " )\n", + ")\n", + "Z_modes = eq.surface.Z_basis.modes[\n", + " np.max(np.abs(eq.surface.Z_basis.modes), 1) > k, :\n", + "]\n", + "constraints = (\n", + " ForceBalance(eq=eq),\n", + " FixBoundaryR(eq=eq, modes=R_modes),\n", + " FixBoundaryZ(eq=eq, modes=Z_modes),\n", + " FixPressure(eq=eq),\n", + " FixPsi(eq=eq),\n", + " FixCurrent(eq=eq),\n", + ")\n", + "optimizer = Optimizer(\"proximal-lsq-exact\")" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Building objective: force\n", + "Precomputing transforms\n", + "Timer: Precomputing transforms = 133 ms\n", + "Timer: Objective build = 161 ms\n", + "Timer: Proximal projection build = 2.08 sec\n", + "Building objective: lcfs R\n", + "Building objective: lcfs Z\n", + "Building objective: fixed pressure\n", + "Building objective: fixed Psi\n", + "Building objective: fixed current\n", + "Timer: Objective build = 139 ms\n", + "Timer: Linear constraint projection build = 2.18 sec\n", + "Number of parameters: 624\n", + "Number of objectives: 12251\n", + "Timer: Initializing the optimization = 4.67 sec\n", + "\n", + "Starting optimization\n", + "Using method: proximal-lsq-exact\n", + " Iteration Total nfev Cost Cost reduction Step norm Optimality \n", + " 0 1 2.003e+04 1.949e+02 \n", + " 1 5 1.551e+04 4.515e+03 2.594e-02 1.685e+02 \n", + "Warning: Maximum number of iterations has been exceeded.\n", + " Current function value: 1.551e+04\n", + " Total delta_x: 2.594e-02\n", + " Iterations: 1\n", + " Function evaluations: 5\n", + " Jacobian evaluations: 2\n", + "Timer: Solution time = 1.89 min\n", + "Timer: Avg time per step = 56.9 sec\n", + "==============================================================================================================\n", + " Start --> End\n", + "Total (sum of squares): 2.003e+04 --> 1.551e+04, \n", + "Maximum absolute Quasi-symmetry (1,2) two-term error: 1.058e-01 --> 2.625e-01 (T^3)\n", + "Minimum absolute Quasi-symmetry (1,2) two-term error: 1.547e-05 --> 1.156e-05 (T^3)\n", + "Average absolute Quasi-symmetry (1,2) two-term error: 5.258e-02 --> 7.294e-02 (T^3)\n", + "Maximum absolute Quasi-symmetry (1,2) two-term error: 1.155e-01 --> 2.864e-01 (normalized)\n", + "Minimum absolute Quasi-symmetry (1,2) two-term error: 1.688e-05 --> 1.261e-05 (normalized)\n", + "Average absolute Quasi-symmetry (1,2) two-term error: 5.737e-02 --> 7.959e-02 (normalized)\n", + "Maximum absolute Quasi-symmetry (1,2) two-term error: 2.241e-01 --> 5.706e-01 (T^3)\n", + "Minimum absolute Quasi-symmetry (1,2) two-term error: 1.994e-05 --> 2.975e-05 (T^3)\n", + "Average absolute Quasi-symmetry (1,2) two-term error: 9.189e-02 --> 1.198e-01 (T^3)\n", + "Maximum absolute Quasi-symmetry (1,2) two-term error: 2.446e-01 --> 6.226e-01 (normalized)\n", + "Minimum absolute Quasi-symmetry (1,2) two-term error: 2.176e-05 --> 3.246e-05 (normalized)\n", + "Average absolute Quasi-symmetry (1,2) two-term error: 1.003e-01 --> 1.307e-01 (normalized)\n", + "Aspect ratio: 6.000e+00 --> 6.242e+00 (dimensionless)\n", + "Maximum absolute Force error: 1.757e+01 --> 4.893e+01 (N)\n", + "Minimum absolute Force error: 1.160e-05 --> 1.148e-04 (N)\n", + "Average absolute Force error: 3.140e-01 --> 6.310e-01 (N)\n", + "Maximum absolute Force error: 1.256e-05 --> 3.498e-05 (normalized)\n", + "Minimum absolute Force error: 8.291e-12 --> 8.205e-11 (normalized)\n", + "Average absolute Force error: 2.244e-07 --> 4.511e-07 (normalized)\n", + "R boundary error: 0.000e+00 --> 0.000e+00 (m)\n", + "Z boundary error: 0.000e+00 --> 0.000e+00 (m)\n", + "Fixed pressure profile error: 0.000e+00 --> 0.000e+00 (Pa)\n", + "Fixed Psi error: 0.000e+00 --> 0.000e+00 (Wb)\n", + "Fixed current profile error: 0.000e+00 --> 0.000e+00 (A)\n", + "==============================================================================================================\n" + ] + } + ], + "source": [ + "eq.optimize(\n", + " objective=objective,\n", + " constraints=constraints,\n", + " optimizer=optimizer,\n", + " maxiter=1,\n", + " verbose=3,\n", + " options={\n", + " \"initial_trust_ratio\": 1.0,\n", + " },\n", + ");" + ] + }, { "cell_type": "code", "execution_count": null, From 62e827ec8bdaabd935a3f4f1285b03c3c8fd0dff Mon Sep 17 00:00:00 2001 From: YigitElma Date: Thu, 13 Feb 2025 20:16:24 -0500 Subject: [PATCH 73/75] implement multicpu, add a test, need to make it work tho --- desc/__init__.py | 56 ++- desc/backend.py | 17 +- desc/objectives/getters.py | 15 +- desc/objectives/objective_funs.py | 28 +- docs/notebooks/tutorials/multi_device.ipynb | 445 +++++++++++++------- setup.cfg | 1 + tests/test_multidevice.py | 63 +++ 7 files changed, 446 insertions(+), 179 deletions(-) create mode 100644 tests/test_multidevice.py diff --git a/desc/__init__.py b/desc/__init__.py index 4aa8da27e6..37428255e3 100644 --- a/desc/__init__.py +++ b/desc/__init__.py @@ -81,7 +81,39 @@ def _get_processor_name(): return "" -def set_device(kind="cpu", gpuid=None, num_device=1): +def _set_cpu_count(n): + """Set the number of CPUs visible to JAX. + + By default, JAX sees the whole CPU as a single device, regardless of the number of + cores or threads. It then uses multiple cores and threads for lower level + parallelism within individual operations. + + Alternatively, you can force JAX to expose a given number of "virtual" CPUs that + can then be used manually for higher level parallelism (as in at the level of + multiple objective functions.) + + This function is mainly for testing on CI purposes of the parallelism in DESC. + + Parameters + ---------- + n : int + Number of virtual CPUs for high level parallelism. + + Notes + ----- + This function must be called before importing anything else from DESC or JAX, + and before calling ``desc.set_device``, otherwise it will have no effect. + """ + xla_flags = os.getenv("XLA_FLAGS", "") + xla_flags = re.sub( + r"--xla_force_host_platform_device_count=\S+", "", xla_flags + ).split() + os.environ["XLA_FLAGS"] = " ".join( + [f"--xla_force_host_platform_device_count={n}"] + xla_flags + ) + + +def set_device(kind="cpu", gpuid=None, num_device=1): # noqa: C901 """Sets the device to use for computation. If kind==``'gpu'`` and a gpuid is specified, uses the specified GPU. If @@ -105,10 +137,6 @@ def set_device(kind="cpu", gpuid=None, num_device=1): number of devices to use. Default is 1. """ - if kind == "cpu" and num_device > 1: - # TODO: implement multi-CPU support - raise ValueError("Cannot request multiple CPUs") - config["kind"] = kind config["num_device"] = num_device @@ -120,8 +148,22 @@ def set_device(kind="cpu", gpuid=None, num_device=1): if kind == "cpu": os.environ["JAX_PLATFORMS"] = "cpu" os.environ["CUDA_VISIBLE_DEVICES"] = "" - config["devices"] = [f"{cpu_info} CPU"] - config["avail_mems"] = [cpu_mem] + if num_device == 1: + config["devices"] = [f"{cpu_info} CPU"] + config["avail_mems"] = [cpu_mem] + else: + try: + import jax + + jax_cpu = jax.devices("cpu") + assert len(jax_cpu) == num_device + config["devices"] = [f"{dev}" for dev in jax_cpu] + config["avail_mems"] = [cpu_mem for _ in range(num_device)] + except ModuleNotFoundError: + raise ValueError( + "JAX not installed. Please install JAX to use multiple CPUs." + "Alternatively, set num_device=1 to use a single CPU." + ) elif kind == "gpu": os.environ["CUDA_DEVICE_ORDER"] = "PCI_BUS_ID" diff --git a/desc/backend.py b/desc/backend.py index 4665f291ce..96e04a6b2d 100644 --- a/desc/backend.py +++ b/desc/backend.py @@ -69,10 +69,19 @@ ) ) -print( - f"CPU Info: {desc_config['cpu_info']} with {desc_config['cpu_mem']:.2f} " - "GB available memory" -) +if desc_config["num_device"] == 1: + print( + f"CPU Info: {desc_config['cpu_info']} with {desc_config['cpu_mem']:.2f} " + "GB available memory" + ) +elif desc_config["kind"] == "cpu": + print(f"Using {desc_config['num_device']} CPUs:") + for i, dev in enumerate(desc_config["devices"]): + print( + f"\t CPU {i}: {dev} with {desc_config['avail_mems'][i]:.2f} " + "GB available memory" + ) + if desc_config["kind"] == "gpu": print(f"Using {desc_config['num_device']} device:") for i, dev in enumerate(desc_config["devices"]): diff --git a/desc/objectives/getters.py b/desc/objectives/getters.py index f476de9648..fba28f78a3 100644 --- a/desc/objectives/getters.py +++ b/desc/objectives/getters.py @@ -346,9 +346,7 @@ def add_if_multiple(constraints, cls): return constraints -def get_parallel_forcebalance( - eq, num_device, grid=None, use_jit=True, check_device=True -): # pragma: no cover +def get_parallel_forcebalance(eq, num_device, grid=None, use_jit=True): """Get an ObjectiveFunction for parallel computing ForceBalance. Parameters @@ -367,15 +365,10 @@ def get_parallel_forcebalance( from desc.backend import desc_config, jax, jnp from desc.grid import LinearGrid - if desc_config["kind"] != "gpu": - raise ValueError( - "Parallel computing is only supported on GPU. " - "Please use DESC with GPU device." - ) - if desc_config["num_device"] != num_device and check_device: + if desc_config["num_device"] < num_device: raise ValueError( f"Number of devices in desc_config ({desc_config['num_device']}) " - f"does not match the number of devices in input ({num_device})." + f"is less than the number of devices in input ({num_device})." ) if grid is not None: if len(grid) != num_device: @@ -414,6 +407,6 @@ def get_parallel_forcebalance( # set the eq to be the same manually obj._things[0] = eq objs += (obj,) - objective = ObjectiveFunction(objs, deriv_mode="blocked") + objective = ObjectiveFunction(objs) objective.build(use_jit=use_jit) return objective diff --git a/desc/objectives/objective_funs.py b/desc/objectives/objective_funs.py index db0ed9df47..d8560210a7 100644 --- a/desc/objectives/objective_funs.py +++ b/desc/objectives/objective_funs.py @@ -349,7 +349,7 @@ def build(self, use_jit=None, verbose=1): # noqa: C901 errorif( isposint(self._jac_chunk_size) and self._deriv_mode in ["auto", "blocked"], ValueError, - "'jac_chunk_size' was passed into ObjectiveFunction, but the " + "\n'jac_chunk_size' was passed into ObjectiveFunction, but the \n" "ObjectiveFunction is not using 'batched' deriv_mode", ) sub_obj_jac_chunk_sizes_are_ints = [ @@ -358,11 +358,11 @@ def build(self, use_jit=None, verbose=1): # noqa: C901 errorif( any(sub_obj_jac_chunk_sizes_are_ints) and self._deriv_mode == "batched", ValueError, - "'jac_chunk_size' was passed into one or more sub-objectives, but the" - " ObjectiveFunction is using 'batched' deriv_mode, so sub-objective " - "'jac_chunk_size' will be ignored in favor of the ObjectiveFunction's " - f"'jac_chunk_size' of {self._jac_chunk_size}." - " Specify 'blocked' deriv_mode if each sub-objective is desired to have a " + "\n'jac_chunk_size' was passed into one or more sub-objectives, but the\n" + " ObjectiveFunction is using 'batched' deriv_mode, so sub-objective \n" + "'jac_chunk_size' will be ignored in favor of the ObjectiveFunction's \n" + f"'jac_chunk_size' of {self._jac_chunk_size}.\n" + " Specify 'blocked' deriv_mode if each sub-objective is desired to have a\n" "different 'jac_chunk_size' for its Jacobian computation.", ) @@ -372,11 +372,15 @@ def build(self, use_jit=None, verbose=1): # noqa: C901 else: self._deriv_mode = "blocked" - if self._is_multi_device and self._deriv_mode != "blocked": - raise ValueError( - "When using multiple GPUs, the deriv_mode must be set to 'blocked'. " - "When you are creating the ObjectiveFunction, set deriv_mode='blocked'." - ) + warnif( + self._is_multi_device and self._deriv_mode != "blocked", + UserWarning, + "\nWhen using multiple devices, the ObjectiveFunction will run each \n" + "sub-objective on the device specified in the sub-objective. \n" + "Setting the deriv_mode to 'blocked' to ensure that each sub-objective\n" + "runs on the correct device.", + ) + self._deriv_mode != "blocked" if self._jac_chunk_size == "auto": # Heuristic estimates of fwd mode Jacobian memory usage, @@ -762,7 +766,7 @@ def _jvp_blocked(self, v, x, constants=None, op="scaled"): for k, (obj, const) in enumerate(zip(self.objectives, constants)): # TODO: this is for debugging purposes, must be deleted before merging! if self._is_multi_device: - print(f"This should run on GPU id:{obj._device_id}") + print(f"This should run on device id:{obj._device_id}") # get the xs that go to that objective thing_idx = self._things_per_objective_idx[k] xi = [xs[i] for i in thing_idx] diff --git a/docs/notebooks/tutorials/multi_device.ipynb b/docs/notebooks/tutorials/multi_device.ipynb index df1bc9d14c..b8ce359801 100644 --- a/docs/notebooks/tutorials/multi_device.ipynb +++ b/docs/notebooks/tutorials/multi_device.ipynb @@ -31,10 +31,11 @@ "metadata": {}, "outputs": [], "source": [ - "num_device = 2\n", - "from desc import set_device\n", + "num_device = 4\n", + "from desc import set_device, _set_cpu_count\n", "\n", - "set_device(\"gpu\", num_device=num_device)" + "_set_cpu_count(num_device)\n", + "set_device(\"cpu\", num_device=num_device)" ] }, { @@ -46,11 +47,12 @@ "name": "stdout", "output_type": "stream", "text": [ - "DESC version 0.13.0+1530.gb3e961fcc.dirty,using JAX backend, jax version=0.4.38, jaxlib version=0.4.38, dtype=float64\n", - "CPU Info: AMD EPYC 7453 28-Core Processor CPU with 968.37 GB available memory\n", - "Using 2 device:\n", - "\t Device 0: NVIDIA A100-SXM4-40GB (id=0) with 40.00 GB available memory\n", - "\t Device 1: NVIDIA A100-SXM4-40GB (id=1) with 40.00 GB available memory\n" + "DESC version 0.13.0+1539.gb6b43370b.dirty,using JAX backend, jax version=0.4.38, jaxlib version=0.4.38, dtype=float64\n", + "Using 4 CPUs:\n", + "\t CPU 0: TFRT_CPU_0 with 6.26 GB available memory\n", + "\t CPU 1: TFRT_CPU_1 with 6.26 GB available memory\n", + "\t CPU 2: TFRT_CPU_2 with 6.26 GB available memory\n", + "\t CPU 3: TFRT_CPU_3 with 6.26 GB available memory\n" ] } ], @@ -71,9 +73,19 @@ "cell_type": "code", "execution_count": 4, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/yigit/Codes/DESC/desc/utils.py:560: UserWarning: Reducing radial (L) resolution can make plasma boundary inconsistent. Recommend calling `eq.surface = eq.get_surface_at(rho=1.0)`\n", + " warnings.warn(colored(msg, \"yellow\"), err)\n" + ] + } + ], "source": [ - "eq = get(\"HELIOTRON\")" + "eq = get(\"HELIOTRON\")\n", + "eq.change_resolution(3, 3, 3, 6, 6, 6)" ] }, { @@ -85,14 +97,40 @@ "name": "stdout", "output_type": "stream", "text": [ + "Precomputing transforms\n", + "Precomputing transforms\n", "Precomputing transforms\n", "Precomputing transforms\n" ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/yigit/Codes/DESC/desc/utils.py:560: UserWarning: \n", + "When using multiple devices, the ObjectiveFunction will run each \n", + "sub-objective on the device specified in the sub-objective. \n", + "Setting the deriv_mode to 'blocked' to ensure that each sub-objective \n", + "runs on the correct device.\n", + " warnings.warn(colored(msg, \"yellow\"), err)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "None\n", + "TFRT_CPU_1\n", + "TFRT_CPU_2\n", + "TFRT_CPU_3\n" + ] } ], "source": [ - "obj = get_parallel_forcebalance(eq, num_device=num_device, check_device=False)\n", - "cons = get_fixed_boundary_constraints(eq)" + "obj = get_parallel_forcebalance(eq, num_device=num_device)\n", + "cons = get_fixed_boundary_constraints(eq)\n", + "for obji in obj.objectives:\n", + " print(obji._device)" ] }, { @@ -121,44 +159,52 @@ "Building objective: lambda gauge\n", "Building objective: axis R self consistency\n", "Building objective: axis Z self consistency\n", - "Timer: Objective build = 1.87 sec\n", - "Timer: Linear constraint projection build = 7.52 sec\n", - "Number of parameters: 1593\n", - "Number of objectives: 34632\n", - "Timer: Initializing the optimization = 9.51 sec\n", + "Timer: Objective build = 1.53 sec\n", + "Timer: Linear constraint projection build = 3.80 sec\n", + "Number of parameters: 76\n", + "Number of objectives: 2704\n", + "Timer: Initializing the optimization = 5.36 sec\n", "\n", "Starting optimization\n", "Using method: lsq-exact\n", - "This should run on GPU id:0\n", - "This should run on GPU id:1\n", " Iteration Total nfev Cost Cost reduction Step norm Optimality \n", - " 0 1 3.654e-07 1.803e-04 \n", - "This should run on GPU id:0\n", - "This should run on GPU id:1\n", - " 1 6 2.102e-07 1.552e-07 1.244e-03 5.327e-05 \n", - "Warning: Maximum number of function evaluations has been exceeded.\n", - " Current function value: 2.102e-07\n", - " Total delta_x: 1.244e-03\n", + " 0 1 8.573e+06 4.135e+03 \n", + " 1 2 7.294e+05 7.844e+06 5.352e-01 6.490e+02 \n", + "Warning: Maximum number of iterations has been exceeded.\n", + " Current function value: 7.294e+05\n", + " Total delta_x: 5.352e-01\n", " Iterations: 1\n", - " Function evaluations: 6\n", + " Function evaluations: 2\n", " Jacobian evaluations: 2\n", - "Timer: Solution time = 27.0 sec\n", - "Timer: Avg time per step = 13.5 sec\n", + "Timer: Solution time = 13.4 sec\n", + "Timer: Avg time per step = 6.73 sec\n", "==============================================================================================================\n", " Start --> End\n", - "Total (sum of squares): 3.654e-07 --> 2.102e-07, \n", - "Maximum absolute Force error: 1.378e+02 --> 2.528e+02 (N)\n", - "Minimum absolute Force error: 1.059e-10 --> 1.059e-10 (N)\n", - "Average absolute Force error: 2.610e+01 --> 1.893e+01 (N)\n", - "Maximum absolute Force error: 1.108e-05 --> 2.033e-05 (normalized)\n", - "Minimum absolute Force error: 8.517e-18 --> 8.519e-18 (normalized)\n", - "Average absolute Force error: 2.099e-06 --> 1.522e-06 (normalized)\n", - "Maximum absolute Force error: 8.201e+03 --> 6.285e+03 (N)\n", - "Minimum absolute Force error: 1.635e-12 --> 2.274e-12 (N)\n", - "Average absolute Force error: 8.007e+01 --> 7.106e+01 (N)\n", - "Maximum absolute Force error: 6.596e-04 --> 5.055e-04 (normalized)\n", - "Minimum absolute Force error: 1.315e-19 --> 1.829e-19 (normalized)\n", - "Average absolute Force error: 6.440e-06 --> 5.715e-06 (normalized)\n", + "Total (sum of squares): 2.844e+10 --> 7.294e+05, \n", + "Maximum absolute Force error: 2.650e+05 --> 1.299e+05 (N)\n", + "Minimum absolute Force error: 1.534e-10 --> 1.681e-10 (N)\n", + "Average absolute Force error: 9.802e+04 --> 4.428e+04 (N)\n", + "Maximum absolute Force error: 2.131e-02 --> 1.045e-02 (normalized)\n", + "Minimum absolute Force error: 1.234e-17 --> 1.352e-17 (normalized)\n", + "Average absolute Force error: 7.883e-03 --> 3.561e-03 (normalized)\n", + "Maximum absolute Force error: 4.785e+05 --> 3.814e+05 (N)\n", + "Minimum absolute Force error: 1.889e-10 --> 1.945e-10 (N)\n", + "Average absolute Force error: 1.791e+05 --> 1.171e+05 (N)\n", + "Maximum absolute Force error: 3.848e-02 --> 3.067e-02 (normalized)\n", + "Minimum absolute Force error: 1.519e-17 --> 1.565e-17 (normalized)\n", + "Average absolute Force error: 1.441e-02 --> 9.422e-03 (normalized)\n", + "Maximum absolute Force error: 8.926e+06 --> 2.599e+06 (N)\n", + "Minimum absolute Force error: 9.420e-11 --> 1.601e-10 (N)\n", + "Average absolute Force error: 4.594e+05 --> 1.831e+05 (N)\n", + "Maximum absolute Force error: 7.178e-01 --> 2.091e-01 (normalized)\n", + "Minimum absolute Force error: 7.576e-18 --> 1.287e-17 (normalized)\n", + "Average absolute Force error: 3.695e-02 --> 1.473e-02 (normalized)\n", + "Maximum absolute Force error: 6.431e+12 --> 2.805e+10 (N)\n", + "Minimum absolute Force error: 7.111e-13 --> 5.213e-11 (N)\n", + "Average absolute Force error: 4.122e+09 --> 3.074e+07 (N)\n", + "Maximum absolute Force error: 5.172e+05 --> 2.256e+03 (normalized)\n", + "Minimum absolute Force error: 5.719e-20 --> 4.193e-18 (normalized)\n", + "Average absolute Force error: 3.315e+02 --> 2.472e+00 (normalized)\n", "R boundary error: 0.000e+00 --> 0.000e+00 (m)\n", "Z boundary error: 0.000e+00 --> 0.000e+00 (m)\n", "Fixed Psi error: 0.000e+00 --> 0.000e+00 (Wb)\n", @@ -167,10 +213,33 @@ "Fixed sheet current error: 0.000e+00 --> 0.000e+00 (~)\n", "==============================================================================================================\n" ] + }, + { + "data": { + "text/plain": [ + "(Equilibrium at 0x7e5726b83f50 (L=3, M=3, N=3, NFP=19, sym=True, spectral_indexing=fringe),\n", + " message: Maximum number of iterations has been exceeded.\n", + " success: False\n", + " fun: [-9.316e-05 -9.293e-05 ... 2.140e-02 -4.778e-03]\n", + " x: [-2.477e-02 -1.206e-01 ... 7.442e-03 1.768e-01]\n", + " nit: 1\n", + " cost: 729415.2017973666\n", + " v: [ 1.000e+00 1.000e+00 ... 1.000e+00 1.000e+00]\n", + " optimality: 649.0096310587396\n", + " nfev: 2\n", + " njev: 2\n", + " allx: [Array([-3.392e-05, 8.921e-06, ..., 0.000e+00, 0.000e+00], dtype=float64), Array([ 2.416e-05, 1.501e-03, ..., 0.000e+00, 0.000e+00], dtype=float64)]\n", + " alltr: [Array( 1.402e+06, dtype=float64), np.float64(1401525.8219770438)]\n", + " history: [[{'R_lmn': Array([-3.392e-05, 8.921e-06, ..., 0.000e+00, 1.850e-05], dtype=float64), 'Z_lmn': Array([ 9.011e-06, 1.167e-05, ..., -3.697e-05, 1.686e-05], dtype=float64), 'L_lmn': Array([-6.194e-07, -1.567e-05, ..., -9.721e-06, -1.466e-05], dtype=float64), 'p_l': Array([ 1.800e+04, -3.600e+04, ..., 0.000e+00, 0.000e+00], dtype=float64), 'i_l': Array([ 1.000e+00, 1.500e+00, ..., 0.000e+00, 0.000e+00], dtype=float64), 'c_l': Array([], shape=(0,), dtype=float64), 'Psi': Array([ 1.000e+00], dtype=float64), 'Te_l': Array([], shape=(0,), dtype=float64), 'ne_l': Array([], shape=(0,), dtype=float64), 'Ti_l': Array([], shape=(0,), dtype=float64), 'Zeff_l': Array([], shape=(0,), dtype=float64), 'a_lmn': Array([], shape=(0,), dtype=float64), 'Ra_n': Array([ 1.039e+01, 1.019e-01, 1.330e-03, 1.737e-05], dtype=float64), 'Za_n': Array([ 1.802e-05, 1.335e-03, 9.939e-02], dtype=float64), 'Rb_lmn': Array([ 0.000e+00, 0.000e+00, ..., 0.000e+00, 0.000e+00], dtype=float64), 'Zb_lmn': Array([ 0.000e+00, 0.000e+00, ..., 0.000e+00, 0.000e+00], dtype=float64), 'I': Array([], shape=(0,), dtype=float64), 'G': Array([], shape=(0,), dtype=float64), 'Phi_mn': Array([], shape=(0,), dtype=float64)}], [{'R_lmn': Array([ 2.416e-05, 1.501e-03, ..., 0.000e+00, 1.858e-03], dtype=float64), 'Z_lmn': Array([-7.446e-04, -3.249e-04, ..., 1.482e-03, 1.084e-03], dtype=float64), 'L_lmn': Array([-2.244e-04, -7.899e-04, ..., 9.491e-04, -7.183e-04], dtype=float64), 'p_l': Array([ 1.800e+04, -3.600e+04, ..., 0.000e+00, 0.000e+00], dtype=float64), 'i_l': Array([ 1.000e+00, 1.500e+00, ..., 0.000e+00, 0.000e+00], dtype=float64), 'c_l': Array([], shape=(0,), dtype=float64), 'Psi': Array([ 1.000e+00], dtype=float64), 'Te_l': Array([], shape=(0,), dtype=float64), 'ne_l': Array([], shape=(0,), dtype=float64), 'Ti_l': Array([], shape=(0,), dtype=float64), 'Zeff_l': Array([], shape=(0,), dtype=float64), 'a_lmn': Array([], shape=(0,), dtype=float64), 'Ra_n': Array([ 1.031e+01, 8.864e-02, -1.262e-02, -5.261e-04], dtype=float64), 'Za_n': Array([-1.489e-03, 2.919e-03, 1.679e-01], dtype=float64), 'Rb_lmn': Array([ 0.000e+00, 0.000e+00, ..., 0.000e+00, 0.000e+00], dtype=float64), 'Zb_lmn': Array([ 0.000e+00, 0.000e+00, ..., 0.000e+00, 0.000e+00], dtype=float64), 'I': Array([], shape=(0,), dtype=float64), 'G': Array([], shape=(0,), dtype=float64), 'Phi_mn': Array([], shape=(0,), dtype=float64)}]])" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" } ], "source": [ - "eq.solve(objective=obj, constraints=cons, maxiter=1, ftol=0, gtol=0, xtol=0, verbose=3);" + "eq.solve(objective=obj, constraints=cons, maxiter=1, ftol=0, gtol=0, xtol=0, verbose=3)" ] }, { @@ -180,9 +249,29 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -190,9 +279,9 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -216,9 +305,19 @@ "cell_type": "code", "execution_count": 8, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/yigit/Codes/DESC/desc/utils.py:560: UserWarning: Reducing radial (L) resolution can make plasma boundary inconsistent. Recommend calling `eq.surface = eq.get_surface_at(rho=1.0)`\n", + " warnings.warn(colored(msg, \"yellow\"), err)\n" + ] + } + ], "source": [ - "eq = get(\"HELIOTRON\")" + "eq = get(\"HELIOTRON\")\n", + "eq.change_resolution(3, 3, 3, 6, 6, 6)" ] }, { @@ -231,12 +330,12 @@ "output_type": "stream", "text": [ "Precomputing transforms\n", - "Timer: Precomputing transforms = 1.22 sec\n", + "Timer: Precomputing transforms = 606 ms\n", "Precomputing transforms\n", - "Timer: Precomputing transforms = 1.21 sec\n", + "Timer: Precomputing transforms = 684 ms\n", "Precomputing transforms\n", - "Timer: Precomputing transforms = 1.23 sec\n", - "Timer: Objective build = 14.1 ms\n" + "Timer: Precomputing transforms = 681 ms\n", + "Timer: Objective build = 6.35 ms\n" ] } ], @@ -272,14 +371,10 @@ "R_modes = np.vstack(\n", " (\n", " [0, 0, 0],\n", - " eq.surface.R_basis.modes[\n", - " np.max(np.abs(eq.surface.R_basis.modes), 1) > k, :\n", - " ],\n", + " eq.surface.R_basis.modes[np.max(np.abs(eq.surface.R_basis.modes), 1) > k, :],\n", " )\n", ")\n", - "Z_modes = eq.surface.Z_basis.modes[\n", - " np.max(np.abs(eq.surface.Z_basis.modes), 1) > k, :\n", - "]\n", + "Z_modes = eq.surface.Z_basis.modes[np.max(np.abs(eq.surface.Z_basis.modes), 1) > k, :]\n", "constraints = (\n", " FixBoundaryR(eq=eq, modes=R_modes),\n", " FixBoundaryZ(eq=eq, modes=Z_modes),\n", @@ -307,11 +402,11 @@ "Building objective: lambda gauge\n", "Building objective: axis R self consistency\n", "Building objective: axis Z self consistency\n", - "Timer: Objective build = 385 ms\n", - "Timer: Linear constraint projection build = 3.30 sec\n", - "Number of parameters: 1614\n", - "Number of objectives: 1236\n", - "Timer: Initializing the optimization = 3.80 sec\n", + "Timer: Objective build = 274 ms\n", + "Timer: Linear constraint projection build = 1.74 sec\n", + "Number of parameters: 97\n", + "Number of objectives: 456\n", + "Timer: Initializing the optimization = 2.04 sec\n", "\n", "Starting optimization\n", "Using method: lsq-exact\n", @@ -319,41 +414,64 @@ "This should run on GPU id:1\n", "This should run on GPU id:1\n", " Iteration Total nfev Cost Cost reduction Step norm Optimality \n", - " 0 1 9.547e+04 3.162e+02 \n", + " 0 1 1.561e+22 1.767e+11 \n", "This should run on GPU id:0\n", "This should run on GPU id:1\n", "This should run on GPU id:1\n", - " 1 6 4.883e+04 4.664e+04 5.955e+00 1.431e+02 \n", - "Warning: Maximum number of function evaluations has been exceeded.\n", - " Current function value: 4.883e+04\n", - " Total delta_x: 5.955e+00\n", + " 1 5 5.466e+21 1.014e+22 2.003e+01 1.046e+11 \n", + "Warning: Maximum number of iterations has been exceeded.\n", + " Current function value: 5.466e+21\n", + " Total delta_x: 2.003e+01\n", " Iterations: 1\n", - " Function evaluations: 6\n", + " Function evaluations: 5\n", " Jacobian evaluations: 2\n", - "Timer: Solution time = 26.0 sec\n", - "Timer: Avg time per step = 13.0 sec\n", + "Timer: Solution time = 8.54 sec\n", + "Timer: Avg time per step = 4.27 sec\n", "==============================================================================================================\n", " Start --> End\n", - "Total (sum of squares): 9.547e+04 --> 4.883e+04, \n", - "Maximum absolute Quasi-symmetry (1,19) two-term error: 5.074e-01 --> 1.932e-01 (T^3)\n", - "Minimum absolute Quasi-symmetry (1,19) two-term error: 9.317e-06 --> 1.989e-05 (T^3)\n", - "Average absolute Quasi-symmetry (1,19) two-term error: 1.363e-01 --> 2.698e-02 (T^3)\n", - "Maximum absolute Quasi-symmetry (1,19) two-term error: 8.055e+00 --> 3.067e+00 (normalized)\n", - "Minimum absolute Quasi-symmetry (1,19) two-term error: 1.479e-04 --> 3.158e-04 (normalized)\n", - "Average absolute Quasi-symmetry (1,19) two-term error: 2.165e+00 --> 4.283e-01 (normalized)\n", - "Maximum absolute Quasi-symmetry (1,19) two-term error: 1.686e+00 --> 1.997e+00 (T^3)\n", - "Minimum absolute Quasi-symmetry (1,19) two-term error: 1.764e-04 --> 9.557e-05 (T^3)\n", - "Average absolute Quasi-symmetry (1,19) two-term error: 4.168e-01 --> 2.352e-01 (T^3)\n", - "Maximum absolute Quasi-symmetry (1,19) two-term error: 2.676e+01 --> 3.170e+01 (normalized)\n", - "Minimum absolute Quasi-symmetry (1,19) two-term error: 2.800e-03 --> 1.517e-03 (normalized)\n", - "Average absolute Quasi-symmetry (1,19) two-term error: 6.616e+00 --> 3.733e+00 (normalized)\n", - "Aspect ratio: 1.048e+01 --> 1.004e+01 (dimensionless)\n", + "Total (sum of squares): 5.469e+26 --> 5.466e+21, \n", + "Maximum absolute Quasi-symmetry (1,19) two-term error: 5.015e-01 --> 1.664e-01 (T^3)\n", + "Minimum absolute Quasi-symmetry (1,19) two-term error: 1.219e-03 --> 7.828e-04 (T^3)\n", + "Average absolute Quasi-symmetry (1,19) two-term error: 1.947e-01 --> 6.795e-02 (T^3)\n", + "Maximum absolute Quasi-symmetry (1,19) two-term error: 7.961e+00 --> 2.641e+00 (normalized)\n", + "Minimum absolute Quasi-symmetry (1,19) two-term error: 1.935e-02 --> 1.243e-02 (normalized)\n", + "Average absolute Quasi-symmetry (1,19) two-term error: 3.091e+00 --> 1.079e+00 (normalized)\n", + "Maximum absolute Quasi-symmetry (1,19) two-term error: 2.906e+12 --> 9.188e+09 (T^3)\n", + "Minimum absolute Quasi-symmetry (1,19) two-term error: 1.348e-03 --> 2.568e-04 (T^3)\n", + "Average absolute Quasi-symmetry (1,19) two-term error: 3.194e+09 --> 1.010e+07 (T^3)\n", + "Maximum absolute Quasi-symmetry (1,19) two-term error: 4.614e+13 --> 1.459e+11 (normalized)\n", + "Minimum absolute Quasi-symmetry (1,19) two-term error: 2.141e-02 --> 4.077e-03 (normalized)\n", + "Average absolute Quasi-symmetry (1,19) two-term error: 5.070e+10 --> 1.603e+08 (normalized)\n", + "Aspect ratio: 1.053e+01 --> 8.876e+00 (dimensionless)\n", "R boundary error: 0.000e+00 --> 0.000e+00 (m)\n", "Z boundary error: 0.000e+00 --> 0.000e+00 (m)\n", "Fixed pressure profile error: 0.000e+00 --> 0.000e+00 (Pa)\n", "Fixed Psi error: 0.000e+00 --> 0.000e+00 (Wb)\n", "==============================================================================================================\n" ] + }, + { + "data": { + "text/plain": [ + "(Equilibrium at 0x7e56a13c7140 (L=3, M=3, N=3, NFP=19, sym=True, spectral_indexing=fringe),\n", + " message: Maximum number of iterations has been exceeded.\n", + " success: False\n", + " fun: [ 3.114e-01 9.780e-01 ... 6.524e+02 8.763e+01]\n", + " x: [-1.118e-01 5.238e-02 ... 1.617e+00 -2.211e-01]\n", + " nit: 1\n", + " cost: 5.465705943561737e+21\n", + " v: [ 1.000e+00 1.000e+00 ... 1.000e+00 1.000e+00]\n", + " optimality: 104553392458.05392\n", + " nfev: 5\n", + " njev: 2\n", + " allx: [Array([-3.392e-05, 8.921e-06, ..., 0.000e+00, 0.000e+00], dtype=float64), Array([-4.503e-05, -1.034e-03, ..., 0.000e+00, 0.000e+00], dtype=float64)]\n", + " alltr: [Array( 2.307e+16, dtype=float64), np.float64(5767465574622139.0), np.float64(1441866393655534.8), np.float64(360466598413883.75), np.float64(360466598413883.75)]\n", + " history: [[{'R_lmn': Array([-3.392e-05, 8.921e-06, ..., 0.000e+00, 1.850e-05], dtype=float64), 'Z_lmn': Array([ 9.011e-06, 1.167e-05, ..., -3.697e-05, 1.686e-05], dtype=float64), 'L_lmn': Array([-6.194e-07, -1.567e-05, ..., -9.721e-06, -1.466e-05], dtype=float64), 'p_l': Array([ 1.800e+04, -3.600e+04, ..., 0.000e+00, 0.000e+00], dtype=float64), 'i_l': Array([ 1.000e+00, 1.500e+00, ..., 0.000e+00, 0.000e+00], dtype=float64), 'c_l': Array([], shape=(0,), dtype=float64), 'Psi': Array([ 1.000e+00], dtype=float64), 'Te_l': Array([], shape=(0,), dtype=float64), 'ne_l': Array([], shape=(0,), dtype=float64), 'Ti_l': Array([], shape=(0,), dtype=float64), 'Zeff_l': Array([], shape=(0,), dtype=float64), 'a_lmn': Array([], shape=(0,), dtype=float64), 'Ra_n': Array([ 1.039e+01, 1.019e-01, 1.330e-03, 1.737e-05], dtype=float64), 'Za_n': Array([ 1.802e-05, 1.335e-03, 9.939e-02], dtype=float64), 'Rb_lmn': Array([ 0.000e+00, 0.000e+00, ..., 0.000e+00, 0.000e+00], dtype=float64), 'Zb_lmn': Array([ 0.000e+00, 0.000e+00, ..., 0.000e+00, 0.000e+00], dtype=float64), 'I': Array([], shape=(0,), dtype=float64), 'G': Array([], shape=(0,), dtype=float64), 'Phi_mn': Array([], shape=(0,), dtype=float64)}], [{'R_lmn': Array([-4.503e-05, -1.034e-03, ..., 0.000e+00, -1.036e-03], dtype=float64), 'Z_lmn': Array([-4.761e-04, -1.745e-03, ..., 8.102e-04, -2.369e-04], dtype=float64), 'L_lmn': Array([-2.543e-03, -3.826e-03, ..., 3.800e-04, 7.083e-04], dtype=float64), 'p_l': Array([ 1.800e+04, -3.600e+04, ..., 0.000e+00, 0.000e+00], dtype=float64), 'i_l': Array([ 1.776e+00, -3.323e+00, ..., 3.407e+00, 3.810e+00], dtype=float64), 'c_l': Array([], shape=(0,), dtype=float64), 'Psi': Array([ 1.000e+00], dtype=float64), 'Te_l': Array([], shape=(0,), dtype=float64), 'ne_l': Array([], shape=(0,), dtype=float64), 'Ti_l': Array([], shape=(0,), dtype=float64), 'Zeff_l': Array([], shape=(0,), dtype=float64), 'a_lmn': Array([], shape=(0,), dtype=float64), 'Ra_n': Array([ 1.042e+01, 8.998e-02, -2.521e-03, 3.798e-04], dtype=float64), 'Za_n': Array([-9.521e-04, -1.837e-03, 7.433e-02], dtype=float64), 'Rb_lmn': Array([ 0.000e+00, 0.000e+00, ..., 0.000e+00, 0.000e+00], dtype=float64), 'Zb_lmn': Array([ 0.000e+00, 0.000e+00, ..., 0.000e+00, 0.000e+00], dtype=float64), 'I': Array([], shape=(0,), dtype=float64), 'G': Array([], shape=(0,), dtype=float64), 'Phi_mn': Array([], shape=(0,), dtype=float64)}]])" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" } ], "source": [ @@ -366,7 +484,7 @@ " options={\n", " \"initial_trust_ratio\": 1.0,\n", " },\n", - ");" + ")" ] }, { @@ -378,17 +496,27 @@ }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 12, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/yigit/Codes/DESC/desc/utils.py:560: UserWarning: Reducing radial (L) resolution can make plasma boundary inconsistent. Recommend calling `eq.surface = eq.get_surface_at(rho=1.0)`\n", + " warnings.warn(colored(msg, \"yellow\"), err)\n" + ] + } + ], "source": [ "eq = get(\"precise_QA\")\n", - "eq.change_resolution(12,12,12,24,24,24)" + "# eq.change_resolution(12, 12, 12, 24, 24, 24)\n", + "eq.change_resolution(3, 3, 3, 6, 6, 6)" ] }, { "cell_type": "code", - "execution_count": 24, + "execution_count": 13, "metadata": {}, "outputs": [ { @@ -396,12 +524,12 @@ "output_type": "stream", "text": [ "Precomputing transforms\n", - "Timer: Precomputing transforms = 114 ms\n", + "Timer: Precomputing transforms = 810 ms\n", "Precomputing transforms\n", - "Timer: Precomputing transforms = 118 ms\n", + "Timer: Precomputing transforms = 1.32 sec\n", "Precomputing transforms\n", - "Timer: Precomputing transforms = 86.1 ms\n", - "Timer: Objective build = 10.5 ms\n" + "Timer: Precomputing transforms = 407 ms\n", + "Timer: Objective build = 5.30 ms\n" ] } ], @@ -429,22 +557,18 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": 14, "metadata": {}, "outputs": [], "source": [ - "k = 12\n", + "k = 1\n", "R_modes = np.vstack(\n", " (\n", " [0, 0, 0],\n", - " eq.surface.R_basis.modes[\n", - " np.max(np.abs(eq.surface.R_basis.modes), 1) > k, :\n", - " ],\n", + " eq.surface.R_basis.modes[np.max(np.abs(eq.surface.R_basis.modes), 1) > k, :],\n", " )\n", ")\n", - "Z_modes = eq.surface.Z_basis.modes[\n", - " np.max(np.abs(eq.surface.Z_basis.modes), 1) > k, :\n", - "]\n", + "Z_modes = eq.surface.Z_basis.modes[np.max(np.abs(eq.surface.Z_basis.modes), 1) > k, :]\n", "constraints = (\n", " ForceBalance(eq=eq),\n", " FixBoundaryR(eq=eq, modes=R_modes),\n", @@ -458,7 +582,7 @@ }, { "cell_type": "code", - "execution_count": 26, + "execution_count": 15, "metadata": {}, "outputs": [ { @@ -467,62 +591,93 @@ "text": [ "Building objective: force\n", "Precomputing transforms\n", - "Timer: Precomputing transforms = 133 ms\n", - "Timer: Objective build = 161 ms\n", - "Timer: Proximal projection build = 2.08 sec\n", + "Timer: Precomputing transforms = 863 ms\n", + "Timer: Objective build = 1.08 sec\n", + "Timer: Proximal projection build = 4.83 sec\n", "Building objective: lcfs R\n", "Building objective: lcfs Z\n", "Building objective: fixed pressure\n", "Building objective: fixed Psi\n", "Building objective: fixed current\n", - "Timer: Objective build = 139 ms\n", - "Timer: Linear constraint projection build = 2.18 sec\n", - "Number of parameters: 624\n", - "Number of objectives: 12251\n", - "Timer: Initializing the optimization = 4.67 sec\n", + "Timer: Objective build = 232 ms\n", + "Timer: Linear constraint projection build = 1.11 sec\n", + "Number of parameters: 8\n", + "Number of objectives: 911\n", + "Timer: Initializing the optimization = 6.23 sec\n", "\n", "Starting optimization\n", "Using method: proximal-lsq-exact\n", " Iteration Total nfev Cost Cost reduction Step norm Optimality \n", - " 0 1 2.003e+04 1.949e+02 \n", - " 1 5 1.551e+04 4.515e+03 2.594e-02 1.685e+02 \n", + " 0 1 2.011e+04 1.952e+02 \n", + " 1 4 8.735e+03 1.138e+04 4.838e-02 1.104e+02 \n", "Warning: Maximum number of iterations has been exceeded.\n", - " Current function value: 1.551e+04\n", - " Total delta_x: 2.594e-02\n", + " Current function value: 8.735e+03\n", + " Total delta_x: 4.838e-02\n", " Iterations: 1\n", - " Function evaluations: 5\n", + " Function evaluations: 4\n", " Jacobian evaluations: 2\n", - "Timer: Solution time = 1.89 min\n", - "Timer: Avg time per step = 56.9 sec\n", + "Timer: Solution time = 29.2 sec\n", + "Timer: Avg time per step = 14.6 sec\n", "==============================================================================================================\n", " Start --> End\n", - "Total (sum of squares): 2.003e+04 --> 1.551e+04, \n", - "Maximum absolute Quasi-symmetry (1,2) two-term error: 1.058e-01 --> 2.625e-01 (T^3)\n", - "Minimum absolute Quasi-symmetry (1,2) two-term error: 1.547e-05 --> 1.156e-05 (T^3)\n", - "Average absolute Quasi-symmetry (1,2) two-term error: 5.258e-02 --> 7.294e-02 (T^3)\n", - "Maximum absolute Quasi-symmetry (1,2) two-term error: 1.155e-01 --> 2.864e-01 (normalized)\n", - "Minimum absolute Quasi-symmetry (1,2) two-term error: 1.688e-05 --> 1.261e-05 (normalized)\n", - "Average absolute Quasi-symmetry (1,2) two-term error: 5.737e-02 --> 7.959e-02 (normalized)\n", - "Maximum absolute Quasi-symmetry (1,2) two-term error: 2.241e-01 --> 5.706e-01 (T^3)\n", - "Minimum absolute Quasi-symmetry (1,2) two-term error: 1.994e-05 --> 2.975e-05 (T^3)\n", - "Average absolute Quasi-symmetry (1,2) two-term error: 9.189e-02 --> 1.198e-01 (T^3)\n", - "Maximum absolute Quasi-symmetry (1,2) two-term error: 2.446e-01 --> 6.226e-01 (normalized)\n", - "Minimum absolute Quasi-symmetry (1,2) two-term error: 2.176e-05 --> 3.246e-05 (normalized)\n", - "Average absolute Quasi-symmetry (1,2) two-term error: 1.003e-01 --> 1.307e-01 (normalized)\n", - "Aspect ratio: 6.000e+00 --> 6.242e+00 (dimensionless)\n", - "Maximum absolute Force error: 1.757e+01 --> 4.893e+01 (N)\n", - "Minimum absolute Force error: 1.160e-05 --> 1.148e-04 (N)\n", - "Average absolute Force error: 3.140e-01 --> 6.310e-01 (N)\n", - "Maximum absolute Force error: 1.256e-05 --> 3.498e-05 (normalized)\n", - "Minimum absolute Force error: 8.291e-12 --> 8.205e-11 (normalized)\n", - "Average absolute Force error: 2.244e-07 --> 4.511e-07 (normalized)\n", - "R boundary error: 0.000e+00 --> 0.000e+00 (m)\n", - "Z boundary error: 0.000e+00 --> 0.000e+00 (m)\n", + "Total (sum of squares): 2.011e+04 --> 8.735e+03, \n", + "Maximum absolute Quasi-symmetry (1,2) two-term error: 1.813e-01 --> 6.254e-01 (T^3)\n", + "Minimum absolute Quasi-symmetry (1,2) two-term error: 2.150e-04 --> 4.713e-03 (T^3)\n", + "Average absolute Quasi-symmetry (1,2) two-term error: 5.169e-02 --> 2.630e-01 (T^3)\n", + "Maximum absolute Quasi-symmetry (1,2) two-term error: 1.978e-01 --> 6.824e-01 (normalized)\n", + "Minimum absolute Quasi-symmetry (1,2) two-term error: 2.346e-04 --> 5.143e-03 (normalized)\n", + "Average absolute Quasi-symmetry (1,2) two-term error: 5.640e-02 --> 2.869e-01 (normalized)\n", + "Maximum absolute Quasi-symmetry (1,2) two-term error: 1.161e+00 --> 9.141e-01 (T^3)\n", + "Minimum absolute Quasi-symmetry (1,2) two-term error: 1.945e-03 --> 1.241e-03 (T^3)\n", + "Average absolute Quasi-symmetry (1,2) two-term error: 1.051e-01 --> 2.811e-01 (T^3)\n", + "Maximum absolute Quasi-symmetry (1,2) two-term error: 1.267e+00 --> 9.974e-01 (normalized)\n", + "Minimum absolute Quasi-symmetry (1,2) two-term error: 2.122e-03 --> 1.354e-03 (normalized)\n", + "Average absolute Quasi-symmetry (1,2) two-term error: 1.147e-01 --> 3.067e-01 (normalized)\n", + "Aspect ratio: 5.996e+00 --> 6.709e+00 (dimensionless)\n", + "Maximum absolute Force error: 1.345e+05 --> 1.302e+04 (N)\n", + "Minimum absolute Force error: 8.350e+00 --> 2.077e+00 (N)\n", + "Average absolute Force error: 5.462e+03 --> 1.001e+03 (N)\n", + "Maximum absolute Force error: 9.614e-02 --> 9.309e-03 (normalized)\n", + "Minimum absolute Force error: 5.969e-06 --> 1.485e-06 (normalized)\n", + "Average absolute Force error: 3.904e-03 --> 7.158e-04 (normalized)\n", + "R boundary error: 0.000e+00 --> 4.734e-19 (m)\n", + "Z boundary error: 0.000e+00 --> 3.478e-18 (m)\n", "Fixed pressure profile error: 0.000e+00 --> 0.000e+00 (Pa)\n", "Fixed Psi error: 0.000e+00 --> 0.000e+00 (Wb)\n", "Fixed current profile error: 0.000e+00 --> 0.000e+00 (A)\n", "==============================================================================================================\n" ] + }, + { + "data": { + "text/plain": [ + "(Equilibrium at 0x7e5688ede8a0 (L=3, M=3, N=3, NFP=2, sym=True, spectral_indexing=ansi),\n", + " message: Maximum number of iterations has been exceeded.\n", + " success: False\n", + " fun: [-6.669e-02 -1.838e-01 ... 1.709e-01 -1.291e+02]\n", + " x: [-2.124e-01 1.388e-01 1.794e-01 -7.720e-02 -1.261e-01\n", + " 4.834e-02 -2.327e-01 -1.485e-01]\n", + " nit: 1\n", + " cost: 8735.080665954583\n", + " v: [ 1.000e+00 1.000e+00 1.000e+00 1.000e+00 1.000e+00\n", + " 1.000e+00 1.000e+00 1.000e+00]\n", + " optimality: 110.41872641325968\n", + " nfev: 4\n", + " njev: 2\n", + " allx: [Array([ 0.000e+00, 0.000e+00, ..., 1.082e-03, -2.543e-03], dtype=float64), Array([ 0.000e+00, 0.000e+00, ..., 1.082e-03, -2.543e-03], dtype=float64)]\n", + " alltr: [Array( 5.665e+02, dtype=float64), np.float64(130.5803471209196), np.float64(32.6450867802299), np.float64(65.29017356045979)]\n", + " history: [[{'R_lmn': Array([-3.535e-03, 1.627e-03, ..., 5.860e-04, 1.585e-04], dtype=float64), 'Z_lmn': Array([-9.096e-04, 1.867e-03, ..., -1.343e-04, 1.075e-03], dtype=float64), 'L_lmn': Array([-2.543e-03, -2.040e-04, ..., -1.109e-03, -1.629e-03], dtype=float64), 'p_l': Array([ 0.000e+00, 0.000e+00, 0.000e+00, 0.000e+00,\n", + " 0.000e+00], dtype=float64), 'i_l': Array([], shape=(0,), dtype=float64), 'c_l': Array([ 0.000e+00, 0.000e+00, 0.000e+00, 0.000e+00,\n", + " 0.000e+00], dtype=float64), 'Psi': Array([ 8.700e-02], dtype=float64), 'Te_l': Array([], shape=(0,), dtype=float64), 'ne_l': Array([], shape=(0,), dtype=float64), 'Ti_l': Array([], shape=(0,), dtype=float64), 'Zeff_l': Array([], shape=(0,), dtype=float64), 'a_lmn': Array([], shape=(0,), dtype=float64), 'Ra_n': Array([ 1.020e+00, 1.971e-01, 2.315e-02, 2.547e-03], dtype=float64), 'Za_n': Array([-2.473e-03, -2.071e-02, -1.521e-01], dtype=float64), 'Rb_lmn': Array([ 2.268e-04, 1.531e-03, ..., 2.246e-03, 1.295e-04], dtype=float64), 'Zb_lmn': Array([ 4.367e-04, 9.219e-04, ..., 1.082e-03, -2.543e-03], dtype=float64), 'I': Array([], shape=(0,), dtype=float64), 'G': Array([], shape=(0,), dtype=float64), 'Phi_mn': Array([], shape=(0,), dtype=float64)}], [{'R_lmn': Array([-3.535e-03, 1.627e-03, ..., 5.860e-04, 1.585e-04], dtype=float64), 'Z_lmn': Array([-9.096e-04, 1.867e-03, ..., -1.343e-04, 1.075e-03], dtype=float64), 'L_lmn': Array([-2.543e-03, -2.040e-04, ..., -1.109e-03, -1.629e-03], dtype=float64), 'p_l': Array([ 0.000e+00, 0.000e+00, 0.000e+00, 0.000e+00,\n", + " 0.000e+00], dtype=float64), 'i_l': Array([], shape=(0,), dtype=float64), 'c_l': Array([ 0.000e+00, 0.000e+00, 0.000e+00, 0.000e+00,\n", + " 0.000e+00], dtype=float64), 'Psi': Array([ 8.700e-02], dtype=float64), 'Te_l': Array([], shape=(0,), dtype=float64), 'ne_l': Array([], shape=(0,), dtype=float64), 'Ti_l': Array([], shape=(0,), dtype=float64), 'Zeff_l': Array([], shape=(0,), dtype=float64), 'a_lmn': Array([], shape=(0,), dtype=float64), 'Ra_n': Array([ 1.020e+00, 1.971e-01, 2.315e-02, 2.547e-03], dtype=float64), 'Za_n': Array([-2.473e-03, -2.071e-02, -1.521e-01], dtype=float64), 'Rb_lmn': Array([ 2.268e-04, 1.531e-03, ..., 2.246e-03, 1.295e-04], dtype=float64), 'Zb_lmn': Array([ 4.367e-04, 9.219e-04, ..., 1.082e-03, -2.543e-03], dtype=float64), 'I': Array([], shape=(0,), dtype=float64), 'G': Array([], shape=(0,), dtype=float64), 'Phi_mn': Array([], shape=(0,), dtype=float64)}], [{'R_lmn': Array([-3.074e-03, 1.531e-03, ..., -1.188e-04, 1.295e-04], dtype=float64), 'Z_lmn': Array([-6.459e-04, 9.544e-04, ..., -7.129e-05, 2.324e-04], dtype=float64), 'L_lmn': Array([ 1.664e-03, 5.507e-04, ..., -2.559e-03, 1.939e-03], dtype=float64), 'p_l': Array([ 0.000e+00, 0.000e+00, 0.000e+00, 0.000e+00,\n", + " 0.000e+00], dtype=float64), 'i_l': Array([], shape=(0,), dtype=float64), 'c_l': Array([ 0.000e+00, 0.000e+00, 0.000e+00, 0.000e+00,\n", + " 0.000e+00], dtype=float64), 'Psi': Array([ 8.700e-02], dtype=float64), 'Te_l': Array([], shape=(0,), dtype=float64), 'ne_l': Array([], shape=(0,), dtype=float64), 'Ti_l': Array([], shape=(0,), dtype=float64), 'Zeff_l': Array([], shape=(0,), dtype=float64), 'a_lmn': Array([], shape=(0,), dtype=float64), 'Ra_n': Array([ 1.050e+00, 1.833e-01, 2.304e-02, 2.564e-03], dtype=float64), 'Za_n': Array([-1.729e-03, -1.924e-02, -1.507e-01], dtype=float64), 'Rb_lmn': Array([ 2.268e-04, 1.531e-03, ..., 2.246e-03, 1.295e-04], dtype=float64), 'Zb_lmn': Array([ 4.367e-04, 9.219e-04, ..., 1.082e-03, -2.543e-03], dtype=float64), 'I': Array([], shape=(0,), dtype=float64), 'G': Array([], shape=(0,), dtype=float64), 'Phi_mn': Array([], shape=(0,), dtype=float64)}]])" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" } ], "source": [ @@ -535,7 +690,7 @@ " options={\n", " \"initial_trust_ratio\": 1.0,\n", " },\n", - ");" + ")" ] }, { @@ -548,9 +703,9 @@ ], "metadata": { "kernelspec": { - "display_name": "desc-env [~/.conda/envs/desc-env/]", + "display_name": "desc-env", "language": "python", - "name": "conda_desc-env" + "name": "python3" }, "language_info": { "codemirror_mode": { @@ -562,7 +717,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.11.6" + "version": "3.12.7" } }, "nbformat": 4, diff --git a/setup.cfg b/setup.cfg index 93b478c506..b3ebfd05ea 100644 --- a/setup.cfg +++ b/setup.cfg @@ -79,6 +79,7 @@ per-file-ignores = desc/compute/data_index.py: E501 # need imports in weird order for selecting device before benchmarks tests/benchmarks/benchmark*.py: E402 + tests/test_multidevice.py: E402 # stop complaining about setting gpu before import other desc stuff desc/examples/precise_QA.py: E402 desc/examples/precise_QH.py: E402 diff --git a/tests/test_multidevice.py b/tests/test_multidevice.py new file mode 100644 index 0000000000..d7ddc543b3 --- /dev/null +++ b/tests/test_multidevice.py @@ -0,0 +1,63 @@ +"""Tests for the multidevice capabilities.""" + +# This file has to run on a separate process because it changes the number of CPUs +from desc import _set_cpu_count, set_device + +num_device = 1 +_set_cpu_count(num_device) +set_device(kind="cpu", num_device=num_device) + +import numpy as np +import pytest + +from desc.backend import jax, jnp +from desc.examples import get +from desc.grid import Grid, LinearGrid +from desc.objectives import ForceBalance, ObjectiveFunction + + +@pytest.mark.xfail(reason="This test is not working right now") +@pytest.mark.unit +def test_multidevice_jac(): + """Test that the Jacobian is the same for a single and multi device.""" + eq = get("HELIOTRON") + eq.change_resolution(3, 3, 3, 6, 6, 6) + + # TODO: This doesn't work right now because grid order is not the same + grid1 = LinearGrid( + M=eq.M_grid, N=eq.N_grid, NFP=eq.NFP, rho=np.array([0.2, 0.4]), sym=True + ) + grid2 = LinearGrid( + M=eq.M_grid, N=eq.N_grid, NFP=eq.NFP, rho=np.array([0.6, 0.8]), sym=True + ) + grid1 = Grid(grid1.nodes, weights=grid1.weights, spacing=grid1.spacing) + grid2 = Grid(grid2.nodes, weights=grid2.weights, spacing=grid2.spacing) + grid3 = Grid( + jnp.vstack([grid1.nodes, grid2.nodes]), + weights=jnp.hstack([grid1.weights, grid2.weights]), + spacing=jnp.hstack([grid1.spacing, grid2.spacing]), + ) + + objective1 = ForceBalance(eq, grid=grid1, device_id=0) + objective2 = ForceBalance(eq, grid=grid2, device_id=0) + objective3 = ForceBalance(eq, grid=grid3, device_id=0) + + for obj in [objective1, objective2, objective3]: + obj.build() + obj = jax.device_put(obj, device=obj._device) + obj.things[0] = eq + + obj1 = ObjectiveFunction([objective1, objective2]) + obj2 = ObjectiveFunction(objective3) + obj1.build(use_jit=False) + obj2.build(use_jit=False) + + np.testing.assert_allclose(obj1.x(eq), obj2.x(eq)) + + np.testing.assert_allclose( + grid3.nodes, jnp.vstack([grid1.nodes, grid2.nodes]), atol=1e-12, rtol=1e-12 + ) + err1 = objective1.jac_scaled_error(obj1.x(eq)) + err2 = objective2.jac_scaled_error(obj2.x(eq)) + + np.testing.assert_allclose(err1, err2) From 315b4ed8ebe71ac9d541daa71f19e33206812caa Mon Sep 17 00:00:00 2001 From: YigitElma Date: Fri, 14 Feb 2025 00:41:25 -0500 Subject: [PATCH 74/75] improve test --- desc/objectives/objective_funs.py | 3 +- tests/test_multidevice.py | 76 ++++++++++++++++++++----------- 2 files changed, 51 insertions(+), 28 deletions(-) diff --git a/desc/objectives/objective_funs.py b/desc/objectives/objective_funs.py index d8560210a7..1205e8d2ef 100644 --- a/desc/objectives/objective_funs.py +++ b/desc/objectives/objective_funs.py @@ -380,7 +380,8 @@ def build(self, use_jit=None, verbose=1): # noqa: C901 "Setting the deriv_mode to 'blocked' to ensure that each sub-objective\n" "runs on the correct device.", ) - self._deriv_mode != "blocked" + if self._is_multi_device: + self._deriv_mode = "blocked" if self._jac_chunk_size == "auto": # Heuristic estimates of fwd mode Jacobian memory usage, diff --git a/tests/test_multidevice.py b/tests/test_multidevice.py index d7ddc543b3..dbfc57a4a9 100644 --- a/tests/test_multidevice.py +++ b/tests/test_multidevice.py @@ -10,54 +10,76 @@ import numpy as np import pytest -from desc.backend import jax, jnp +from desc.backend import jax from desc.examples import get -from desc.grid import Grid, LinearGrid +from desc.grid import LinearGrid from desc.objectives import ForceBalance, ObjectiveFunction -@pytest.mark.xfail(reason="This test is not working right now") +@pytest.mark.xfail(reason="We need to make a new action for these tests.") @pytest.mark.unit def test_multidevice_jac(): """Test that the Jacobian is the same for a single and multi device.""" eq = get("HELIOTRON") - eq.change_resolution(3, 3, 3, 6, 6, 6) + eq.change_resolution(6, 6, 3, 12, 12, 6) + eq1 = eq.copy() + eq2 = eq.copy() - # TODO: This doesn't work right now because grid order is not the same grid1 = LinearGrid( - M=eq.M_grid, N=eq.N_grid, NFP=eq.NFP, rho=np.array([0.2, 0.4]), sym=True + M=eq.M_grid, N=eq.N_grid, NFP=eq.NFP, rho=np.array([0.2]), sym=True ) grid2 = LinearGrid( M=eq.M_grid, N=eq.N_grid, NFP=eq.NFP, rho=np.array([0.6, 0.8]), sym=True ) - grid1 = Grid(grid1.nodes, weights=grid1.weights, spacing=grid1.spacing) - grid2 = Grid(grid2.nodes, weights=grid2.weights, spacing=grid2.spacing) - grid3 = Grid( - jnp.vstack([grid1.nodes, grid2.nodes]), - weights=jnp.hstack([grid1.weights, grid2.weights]), - spacing=jnp.hstack([grid1.spacing, grid2.spacing]), + grid3 = LinearGrid( + M=eq.M_grid, N=eq.N_grid, NFP=eq.NFP, rho=np.array([0.2, 0.6]), sym=True + ) + grid4 = LinearGrid( + M=eq.M_grid, N=eq.N_grid, NFP=eq.NFP, rho=np.array([0.4, 0.8, 0.9]), sym=True ) - objective1 = ForceBalance(eq, grid=grid1, device_id=0) - objective2 = ForceBalance(eq, grid=grid2, device_id=0) - objective3 = ForceBalance(eq, grid=grid3, device_id=0) + objective1 = ForceBalance(eq1, grid=grid1, device_id=0) + objective2 = ForceBalance(eq1, grid=grid2, device_id=1) + objective3 = ForceBalance(eq2, grid=grid3, device_id=0) + objective4 = ForceBalance(eq2, grid=grid4, device_id=0) - for obj in [objective1, objective2, objective3]: + for obj in [objective1, objective2, objective3, objective4]: obj.build() obj = jax.device_put(obj, device=obj._device) - obj.things[0] = eq + objective1.things[0] = eq1 + objective2.things[0] = eq1 + objective3.things[0] = eq2 + objective4.things[0] = eq2 + # this one is multi-device, and grids have different sizes obj1 = ObjectiveFunction([objective1, objective2]) - obj2 = ObjectiveFunction(objective3) - obj1.build(use_jit=False) - obj2.build(use_jit=False) + # this one is single device, and grids have different sizes + obj2 = ObjectiveFunction([objective3, objective4]) + obj1.build() + obj2.build() - np.testing.assert_allclose(obj1.x(eq), obj2.x(eq)) + assert obj1._is_multi_device + assert not obj2._is_multi_device - np.testing.assert_allclose( - grid3.nodes, jnp.vstack([grid1.nodes, grid2.nodes]), atol=1e-12, rtol=1e-12 - ) - err1 = objective1.jac_scaled_error(obj1.x(eq)) - err2 = objective2.jac_scaled_error(obj2.x(eq)) + np.testing.assert_allclose(obj1.x(eq1), obj2.x(eq2)) + + # multi-device objective must be blocked + assert obj1._deriv_mode == "blocked" + assert obj2._deriv_mode == "batched" + + # creating grids like grid3 = [grid1, grid2] doesn't give the same + # node, spacing and weight ordering, so we can't compare the Jacobians + # or the objective values directly. Instead, we compare the objective + # values before and after a single iteration of the solver. This should + # always decrease the objective value. + error_init1 = obj1.compute_scalar(obj1.x(eq1)) + error_init2 = obj2.compute_scalar(obj2.x(eq2)) + + eq1.solve(objective=obj1, maxiter=1) + eq2.solve(objective=obj2, maxiter=1) + + error_final1 = obj1.compute_scalar(obj1.x(eq1)) + error_final2 = obj2.compute_scalar(obj2.x(eq2)) - np.testing.assert_allclose(err1, err2) + assert error_final1 < error_init1 + assert error_final2 < error_init2 From b22fb50728cdd00f311603b662a36daa51891abc Mon Sep 17 00:00:00 2001 From: YigitElma Date: Thu, 20 Feb 2025 19:55:37 -0500 Subject: [PATCH 75/75] add multiprocessing, for some reason jax.Dvice object is not picklable so I removed the obj._device attribute, instead use config kind and device_id to have same function --- desc/backend.py | 11 +- desc/objectives/getters.py | 2 +- desc/objectives/objective_funs.py | 100 +++-- desc/optimize/_constraint_wrappers.py | 5 +- docs/notebooks/tutorials/multi_device.ipynb | 437 ++++---------------- tests/test_multidevice.py | 5 +- 6 files changed, 180 insertions(+), 380 deletions(-) diff --git a/desc/backend.py b/desc/backend.py index 96e04a6b2d..a56cc50eea 100644 --- a/desc/backend.py +++ b/desc/backend.py @@ -502,8 +502,11 @@ def jit_with_device(method): Decorates a method of a class with a dynamic device, allowing the method to be compiled with jax.jit for the specific device. This is needed since - @functools.partial(jax.jit, device=obj._device) is not - allowed in a class definition. + @functools.partial( + jax.jit, + device=jax.devices(desc_config["kind"])[obj._device_id] + ) + is not allowed in a class definition. Parameters ---------- @@ -515,7 +518,9 @@ def jit_with_device(method): @functools.wraps(method) def wrapper(self, *args, **kwargs): # Compile the method with jax.jit for the specific device - wrapped = jax.jit(method, device=self._device) + wrapped = jax.jit( + method, device=jax.devices(desc_config["kind"])[self._device_id] + ) return wrapped(self, *args, **kwargs) return wrapper diff --git a/desc/objectives/getters.py b/desc/objectives/getters.py index fba28f78a3..3da572d215 100644 --- a/desc/objectives/getters.py +++ b/desc/objectives/getters.py @@ -401,7 +401,7 @@ def get_parallel_forcebalance(eq, num_device, grid=None, use_jit=True): gridi = grid[i] obj = ForceBalance(eq, grid=gridi, device_id=i) obj.build(use_jit=use_jit) - obj = jax.device_put(obj, obj._device) + obj = jax.device_put(obj, jax.devices(desc_config["kind"])[i]) # if the eq is also distrubuted across GPUs, then some internal logic # that checks if the things are different will fail, so we need to # set the eq to be the same manually diff --git a/desc/objectives/objective_funs.py b/desc/objectives/objective_funs.py index 1205e8d2ef..ca817d36be 100644 --- a/desc/objectives/objective_funs.py +++ b/desc/objectives/objective_funs.py @@ -116,6 +116,16 @@ } +# +def worker(flat_obj, structure, op, vi, xi, queue): + """Worker function for multiprocessing.""" + obj = jax.tree_util.tree_unflatten(structure, flat_obj) + # TODO: this is for debugging purposes, must be deleted before merging! + print(f"This should run on device id:{obj._device_id}") + Ji = getattr(obj, "jvp_" + op)(vi, xi) + queue.put((obj._device_id, Ji)) + + def collect_docs( overwrite=None, target_default="", @@ -488,7 +498,10 @@ def compute_unscaled(self, x, constants=None): f = pconcat( [ obj.compute_unscaled( - *jax.device_put(par, obj._device), constants=const + *jax.device_put( + par, jax.devices(desc_config["kind"])[obj._device_id] + ), + constants=const, ) for par, obj, const in zip(params, self.objectives, constants) ] @@ -527,7 +540,10 @@ def compute_scaled(self, x, constants=None): f = pconcat( [ obj.compute_scaled( - *jax.device_put(par, obj._device), constants=const + *jax.device_put( + par, jax.devices(desc_config["kind"])[obj._device_id] + ), + constants=const, ) for par, obj, const in zip(params, self.objectives, constants) ] @@ -566,7 +582,10 @@ def compute_scaled_error(self, x, constants=None): f = pconcat( [ obj.compute_scaled_error( - *jax.device_put(par, obj._device), constants=const + *jax.device_put( + par, jax.devices(desc_config["kind"])[obj._device_id] + ), + constants=const, ) for par, obj, const in zip(params, self.objectives, constants) ] @@ -636,13 +655,19 @@ def print_value(self, x, x0=None, constants=None): params, params0, self.objectives, constants ): if self._is_multi_device: # pragma: no cover - par = jax.device_put(par, obj._device) - par0 = jax.device_put(par0, obj._device) + par = jax.device_put( + par, jax.devices(desc_config["kind"])[obj._device_id] + ) + par0 = jax.device_put( + par0, jax.devices(desc_config["kind"])[obj._device_id] + ) obj.print_value(par, par0, constants=const) else: # pragma: no cover for par, obj, const in zip(params, self.objectives, constants): if self._is_multi_device: - par = jax.device_put(par, obj._device) + par = jax.device_put( + par, jax.devices(desc_config["kind"])[obj._device_id] + ) obj.print_value(par, constants=const) return None @@ -764,21 +789,50 @@ def _jvp_blocked(self, v, x, constants=None, op="scaled"): # basic idea is we compute the jacobian of each objective wrt each thing # one by one, and assemble into big block matrix # if objective doesn't depend on a given thing, that part is set to 0. - for k, (obj, const) in enumerate(zip(self.objectives, constants)): - # TODO: this is for debugging purposes, must be deleted before merging! - if self._is_multi_device: - print(f"This should run on device id:{obj._device_id}") - # get the xs that go to that objective - thing_idx = self._things_per_objective_idx[k] - xi = [xs[i] for i in thing_idx] - vi = [vs[i] for i in thing_idx] - if self._is_multi_device: # pragma: no cover - # inputs to jitted functions must live on the same device. Need to - # put xi and vi on the same device as the objective - xi = jax.device_put(xi, obj._device) - vi = jax.device_put(vi, obj._device) - Ji_ = getattr(obj, "jvp_" + op)(vi, xi, constants=const) - J += [Ji_] + if not self._is_multi_device: + for k, (obj, const) in enumerate(zip(self.objectives, constants)): + # get the xs that go to that objective + thing_idx = self._things_per_objective_idx[k] + xi = [xs[i] for i in thing_idx] + vi = [vs[i] for i in thing_idx] + Ji_ = getattr(obj, "jvp_" + op)(vi, xi, constants=const) + J += [Ji_] + else: # pragma: no cover + import multiprocessing + + # 'fork' is not compatible with JAX + multiprocessing.set_start_method("spawn", force=True) + + processes = [] + queue = multiprocessing.Queue() + # for testing first assume every objective lives on different device + for k, (obj, const) in enumerate(zip(self.objectives, constants)): + # flatten the objective to pass to the workers + flat_obj, structure = jax.tree_util.tree_flatten(obj) + # get the xs that go to that objective + thing_idx = self._things_per_objective_idx[k] + xi = [xs[i] for i in thing_idx] + vi = [vs[i] for i in thing_idx] + processes.append( + multiprocessing.Process( + target=worker, + args=(flat_obj, structure, op, vi, xi, queue), + name=f"Worker-{obj._device_id}", + ) + ) + for p in processes: + p.start() + + J = [] + names = [] + for _ in processes: + worker_name, Ji = queue.get() # Blocks until a result is available + J.append(Ji) + names.append(worker_name) + + for p in processes: + p.join() + # this is the transpose of the jvp when v is a matrix, for consistency with # jvp_batched if not self._is_multi_device: @@ -1155,10 +1209,6 @@ def __init__( # _device to a jaxlib.xla_extension.Device type, jit will throw error expecting # it to be static. So we set _device to None in that case which is simpler then # making it static. - if device_id != 0: - self._device = jax.devices(desc_config["kind"])[device_id] - else: - self._device = None self._target = target self._bounds = bounds diff --git a/desc/optimize/_constraint_wrappers.py b/desc/optimize/_constraint_wrappers.py index 5503a39e57..4d87b94f8c 100644 --- a/desc/optimize/_constraint_wrappers.py +++ b/desc/optimize/_constraint_wrappers.py @@ -4,6 +4,7 @@ import numpy as np +from desc import config as desc_config from desc.backend import jax, jit, jnp, pconcat from desc.batching import batched_vectorize from desc.objectives import ( @@ -1153,8 +1154,8 @@ def _proximal_jvp_blocked_pure(objective, vgs, xgs, op): if objective._is_multi_device: # pragma: no cover # inputs to jitted functions must live on the same device. Need to # put xi and vi on the same device as the objective - xi = jax.device_put(xi, obj._device) - vi = jax.device_put(vi, obj._device) + xi = jax.device_put(xi, jax.devices(desc_config["kind"])[obj._device_id]) + vi = jax.device_put(vi, jax.devices(desc_config["kind"])[obj._device_id]) assert len(xi) > 0 assert len(vi) > 0 assert len(xi) == len(vi) diff --git a/docs/notebooks/tutorials/multi_device.ipynb b/docs/notebooks/tutorials/multi_device.ipynb index b8ce359801..4e758f9cb4 100644 --- a/docs/notebooks/tutorials/multi_device.ipynb +++ b/docs/notebooks/tutorials/multi_device.ipynb @@ -31,7 +31,7 @@ "metadata": {}, "outputs": [], "source": [ - "num_device = 4\n", + "num_device = 2\n", "from desc import set_device, _set_cpu_count\n", "\n", "_set_cpu_count(num_device)\n", @@ -42,23 +42,35 @@ "cell_type": "code", "execution_count": 3, "metadata": {}, + "outputs": [], + "source": [ + "# import jax\n", + "\n", + "# jax.config.update(\"jax_compilation_cache_dir\", \"./jax-caches\")\n", + "# jax.config.update(\"jax_persistent_cache_min_entry_size_bytes\", -1)\n", + "# jax.config.update(\"jax_persistent_cache_min_compile_time_secs\", 0)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "DESC version 0.13.0+1539.gb6b43370b.dirty,using JAX backend, jax version=0.4.38, jaxlib version=0.4.38, dtype=float64\n", - "Using 4 CPUs:\n", - "\t CPU 0: TFRT_CPU_0 with 6.26 GB available memory\n", - "\t CPU 1: TFRT_CPU_1 with 6.26 GB available memory\n", - "\t CPU 2: TFRT_CPU_2 with 6.26 GB available memory\n", - "\t CPU 3: TFRT_CPU_3 with 6.26 GB available memory\n" + "DESC version 0.13.0+1543.g3edf125e0.dirty,using JAX backend, jax version=0.5.0, jaxlib version=0.5.0, dtype=float64\n", + "Using 2 CPUs:\n", + "\t CPU 0: TFRT_CPU_0 with 7.25 GB available memory\n", + "\t CPU 1: TFRT_CPU_1 with 7.25 GB available memory\n" ] } ], "source": [ "import numpy as np\n", "\n", + "from desc import config as desc_config\n", "from desc.examples import get\n", "from desc.objectives import *\n", "from desc.objectives.getters import *\n", @@ -71,7 +83,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 5, "metadata": {}, "outputs": [ { @@ -90,15 +102,13 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 6, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Precomputing transforms\n", - "Precomputing transforms\n", "Precomputing transforms\n", "Precomputing transforms\n" ] @@ -110,7 +120,7 @@ "/home/yigit/Codes/DESC/desc/utils.py:560: UserWarning: \n", "When using multiple devices, the ObjectiveFunction will run each \n", "sub-objective on the device specified in the sub-objective. \n", - "Setting the deriv_mode to 'blocked' to ensure that each sub-objective \n", + "Setting the deriv_mode to 'blocked' to ensure that each sub-objective\n", "runs on the correct device.\n", " warnings.warn(colored(msg, \"yellow\"), err)\n" ] @@ -119,10 +129,8 @@ "name": "stdout", "output_type": "stream", "text": [ - "None\n", - "TFRT_CPU_1\n", - "TFRT_CPU_2\n", - "TFRT_CPU_3\n" + "TFRT_CPU_0\n", + "TFRT_CPU_1\n" ] } ], @@ -130,12 +138,12 @@ "obj = get_parallel_forcebalance(eq, num_device=num_device)\n", "cons = get_fixed_boundary_constraints(eq)\n", "for obji in obj.objectives:\n", - " print(obji._device)" + " print(jax.devices(desc_config[\"kind\"])[obji._device_id])" ] }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 7, "metadata": { "editable": true, "slideshow": { @@ -159,52 +167,52 @@ "Building objective: lambda gauge\n", "Building objective: axis R self consistency\n", "Building objective: axis Z self consistency\n", - "Timer: Objective build = 1.53 sec\n", - "Timer: Linear constraint projection build = 3.80 sec\n", + "Timer: Objective build = 1.46 sec\n", + "Timer: Linear constraint projection build = 4.23 sec\n", "Number of parameters: 76\n", - "Number of objectives: 2704\n", - "Timer: Initializing the optimization = 5.36 sec\n", + "Number of objectives: 2028\n", + "Timer: Initializing the optimization = 5.74 sec\n", "\n", "Starting optimization\n", "Using method: lsq-exact\n", + "DESC version 0.13.0+1543.g3edf125e0.dirty,using JAX backend, jax version=0.5.0, jaxlib version=0.5.0, dtype=float64\n", + "CPU Info: 13th Gen Intel(R) Core(TM) i5-1335U CPU with 6.56 GB available memory\n", + "This should run on device id:0\n", + "DESC version 0.13.0+1543.g3edf125e0.dirty,using JAX backend, jax version=0.5.0, jaxlib version=0.5.0, dtype=float64\n", + "CPU Info: 13th Gen Intel(R) Core(TM) i5-1335U CPU with 6.36 GB available memory\n", + "This should run on device id:1\n", " Iteration Total nfev Cost Cost reduction Step norm Optimality \n", - " 0 1 8.573e+06 4.135e+03 \n", - " 1 2 7.294e+05 7.844e+06 5.352e-01 6.490e+02 \n", + " 0 1 2.515e+07 7.084e+03 \n", + "DESC version 0.13.0+1543.g3edf125e0.dirty,using JAX backend, jax version=0.5.0, jaxlib version=0.5.0, dtype=float64\n", + "CPU Info: 13th Gen Intel(R) Core(TM) i5-1335U CPU with 6.31 GB available memory\n", + "This should run on device id:0\n", + "DESC version 0.13.0+1543.g3edf125e0.dirty,using JAX backend, jax version=0.5.0, jaxlib version=0.5.0, dtype=float64\n", + "CPU Info: 13th Gen Intel(R) Core(TM) i5-1335U CPU with 6.27 GB available memory\n", + "This should run on device id:1\n", + " 1 2 1.201e+07 1.314e+07 5.573e-01 4.358e+03 \n", "Warning: Maximum number of iterations has been exceeded.\n", - " Current function value: 7.294e+05\n", - " Total delta_x: 5.352e-01\n", + " Current function value: 1.201e+07\n", + " Total delta_x: 5.573e-01\n", " Iterations: 1\n", " Function evaluations: 2\n", " Jacobian evaluations: 2\n", - "Timer: Solution time = 13.4 sec\n", - "Timer: Avg time per step = 6.73 sec\n", + "Timer: Solution time = 20.5 sec\n", + "Timer: Avg time per step = 10.2 sec\n", "==============================================================================================================\n", " Start --> End\n", - "Total (sum of squares): 2.844e+10 --> 7.294e+05, \n", - "Maximum absolute Force error: 2.650e+05 --> 1.299e+05 (N)\n", - "Minimum absolute Force error: 1.534e-10 --> 1.681e-10 (N)\n", - "Average absolute Force error: 9.802e+04 --> 4.428e+04 (N)\n", - "Maximum absolute Force error: 2.131e-02 --> 1.045e-02 (normalized)\n", - "Minimum absolute Force error: 1.234e-17 --> 1.352e-17 (normalized)\n", - "Average absolute Force error: 7.883e-03 --> 3.561e-03 (normalized)\n", - "Maximum absolute Force error: 4.785e+05 --> 3.814e+05 (N)\n", - "Minimum absolute Force error: 1.889e-10 --> 1.945e-10 (N)\n", - "Average absolute Force error: 1.791e+05 --> 1.171e+05 (N)\n", - "Maximum absolute Force error: 3.848e-02 --> 3.067e-02 (normalized)\n", - "Minimum absolute Force error: 1.519e-17 --> 1.565e-17 (normalized)\n", - "Average absolute Force error: 1.441e-02 --> 9.422e-03 (normalized)\n", - "Maximum absolute Force error: 8.926e+06 --> 2.599e+06 (N)\n", - "Minimum absolute Force error: 9.420e-11 --> 1.601e-10 (N)\n", - "Average absolute Force error: 4.594e+05 --> 1.831e+05 (N)\n", - "Maximum absolute Force error: 7.178e-01 --> 2.091e-01 (normalized)\n", - "Minimum absolute Force error: 7.576e-18 --> 1.287e-17 (normalized)\n", - "Average absolute Force error: 3.695e-02 --> 1.473e-02 (normalized)\n", - "Maximum absolute Force error: 6.431e+12 --> 2.805e+10 (N)\n", - "Minimum absolute Force error: 7.111e-13 --> 5.213e-11 (N)\n", - "Average absolute Force error: 4.122e+09 --> 3.074e+07 (N)\n", - "Maximum absolute Force error: 5.172e+05 --> 2.256e+03 (normalized)\n", - "Minimum absolute Force error: 5.719e-20 --> 4.193e-18 (normalized)\n", - "Average absolute Force error: 3.315e+02 --> 2.472e+00 (normalized)\n", + "Total (sum of squares): 8.361e+10 --> 1.201e+07, \n", + "Maximum absolute Force error: 4.884e+05 --> 8.231e+05 (N)\n", + "Minimum absolute Force error: 1.534e-10 --> 1.402e-10 (N)\n", + "Average absolute Force error: 1.541e+05 --> 1.375e+05 (N)\n", + "Maximum absolute Force error: 3.928e-02 --> 6.619e-02 (normalized)\n", + "Minimum absolute Force error: 1.234e-17 --> 1.128e-17 (normalized)\n", + "Average absolute Force error: 1.239e-02 --> 1.106e-02 (normalized)\n", + "Maximum absolute Force error: 6.431e+12 --> 5.142e+10 (N)\n", + "Minimum absolute Force error: 7.111e-13 --> 1.655e-12 (N)\n", + "Average absolute Force error: 5.758e+09 --> 1.046e+08 (N)\n", + "Maximum absolute Force error: 5.172e+05 --> 4.135e+03 (normalized)\n", + "Minimum absolute Force error: 5.719e-20 --> 1.331e-19 (normalized)\n", + "Average absolute Force error: 4.631e+02 --> 8.416e+00 (normalized)\n", "R boundary error: 0.000e+00 --> 0.000e+00 (m)\n", "Z boundary error: 0.000e+00 --> 0.000e+00 (m)\n", "Fixed Psi error: 0.000e+00 --> 0.000e+00 (Wb)\n", @@ -217,23 +225,23 @@ { "data": { "text/plain": [ - "(Equilibrium at 0x7e5726b83f50 (L=3, M=3, N=3, NFP=19, sym=True, spectral_indexing=fringe),\n", + "(Equilibrium at 0x7f58e4012a50 (L=3, M=3, N=3, NFP=19, sym=True, spectral_indexing=fringe),\n", " message: Maximum number of iterations has been exceeded.\n", " success: False\n", - " fun: [-9.316e-05 -9.293e-05 ... 2.140e-02 -4.778e-03]\n", - " x: [-2.477e-02 -1.206e-01 ... 7.442e-03 1.768e-01]\n", + " fun: [-1.320e-04 -1.389e-04 ... 1.297e-01 9.594e-03]\n", + " x: [-9.209e-03 -1.293e-01 ... 1.671e-02 1.916e-01]\n", " nit: 1\n", - " cost: 729415.2017973666\n", + " cost: 12008336.70921457\n", " v: [ 1.000e+00 1.000e+00 ... 1.000e+00 1.000e+00]\n", - " optimality: 649.0096310587396\n", + " optimality: 4357.5087192217225\n", " nfev: 2\n", " njev: 2\n", - " allx: [Array([-3.392e-05, 8.921e-06, ..., 0.000e+00, 0.000e+00], dtype=float64), Array([ 2.416e-05, 1.501e-03, ..., 0.000e+00, 0.000e+00], dtype=float64)]\n", - " alltr: [Array( 1.402e+06, dtype=float64), np.float64(1401525.8219770438)]\n", - " history: [[{'R_lmn': Array([-3.392e-05, 8.921e-06, ..., 0.000e+00, 1.850e-05], dtype=float64), 'Z_lmn': Array([ 9.011e-06, 1.167e-05, ..., -3.697e-05, 1.686e-05], dtype=float64), 'L_lmn': Array([-6.194e-07, -1.567e-05, ..., -9.721e-06, -1.466e-05], dtype=float64), 'p_l': Array([ 1.800e+04, -3.600e+04, ..., 0.000e+00, 0.000e+00], dtype=float64), 'i_l': Array([ 1.000e+00, 1.500e+00, ..., 0.000e+00, 0.000e+00], dtype=float64), 'c_l': Array([], shape=(0,), dtype=float64), 'Psi': Array([ 1.000e+00], dtype=float64), 'Te_l': Array([], shape=(0,), dtype=float64), 'ne_l': Array([], shape=(0,), dtype=float64), 'Ti_l': Array([], shape=(0,), dtype=float64), 'Zeff_l': Array([], shape=(0,), dtype=float64), 'a_lmn': Array([], shape=(0,), dtype=float64), 'Ra_n': Array([ 1.039e+01, 1.019e-01, 1.330e-03, 1.737e-05], dtype=float64), 'Za_n': Array([ 1.802e-05, 1.335e-03, 9.939e-02], dtype=float64), 'Rb_lmn': Array([ 0.000e+00, 0.000e+00, ..., 0.000e+00, 0.000e+00], dtype=float64), 'Zb_lmn': Array([ 0.000e+00, 0.000e+00, ..., 0.000e+00, 0.000e+00], dtype=float64), 'I': Array([], shape=(0,), dtype=float64), 'G': Array([], shape=(0,), dtype=float64), 'Phi_mn': Array([], shape=(0,), dtype=float64)}], [{'R_lmn': Array([ 2.416e-05, 1.501e-03, ..., 0.000e+00, 1.858e-03], dtype=float64), 'Z_lmn': Array([-7.446e-04, -3.249e-04, ..., 1.482e-03, 1.084e-03], dtype=float64), 'L_lmn': Array([-2.244e-04, -7.899e-04, ..., 9.491e-04, -7.183e-04], dtype=float64), 'p_l': Array([ 1.800e+04, -3.600e+04, ..., 0.000e+00, 0.000e+00], dtype=float64), 'i_l': Array([ 1.000e+00, 1.500e+00, ..., 0.000e+00, 0.000e+00], dtype=float64), 'c_l': Array([], shape=(0,), dtype=float64), 'Psi': Array([ 1.000e+00], dtype=float64), 'Te_l': Array([], shape=(0,), dtype=float64), 'ne_l': Array([], shape=(0,), dtype=float64), 'Ti_l': Array([], shape=(0,), dtype=float64), 'Zeff_l': Array([], shape=(0,), dtype=float64), 'a_lmn': Array([], shape=(0,), dtype=float64), 'Ra_n': Array([ 1.031e+01, 8.864e-02, -1.262e-02, -5.261e-04], dtype=float64), 'Za_n': Array([-1.489e-03, 2.919e-03, 1.679e-01], dtype=float64), 'Rb_lmn': Array([ 0.000e+00, 0.000e+00, ..., 0.000e+00, 0.000e+00], dtype=float64), 'Zb_lmn': Array([ 0.000e+00, 0.000e+00, ..., 0.000e+00, 0.000e+00], dtype=float64), 'I': Array([], shape=(0,), dtype=float64), 'G': Array([], shape=(0,), dtype=float64), 'Phi_mn': Array([], shape=(0,), dtype=float64)}]])" + " allx: [Array([-3.392e-05, 8.921e-06, ..., 0.000e+00, 0.000e+00], dtype=float64), Array([ 2.764e-03, 2.509e-03, ..., 0.000e+00, 0.000e+00], dtype=float64)]\n", + " alltr: [Array( 4.615e+06, dtype=float64), np.float64(4614795.672796082)]\n", + " history: [[{'R_lmn': Array([-3.392e-05, 8.921e-06, ..., 0.000e+00, 1.850e-05], dtype=float64), 'Z_lmn': Array([ 9.011e-06, 1.167e-05, ..., -3.697e-05, 1.686e-05], dtype=float64), 'L_lmn': Array([-6.194e-07, -1.567e-05, ..., -9.721e-06, -1.466e-05], dtype=float64), 'p_l': Array([ 1.800e+04, -3.600e+04, ..., 0.000e+00, 0.000e+00], dtype=float64), 'i_l': Array([ 1.000e+00, 1.500e+00, ..., 0.000e+00, 0.000e+00], dtype=float64), 'c_l': Array([], shape=(0,), dtype=float64), 'Psi': Array([ 1.000e+00], dtype=float64), 'Te_l': Array([], shape=(0,), dtype=float64), 'ne_l': Array([], shape=(0,), dtype=float64), 'Ti_l': Array([], shape=(0,), dtype=float64), 'Zeff_l': Array([], shape=(0,), dtype=float64), 'a_lmn': Array([], shape=(0,), dtype=float64), 'Ra_n': Array([ 1.039e+01, 1.019e-01, 1.330e-03, 1.737e-05], dtype=float64), 'Za_n': Array([ 1.802e-05, 1.335e-03, 9.939e-02], dtype=float64), 'Rb_lmn': Array([ 0.000e+00, 0.000e+00, ..., 0.000e+00, 0.000e+00], dtype=float64), 'Zb_lmn': Array([ 0.000e+00, 0.000e+00, ..., 0.000e+00, 0.000e+00], dtype=float64), 'I': Array([], shape=(0,), dtype=float64), 'G': Array([], shape=(0,), dtype=float64), 'Phi_mn': Array([], shape=(0,), dtype=float64)}], [{'R_lmn': Array([ 2.764e-03, 2.509e-03, ..., 0.000e+00, 1.410e-03], dtype=float64), 'Z_lmn': Array([-3.028e-03, -4.071e-03, ..., 2.461e-03, 1.527e-03], dtype=float64), 'L_lmn': Array([ 2.251e-05, -3.981e-03, ..., -3.894e-03, -1.955e-03], dtype=float64), 'p_l': Array([ 1.800e+04, -3.600e+04, ..., 0.000e+00, 0.000e+00], dtype=float64), 'i_l': Array([ 1.000e+00, 1.500e+00, ..., 0.000e+00, 0.000e+00], dtype=float64), 'c_l': Array([], shape=(0,), dtype=float64), 'Psi': Array([ 1.000e+00], dtype=float64), 'Te_l': Array([], shape=(0,), dtype=float64), 'ne_l': Array([], shape=(0,), dtype=float64), 'Ti_l': Array([], shape=(0,), dtype=float64), 'Zeff_l': Array([], shape=(0,), dtype=float64), 'a_lmn': Array([], shape=(0,), dtype=float64), 'Ra_n': Array([ 1.028e+01, 1.494e-01, -1.956e-03, -1.073e-03], dtype=float64), 'Za_n': Array([-6.057e-03, 2.128e-02, 1.771e-01], dtype=float64), 'Rb_lmn': Array([ 0.000e+00, 0.000e+00, ..., 0.000e+00, 0.000e+00], dtype=float64), 'Zb_lmn': Array([ 0.000e+00, 0.000e+00, ..., 0.000e+00, 0.000e+00], dtype=float64), 'I': Array([], shape=(0,), dtype=float64), 'G': Array([], shape=(0,), dtype=float64), 'Phi_mn': Array([], shape=(0,), dtype=float64)}]])" ] }, - "execution_count": 6, + "execution_count": 7, "metadata": {}, "output_type": "execute_result" } @@ -244,50 +252,9 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAWAAAAF2CAYAAABQ7kLKAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlHJYcgAAAAlwSFlzAAAOxQAADsUBR2zs/wAAgvdJREFUeJztnXdc0+fa/z8JBMJM2GGGjSBDREGG4KrW1tXaZWtbO2yfnnPsOO3pOsOn9bSn7TltPW1t7R6nPV227g6tIgoOpsgGGWGGHSCQhIz794dP8kMFZCTfO4Hv+/XipYx8ryuBfHLluq/BIYQQsLCwsLAwDpe2AywsLCyzFVaAWVhYWCjBCjALCwsLJVgBZmFhYaEEK8AsLCwslGAFmIWFhYUSrACzsLCwUIIVYBYWFhZKsALMwsLCQglWgFlYWFgowQowCwsLCyVmnACXlJRgyZIl4HA4mDNnDt54442rfmbbtm3Ytm0bBe/Gpr29HY8++ihSUlKwZMkSpKSkYPny5Xj77bfR19d3zduPd59++eUXzJs3DxwOx9hus7CwTAcyQwFAPv3001G/Nzg4SAYHB5l1aBwaGxuJn58fefvtt4lOpzN8/ccffyQ8Ho/8/PPP17zGte5TZmYmmcqvu6GhgTz++OMEALn//vvJG2+8MelrjEdrayu56aabpnTbxsZG8uSTTxI+n0/eeuutq74/MDBA4uLiyKJFi6btt1qtJjt27CBvvfUWeeutt8i5c+emdb1rUVZWRgoLC8f8nAY//fQTmTt3Lvnwww8v+9ptt91G0SvLZlYKsLmxdu1asm7dulG/d//995Pffvtt2jamKsCEEHL8+HHi6ek5bR+u5J133iHbtm0jYrF4ytc4ffo0ufPOO8kf/vCHq7733XffkYiICJKVlTUNLy/x6KOPGn4Pf//738n//M//TPua43H33XeTvXv3jvk5LRISEkhlZaXhc5lMRqRSKUWPLJtZJ8Bvv/02EYvFJCMjw/C1999/n0RERBCxWEzeeustsmLFChIUFEQ+//xzw89IpVJy++23k9TUVJKamkq2bdtGhoaGDN//97//TZYuXUqWL19OFi1aRN59990xr79q1Sri6OhIPv30U9LT00O4XC756KOPxr0/411jtPtUXV1NMjIyyIIFC8jatWvJm2++OWUB/utf/2qyKKe+vn5aAvz222+TAwcOkOuvv/6yrxcUFJBTp04ROzs7olKppuVjU1MTiYiIMHze19dHuru7p3XNayEWi0lvb++Yn9Ogu7ubBAQEUPVhpmFNMftBhT/84Q/o6urCiRMnDF976KGHYGNjg4ceegjh4eE4evQovv76a/zP//wP7rrrLnA4HKxfvx4JCQn45ptvoNVqcfPNN+OZZ57BW2+9BQDQarU4fPgw7OzsoFKpEB0djbi4OKSkpBiu//DDD8PX1xe//PIL9u7dCz6fj5qaGuh0Ovj7+4/r93jX2LJly2X3SaPRYM2aNVi/fj1ee+01aDQa3HLLLVN+zDIzM3HXXXeN+X2pVIqdO3eOe4309HTccMMNU/ZhLNRqNebMmYOLFy8avqZSqSCRSDA8PIzk5GTY2NhMy98jR47Ay8sL3333HQYHB1FSUoLt27ePe/u2tjZ8++23KCwsxPr16yGXy5GTk4OdO3fC3t4eCoUC27dvR2RkJBQKBfbt24cjR47g559/xsGDB8HlcvHOO+/AyckJVVVVhs/XrVuH2NhYaDQavPbaa3B1dQUAuLu745ZbbkFxcTGys7Px0UcfISYmBl1dXQgPD8czzzyDb7/9FqdPn8YjjzyCixcvory8HGvXrsWyZcsu83316tW44YYbrjpTyMzMxJIlSwAAcrkcn332GY4dO4b3338fWq32mtcfy2cAYz4eY92fa/3+LAbarwCmAuOkILZv335ZtEgIIZ9++ikRCASGzysqKggA0traSs6dO0cAXPbWa8+ePcTOzs6Qsz1+/Di5/vrrSWpqKsnIyCACgYC89tprl13f2dn5Kl/01/71118v+/rbb79NMjIySEREBHnyySfHvcaV9yk7O5sAIDU1NYbvf/fdd1OKgAcHB4mNjc1l992YTCcCVqlUZNeuXWR4eJjw+Xyi0WgIIZfu6/DwMHn44YfJjh07pu3jSy+9RNzc3IhMJiOEEPLBBx+QrVu3jnubjz76iGi1WuLh4UEaGhoIIYQ8++yz5P333yeEEHLrrbeSb7/9lhBCyLfffktuuOGGy277+OOPj/k5IZdSEvq/78bGRvKvf/2LEELIzz//TFQqFXF2diaVlZVEJpORnp4e8sEHHxC1Wk2cnZ3J2bNnCSGEHDx4kPzud7+7yvcjR46QixcvXvX1Rx55xPCu8PPPPydKpZLExMSQqqqqCV1/LJ/HezzGuj8zhVkXAY+HUCg0/J/P5wO4FE01NDQAALZu3Qou91LhiFKphKenJzo7OzE4OIjVq1fj3Xffxf333w8AWLJkCQYHBy+7vouLy1U2w8LCwOVyIZFILvv6H/7wB/zhD3/AkiVL0NXVNe41rqS5uRkA4Onpafiau7v7NW83Gjk5OXBzc0NERMRlX6+qqrrqa0yTm5uLxMRE8Hg8iEQiSCQSKBQKhIWFgcfjITMzE5988sm07Tg5OSEkJAQCgQAAEBAQgD//+c/44IMPxrzNLbfcgvLyckRHR0MsFgMAmpqa4OTkhIKCAmRlZeGbb74BAJSVlWHp0qWG2548eRI333zzmJ9XVFRg3759uP766/H555/D2toajz/+OADg+uuvx8mTJ5GcnHzZ7+e2225DUVER5s2bh6SkJADA+fPnR/0dXnfddaPep2PHjuH5558HAGzYsAE1NTXg8XgIDw+Hl5fXuNcfz+fxHo+x7s9MYVYJcGNjIxobGyd9u8DAQADAN998Ax8fH8PXOzo64OnpiT179kClUuGmm24yfG94eHhC13ZxccGNN96IH374AVu3bp20b6OhT2d0dHTA2dkZAC4T8clw4sSJy8QBgOHtpf4JQSsFUVRUhN///vcAgNDQUFRVVaGvrw933HEHWltb0dLSgsTExKtuN1l/4+Li8MUXXxi+x+FwoNFoxr29QCDA119/jYyMDAAAIQRZWVnYtm0bTpw4gYyMDMOLeVZWFl5//XXIZDIIhUJkZ2fjzTffhFKphFqtvurz4uJiJCQk4M477xzV9vHjxw2pgpH+ZGZmXva73Lt3L/bv34/e3t5rvrA3NTUBAHx8fKBWq+Hs7IxPPvkE9913n8Hv8a4/ns/XejxGuz8zhVklwHV1dZflfifKggULkJiYiN27d+PFF18EcCkf9txzz+Hs2bMGITp58iTWr1+PhoYGFBcXY+XKlRO6/q5du5CcnIzXXnsNTz31lOEPsbS0FE1NTQgODp6Uv0lJSYiMjMR7772H119/HRqNBp9//vmkrqEnMzPTENUDlyL/v/71r/jss88MXxOJRHjllVemdP3poFarDY9VSEgI3n//ffz3v/8FcMnv1NRU8Hi8q243WX9TUlIgl8vR398PZ2dnlJeX4/bbbzd8/+eff0ZwcPBVEVpOTg7Wr18PANizZw+SkpKQlJSE0tJSiEQiAEB9fT1KS0sRGxuLL774AuvXrwefz4erqyt27dp11ef33nsvwsLCDO/QgEu/k/379xt8yszMxKuvvnrV/cjMzMQzzzwDAKiuroadnR2cnZ3x/fff44EHHjD83LFjx+Dv74/w8PDL7ktGRgYOHz6MuLg4BAQE4LvvvkNxcTE+//xzPPbYY+Nef968eWP6LBQKx3w8HnjggTHvz4yAdg7E2FRUVJCNGzcSAGTBggVk48aNho/09HTi5uZGxGIxEQgE5JZbbiGEEPLNN9+QiIgIYmtrS26//XbS1tZGkpKSCACSlJREKisriVQqJZs2bSLJyclk6dKlZP369aSxsdFgd+fOnSQgIICsWLGCbN26lcTGxhKxWEx27tx52fUzMjJIUVHRVX5LpVLy+9//nixcuJCkp6eTuLg4kpKSQnbt2kUGBgbGvYa+CmLkfaqpqSEZGRlk/vz5ZOXKlWTHjh0EAMnIyCASiYTs3r2bxMXFjfk45uXlkaeeeopwuVzy4IMPkh07dpAnnniCBAcHj5o3nAoff/wx2bRpE7G1tSV//OMfybFjxwzfG8+/goICcs8995Dg4GDyxRdfEEIIeeutt8jRo0eJTqcjO3bsIDExMWThwoXkq6++MoqvOTk55LHHHiOvvvoqefTRR8nAwIDhe9dffz35/e9/f9VtwsPDyTvvvEM+/vhj8uSTTxqqZuRyOXnwwQfJ119/Tb7++mtyzz33kNdff520tLQQjUZDbr31VvLxxx+T7Ozsqz7X8+qrr5Jdu3aRzz//nHz44YeX1YDHxsYStVp9lT/z5s0jCoWCEEJIe3s72bRpE9m5c+dV9eNr1669qq66oqKC3HXXXZfVAN9yyy3kgw8+ICUlJRO6/lg+j/d4jHd/ZgIcQtityLOR++67D+7u7vjnP/9J25VRMXf/ruTLL7/E5s2bDZ+3tLRg/fr1yM/Pp+gVi7kzq1IQLJc4fvw4KisrcfToUdqujMpE/cvKykJOTg50Oh0WL15syLcyjUQiuezAEwCys7MNh1EsLGPBRsCzEIVCASsrq6vqY82FifrX39+PoqIiyOVy3HjjjQx5dzXZ2dlIS0szfJ6bm4tt27bBwcEBO3fuRGxsLDXfWMwbVoBZLJbS0lIMDAwgMzPTUB7FwmJJsALMYrEMDAzAyclpQmVULCzmCCvALCwsLJSYcfOAWVhYWCwFtgqCxWIZbcA8+4aOxZJgI2AWi2XXrl0ghOCpp54CuTRalbZLLCyTghVgFovld7/7HTo6OgzDblhYLA1WgFksFkIIMjMzce+999J2hYVlSrACzGKx7Ny5Ezk5Odi9ezdtV1hYpgRbhsbCwsJCCTYCZmFhYaEEK8AsLCwslGAFmIWFhYUSrACzsLCwUIIVYBYWFhZKsALMwsLCQglWgFlYWFgowQowCwsLCyVYAWZhYWGhBCvALCwsLJRgBZiFhYWFEqwAs7CwsFCC3YjBYhYMDQ2hra0Nra2taGtrM/y/tbUV7e3tUKvV0Gg0UKvVUKvV0Gq10Gg00Gg0sLKyAo/HM/xrbW0Na2tr2NjYwMPDAz4+PvDx8YG3tze8vb0N/3d0dKR9t1lmOew0NBaTo9FoUF5ejrKyMoOotra2oqWlBW1tbWhvbzdsOHZ3d4e7uzs8PDzg6ekJb29veHl5gc/nw9raGjwezyCyNjY24HK5qKioQFBQkEGQh4eHodFooFKp0NHRgba2NnR0dKCzsxOdnZ3o6upCf38/HBwc4OXlBW9vb/j6+hqE2sfHB5GRkYiOjoaNjQ3th49lBsMKMItRUavVKCsrQ2FhIfLz85GXl4eSkhLY29sjPDwcnp6el4men58fxGIxAgIC4OzsPGl7Wq0Whw4dwpo1a2BlZTXh2w0ODqKhoQFNTU1oamoyvBhIpVJ0dnbi4sWLkMlkmDt3LhYuXIgFCxYgISEB0dHRsLW1nbSfLCyjwQowy5QZHh5GWVkZCgoKDGJbWloKJycnREZGIiYmBgsXLkRaWhpCQkLA5Rr/yGGqAjwR6uvrkZ2djdzcXJSWlqK8vBy9vb2IiopCQkICFi5ciISEBMTGxrKizDIlWAFmmTCDg4M4evQofvnlF4MoCQSCq8Q2ODjYJGI7GqYU4NGQSCQGUb5w4QIqKirQ3d2NyMhILFy4EKtWrcKqVasgEAhM7guL5cMKMMu4tLS04NChQ9i7dy9OnDiB4OBgZGRkICUlBWlpaQgKCqLqH9MCPBpNTU3Izs7GmTNncOLECVRWViItLQ033XQT1q5di8DAQCp+sZg/rACzXAYhBOfPn8eBAwewb98+lJeXGyK7O+64A2FhYbRdvAxzEOAraWhowHfffYeffvoJubm5CAoKwoYNG7Bu3TosXLiQsXcHLOYPK8AsUKlUyMzMxIEDB7B//34oFAosXrwYa9euxS233AKhUEjbxTExRwEeiVwux969e3HgwAFkZWUBANauXYv169djxYoVsLe3p+whC01YAZ6lKJVK/Pjjj9izZw+OHDkCT09PLF++HDfddBNWrlwJa2vLKBE3dwEeiVarxYkTJ/DDDz/g2LFjaGxsxPLly7Fx40bceuutbF3yLIQV4FlGaWkpPvjgA3zxxRfw9fXFhg0bcNtttyEuLo62a1PCkgT4SiorK/Htt99i3759uHjxIjZt2oSHHnoICQkJ4HA4tN1jYQA2GTULGBwcxCeffILExESkpKSgo6MDBw8eRFlZGV566SWLFV9LZ86cOdi+fTuKioqQmZmJ4eFhXHfddYiLi8O7776Lvr4+2i6ymBhWgGcw1dXV+MMf/gBvb2+89dZbuOOOO9Dc3IxvvvkGixcvpu0eywgWLFiAzz77DC0tLXjkkUfw+eefw8fHB/fffz9KSkpou8diIlgBnmEQQnDkyBGsXr0a8+bNQ2dnJ44ePYrz58/jj3/845S6zViYw97eHo888gjOnTuH06dPQ6PRICUlBRkZGdi/fz+0Wi1tF1mMCCvAM4TBwUHs3r0bc+bMwb333ovY2FjU19fj22+/RVJSEm33WKZAXFwcvvjiC0gkEixZsgTbtm1DaGgo3nzzTTY9MUNgBdjCUSqVeP311+Hv748PPvgATz31FCQSCV599VV4eXnRdo/FCLi6uuKFF15AfX09duzYge+++w7+/v7YsWMHBgcHabvHMg1YAbZQtFotPvvsM4SFheGLL77AF198gcLCQmzdupWd4DVDsbKywubNm3HmzBkcOHAAhw8fRlBQEHbt2gW1Wk3bPZYpwAqwhUEIwYEDBxAdHY0dO3bgpZdeQlFREdasWUPbNRYGWbJkCc6ePYv33nsP7777LiIiIvD1119Dp9PRdo1lErACbEFkZ2cjNTUVDz/8MLZu3Yqqqircc889bGvrLGbjxo0oKSnBM888g2effRbx8fH49ddfwZb3WwbsM9cCKCkpwY033oi1a9di6dKluHjxIv74xz9aTLcai2nhcrl4+OGHUV1djdtvvx2bN2/G0qVLkZubS9s1lmvACrAZ09DQgM2bNyM5ORkBAQGoqanBSy+9BAcHB9qusZghtra2eP7551FbW4sFCxZgxYoVuPnmm1FVVUXbNZYxYAXYDOnp6cFjjz2GuXPnQqvVorS0FO+99x7c3d1pu8ZiATg7O+Nf//oXqqurIRQKMX/+fDz44INoa2uj7RrLFbACbGbs378fkZGRqKiowNmzZ/H111+z82RZpoRIJMInn3yC8+fPo6urC1FRUfjyyy/Z/LAZwQqwmdDT04M777wTDzzwAF555RUcOXIEMTExtN1imQGEhYVh3759+Oijj/CnP/0J69atY6NhM2HWCHB+fj5OnjyJN998k7YrV3HgwAFERkZCJpOhpKQE9913H22XWGYgGzduRFlZGezs7BAVFYWvvvqKjYYpM2sEuLKyEomJiairq6PtioGenh7cdddduP/++/GPf/wDP/30E7y9vWm7xTKDcXV1xXfffYcPPvgATz75JNavXw+pVErbLWRlZeHll1/G3//+d8Pg+tnArJoHfOjQIfD5fPB4POTk5ECn02Hx4sXIyMhg3JeDBw/iwQcfxPz58/HJJ5+wwjtFLHkeMG26u7vx8MMP4/jx43jnnXewadMmanOI+/v7UVRUBLlcjhtvvJGKDzSYNRHwSy+9hDVr1uDf//434uPjkZqaivj4eMbFt7e3F5s3b8aWLVvw0ksv4eeff2bFl4UKbm5u2LNnD3bv3o0//vGP2LBhA9rb26n40tjYCBsbGxQXF1OxT4tZI8CLFi1CTk4O5s+fT+2XfejQIURGRqKzsxMXLlzAgw8+yKh9FpbRuO2221BaWgpra2tERkbi66+/Zjw3LBaLkZycjEceeYRRu7SZVSkIPQMDA3ByckJvby9cXFwYsfe73/0OP/30E1555RVs3brV5DZnC2wKwrh8++23eOyxx7Bo0SJ8/PHHcHNzo+3SjGZWCjCT1NXVYc2aNfD09MSXX34JPz8/2i6ZJYQQqFQqKJVKw8eVn2u1Wuh0OhBCDB86nQ7Dw8Ows7MDh8MBh8MBl8uFlZUVbG1twefzL/vQf83W1padoTEGXV1d2LJlC0pLS3Ho0CFER0fTdmnGMmsE+FqHC6Z4GDIzM7Fx40Zs2rQJb7311qyP0AghUCqVkMlkkMlk6O/vh0KhMIgth8MZVSz1H9bW1peJLIfDgU6nQ1ZWFhYvXgwOh2MQZo1GM6qI6z/X6XSXXd/Z2RlCoRBCodAg5rMZnU6Hv/zlL3jnnXfw5ZdfYt26dSa1N9rjPRukadZMcxn5y9yzZw/kcjm2bNliMlvvvvsunn32WfzrX//Cww8/bBI75gwhBAqFAjKZDH19fYZ/1Wo1BAIBBAIBvLy8YG9vbxBBHo83aeHTr+gRCAQTfoEjhECtVhtEWaFQoL+/H7W1tejr6wOXyzWIsUAggFAohL29/awSZS6Xi5dffhkxMTG4++678fTTT+P555832WNACDH589IcmTUCrOf8+fOIjY3F6dOnTXL94eFhbNu2Dfv378fhw4eRnp5uEjvmhk6nQ29vLzo6OgwRrkajMQiYj48PoqKi4OTkRP2tP4fDgY2NDWxsbK7akUcIwcDAgOFFo66uziDK+vvi6ekJNzc36veDCTZt2oSIiAjcdNNNKC4uxmeffQZ7e3uj2zH189JcmXUC3NHRYYh2jE1nZyduvvlmDAwM4Ny5cxCLxUa3YU6o1Wp0dnaira0NHR0dsLKygpeXF3x9fTF37lw4OjpanEhxOBw4OzvD2dkZ/v7+AC6Jslwuh0wmQ29vL4qLi6FSqeDl5QWRSARPT88ZvYVk/vz5yM/Px/r165GamooDBw4YHhtjYcrnpTkz6wR45cqV+PrrrzEwMGDU6164cAFr1qzBggUL8Ouvv5okSjAHhoaGIJVKIZVK0d3dDWdnZ4hEIoSGhsLZ2XlGvk3ncDhwcnKCk5MT/P39DYIslUpRX1+PoqIiuLq6QiQSwcvLC46OjrRdNjoeHh44efIktm7dioSEBOzbtw8pKSlGu76pnpfmzqw5hDMlP/74I7Zs2YInnngC27dvt7iobzwIIejr60NbWxukUikGBwfh7u5uEBs7Ozuq/plDGZpKpUJ7ezukUik6OjpgZ2cHkUgEb29vuLi4zLgXpTfffBN//etf8dZbb+H++++n7Y5FM+siYGOi0+mwY8cOvPnmm/j4449x66230nbJaAwPD6O5uRkSiQRKpRIikQhz5syBh4cHu4njCmxtbREQEICAgABotVp0dXVBKpUiNzcX1tbWEIvFCAgIgK2tLW1XjcITTzyBqKgobN68GRcuXMC//vUv9m9iirAR8BRRKBTYvHkzioqK8OOPP2LevHm0XZo2hBD09PSgoaEBbW1tcHV1RWBgIEQikdlG9eYQAY+FTqdDR0cHJBIJOjs74eXlBbFYDA8PjxkRFV+8eBHr1q2Dj48PfvjhBwgEAtouWRysAE+BwcFBrFmzBgqFAocOHbL4TRVarRbNzc2oq6uDSqUyRGyWsPrInAV4JAqFAo2NjZBIJOByuQgODoa/vz94PB5t16aFXC7HTTfdhJ6eHhw9ehSurq60XbIoWAGeJP39/Vi9ejWsra3x008/WYRIjYVCoUB9fT0kEgkcHBwQHBwMHx8fs412R8NSBFgPIQRSqRR1dXWQyWQICAhAcHCwRf8dDQ8PY+PGjWhsbMRvv/0GDw8P2i5ZDKwAT4Le3l6sXLkSAoHAMNrSEhkaGkJlZSVaW1vh7e2N4OBgRmZimAJLE+CR9PX1oa6uDi0tLfDy8kJkZKTFVlBoNBrcfvvtKC8vR2ZmJkQiEW2XLAJWgCdIV1cXVqxYAR8fH+zbt88i6z5VKhWqq6shkUjg7++P8PBw6lUM08WSBViPSqVCTU0NGhoa4Ofnh4iICIv8vWi1WmzevBn5+fnIzMxk555MAMt5r0mRjo4OpKenIygoCAcOHLA48dVoNKiqqsJvv/0GpVKJJUuWIC4uziKf5DMRW1tbREdHY9myZSCE4NixYygrK8Pw8DBt1yaFlZUVvvrqK6SlpSE1NRUSiYS2S2YPWztyDbq7u7F06VKIxWK89NJLFlVuo9Pp0NDQgOrqajg7OyM1NRVCoZC2WyxjYG9vj/j4eISEhKCiogK//fYbwsLCEBwcbDHRPZfLxV/+8hfI5XJkZGQgJycHvr6+tN0yW9gIeBxkMhmuu+46hIaG4ptvvkFTUxOqqqpou3VNCCFobm7GsWPH0NTUhISEBKSkpLDiayE4OzsjKSkJixYtQnt7O3777TdIJBLodDrarl2T+vp6VFdX44MPPsCSJUuwZMkSs9g5Z66wOeAxGBgYwIoVK+Dq6oqDBw/C2toacrkcOTk5CAwMREREBG0XR6WrqwulpaXQaDSIjIyEj4/PjKg5HYuZkAMeD0IIOjo6UF5eDp1Oh+joaHh5edF2a1Tq6+tRWVmJlJQUCAQC6HQ63Hnnnbhw4QJOnjxp8eWapoAV4FEYGhrCqlWrYGNjg59++umyDiZzFWGNRoPy8nI0NzcjMjISYrHYosrJpspMF2A9+nc1ZWVl8PT0RHR0tFmdRVwpvnq0Wi1uvfVW1NXVITMz02KrbUzFzH+GThKlUom1a9cCAA4fPnxV+6ijoyNSU1PR0NBgNumIrq4uZGZmYnBwEEuXLkVQUNCsEN/ZBIfDgb+/P5YuXQqdTofMzEyzeWs/lvgClw7mvvvuO/j5+WHlypXo7++n5KV5wj5LR0AIwUMPPYS+vj788ssvY9b5mosIazQaXLhwAbm5uQgPD8eiRYvYyoYZjq2tLRYsWICYmBgUFRWhsLAQarWamj/jia8ea2tr/Pjjj3BycsKmTZsMQ/RZWAG+jDfeeAOZmZk4ePDgNTuTaIvwlVGvWCye0blelsvx8fHBsmXLoNVqcfz4cSrr5CcivnpsbGywd+9e1NTU4C9/+QtDHpo/llNTZWJ++eUXvPjiizhy5Ai8vb0ndBu9COfk5AAAIzlhjUaDiooKNDU1Ye7cuQgICGCFd5Zia2uLhQsXoqWlBYWFhfDy8kJMTAwj8yUmI756BAIBDhw4gJSUFMTGxmLTpk0m9tL8YSNgAFVVVbjjjjvw9ttvIykpaVK3ZTIS7u7uxokTJyCXy9mol8WAr68vo9HwVMRXz5w5c/DFF1/goYceQn5+vok8tBxmvQDLZDKsWbMGDz74IO65554pXcPUIkwIQW1tLc6ePYuwsDA218tyFfpoODo6GoWFhaisrDTJVuHpiK+eNWvW4Pnnn8e6devQ1tZmZA8ti1ldhqbVarF69WpYWVnh8OHD064cMEWJmlarRXFxMbq7u5GUlHTVEsnZzmwpQ5sMg4ODOHfuHBwdHTF//nyjdW8aQ3xHctddd6GmpgYnT5602MFW02VWR8B/+tOf0NzcjO+//94oZVvGjoSVSiVycnKgUCiQnp7Oii/LhHBwcMDixYtBCMGpU6cwNDQ07WsaW3wB4JNPPgEAPPTQQyaJ1i2BWSvAn332Gf7zn/9g//79Rh0BaCwRlslkyMrKgkAgQHJy8oxZZ8PCDDweD4mJiRCJRMjKykJXV9eUr2UK8QUupU3279+P48eP44033jDadS2JWVkFcfbsWWzbtg179uxBWFiY0a8/3eqI5uZmFBcXIyoqCkFBQUb3j2V2wOFwEBkZCScnJ5w7dw5z585FYGDgpK5hKvHV4+3tjR9++AErV67E3Llzcf311xvdhjkz6yLg5uZmrF+/Hi+88AJWrVplMjtTiYQJISgvL0dJSQmSkpJY8WUxCn5+fkhNTUVVVRWKi4snPNTH1OKrJykpCW+//TbuuOMOs+kuZYpZdQinUCiQmpqKuLg4fPrpp4zYnOjBnFqtRmFhIYaGhpCYmGjRK2qmikajgUKhgFKphFKphEqlMvxf/6FWq6HT6UAIASHEICZWVlbgcDjgcDiwsbEBn8+Hra0t+Hy+4UP/uZ2dncXvYpsKSqUSubm5sLKywoIFC8ZNazElviN58sknceDAAeTl5c2ayX2zSoCfeOIJZGdn48yZM4zO9b2WCKtUKpw+fRoODg5GPbU2Z9RqNfr6+tDX1weZTAaZTAa5XD6meOo/eDweuFwuuFwuOBwOdDodjh49iuXLl4PL5UKn02F4eHhMEVepVFCpVHBwcIBQKIRAIIBQKIRQKJwVoqyvqunp6UFKSgrs7e2v+hka4gtcml+9cuVKeHt74z//+Q9jdmkyawQ4JycHq1evRm5uLubMmcO4/bFEWKlU4vTp03B1dUVcXNyMbKwghGBgYACdnZ3o7e2FTCbD4OCgQQRHCuFkRXAqZWhqtRr9/f0G4deLv729vcEfT09PODs7z9jfR0VFBZqbm5GamnrZuy1a4qunubkZsbGx+Pzzzw1DsWYyMz/UwqXxkvfeey+effZZKuILjH4wp1AokJOTA09PT8TExMyoJ7tOp0N3dzekUina29uhUqng6ekJFxcXBAYGQiAQUIs4eTwe3Nzc4ObmZviaRqO5LBq/ePEirKys4OXlBW9vb7i5uc2YOmP94RyXy0V2djZSUlLg5OREXXyBS/nqV199FVu3bkVFRcWMH185KyLgxx9/HGfPnsXp06epj2nUR8I+Pj6QSqXw8fFBVFTUjBBftVqN9vZ2SKVSdHR0gMfjQSQSQSQSwc3NzSSPvakaMQgh6OnpgVQqhVQqhUKhgKenJ0QiEby8vGZMWWBNTQ1qa2shFovR0NBAVXxHsmrVKnh4eODLL7+k7YpJmfECnJ2djRtuuAF5eXlmM0C9s7MTp0+fhpubG1JTUy1afPUbGyQSCdrb2yEQCAyi6+TkZPL7xlQnnFwuN4hxb28v3N3dIRaLIRKJqL+oT5e8vDy0trZi4cKF8PHxoe0OAKClpQWxsbH47LPPZnQqYkanIPSph+eee85sxFehUOD8+fMIDAyEVCpFdXW12fg2GZRKJSQSCSQSCTgcDsRiMWJiYmbsjApHR0eEhoYiNDQUKpUKzc3NqKiowIULFxAQEIDAwMBRD7TMnfr6enR1dSEkJAQXLlyAs7OzURuTpoqvry9effVVPPjgg6ioqICrqyttl0zCjI6AH3vsMeTm5iInJ8csohSlUons7GyIRCLMnTsXg4ODZrneaDx6e3tRV1eHtrY2eHl5ITAwEO7u7tSieJqzIPRpColEgtbWVnh6eiI4OBhubm4W8a7mypxvdXU16uvrkZaWZjZlkKtXr4arqyu++uor2q6YhBkrwKdOncKNN95oNqkHlUqFnJwcuLu7X3bgZq475q6ko6MDVVVVGBgYQGBgIIKCgswi2jWXYTz6dwT19fXg8/mIiIiASCQyWyEe68CtsrISTU1NSE1NNYuIXp+K+PTTT7Fu3Tra7hidGSnAg4ODiImJwcMPP4xnnnmGtjvQaDTIzs6GQCDAvHnzrnpSmrMI9/b2ory8HAMDAwgPD0dAQIBZ1SmbiwDr0el0aG5uRmVlJfh8PqKiosxuG/B41Q76bsy2tjakp6ebxeLPjz/+GM8///yMTEXMSAF+9NFHkZ+fj+zsbOqpB0IICgoKoFarsWjRojEjInMTYblcjoqKCnR0dCAsLAzBwcFmJbx6zE2A9Wi1WjQ0NKC6uhouLi6IjIw0i+qCiZSa6f9mh4eHsWjRIurPIQC44YYbIBQK8d///pe2K0aF/iNrZE6ePInPPvsMn3/+uVn84dTU1EAmk2HBggXjvh2lvWNOj/6Q8MSJE7Czs8N1112H8PBwsxRfc8bKygohISFYsWIFBAIBsrOzUVBQgMHBQWo+TbTOl8PhID4+HsPDwygvL2fQw7H5+OOPceTIEezfv5+2K0aFvkIZEYVCgS1btuAvf/mLSaacTZa2tjZcvHgRSUlJE2o6oCnCOp0OlZWVOHbsGAghWLZsGaKjo83iLaglw+PxEBkZieXLl4PH4yEzMxOlpaXQaDSM+jHZJgsrKyskJSWhubkZEomEAQ/Hx9vbG//85z+xdetW9Pb20nbHaMwoAX777bchEAjw1FNP0XYF/f39KCwsxIIFC+Dk5DTh29EQYf3s4c7OTqSnpyM+Pt4sDmBmEnw+H7GxsVi6dCn6+/tx4sQJdHd3M2J7qh1udnZ2SExMRGlpKXp6ekzo4cS47777EB0djVdeeYW2K0ZjxuSAZTIZAgMD8c0331CfKTo8PIysrCwEBQUhNDR0StdgIies0+lQXV2N2tpaREREICQkxGxP7cfCXHPA40EIgUQiQVlZGQICAhAZGWmyFI8x2osbGxtRXl6OjIwM6pUv+fn5WLJkCaqqquDr60vVF2MwYyLgV155BfPmzaMuvjqdDnl5eXBzc0NISMiUr2PqSLivrw9ZWVno6OhAeno6QkNDLU58LRUOh4PAwEAsXboUAwMDJouGjTXbISAgAH5+fjh37hzjqZMrWbBgAa677jps376dqh/GYkZEwK2trQgPD8exY8cmvVbe2Fy4cAEymQypqalGiciMHQnPhKh3JJYYAY9kZDQsFosRGRlplPth7ME6hBCcPXsWPB4PCQkJVP9mampqMG/ePBQWFppFxdB0mBER8AsvvIDly5dTF9+Ghga0tbUhMTHRaGJgzEhYoVDg1KlTbNRrRoyMhvW5YblcPq1rmmKqGYfDwYIFCyCTyVBTU2OUa06VsLAw3H777Xj++eep+mEMLF6Aq6ur8eWXX+K1116j6kdfXx/KysqQmJho9BXbxhDhnp4eZGVlwc3NDWlpaZM6GGQxPfb29khOToafnx9OnjyJjo6OKV3HlCMleTwekpKSUFNTM60ln8bg5ZdfxtGjR5GXl0fVj+li8QL8/PPP49Zbb6X6VkSn06GoqAjh4eEmm186HRFubGzEmTNnEBUVhejoaLOoj2a5Gg6Hg4iICMybNw95eXmora2d1Lp2Jub5Ojk5ITo6GufPn6eaDxaJRNi6dSuefvppi15pb9HPxPz8fBw5cgT/+Mc/qPpRU1MDDoczrUO3iTBZESaEoLS0FOXl5UhOTkZAQIBJ/WMxDj4+PkhLS0NtbS3Onz8PrVZ7zdswOUw9ICAADg4OqKioMKmda7F9+3aUlpbi6NGjVP2YDhYtwE8//TQeeOABeHt7U/Ohr68PFy9exPz58xmJLCcqwmq1GmfPnkVXVxcyMjJmXA/9TEcgECAjIwODg4M4ffo0lErlmD/L9CYLDoeDefPmoampiWoqwtnZGU888QT+9Kc/TXjTs7lhsQJ89OhRXLhwAf/7v/9LzYeRqQcmc6rXEuHBwUFkZWWBx+MhLS2Neu0my9SwtbVFSkoKnJ2dcfLkSfT391/1M7TWCNnZ2WHu3LkoKiqimop48sknIZPJ8N1331HzYTpYpADrdDo8/fTTePTRR6kOOKmpqQGXy51ys8V0GEuEBwYGkJ2dDT8/PyQkJMzqGQ5nGnrx8rEanJVYbusql8tFXFwcQkJCkJOTA5lMZvge7R1uAQEBcHR0pDovwtbWFs899xyef/55DA8PU/NjqlikAH///ffo6uqiOmpSn3qIj4+nVsp1pQj39/cjJycHwcHBmDNnzqwuMTvT0Iu0XTn426/VSH0nx6JFGABCQkIQGRmJ06dPo6enh7r4Av8/FdHc3Ew1FbF161bw+Xx8+OGH1HyYKhYnwDqdDn/729/w9NNPU1uMqNPpUFhYyHjqYTT0IlxXV4eTJ08iLCzMLAYR0SaztgscDgdaHQGHw0HmRWbmLpiSwMBAxMTE4PTp0ygvLzeLBZrmkIqwsrLCCy+8gB07dlhcFGxxAnz06FH09/fj4YcfpuZDdXU1rKysqKQeRkOn04GQS0JDu1XUXFgW6g5CCKy4HBBCsDTU7do3sgBG/n4nUh3BBAEBAXBycqKaiti4cSMEAgH27NlDzYepYHEC/Oabb+Kee+6hNiaxv78ftbW1VFMPI5HL5Th9+jQiIiKQkZFBfZ7waNDIxS4SuyDnD6nYsSoCOX9IxSKxaeqzmUSfdli8eDFiYmJw9uzZy3LCtOBwOIiLi0NzczNjE96uhMvl4sEHH8Qbb7xBxf5UsahZEFVVVYiPj0d9fT28vLyo+HD27FkIBAJERkZSsT+SoaEhnDp1CkFBQQgPDwdgfps19LlYDudSJGoMMSSEQKfTQafTQaPR4MiRI1i9ejV4PJ5ZvCiagtFyvg0NDaioqEBqaiqcnZ0pewjU1taiubkZ6enpVH4Pg4OD8Pf3x08//YRFixYxbn8qWNQR+VtvvYU1a9ZQE9+uri709vYiISGBiv2RaDQanDt3Dn5+fgbxBf5/TjgnJwcAqIvwyFysFfdSLvZaAqzT6SCXyyGTyTA4OAilUgmlUgmVSmX490p+/vlnAICNjQ34fD74fD5sbW3B5/Ph4OAAoVAIJycni+wCHOvALTAw0PB3kJ6eTu1MZKQ/+o3ZPj4+jNt3cHDA7bffjjfffBPffvst4/angsVEwDKZDH5+fjhx4gQWLFjAuH1CCE6dOgVfX1+Td7xNxJe8vDwQQpCYmDhqtGEukfBZSS9S3xk/AlYqlejo6IBMJoNMJkN/fz+srKwgEAjg5OR0laDy+XxYWVmBw+FAp9Ph8OHDWL16NQAYRHqkYOvFXK1Ww9nZGUKhEEKhEJ6enmZfI32tagdCCIqKiqBQKJCcnEz9BaapqQnV1dVYunQpFV9qa2sRExODmpoai5gXbDEC/MYbb+D777/HmTNnqNhva2tDSUkJli9fTn3sYWVlJVpbW7F48eJxVx2ZkwhnXuzG0lA3LBK7gBCCgYEBtLW1ob29HX19fXB1dYWLi4tBHO3s7Cb0Nnai4ygJIVAqlZDJZOjr60Nvby+6urrg5OQEkUgEkUgEgUBgVimMiZaaabVa5OTkQCAQIC4ujkEPr4YQghMnTiA4OBhisZiKDzfccAPmzZuHl19+mYr9yWARAkwIQXh4OP785z9jy5YtVOxnZmYiNDSU+jyFlpYWXLhwAenp6XBwcLjmz5uLCOt9kUgkaG1thVqthpeXF0QiETw9PSe0M280pjMPWKPRoLOzE1KpFO3t7eBwOPDx8YFYLKaeU51sna9SqURWVhbCw8MRFBTEgIdjI5VKUVxcjBUrVlAJVn799VfcfffdaGlpmfLfFVNYRA741KlT6Ovrw5133knFfmNjIwDA39+fin09MpkM58+fR2Ji4oTEF6CfE9bpdJBKpaivr0dvby98fX0RHx8PV1dX6m+Xra2t4e3tDW9vbxBC0Nvbi6amJpw6dQpOTk4ICgqCr68v435OpcmCz+cjKSkJOTk5cHJygru7u4m9HBsvLy84ODigrq6OSk36ddddB2dnZxw8eBA333wz4/Yng0WcSOzevRsbN26kUnqm1WpRVVWFqKgoqm9PlUolcnNzERUVBQ8Pj0ndlsaiT61Wi9raWvz222+oqKiAj48PVq1ahfj4eLi7u1MX3yvhcDhwdXVFXFwcVq1aBbFYjNraWhw5cgTV1dUTqq82RrnddDrchEKhYZTl4ODglH2YLhwOB1FRUaipqYFarWbcPpfLxaZNm7B7927GbU8Ws09B9PT0wNfXF4WFhVRKvy5evIi2tjakpaVRE2BCCE6fPg0HBwfExcVN2Q+mFn02NTWhsrIS9vb2iIiIgIeHh8keO1OuJCKEoLu7G9XV1ejv70d4eDgCAwNHffEwRrmdsdqLKyoq0N7ejvT0dKovdOfOnYOTkxOioqIYty2VShEUFITKykpqueiJYF5hyCh8+eWXmDdvHhXxVavVqK6uph791tfXQ6VSISYmZlp+mDISJoSgra0NmZmZqK2tRVxcHNLS0uDp6WlWB1uTgcPhwN3dHSkpKUhISEBTUxOOHTuGpqamq4aAT7f12ZizHebMmQMul4vq6uppXWe6REZGoq6uDgqFgnHbIpEIS5cuxccff8y47clg1gJMCMHu3btx3333UbF/8eJFuLm5wc2NXhvr4OAgKioqEB8fb5QIzxQirI+sS0pKEBYWhqVLl0IkElms8I6Gh4cH0tPTMXfuXFRVVSErKwt9fX2G70+n9dnYg3U4HA7i4+NRW1t7mY9M4+zsDB8fH2ovBA8//DA++ugjs27PN2sBLigogFQqxT333MO4bY1Gg/r6+suaHJhGX+MZFBRk1FVHxhJhQghqa2sNu+aWL1+OgICAGSW8I9FXSSxbtgy+vr7Izs5GVVUVdDrdlFufTTXVzMnJCRERESgsLKQ6rDw8PBxNTU2jNs+YmrVr14LH4+G3335j3PZEMWsB3rt3L5YuXWr0JZcTobm5GY6Ojibb8TYR6urqMDw8bJJ87XRFWC6XIzs7GxKJBKmpqUZbp24JcLlchIWFIT09HVKp1DAsfZHYBc8tD6UuvnpCQkJgbW1NdTaIo6Mj3N3dIZFIGLfN5XKxcuVK7Nu3j3HbE8WsBXjfvn1Yv34943YJIairq6Pa8SaXy1FZWWm01MNoTFWEJRIJsrKy4O7ujoyMDAiFQpP4Z+44OTlh8eLF8PX1xalTp3Dx4sUJL4hkYp6vPhVRV1dHdWhPcHAw6uvrqUTit9xyCw4cOGC2izvNVoAbGhpQV1eHDRs2MG67q6sLarWa2q45QgjOnz9v9NTDaExGhHU6HS5cuIDKykokJyfPqqh3LPTR8OLFi9HQ0IDCwsJrjolkcpi6o6MjIiIiUFRURC0V4eHhAR6Ph7a2NsZtL1++HCqVCkVFRYzbnghmK8AHDx5EYmIilY6kuro6BAUFUSvhaWhoMFnqYTQmIsLDw8M4c+YMZDIZu+RzFJydnZGeng6VSoXs7OwxT/5pbLLQpyJqamoYsXclHA4HwcHBqK2tZdy2tbU1Fi9ejP379zNueyKYrQDv27cPN9xwA+N2FQoFOjs7qdUOajQaVFVVISYmhtHocjwR7u/vR1ZWFuzs7JCamkolJz8ZaO2Cs7GxwaJFi+Dq6oqsrCz09l5un9YaIQ6Hg5iYGFy8eJHKYRgA+Pn5YWBggEpVxrp168w2D2yWAtzf34/s7GzcfvvtjNuWSCQQiUTURvvV1tbC2dl50t1u00EvWKXd6qtEuKenB9nZ2QgKCjJpPtpY0N4Fx+VyERMTY9jf1tHRAYD+Ak2hUAgvLy9qJWHW1tbw9/enchi3ceNGVFVVobm5mXHb18IsBfjXX381dB0xCSEEjY2N1KJflUqFixcvMto5dKVgjRThoqIinDlzBjExMQgNDbWI8jJz2QUnFouRkJCAvLw8FBcXU1+gCVxqjJBIJNTalMViMZqbmxlfpSQQCLBw4UIcPHiQUbsTwSwFeN++fVixYgXjdjs6OsDlcqkNMqmuroaXlxejVQWjCZajoyOioqLQ2NgIT09Pkw8hMmbKwJx2wYlEIvj7+6OhoQHh4eHUF2g6ODggICAAlZWVVOwLBAI4ODigtbWVcdurV6/G3r17Gbd7LcxOgDUaDQ4fPozbbruNcdsSiYRaI8HQ0BAkEgnmzJnDqN3RBKunpwcXLlxAdHQ0enp6TFpHauyUgTntgquvr0dLSwtiY2NRWVlpSEfQJDw8HFKplFqHXGBgIJU0xG233YaTJ09CLpczbns8zE6AT58+DXt7eyQlJTFqV61Wo729ndq838rKSvj7+8PR0ZFRu1cKVrQbD2fPnkVMTAxCQkJMPkXNFCmDyTZEmIKROd+goCBDOoL2Ek0+n4/g4GBUVFRQse/r6wuZTIahoSFG7YaGhiI4OBhHjhxh1O61MDsB3r9/P5V1Ju3t7RAKhVRO+Pv7+9HW1kZtYLpesBJ8HHHu3DmEhIQYXohMPcrSnFIGxmK0AzeRSISoqCjk5uZCqVRS9S80NNSwEYRprK2t4eHhAalUyrjtFStWmF01hFkKMI3mC6lUCpFIxLhdAKipqUFgYCDV8i5CCAoKCuDs7HzV/AtTirA5pQxGY7L56fGqHYKCguDl5YW8vDzGD6JGwuPxEBYWRq0uWCQSURHgW265BYcPH6b62F+JWQlwVVUVpFIp1q5dy6hdnU6H9vZ2KtuWlUol2traEBwczLjtkZSXl0OpVCI+Pn7UHLipRZh2ymA0JpufnkipmX6k6IULF6i2x4rFYvT09GBgYIBx215eXuju7mZ8WHtaWhp4vEspNnPBrAQ4MzMTCxcuZDwS7O7uhq2tLZycnBi1C1x60opEIqrbeVtaWtDU1ITExERYW4+9pYrGZg2aTCY/PdE6Xy6Xi4ULF6KrqwsNDQ0m8Hpi8Hg8+Pv7o66ujnHbfD4fAoGA8UNJLpeLlJQUZGZmMmp3PMxKgPPy8qhsddWnH5iuftBqtWhoaKAa/SqVShQXF2P+/Pmwt7e/5s/PJhGeaH56sk0Wtra2WLBgAcrLy6meygcFBaGpqQnDw8OM26aVhpg/fz5yc3MZtzsWZiXA+fn5SExMZNQmIQRSqZRK+qGtrQ12dnbURl4SQlBcXAxfX194enpO+HazRYQnkp+eaoebi4sLgoODUVRURC0V4eTkBDc3NzQ1NTFuWyQSob29nfEBQcnJySgoKGDU5niYjQCrVCpUVFRg8eLFjNodGBiAWq2msvWioaEBgYGB1DrMmpub0dfXN6XOu9kkwmPlp6fbXhweHg61Wk0lDaBHLBZDIpEw/iLg5OQEHo+Hnp4eRu0uWrQIHR0d6OzsZNTuWJiNAJeUlMDV1ZXx1e/66Jfpsje5XA6ZTAZfX19G7epRKBQoKSlBfHw8eDzelK4xW0R4NIwx28HKygrz589HZWXlqKkIJoYKiUQiDA8PXzU4yNRwOBwqaQgHBweEhISYTRRsNgJcUFBAZfEmrfSDRCKBr6/vlMVvupSWlsLX13faQ39KutQo4fqhuraO0ZX3KpUKCoXCMNdApVIxVl5kzME6QqEQwcHBKC4uviwKZWqoEJfLpTYkx8vLC1KplPHoOyoqymwEeOwjb4bJy8tDbGwsozZVKhX6+voYF2BCCFpaWjB//nxG7erp7e1FZ2fntOdtjFzF7mWrw25ceittzIYSjUaDvr4+yGQyw7/60ikrKyvDO5ejR48CuBSVC4VCCAQCw7/GfJEzxVSzsLAwHDt2DB0dHYa/xZEVGFbcSxUYpirT8/f3x6lTpxAXF8foO0F3d3eoVCrI5XJGK5Di4+PN5iDObAQ4Pz8fTz31FKM2u7q6IBQKGY9C+/v7odVqqQw1J4SgvLwcoaGhsLGxmda1RopEu4qLKl4AbP6vtGo6IqzRaNDa2oqmpiZ0d3fDzs4OQqEQQqEQfn5+ht8Zh8OBVqvFoUOHcOONN4IQYhBpmUyGhoYGDA4OwsXFBQEBAdN+x2GqkZLW1taIiIhAeXk5PD09weFwsCzUHX/9pYqRDkEnJyfY2tqiu7ub0TGoXC4XHh4e6OrqYlSAk5KS8P777zNmbzzMQoBVKhXKy8uRlpbGqF2ZTEalAoFW3hkAOjs7MTAwYJRZG1eKRFq4D6LdxMjJyQEweREeGhpCXV0dJBIJnJycEBAQgIULF07ohYLD4cDa2hru7u6XTbNTq9Voa2tDU1MTSktL4e/vj5CQkEnP3DD1PN+AgABcvHgRLS0t8PPzM1RgZF7sxtJQN5M2qYzMxzIpwMClFAzT8zFSUlLQ3t6Orq4uapMP9ZiFAJeWlkIoFDI+/1cmk1EZviOVShEWFsa4XX30GxERMW7DxUQZSyRSU1MnJcLDw8MoKytDS0sLfH19sXjxYqOtouLxeAgICEBAQADkcjlqa2tx4sQJiEQiREdHT6jph4lh6lwuF1FRUSgrK4OPjw+4XC4WiV0Y6w708vLC+fPnER0dzWhVjlAoREtLC2P2gEtpquDgYBQUFGDVqlWM2r4SsziEKygoYHQIOQDD21WmN/oqFAr09/czHmkAl+qONRqNUQfOj1amNZnqCKlUiszMTGg0Gixfvhzx8fEm2wPo6OiIuLg4XHfddbCyskJmZiaam5vHPQRicpOFt7c3bGxs0NjYaFI7o+Hm5ga1Ws14a7JAIMDAwADj8xkiIyPN4iDOLAQ4Pz8fMTExjNocGhqCTqdjfPxje3s73N3dqVQ/1NbWIiQkhJHUx7VEWK1Wo7CwEEVFRYiJicHChQsZa8e2tbVFfHw85s+fj7KyMuTl5Y26K43pNUIcDgehoaGora1lvDKAy+UaqhKYxNbWFnw+H/39/YzajY+PR15eHqM2R8MsBDgvL4/xDjiZTAahUMh4EwStsjd99QCTddZjiXB3dzeOHz8OrVaLZcuWwcfHhzGfRuLl5YVly5aBx+Ph+PHjaG9vN3yP1g43b29vaLVaKo0CNAQYuBQFM50HXrRoEfLz8xm1ORrUBVif/6NxAMf0ihiNRoOuri4qYy8bGhoQEBBglNzvZLhShNvb23H27FlERkZi4cKF1Jaf6uHxeIiPj8e8efOQn5+PlpYWqgs0uVwuAgMDUV9fz6hd4JIA9/X1MT6vmMZBXGpqKtra2qjMRB4JdQGWSCTg8/kICgpi1C6N/G9vby/s7OwmNPTGmKjVajQ3N1NbNqoX4draWuTm5iIhIYHa5pGx8Pb2xqJFi1BUVISysrJpie90O9gCAgLQ0dHBuBDyeDy4uLigu5vZRaZCoZDxFUmOjo7w8fGhNhNZD3UBbmtrY/xAihBCJQKmVfbW2toKoVBIZdymHn3O3crKito+smvR398PDocDDocz5Sllxuhg4/P58PLyonIYRyMaFQqFhtp4JvHw8EBbWxujNq9kVgqwXgyYFiQaog9cEmBaMyeAS5F/Xl4eFixYgPT0dLOcHaFPO6SlpSEpKQnnz5+fUh7WWDvu/Pz8qIgDjXysra0tbG1tGT+Ic3d3ZwW4ra2N8WLovr4+CAQCxg/gaKQ9aOadgUtzG/RzPkQikVkO8Lky5+vu7o64uDgUFhZOemuDsXbceXh4oL+/HwqFYkq3nyr6dADTVRg0Im9PT09WgFtaWiY1i9YY9Pf3m6zWdCzUajWGhoZMGgGPlnvs6OiAk5MTtY0bFRUVsLOzuyzHb04iPNaBm5+fH1xdXVFSUjKp6xlrxx2Px4Obm9tllRlM4OjoCJ1Ox/jWYmdnZ8ZrkL29vRlvArkS6gLc2toKb29vRm0qlUrGBUkmk8HR0dFkVQhj5R5pLhvt6emBRCIZdc+cOYjwtaodYmNj0d7ePunSLGPtuKMxrpHD4VCJRu3s7Bg/dPTx8WEFuLW1FX5+fozaVKlUjJc/mTr/O1rukRCC9vZ2KgKs1WpRWFiIuXPnjln1QVOEJ1JqZmtri7i4OBQXF1Nb29PZ2QmNRsOoXVp5YKYF2NfXl01BtLW1MX5ApFQqGV/8aer872i5R/2pPo2Dv+rqatjZ2V2z9I2GCE+mztfHxweurq6oqKhgxLeR2Nvbw8HBgfGtETQiYD6fP2o3oikJCAig0ngyErMQYKZrQmkJsCmFcLTcI61uP41Gg/r6esydO3dCtpkU4ak0WURFRaGpqYnxCA2gI4YCgYDxigQ+nw+lUsno4V9gYCC6u7sZf4cxEqoCrB9Mw+QUNEIIVCoV4wKsUChM3oBxZe5RL8BTYTrNBBKJxDAQfaIwIcJT7XBzcHCAl5cXle40Gk0KdnZ2GB4eZrQu19bWFjqdbtJVJ9PBw8MDPB6P8YPOkVAVYKlUCgcHB0ZLs/Rvc6Y7jHwyqNVqaLVai8k7T6eZgBCC+vp6hISETNquKUV4uu3FISEhkEgkjG/xpREB83g8WFlZMRrxc7lcxvPAXC4X7u7uaG1tZczmVT5Qs4xLB3BM1wArlUrY2toy+rZcpVIZ/qiZQqfTob+/f0ovbtNpJujt7YVGo5lyaaEpRNgYsx1cXFzA4/HQ0dFhFJ8mirOzMxQKBeOHgDRysjQO4mg3Y1AVYBpNGDTSDzRyzgMDA+DxeFOyO51mgsbGRvj7+09r5KUxRdhYg3U4HA4CAgIYbw+2traGo6Mj42kIfU6WaZtMiz7tZgyqGzHa2toYb8KgIYY0bA4NDcHBwWFKkf501uF0dXVh3rx5k7Z5JXoRnup6I8D4IyW9vLxQU1MDQgij76AcHBwYb4ygJcBM26Q9D4KqAPf09DBeIjVbBFifapkqU1mHo1arMTg4aLTf6XRE2BQjJZ2cnKDT6Rg5UB3JbBFDGjZdXV0Zn/42EqopCI1Gw+hhGECnCWO6YjgVaKRa+vr64OjoaNRtH1NJR5hqnq++pppGjSzTwkQjH2tra8t4CoLH483eMjSNRsPowRQAw0hEJpkteefplL2Nx2RE2NTD1Gl1iTEtTDTysVZWVoxXmVhbW1PpctRDVYCHh4cZ39Cg0+kYb0xQq9WM74Cbac0mExFhJjZZ0KjLpREB83g8RmtygUvvMGgI8KyOgJkWYKYPUPQ2mViEORIaqRZTT5kbT4QbGhoYWSPk7OzMeJcYjQiYy+UyPpKSw+EwbnPWCzDTkSENMaQRddO4n1qt1uS/z7FEuKqqipEdblPNGU6ns5DL5V4VGU537dG1oCGGNETfWJF+f38//vd//xc///wz3nvvvQnfblLhZ0tLC/79738bTg1dXV3x6KOPTnnTrkajga2tLaMtj1qtFoQQRm3qdLpZYVNvy9Q27ezssGjRIpw5c8bQRpqYmAhHR0dG7q9Go5mUnXOSXix//ww4HA52HKnE8f9JRmLAxCtMCCFQKpUGm9O93kRtKhQKxv9mR95PJujp6UFZWdm0r/PZZ58hISEBq1evxi233IK77rprQu8GOWQSLzklJSUIDg5GdnY2urq6cNddd03L6QceeAA6nQ4bNmyY1nVYWFhYpsKLL76IwsLCaUfe27Ztw5YtW5CQkIDf//732LJlCxYuXHjN200qAo6JicGnn36KDRs2YPfu3VN2Vo++U2vNmjXTvtZEKSgogLu7O6Mbgs+cOYPAwEBGB89nZWVh7ty5jHYaHjt2DAsWLGCktruhoQHV1dWIjo5GYWEhwsLCptSsMVkUCgVOnDiB1atXT/g2uY29WLb7jOFt/WQj1v7+fpw7dw7XXXedUa43Ebq6ulBWVoaMjAyjXnc8WltbIZFIkJyczJjNkpISowwDG1ldpdVqJ1xpNekTsJycHNx3330oKiqa7E2vgsfjTcpZY6DPizJtk8PhzHibelumtllfX4/q6mqkpKTA0dERhYWFaGpqgpWVFSMibGVlNan7mBzkjszfpU2psxC49LvkcrkGm9O93kTgcDiX2WQCGjaNdQ41d+5ctLW1Yd68eWhqakJwcPCEbjdpAX7hhRcAAP/6178me9OrjVtbM15eQ+NwYbaU19jY2Jj893llqZk+X5icnIwzZ84AmFrb8kRRKpVTah6aSmehntHq5adzvYkwW6qFjFWJtXnzZuzcuRM6nQ5LliyZcD38pC3rt1cYY4g6DZGgcdI62im2qaFRuqRvUvDx8THJ9cer83VwcJj27IiJYKpmk/GgUdOt0+kYF0Maom+sCNjZ2Rl/+9vfAAA33njjhG9HtQxtthR70+pkYvrdhSln106kyYKJoe6m3mwyGjQEWKVSMT4mgFaTFNO9CCOhKsDW1taMlpzobTIddc8mAe7r6zP6O4zJdLiZWoRnSwRMo32eRmMWjV6EkVAV4NkycYnWMBWmRV9fh6tQKIx2zam0F5tKhI097W2i0BogNRvml9AYlDUSqgLs6emJrq4uRm3OFgGers2pdFpxuVwIBAL09hqnO2s6sx1MIcIymQz29vazYq7HbLHZ0dEBkUjEqM2RUBVgHx8fVoBNhJOTEwYGBqaU757OTjiRSISWlpZJ27wSYwzWMbYIt7S0MFrLrae/vx9OTk6M2pwtAtzZ2WmyQ+OJQFWAvb29GRdgmqP9mKy+4PP54PF4GBgYmPRtp7MTzt/fH+3t7dN6jI051cxYIqzRaNDS0jLltvupolAooFarqQjwbJib3dXVReVFVY9ZCDCTB3F8Pp/Kym2tVsvo4d90hodPZyccn8+Hh4fHlHenmWKkpDFEuKWlBU5OTiad9jYafX19cHZ2ZrQkjBBC5RCOhs1ZLcAeHh4ghDC6k8na2hpWVlaMRsFcLpeRJoUrmersWv1OuB2rIpDzh9RJF/yHhISgrq5u0ukPU87znY4IE0JQW1uLkJAQo/o0EWhUXegHlDMZjWo0Gmg0GkYFeHh4GD09PbNXgK2srODh4QGJRMKYTQ6HQyUn6+DgALlcblIbVx6cTacud5HYBc8tD51St5W7uztsbW3R3Nw84dswMUx9qiLc3t4OjUZD5YlKQ4Dlcjns7e0ZrclVKpXg8XiMtiE3NjaCx+PBxcV0HYXXgqoAA5cObZhe9U1DgE29yma0gzN9BMx03TOHw8GcOXNQXl4+oXcaTIivnsmKsEajQUlJCebMmUOlM6y3t5dxAZbJZFSaTZjO/zY2NsLLy4vx5o+RUBdgb2/vSUVKxoDGQZypV9mMdnBmZ2cHR0dHdHZ2mszuWIhEInh6eqKkpGTcn2NSfPVMRoTLysrg5OTE+OEbcGlWLZfLZTzvTCPqppH/bW5uppp+AMxAgH19fRnNAQN023RNVQkx1sGZSCSCVCo1ic1rER0dje7ubrS2to76fRriq2ciItzZ2YmWlhbExcVRiZKkUilEIhHjtvv6+mZFtx8rwLgkwEwLhL29PYaGhhi16eTkBLVabTLhH+vgTCQSob29nfEBRMCl6WhxcXEoLi6+6h0HTfHVM54IazQanD9/HtHR0bCzs6Pin16AmUSj0UAulzP+OxkaGmL8cW5tbTUMF6MFdQH29vZGR0cHozZprBbXv5U0pd3RDs70kYyxutMmi0gkgpeXF4qKigxVEeYgvnpGE2FCCIqLi6ecejDGvja5XA6FQsHoQH3gUvRrZ2fH+CAeGmmP9vZ2qk0YgJkIMNM5SoFAgMHBQcYnsdFYac7hcKimIQAgNjYWw8PDKCoqQl1dndmIr56RIlxZWYnS0lL09fVh/vz5k377P50uwpFIpVJ4enoyWhUA0BFCQgiVKXOdnZ1sCoJGOzKPx4O9vT3j68VNOa5xPPz8/NDU1MT4GE491tbWWLRokWHNTXJystmIrx5HR0ekpKTg4sWLaGpqQnJy8pSiwOl0EeohhKCxsRF+fn6Tvu10oZH/HRgYAJfLhb29PaN2abchA2YgwL6+vujs7DQUfzMFDTF0cXFBb28v4/lYNzc3WFlZMZ7qGUlLSwu0Wi3s7OxQW1tL7cVgLAghqK+vh42NDTgczpRLI6fTRaint7cXw8PDjOd/CSHo6elhXID1os/0YSObgsClHKF+rxeT0MgDOzk5gcvloqenh1G7HA4HYrEYDQ0NjNrVo8/5pqamIj09HYODgzh79qxRx1ZOB5VKhby8PHR3dyM9PR2LFy+ectvydLsIgUsLR/39/RmvO5bL5VCpVHBzm/yLxnSgUXfc0NCA/v5+RnYIjgd1AeZwOJg/fz5Onz7NqF0aETDNfKxYLEZXV5fJu/Gu5MoDNxsbG8MyzczMTEgkEioVGnpaW1uRmZkJa2trpKWlgc/nT3t2xHS6CJVKJVpbWxEUFDTp204Xfd6ZaeGnkfbIzs5GVFQU1VnAgBkIMAAsXLgQBQUFjNoUCoUYHBxkvEuMlgDb2NjAz88PdXV1jNkcq9rB2toasbGxSExMRHV1Nc6dO8d4NKxSqZCfn48LFy5g3rx5mD9//mVzfplYbzQaDQ0N8PT0ZDwfCtApeyOEUDn4y83NxcKFCxm1ORpmIcALFixAWVkZozb1B3FMVyW4u7tDoVAwHokCl4bkNDY2MiJ2Eyk1c3d3x9KlS2Fvb4/MzExcvHjR5JUpGo0G9fX1yMzMBJfLxbJly8YUHaZFeHh4GHV1dQgNDTW5rStRqVSQyWTw8vJi1K5cLqdyAFdSUoIFCxYwanM06G2jG0FCQgKqq6sZ3wmlzwMzmfOysrKCp6cn2tvb4ejoyJhd4FIO2tfXF1VVVZg3b55RrnmmoReZtV1YFupueMs9mTpffTSs96uqqgpisRhisdioM3AHBwfR2NiIhoYGODk5Yf78+fD09Lzm7fQibOptywBQU1MDNzc3uLq6mszGWLS3t8PFxYVK/a9AIGD8AK68vBwJCQmM2hwNsxBgsVgMW1tbFBQUICkpiTG7tMrCRCIRmpqaqIw3nDNnDo4dO4aQkJBpC5y+5pXD4eCvv1Qh5w+p8NLJplTn6+bmhpSUFPT19aGurg5ZWVlwdnaGj48PhEIhBALBpFYBaTQa9Pf3o7e3F21tbZDJZPD29kZSUtKkBY4JEVYoFKivr0d6errha6O9uJkKGukHgE7+VyKRoLe3FzExMYzaHQ2zEOCRB3FMCrCLiwujozD1eHl5obi4GMPDw4xHHHZ2dggKCkJFRQUSExOnda2RNa9WXA7OV9RATLqn1WQhEAgQHx+PmJgYtLa2oqOjAw0NDRgcHISjo6NBjG1sbC5rUmhuboZGo0FfXx9kMhnkcjns7OwgFArh5+eHpKSkae1yM7UIV1VVwdfX1zB4Z7QXN1OJsFarRUdHB6Kiokxy/fHo6elhPOWSnZ2NyMhI6gdwgJkIMEDnIM7V1RUqlQoDAwOMrnyxtbWFUCiEVCpFQEAAY3b1hIWF4bfffkNPT8+03u4uC3XHX3+pghWXg5VeWvhoupCyONUoJUXW1tYICAgwPD5qtdogrn19fVCr1dBqtYZ64tbWVtjY2MDZ2Rl+fn4QCoVGf3EzlQgPDAygubkZy5cvN3ztyhe3zIvdJhPgzs5Ow+Q8JlGpVOjr64OHhwejdnNzc80i/wuYkQAvWLAAR44cYdQml8uFp6cnpFIp4zu3AgIC0NjYSEWAbWxsEBERgeLiYmRkZEy57Ehf83q+ogY+mi5kGEl8R4PH48Hd3f2q2QharRaHDh1CYmIiI227xhZh/dyJ4ODgy4bRjHxxm2pDx0SRSCRUxm1KpVK4uroyvmW6pKQEt912G6M2x8IsqiCASwdxlZWVs6YszNfXFzKZbEpLM41BcHAwrK2tp32676WTQUy6TSq+5oYxqyPq6uowPDx8lZAbo6FjIiiVSnR0dFAJBGjlnSsqKsziAA4wIwEODAyEjY0Nzp8/z6hdLy8vyGQyxge0W1tbw8/Pj0oOGriUd4+Pj0ddXd2UDyLNaaoZ0xhDhOVyOSorKxEfHz9q9D6dho6Jot8KwfQsXq1Wi87OTsYFuLm5GV1dXWZxAAeYkQDrD+L0b+2YwsbGBi4uLmhvb2fULnDpRaepqYnRDc0jcXR0xJw5c1BYWDhpH2aL+I43WnK6iz6LiooQFBREbScZIQQSiQRisZhx211dXbC3t4eDgwOjdk+dOoXIyEjGX3DGwmwEGKBzEAfQS0MIhUI4ODgwvpJpJMHBweDxeKisrJzwbWaT+F5rtORURVjfdEJzFoFUKgWHw5lQPbQpbNNIP5jTARxgZgKcmJjIeAoCuCTAHR0dVCLR4OBg1NXVUZuHwOFwkJCQgMbGxgm9EMwW8QUmPlpysiLc0dGB6upqLFiwgPF5vyOpq6tDcHAw400QhBBqAsx0r8G1MCsBXrFiBSorKxnPizo6OsLOzg7d3ZOf3TpdfHx8MDw8zPhM5JHY29tj4cKFKC4uHjcfPJvEF5jcaMmJirBcLkd+fj7mz5/P+LLNkehL+mhUP/T19YEQwnjqpb+/H3l5eVi9ejWjdsfDrARYIBAgNTUV3333HeO2aaUhuFwugoKCUFNTw7jtkbi7u2Pu3Lk4d+7cqHvrZpv4ApOvRLiWCKvVapw7dw6hoaHUNzFcvHgRYrGY8RIw4FL6gcY6+B9//BGhoaFUKj7GwqwEGABuuukm/Pzzz4zb1QswjVRAUFAQ+vr6qKyPH0lgYCBEIhFyc3MvS8eYWnyNsUPNVEy2EmEsEdbpdMjPz4dAIEBYWJip3J0QfX19kEqlVIb+APTyvwcPHsSGDRsYtzseZifAa9euxdmzZxmfFubq6gqdTkdleSWPx0NERATKy8upzsYFgJiYGFhbWyMvLw86nY4R8TXGDjVz4koR1lc8DA8PY968eVRW3I+kvLwcISEhVCoB5HI55HI5491vWq0WWVlZWLduHaN2r4XZCXBQUBACAwOxb98+Ru1yOBz4+/tTq8sNDAzE8PAw2traGLc9MgLlcrlITEyERqNBVlYWKioqTJp2MMYOtSsxh4haL8L19fXIysrCwMAAkpOTGZ32NxpdXV2QyWRUBkEBl7rufH19GX8cjh07Bmtra7NpwNBjdgIMAOvXr8eBAwcYtysWi9HS0sL4tmTgUi54zpw5qKioYHRf2mgRqLW1NUQiEQYGBiAQCEw6I8AYO9RGYk4RtYODA1xdXdHf3w8PDw/GBy9dCSEE5eXlCA8Pp5L71el0aGxspFJ3/OOPP2LdunWMb/u4Fublzf+xfv16nDhxgvGyMEdHR7i4uFCry/Xz8wOXy0VTUxNjNkeLQOvr61FTU4PU1FQQQpCXl2ey34WxW25NEVFPBZ1Oh8LCQgwNDSEtLQ3Nzc2MbtYYDalUCqVSicDAQCr229rawOfzqTSeHD9+3OzSD4CZCnBiYiIIIcjKymLctlgsptoeHBUVhcrKSsZefK6MQJOEKkPO183NDYsWLQIhBKdOnTLZJg1jttwaO6KeCiqVCmfOnMHQ0BBSUlLg6upKZb3RSHQ6HcrLyzFnzhxqtcf6rjumc+AVFRVXTZszF8xSgLlcLtasWYMffviBcdve3t5QKBRUDuMAwNPTEw4ODqitrWXE3sgI9OgdQVB1NF6W87W2tkZSUhLc3d2RlZXF+EbnycLUEJux6O/vx8mTJ2FnZ4eUlBRD2oHWjjk9TU1NhnMOGgwODqKnpwd+fn6M2/7mm2+wfPnyy6bNmQtmKcDApTTEsWPHGLdrZWWFgIAARpdXjoTD4SA6Oho1NTWMVYIsErvgjmCrq8RXD5fLRXR0NCIjI3HmzBk0NjYy4tdUYWKIzWi0tbXh1KlTCA4OHnXADi0RViqVKCsrQ0xMDLUKjLq6Ovj6+lLJg//6669mV36mx2wF+LrrrkNDQwOVBoXg4GC0tbWN2pDABEKhEMHBwSgqKmKkLG2ipWZisRjJyckoLy/HhQsXGB8daq7o394XFRVh4cKFCAkJGVPomBZh/bxhX19fxku/9KjVajQ2NlKpvOjq6kJRURHWrFnDuO2JYLYC7ODggKVLl+Lrr79m3LadnR28vLzQ0NDAuG09ERER0Gg0Jo/EJ1vn6+rqioyMDMjlcpw4cYJK+7Y5IZPJkJWVhe7ubqSnp09q0ScTItzc3Iy+vj4q64b0NDY2QigUUmm93rNnD2JjYxnf9jxRzFaAAWDDhg1UuuKAS1FwQ0MDtVGRXC4X8fHxqKysNFkqYqpNFnZ2dkhOTkZYWBjOnj2LkpKSWRcN63Q6VFRUICcnBwEBAUhLS5tUuR4TIqxQKFBSUoL4+HgqZWfApQi8vr4ewcHBVOybY/fbSMxegIuKilBfX8+4bVdXV/D5fKqjIk2ZiphuhxuHw4FYLMbSpUsxMDCAEydOoL29nXonHxN0dXUhKysLXV1dyMjIGDflMB6mFGFzSD0AMLT302g97unpwYkTJ3DrrbcybnuimLUAe3l5YfXq1Xj77bcZt83hcBAeHo6qqipqUTDw/1MRxqyKMGZ7sb29vSEaPn/+PHJycsy+UmKq9PX14ezZs8jLy4NYLL4q6p1KB56pRLipqQkDAwOYO3eu0a45WQghqKysRFhYGJXDv927dyM+Ph7h4eGM254oZi3AAPDwww/ju+++oyKC3t7e4PP5VHPB+lREVVWVUfbHmWK2gz4aXr58Oby8vHD27Fnk5uZS23dnbAYHB1FQUIDs7GwIBAKsWLHiqjm60+nAM7YIKxQKlJaWIj4+nmrrc3NzM3Q6HbXpY1999RUeeeQRKrYnitkL8HXXXQcOh4Mff/yRcdv6xojq6moq7cl6hEIhwsLCcO7cuWn5YerBOtbW1ggLC8OKFSvg4OCArKws5Ofno6enxyJTE319fSgsLERmZiZ4PB6WL1+OyMjIUfOp0+3AM5YIa7Va5ObmIiAg4KoN0kyi0+lQWVmJyMhIKu2/p06dQktLCzZu3Mi47clg9gJsZWWFrVu34qOPPqJi393dHUKhkLHGiLEICwuDUChEfn7+lMSMyXm+NjY2mDt3rkGIz507h5MnT0IikZj9YZ1Wq0VTUxOys7ORk5MDW1tbLFu2DLGxseNODzNGB950RVg/dc3GxoZq1QMANDQ0wMbGhtrc4127duGee+4xm91vY8EhFhCaNDc3IywsDDU1NVQ6afr6+pCdnY0VK1bA1taWcft6NBoNsrOz4e7ujujo6AnfjvYwda1Wi5aWFkgkEvT398Pb2xsikQienp7Tfous1Wpx6NAhrFmzZsotthqNBl1dXZBKpWhtbYWDgwPEYjH8/Pwm5d9ZSS8yL3ZjaajbtJpA5HI5cnJyEBgYOKmdcdXV1WhsbERGRga1qgfgUt3vb7/9hgULFlA5AOzv74efnx9Onz49qecJDSxCgAHgxhtvRHR0NF599VUq9gsKCsDj8RAbG0vFvh6FQoGsrCxERUVNKLdGW3yvZGBgAK2trWhra8PAwADc3d0hEokgEomm1Co6VQFWKpVob2+HVCpFZ2cnHBwcIBKJ4OPjYxaP02RFWCqVorCwEIsXL4aTkxMDHo5NZWUlent7kZycTMX+66+/jm+//Ra5ublU7E8GixHgX3/9Fffdd5/hrQ3TDA4OIjMzE0uXLmV8lfaV9PT04MyZM0hOToarq+uYP2du4nslCoXiMhHk8XgQCoWGD4FAAD6fP+4J+kQEWKlUGnagyWQy9PX1QalUXib+9vb2prqbU2aiItzf349Tp05hwYIF1BsOVCoVfvvtN6SmpkIoFDJuX6fTISoqCn/9619x1113MW5/sliMAOt0OkREROCZZ57Bgw8+SMWHCxcuQK1Wm8VQZ4lEgoqKCmRkZIwaOZqT+J5p6EVmbReWhbqP+dZcp9Ohv7//MqHs7+8Hl8sFn88Hn8+Hra2t4f9WVlbgcC7lWy9cuIDo6GgQQqBSqaBUKg0fKpUKGo0Gzs7OBlHXd2XR3Eg8Ua4lwsPDw8jKykJQUBC1FUMjKSkpgUqlorb6/cCBA3jooYfQ2NhIff7yRLAYAQaAd999Fx9//DEKCgqo2FcqlTh27BjS0tKoixoAlJaWoqur67KpW4D5iW/arhyDWE5mQplOp4NCoTAI6Uhh1el0ho/29nb4+PjAysrqMpHWi7adnZ1FiO1YjCXCGo0GZ8+ehZ2dHebPn0991dHQ0BCOHz+OJUuWmHSI/3gsX74cGRkZ+Nvf/kbF/mSxKAGWy+Xw9fXFoUOHsHjxYio+VFZWoqenB8nJydT/4AkhKCwsxODgIJKTk8Hj8cxKfAHg5WM1+Nuv1dDqLlUI7FgVgeeWGy9SM8YhnCVwpQhrtVqcO3cOXC4XCxcuNIv7XlBQAGtra8TFxVGxX1FRgYSEBDQ0NExoJoc5YPZlaCNxdHTEgw8+iH/961/UfAgNDcXg4CCjWyvGgsPhID4+Hnw+H2fPnkVtba1ZiS9gHgPSZwIjS9QqKyuRl5cHAGYjvlKpFB0dHZgzZw41H/75z3/i1ltvtRjxBSwsAgYu1RdGRUWhqqqK2nDprq4u5ObmYunSpWYx5Fmn0+HEiROQy+VIS0sb92COBsYqzxqN8SLgieSeLY3+/n5kZWUZ6pNpL/kELuWhjx8/jtjYWPj4+FDxoa+vD/7+/jh58iTmzZtHxYepYFERMHBpe/ANN9yA7du3U/PB3d0dfn5+OH/+vFl0eEkkEiiVSri6uqKsrIxq195o0BiQbk7LOY2FVqtFWVkZnJ2dodPpqDcH6SkpKYG7uzs18QWAv//970hISLAo8QUsUIAB4KWXXsK3335LZVi7nqioKMjlcurbIfQ539TUVKSkpIDP5+P06dMYHh6m6hdtzGU5p7HQH7gRQpCamoq0tDSqO+b06EsIY2JiqPnQ3t6ODz74AK+88go1H6aKRQpwREQENm3ahKeffpqaD9bW1oiPj0dZWZnJllVeiysP3LhcLhISEuDo6IicnBwMDQ1R8cscmEm5Z6VSidOnT8PKygpJSUmwtramvmMOuJR6OH/+PGJjY6l2iP75z3/GsmXLkJSURM2HqWJxOWA9LS0tiIiIwPHjx5GYmEjNjwsXLmBwcBCLFi1itCpivGoHQggqKiogkUiQmJgINzfLFZ9rMV4O2JS5Z6aQyWQ4d+4cRCIRYmJirhpsM9W2ZWNQUFAAQgi1ml8AqKmpwbx581BQUED1AHCqWGQEDAC+vr743e9+h2effZaqHzRSEdcqNdNPcYuJicHZs2epjtOkCa3lnMaipaUFOTk5CA8PR1xc3KhTxWhFwm1tbdRTDwDw7LPP4vbbb7dI8QUA+keo0+C5555DYGAgfv31V6xatYqKD/pURG5uLjw9PU1eFTGZOl8/Pz84ODggNzcX/f39iI6OpjIakGVy6AeZNzQ0IDEx8ZoDbfQinJOTAwAmj4SHh4dRXFxMPfVQUFCAX3/9FZWVldR8mC4W/Wx0cXHBc889h+effx46nY6aH+7u7vD39zd5VcRUmixcXFyQkZEBmUyGM2fOzPrDOXNHrVYjNzcXbW1tSE9Pn/A0MSYj4ZKSEnh4eFCtegCAZ555Bo888giVCYnGwqIFGAAeffRRtLa24ptvvqHqR2RkJIaGhkxWmTGdDjc+n4/U1FTw+XxkZWVBJpOZxEeW6TEwMIBTp04BABYvXjzpoU9MiHBDQwO6urqopx5+++035OXl4bnnnqPqx3SxeAG2t7fHiy++iBdeeIHq7jZra2skJibi4sWLkEqlRr22MdqLraysMH/+fAQHByMnJweVlZVU3zWw/H8IIbh48SJOnjwJX19fJCYmTnmerylFuKurC2VlZUhMTKQ66Ean0+G5557Ds88+a3ZNR5PF4gUYAO677z4QQrBr1y6qfjg5OWHBggUoLCxEf3+/Ua5pzNkOHA4HISEhSE9PR0dHB7KystDX12cUP1mmhlwuR3Z2NpqampCamoqIiIhpV9OYQoSHhoaQl5eHuLg4uLjQPdT8/vvv0dzcjMcee4yqH8ZgRgiwtbU1/vGPf+C1116DUqmk6ounpyfCw8Nx7ty5aedbTTVYx8nJCYsXL4afnx+ys7PZaJgChBDU1tYiKysL7u7uyMjIMOr8XGOKsEajwblz5wxbQmii1Wrxt7/9DS+88IJZznCeLDNCgAHg5ptvhre3N/7xj3/QdgUhISFwc3NDXl7elIXN1FPNOBwOwsLCDNHwyZMn2WiYIfRRr0QiQWpqqskWVxpDhPUT9+zt7REZGWlkDyfPe++9B61Wi/vvv5+2K0Zhxggwh8PBa6+9hrffftvoOdip+BIXFwetVovS0tJJ357JkZJOTk5IS0uDr68vsrOzUVZWxlZKmAiNRoOqqiqTRb2jMV0RrqqqglwuN4t5w/39/XjllVfwyiuvmMUQImNgsZ1wY3HHHXdALpfj0KFDtF2BUqlEVlYWIiIiEBgYOKHb0JznOzAwgPLycnR3dyMsLAzBwcFmMepwPCxhHrBOp0NDQwOqq6vh7OyMuXPnMv67nUrHXGtrK4qLi5Genk59DRcA3HPPPZBKpfj111+pvxgYi5nxMjKCXbt2ITIyEp999hm2bNlC1Rc+n4/ExEScPn0ajo6OcHd3H/fnaQ9Td3JyQlJSEnp6elBeXo66ujpEREQgICCAbeCYAoQQNDc3o7KyEjY2NkhISKCyJRiYfLNGX18fioqKkJiYaBbie+jQIezfvx+lpaUzRnyBGRgBA8C+ffuwdetWlJSUQCQS0XYHzc3NKCkpGTeSoC2+V0IIQUdHB8rLy6HT6RAZGQlvb2+z++M3xwh45GOn1WoRFRVlNo/dRCJhpVKJkydPIjQ0FMHBwQx7eDV9fX2Ijo7G9u3bqe2DNBUzUoABYNOmTejv78fhw4dpuwLg0iqjpqYmpKWlXdWubG7iO5Iro7jQ0FB4e3ubTURsTgJMCIFUKkVtbS3kcjnmzJljlu8exhNhlUqFnJwcuLu7IyYmxixeNDZv3ozOzk788ssvZuGPMZmxAtzd3Y3IyEi8+uqruO+++2i7A0IIysvL0dbWhrS0NPD5fADmLb4j0el0aGxsRF1dHdRqNYKCghAYGEh986w5CLBarTY8NhwOB0FBQRCLxWZ9UDSaCA8PD+P06dMQCASYN2+eWYjdgQMHcPfdd6OsrIx6CZwpmLECDAD79+/HAw88gJKSEnh7e9N2B4QQlJSUoLOzE2lpaWhtbbUI8R0JIQRdXV2oq6tDZ2cnvL29IRaL4ebmRuUJS0uACSHo7e2FRCJBS0sLXF1dERwcDC8vL7MQrokwUoSDg4MNZxXmUPEAXEo9zJ07Fy+88AIeeOAB2u6YhBktwABw5513QiaT4aeffqLtCoBLT9zi4mK0t7dDq9UiNTXVYsT3SoaGhiCRSNDY2AgrKysEBATA29sbjo6OjD2BmRbgwcFBSKVSNDY2QqlUIiAgAGKxmNoa9umir0nmcrlwcXFBQkKC2aRM7rrrLnR3d+Pnn382ixcEU2C+75GMxDvvvIPIyEh88sknZlG8zeFw4OzsjKamJtjZ2RlSEZaIvjg/IiICHR0daGpqQk1NDWxtbSESiSASieDq6mo2T+ipoI90pVIppFIphoaG4OHhgYiICIhEIou+bwBga2sLPp+PgYEBODk5mc392b9/Pw4dOoSysrIZK77ALIiAgUt5pPvvv98sUhH6nG9ycjIaGhrQ3d2NlJQUs9iubAx0Oh26urrQ3t4OqVQKtVoNLy8viEQieHp6TnnIzFiYIgLWaDTo7OyEVCpFe3s7OByO4QXF3d2d+mGfsRgeHsaZM2dgb2+PiIgInDlzhspmjSvRpx527NhhFuc3pmRWCDBw6e1MT08Pfv75Z2o+XHngRghBaWkp2tvbkZKSMiN620dCCMHAwIAhepTJZHB0dIRQKIRAIDD8O53DqukKsFarRV9fH/r6+iCTydDX14f+/n44OzsbRFcgEMy4KEylUuH06dNwdnZGfHw8uFwu1fVGI9E/V3/66acZ97hfyawR4J6eHkRFReGll16iktAfq9pBXx3R0tKClJQUi80lToTh4WGDyMlkMshkMigUCjg6OhoE2cHBAXw+H3w+H7a2ttd8Ak5EgAkhUKlUUCqVUKlUGBwcNPgwMDAAPp9/2YuCUCikuunB1CgUCpw5cwaurq6Ii4u77DGmLcL79+/Hvffei7KyMvj6+jJun2lmjQADl7pp7rnnHuTk5DA6WORapWaEEFRXV6O2thYLFy6k1i1Fg+Hh4cuiz6GhIYNQ6nQ6Q45S/2FjYwMOhwMulwsOh2NY3xMeHg4OhwOdTofh4WGoVCooFAqoVCqoVCoAMIi6vb39ZRH4TBbbK+np6UFubi78/Pwwd+7cUV/gaIlwU1MTEhMT8Y9//IN6FytTzCoBBi7tkfvhhx+Qm5tr8kEowOTqfFtbW1FUVITIyEgEBQXN+Ldf40EIgVqthlKpvOxjeHgYhBDDh1arRVNTE8RiMaysrMDhcGBjYzOmcM9mmpqacOHCBURHR0MsFo/7s0yLsFKpRHJyMhISEvDhhx/Omt/VrBNgnU6HdevWQalU4tdffzXpgcpUmiz6+vpw7tw5eHp6IjY21mxOpc0Vc2jEMHf0aa6mpiYsXLgQbm5uE7odUyKs0+lw6623QiqVIjMzk3pzD5PMumc3l8vFf//7X7S0tODxxx83mZ2pdrgJBAJkZGQY/vj1b59ZWKaCWq3GuXPn0NnZifT09AmLL8Dcos8XX3wRubm52Lt376wSX2AWCjAAODs749ChQ/jqq6/w4YcfGv36020vtrW1RUpKCpycnNi1QSxTRi6X4+TJk7CyskJaWtqUqmxMLcI//PADXn/9dRw8eBCenp5Gv765MysFGLi0tWLPnj148sknDZtojYGxZjtwuVzExcUhNDQU2dnZaG1tNZqPLDMf/ZYTPz8/LFiwYFqlfqYS4ZKSEjz44IP47LPPMG/ePKNd15KYtQIMAMuWLcPLL7+M2267DU1NTdO+nrEH63A4HAQHByMxMRHFxcWorKzELEvZs0wS/a65vLw8xMfHG2XJJ2B8Ee7u7sb69evx2GOPYePGjdO+nqUy6w7hroQQgoceegj5+fk4c+bMlFuDTT3VbHBwELm5ubC2tkZ8fPyMrheeDOwh3P9HoVDg/PnzGBwcRGJiIpydnY1uwxgHcxqNBsuWLYO7uzv27Nkzqw+aZ+89/z84HA527doFBwcH3HXXXVNaosnESEkHBwekp6fD3d0dWVlZqK2tZaNhFgCXggiJRILMzEw4ODhgyZIlJhFfwDiR8O9//3vIZDL85z//mdXiC7ACDACwsbHB3r17kZeXhxdffHFSt2Vynq+VlRUiIyORkpICiUSCnJwcyOVyk9pkMW8UCgXOnTuH6upqJCYmIjY21uRziKcjwu+88w5++OEHHDx40CxWHdGGFeD/w8PDAwcPHsQbb7yBH374YUK3oTVM3cXFBRkZGXB1dWWj4VnKyKjX3t4eS5cuvebOQWMyFRE+fvw4nnvuOezdu/eajSCzhRk/jnIyxMXF4dNPP8X9998PDw8PpKenj/mztDdZWFlZGXaNFRUVoa2tDfHx8WxUMQtQKBQoLi7GwMAAEhMTGRXekUxm0ef58+dx++234/XXX8fixYuZctHsYSPgK9i4cSNee+01bNiwAWfPnh31Z2iL70hGRsMnTpxAXV0dGw3PUAghaGxspBb1jsZEIuGysjJcf/31eOKJJ/DQQw8x7KF5w0bAo/Dwww9DqVRizZo1OHLkCObPn2/4njmJr56R0XBhYSGampowd+5c6k9OFuPR29uL8vJyDA0Nmd3ApvEi4ZqaGqxcuRIPPfQQnn/+eVoumi2sAI/BY489BqVSieuvvx7Hjh1DTEyMWYrvSFxcXLBkyRI0NDQgLy8PQqEQUVFRZukry8QYGBhARUUFurq6DGvizXHZ52giXF9fj+XLl+POO+/ECy+8QNlD88T8fpNmxDPPPAOFQoGVK1fiv//9L5RKpdmKrx4rKyuEhIQgICAAtbW1yM7Ohkgkwpw5c9j8sAWhUChQVVWF5uZmBAUFYd68eWY/J2GkCLe3t2PLli1Yv349XnvttVkz3WyysAJ8DbZv3w6FQoG77roLBw4cMGvxHQmPx8OcOXMQFBSEqqoqZGZmIiAgAOHh4Ra9h26mMzw8jJqaGtTX18PX1xfLly+3qHVVjo6OCAwMxPXXX48VK1bgrbfeYsV3HFgBvgYcDgevvPIKuFwu1q5diyNHjiAmJoa2WxPG1tYWsbGxCAkJQWVlJY4dO4aQkBCEhIQYfT8by9TRarWoq6tDTU0N3NzckJ6ebrJmClNSW1uL66+/Htdddx12797Niu81YAV4AnA4HPzjH/+AnZ0dli9fjp9//hkJCQm03ZoUDg4OSEhIQF9fH8rLy/Hbb78hNDQUYrHY7N/azmTUarVhm7SDgwMWLVoEV1dX2m5NiaqqKqxYsQI333wzdu7cyYrvBGAFeBL87W9/A5/Px6pVq3Dw4EEkJyfTdmnSCAQCJCcno6urCxcvXkRVVRX8/f0RHBwMJycn2u7NGgYHB1FfXw+JRAKhUIh58+bB09PTYkWrtLQUK1euxN13341XXnnFYu8H07ACPEmefvpp8Pl83Hjjjdi7dy8yMjJouzQl3N3d4e7uDrlcjrq6OmRlZcHV1RXBwcHw8vJin0AmgBCCrq4u1NXVobOzE76+vkhLS7OYc4WxKCwsxOrVq/HII49g+/bt7N/OJGAFeAo8+uij4PP5WLt2LXbv3o0777yTtktTxtHREbGxsYiMjIREIkFpaSkuXLiAgIAABAQETGmIN8vlKJVKNDY2orGxETqdDoGBgZg3b96MWAZ6+PBh3HPPPXjqqafw3HPP0XbH4mAFeIo89NBD8Pb2xubNm1FSUoKXXnrJoic78Xg8hIaGIiQkBF1dXZBIJDh+/Djc3NwgFovh5eU168c9TgadTofOzk5IJBJ0dHTA09MTMTExFp1muJLXXnsNO3bswHvvvYfNmzfTdscimTXzgPfu3YsTJ05g06ZNWLRokdGuW1ZWhjVr1iA6OhrffPPNjKq1HR4eRlNTExobGzE4OAgPDw+IRCJ4eXmZTSmbOc0DHh4eRnt7O6RSKTo6OsDn8+Hv74+AgACzebyMwfDwMO6//34cO3YM+/fvR2Ji4rSu9+GHH6KyshIKhQKvv/66RZXdTZdZI8DZ2dlIS0szybW7u7txyy23oKurCwcOHEBQUJBJ7NBkcHAQUqkU7e3t6O7uhkAggEgkgkgkgpOTE7WojrYAy+VySKVSSKVS9Pb2wsXFxfAiNRMPNaVSKdavXw+dTof9+/fDx8dn2tfs6OiAm5sbTpw4geXLlxvBS8th1ghweXk5dDodqqqq4O7ujpycHOh0OixevNgoB2lqtRp//OMf8e233+Lrr7+e0X9IarUaHR0dBkHm8XgGMXZzc2M0FcO0AOt0OvT29hpEV6lUwtPT0yC6M7mkLzc3Fxs3bkRGRgY++ugjo0b1e/bswfXXX4+CggKjPzfNmVmTA87Ly8O9996LL7/80jAURC6XG+0XzOPx8PbbbyMmJgYbNmzAyy+/jG3bthnl2uYGj8eDr68vfH19odPp0NPTA6lUiuLiYiiVSgiFQgiFQggEAgiFQjg6Olpk3pMQgsHBQfT19UEmkxk+9C84MTExcHNzo576YIL//Oc/+P3vf4+//vWveOqpp4z++7xw4QJuueUWxMfHAzDuc9OcmTUCPHfuXOTn52P+/PlobGyEjY0NiouLceONNxrVzkMPPYTIyEjcdNNNuHDhAt577z2zHJ5iLLhcrqGkbe7cuRgaGjIIVWNjI0pKSqDT6S4TZHMUZb3YymSyywQXgMHvgIAAxMbGmp3vpkSn0+GZZ57Bhx9+iG+++QY33HCDSewMDg4CgEmfm+bIrElBjGRgYABOTk6GnJ0pkEgkWLt2LYRCIfbu3Qs3NzeT2DF3CCGXibJe3HQ6HQQCAezs7MDn88Hn82Fra2v4P5/Ph7W19TWFbqIpCLVaDaVSCZVKBaVSafhQqVRQKBTo6+sDgMteKAQCwawS2yuRy+W47bbbUF1djUOHDmHOnDkmt8nEc9OcmJUCzBSDg4O4++67cf78eezduxdxcXG0XTIL9KLc398PhUJxmRjq/z88PAwrK6vLRFkvyBwOB1wuFxwOB4QQ1NXVITAw0HBtQgg0Gs1l19NqteDxeJcJvF707ezs4OzsDAcHh1krtldy8eJFrFu3Dj4+Pvj+++9nhRjSYOa+NzYDHBwcsGfPHuzYsQPp6enYvn07Hn/8cYuuFzYGHA4HDg4O45bs6XS6q6JVrVYLnU5nEFlCCLRaLYBLeWkrKyuDOHO53KuEdjbkao3BRx99hGeeeQabN2/G66+/bvIU2rVe9GZyjDhrImDav+TMzExs2bIFYrEYn376KUJCQkxqb7ZAuwxtJtHS0oIHH3wQRUVF+PDDD7F27VrGfdizZw/kcjm2bNnCuG0azJpQbGTU9P333+PTTz+97GumZunSpSgrK0N0dDTmz5+PN998EzqdzuR2WVgmwscff4zY2Fi4ubmhvLycivieP38esbGxjNulyawRYD00f8mOjo549913sXfvXuzcuRNLlixBbW0tFV9YWACgra0Nq1evxvPPP49PP/0UX375JbVxmB0dHbhw4cKsek7MOgE2h1/ysmXLUFpairlz5yIhIQE7d+5ko2EWxvnkk08QExMDFxcXVFRUYN26dVT9WblyJdRqNQYGBqj6wSSzJgc8kq+//hrnzp3Dzp07abuCY8eO4b777kNwcDA+/fTTGdnGbErYHPDkaWtrwwMPPID8/Hx8+OGHWL9+PW2XZi2zLgIGgE2bNpmF+ALA8uXLUVZWhoiICMTHx+Ott95io2EWk/Hpp58iNjYWAoEAFRUVrPhSZlYKsLnh5OSE999/H3v27ME///lPLFu2DPX19bTdYplBSKVS3HjjjYautq+//nrWNgeZE6wAmxErVqxAWVkZwsLCEBsbi23btqGnp4e2WywWjFwuxzPPPIM5c+bAyckJFRUV2LBhA223WP4PVoDNDGdnZ3z44Yc4efIkqqqqEBoaiu3bt2NoaIi2aywWxPDwMF577TWEhoYiJycHP/30E7755hs26jUzWAE2U+Lj43HkyBH88MMP+OmnnxAWFoZ///vfhs4vFpbR0Ol0+OijjxAREYHPP/8cH3/8MU6dOoWUlBTarrGMAivAZs7SpUuRm5uLt99+G7t27UJkZCS++uor9qCO5Sr279+PuLg4vPjii3jxxRdx4cIF3Hjjjex8CzOGFWALgMPh4Oabb0Z5eTmefvpp/OlPf8LChQvx66+/0naNxQw4deoUUlNTcf/99+OBBx5ATU0N7r77brYszwJgBdiCsLa2xoMPPoja2lrcdtttuP322w0RMsvso7S0FDfccANuuOEGrFixAg0NDXj88cdnxLbl2QIrwBaInZ0dnnnmGdTX1yMxMRHLli3Dhg0bUFRURNs1FgaorKzEnXfeiaSkJISEhKC2thYvvPDCjNxBN9NhBdiCcXFxwauvvoqqqip4e3sjLS0NixcvxnfffcfmiGcYOp0OBw4cwPLlyzF//nzweDyUlJTg7bffhqenJ233WKYIK8AzAF9fX7z33ntoamrCmjVr8Mc//hGhoaH4+9//btj0wGKZDA4O4vXXX0dUVBS2bt2K9PR01NfX4/PPP0dwcDBt91imCSvAMwhXV1c888wzaGhowGuvvYaff/4ZAQEBuO+++9j0hIVRUVGB//mf/4G/vz+++uor/OUvf0FTUxO2b98OLy8v2u6xGAlWgGcg1tbWuOWWW5CTk4PMzExwuVwsXrwYCQkJeOuttwwLEFnMC6VSiQ8++ADJyclISEjAwMAADh06hIKCAmzevHlGr7yfrbACPMOZP38+Pv74Y7S1teHhhx/GZ599Bh8fH2zevBlnz56l7R4LLs2ofuCBB+Dr64udO3fizjvvREtLC7766iukpKSwdbwzGFaAZwlOTk546KGHUFhYiKysLDg7O2PlypUICwvDww8/jCNHjrBddgyh0+lw8uRJbNu2DVFRUUhNTYVOp8Phw4dRVlaGbdu2sUswZwmzch4wyyUUCgWOHz+O/fv348CBA9BoNEhPT8fatWtx8803QyAQ0HbxmljKPODBwUHD43zixAmo1WqsWbMGGzZswHXXXQdHR0faLrJQgBVgFgCXorLCwkLs378f+/fvR01NDRITE7Fq1SrcfvvtZrtE1JwFuLm5Gd9++y1++uknnDlzBv7+/tiwYQPWr1+PpKQks/OXhXlYAWYZlcbGRhw8eBD79u3DyZMnERYWhuXLl+PWW29FSkoKuFzzyF6ZkwDrdDrk5+fj+++/x9GjR1FeXo7k5GRs2LABa9euRWhoKFX/WMwPVoBZrkl/fz+OHDmC/fv34/Dhw+DxeIiOjkZsbCwSExOxePFi+Pn5UfGNpgBLpVKcOnUK586dw4ULF1BaWgq5XI7Vq1dj/fr1WL16NZvLZRkXVoBZJoVGo0FhYSHy8/ORl5eHgoICVFRUwM3NDZGRkQZRTktLg1gsNrk/TAlwW1vbZWJbXl6O9vZ2hIeHIyEhAQsXLjT8y5aLsUwUVoBZpo1SqURJSQkKCgqQl5eH/Px8VFRUwMXFBVFRUYiJiUFiYiKSkpIgFouNKlDGFmCNRgOJRIL8/PzLxLajowMRERFYsGCBQWzj4uJgb29vhHvBMlthBZjFJKhUKpSUlFwWLVdUVGB4eBiurq5wd3eHu7s7PD094enpCR8fH/j6+sLPzw9isRgBAQETEreJCrBKpUJjYyMkEgmamprQ0tKC1tZWtLe3o7OzE11dXejq6kJ3dzesrKyuEtvY2FjY2dkZ8yFiYWEFmIU5CCGQyWRoa2tDa2sr2traDP/XC2JbWxukUikUCgWEQiHc3d3h6uoKHo8Ha2trWFlZwdra2vB/LpeLgYEB2NraQqvVQqvVQqPRGD56e3vR2dmJ3t5e8Pl8eHl5wdvbG97e3vDz84OPj4/hc/3/XV1d2eYHFkZgBZjF7CCEYGBgwCDQHR0dUKvV0Gg0hn9HflhZWRkEeuQHj8eDh4eHQWAFAgErrCxmBSvALCwsLJQwj2JOFhYWllkIK8AsLCwslGAFmIWFhYUSrACzsLCwUIIVYBYWFhZKsALMwsLCQglWgFlYWFgowQowCwsLCyVYAWZhYWGhBCvALCwsLJSwpu0AC8tkyc/Px9DQEAoKCvDEE0/QdoeFZcqwETCLxVFZWYnExETU1dXRdoWFZVqww3hYLJJDhw6Bz+eDx+MhJycHOp0OixcvRkZGBm3XWFgmDJuCYLE4XnrpJfz5z3/G2rVr8dVXXwEA5HI5K74sFgebgmCxOBYtWoScnBzMnz8fjY2NsLGxQXFxMW23WFgmDZuCYLFoBgYG4OTkhN7eXnYDMYvFwQowCwsLCyXYHDCLxXGttUJsTMFiKbA5YBaLgxACQgh27doFQgieeuopw9dY8WWxJFgBZrFYfve736GjowNisZi2KywsU4IVYBaLhRCCzMxM3HvvvbRdYWGZEqwAs1gsO3fuRE5ODnbv3k3bFRaWKcFWQbCwsLBQgo2AWVhYWCjBCjALCwsLJVgBZmFhYaEEK8AsLCwslGAFmIWFhYUSrACzsLCwUIIVYBYWFhZKsALMwsLCQglWgFlYWFgowQowCwsLCyVYAWZhYWGhBCvALCwsLJT4f6Nh98qd4unmAAAAAElFTkSuQmCC", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "for obji in obj.objectives:\n", " plot_grid(obji.constants[\"transforms\"][\"grid\"])" @@ -303,18 +270,9 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/yigit/Codes/DESC/desc/utils.py:560: UserWarning: Reducing radial (L) resolution can make plasma boundary inconsistent. Recommend calling `eq.surface = eq.get_surface_at(rho=1.0)`\n", - " warnings.warn(colored(msg, \"yellow\"), err)\n" - ] - } - ], + "outputs": [], "source": [ "eq = get(\"HELIOTRON\")\n", "eq.change_resolution(3, 3, 3, 6, 6, 6)" @@ -322,23 +280,9 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Precomputing transforms\n", - "Timer: Precomputing transforms = 606 ms\n", - "Precomputing transforms\n", - "Timer: Precomputing transforms = 684 ms\n", - "Precomputing transforms\n", - "Timer: Precomputing transforms = 681 ms\n", - "Timer: Objective build = 6.35 ms\n" - ] - } - ], + "outputs": [], "source": [ "grid1 = LinearGrid(\n", " M=eq.M_grid, N=eq.N_grid, NFP=eq.NFP, rho=np.array([0.2, 0.4]), sym=True\n", @@ -354,7 +298,7 @@ "objs = [obj1, obj2, obj3]\n", "for obji in objs:\n", " obji.build(verbose=3)\n", - " obji = jax.device_put(obji, obji._device)\n", + " obji = jax.device_put(obji, jax.devices(desc_config[\"kind\"])[obji._device_id])\n", " obji.things[0] = eq\n", "\n", "objective = ObjectiveFunction(objs)\n", @@ -363,7 +307,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -386,94 +330,9 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Building objective: lcfs R\n", - "Building objective: lcfs Z\n", - "Building objective: fixed pressure\n", - "Building objective: fixed Psi\n", - "Building objective: self_consistency R\n", - "Building objective: self_consistency Z\n", - "Building objective: lambda gauge\n", - "Building objective: axis R self consistency\n", - "Building objective: axis Z self consistency\n", - "Timer: Objective build = 274 ms\n", - "Timer: Linear constraint projection build = 1.74 sec\n", - "Number of parameters: 97\n", - "Number of objectives: 456\n", - "Timer: Initializing the optimization = 2.04 sec\n", - "\n", - "Starting optimization\n", - "Using method: lsq-exact\n", - "This should run on GPU id:0\n", - "This should run on GPU id:1\n", - "This should run on GPU id:1\n", - " Iteration Total nfev Cost Cost reduction Step norm Optimality \n", - " 0 1 1.561e+22 1.767e+11 \n", - "This should run on GPU id:0\n", - "This should run on GPU id:1\n", - "This should run on GPU id:1\n", - " 1 5 5.466e+21 1.014e+22 2.003e+01 1.046e+11 \n", - "Warning: Maximum number of iterations has been exceeded.\n", - " Current function value: 5.466e+21\n", - " Total delta_x: 2.003e+01\n", - " Iterations: 1\n", - " Function evaluations: 5\n", - " Jacobian evaluations: 2\n", - "Timer: Solution time = 8.54 sec\n", - "Timer: Avg time per step = 4.27 sec\n", - "==============================================================================================================\n", - " Start --> End\n", - "Total (sum of squares): 5.469e+26 --> 5.466e+21, \n", - "Maximum absolute Quasi-symmetry (1,19) two-term error: 5.015e-01 --> 1.664e-01 (T^3)\n", - "Minimum absolute Quasi-symmetry (1,19) two-term error: 1.219e-03 --> 7.828e-04 (T^3)\n", - "Average absolute Quasi-symmetry (1,19) two-term error: 1.947e-01 --> 6.795e-02 (T^3)\n", - "Maximum absolute Quasi-symmetry (1,19) two-term error: 7.961e+00 --> 2.641e+00 (normalized)\n", - "Minimum absolute Quasi-symmetry (1,19) two-term error: 1.935e-02 --> 1.243e-02 (normalized)\n", - "Average absolute Quasi-symmetry (1,19) two-term error: 3.091e+00 --> 1.079e+00 (normalized)\n", - "Maximum absolute Quasi-symmetry (1,19) two-term error: 2.906e+12 --> 9.188e+09 (T^3)\n", - "Minimum absolute Quasi-symmetry (1,19) two-term error: 1.348e-03 --> 2.568e-04 (T^3)\n", - "Average absolute Quasi-symmetry (1,19) two-term error: 3.194e+09 --> 1.010e+07 (T^3)\n", - "Maximum absolute Quasi-symmetry (1,19) two-term error: 4.614e+13 --> 1.459e+11 (normalized)\n", - "Minimum absolute Quasi-symmetry (1,19) two-term error: 2.141e-02 --> 4.077e-03 (normalized)\n", - "Average absolute Quasi-symmetry (1,19) two-term error: 5.070e+10 --> 1.603e+08 (normalized)\n", - "Aspect ratio: 1.053e+01 --> 8.876e+00 (dimensionless)\n", - "R boundary error: 0.000e+00 --> 0.000e+00 (m)\n", - "Z boundary error: 0.000e+00 --> 0.000e+00 (m)\n", - "Fixed pressure profile error: 0.000e+00 --> 0.000e+00 (Pa)\n", - "Fixed Psi error: 0.000e+00 --> 0.000e+00 (Wb)\n", - "==============================================================================================================\n" - ] - }, - { - "data": { - "text/plain": [ - "(Equilibrium at 0x7e56a13c7140 (L=3, M=3, N=3, NFP=19, sym=True, spectral_indexing=fringe),\n", - " message: Maximum number of iterations has been exceeded.\n", - " success: False\n", - " fun: [ 3.114e-01 9.780e-01 ... 6.524e+02 8.763e+01]\n", - " x: [-1.118e-01 5.238e-02 ... 1.617e+00 -2.211e-01]\n", - " nit: 1\n", - " cost: 5.465705943561737e+21\n", - " v: [ 1.000e+00 1.000e+00 ... 1.000e+00 1.000e+00]\n", - " optimality: 104553392458.05392\n", - " nfev: 5\n", - " njev: 2\n", - " allx: [Array([-3.392e-05, 8.921e-06, ..., 0.000e+00, 0.000e+00], dtype=float64), Array([-4.503e-05, -1.034e-03, ..., 0.000e+00, 0.000e+00], dtype=float64)]\n", - " alltr: [Array( 2.307e+16, dtype=float64), np.float64(5767465574622139.0), np.float64(1441866393655534.8), np.float64(360466598413883.75), np.float64(360466598413883.75)]\n", - " history: [[{'R_lmn': Array([-3.392e-05, 8.921e-06, ..., 0.000e+00, 1.850e-05], dtype=float64), 'Z_lmn': Array([ 9.011e-06, 1.167e-05, ..., -3.697e-05, 1.686e-05], dtype=float64), 'L_lmn': Array([-6.194e-07, -1.567e-05, ..., -9.721e-06, -1.466e-05], dtype=float64), 'p_l': Array([ 1.800e+04, -3.600e+04, ..., 0.000e+00, 0.000e+00], dtype=float64), 'i_l': Array([ 1.000e+00, 1.500e+00, ..., 0.000e+00, 0.000e+00], dtype=float64), 'c_l': Array([], shape=(0,), dtype=float64), 'Psi': Array([ 1.000e+00], dtype=float64), 'Te_l': Array([], shape=(0,), dtype=float64), 'ne_l': Array([], shape=(0,), dtype=float64), 'Ti_l': Array([], shape=(0,), dtype=float64), 'Zeff_l': Array([], shape=(0,), dtype=float64), 'a_lmn': Array([], shape=(0,), dtype=float64), 'Ra_n': Array([ 1.039e+01, 1.019e-01, 1.330e-03, 1.737e-05], dtype=float64), 'Za_n': Array([ 1.802e-05, 1.335e-03, 9.939e-02], dtype=float64), 'Rb_lmn': Array([ 0.000e+00, 0.000e+00, ..., 0.000e+00, 0.000e+00], dtype=float64), 'Zb_lmn': Array([ 0.000e+00, 0.000e+00, ..., 0.000e+00, 0.000e+00], dtype=float64), 'I': Array([], shape=(0,), dtype=float64), 'G': Array([], shape=(0,), dtype=float64), 'Phi_mn': Array([], shape=(0,), dtype=float64)}], [{'R_lmn': Array([-4.503e-05, -1.034e-03, ..., 0.000e+00, -1.036e-03], dtype=float64), 'Z_lmn': Array([-4.761e-04, -1.745e-03, ..., 8.102e-04, -2.369e-04], dtype=float64), 'L_lmn': Array([-2.543e-03, -3.826e-03, ..., 3.800e-04, 7.083e-04], dtype=float64), 'p_l': Array([ 1.800e+04, -3.600e+04, ..., 0.000e+00, 0.000e+00], dtype=float64), 'i_l': Array([ 1.776e+00, -3.323e+00, ..., 3.407e+00, 3.810e+00], dtype=float64), 'c_l': Array([], shape=(0,), dtype=float64), 'Psi': Array([ 1.000e+00], dtype=float64), 'Te_l': Array([], shape=(0,), dtype=float64), 'ne_l': Array([], shape=(0,), dtype=float64), 'Ti_l': Array([], shape=(0,), dtype=float64), 'Zeff_l': Array([], shape=(0,), dtype=float64), 'a_lmn': Array([], shape=(0,), dtype=float64), 'Ra_n': Array([ 1.042e+01, 8.998e-02, -2.521e-03, 3.798e-04], dtype=float64), 'Za_n': Array([-9.521e-04, -1.837e-03, 7.433e-02], dtype=float64), 'Rb_lmn': Array([ 0.000e+00, 0.000e+00, ..., 0.000e+00, 0.000e+00], dtype=float64), 'Zb_lmn': Array([ 0.000e+00, 0.000e+00, ..., 0.000e+00, 0.000e+00], dtype=float64), 'I': Array([], shape=(0,), dtype=float64), 'G': Array([], shape=(0,), dtype=float64), 'Phi_mn': Array([], shape=(0,), dtype=float64)}]])" - ] - }, - "execution_count": 11, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "eq.optimize(\n", " objective=objective,\n", @@ -496,18 +355,9 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/yigit/Codes/DESC/desc/utils.py:560: UserWarning: Reducing radial (L) resolution can make plasma boundary inconsistent. Recommend calling `eq.surface = eq.get_surface_at(rho=1.0)`\n", - " warnings.warn(colored(msg, \"yellow\"), err)\n" - ] - } - ], + "outputs": [], "source": [ "eq = get(\"precise_QA\")\n", "# eq.change_resolution(12, 12, 12, 24, 24, 24)\n", @@ -516,23 +366,9 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Precomputing transforms\n", - "Timer: Precomputing transforms = 810 ms\n", - "Precomputing transforms\n", - "Timer: Precomputing transforms = 1.32 sec\n", - "Precomputing transforms\n", - "Timer: Precomputing transforms = 407 ms\n", - "Timer: Objective build = 5.30 ms\n" - ] - } - ], + "outputs": [], "source": [ "grid1 = LinearGrid(\n", " M=eq.M_grid, N=eq.N_grid, NFP=eq.NFP, rho=jnp.linspace(0.2, 0.5, 4), sym=True\n", @@ -548,7 +384,7 @@ "objs = [obj1, obj2, obj3]\n", "for obji in objs:\n", " obji.build(verbose=3)\n", - " obji = jax.device_put(obji, obji._device)\n", + " obji = jax.device_put(obji, jax.devices(desc_config[\"kind\"])[obji._device_id])\n", " obji.things[0] = eq\n", "\n", "objective = ObjectiveFunction(objs)\n", @@ -557,7 +393,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -582,104 +418,9 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Building objective: force\n", - "Precomputing transforms\n", - "Timer: Precomputing transforms = 863 ms\n", - "Timer: Objective build = 1.08 sec\n", - "Timer: Proximal projection build = 4.83 sec\n", - "Building objective: lcfs R\n", - "Building objective: lcfs Z\n", - "Building objective: fixed pressure\n", - "Building objective: fixed Psi\n", - "Building objective: fixed current\n", - "Timer: Objective build = 232 ms\n", - "Timer: Linear constraint projection build = 1.11 sec\n", - "Number of parameters: 8\n", - "Number of objectives: 911\n", - "Timer: Initializing the optimization = 6.23 sec\n", - "\n", - "Starting optimization\n", - "Using method: proximal-lsq-exact\n", - " Iteration Total nfev Cost Cost reduction Step norm Optimality \n", - " 0 1 2.011e+04 1.952e+02 \n", - " 1 4 8.735e+03 1.138e+04 4.838e-02 1.104e+02 \n", - "Warning: Maximum number of iterations has been exceeded.\n", - " Current function value: 8.735e+03\n", - " Total delta_x: 4.838e-02\n", - " Iterations: 1\n", - " Function evaluations: 4\n", - " Jacobian evaluations: 2\n", - "Timer: Solution time = 29.2 sec\n", - "Timer: Avg time per step = 14.6 sec\n", - "==============================================================================================================\n", - " Start --> End\n", - "Total (sum of squares): 2.011e+04 --> 8.735e+03, \n", - "Maximum absolute Quasi-symmetry (1,2) two-term error: 1.813e-01 --> 6.254e-01 (T^3)\n", - "Minimum absolute Quasi-symmetry (1,2) two-term error: 2.150e-04 --> 4.713e-03 (T^3)\n", - "Average absolute Quasi-symmetry (1,2) two-term error: 5.169e-02 --> 2.630e-01 (T^3)\n", - "Maximum absolute Quasi-symmetry (1,2) two-term error: 1.978e-01 --> 6.824e-01 (normalized)\n", - "Minimum absolute Quasi-symmetry (1,2) two-term error: 2.346e-04 --> 5.143e-03 (normalized)\n", - "Average absolute Quasi-symmetry (1,2) two-term error: 5.640e-02 --> 2.869e-01 (normalized)\n", - "Maximum absolute Quasi-symmetry (1,2) two-term error: 1.161e+00 --> 9.141e-01 (T^3)\n", - "Minimum absolute Quasi-symmetry (1,2) two-term error: 1.945e-03 --> 1.241e-03 (T^3)\n", - "Average absolute Quasi-symmetry (1,2) two-term error: 1.051e-01 --> 2.811e-01 (T^3)\n", - "Maximum absolute Quasi-symmetry (1,2) two-term error: 1.267e+00 --> 9.974e-01 (normalized)\n", - "Minimum absolute Quasi-symmetry (1,2) two-term error: 2.122e-03 --> 1.354e-03 (normalized)\n", - "Average absolute Quasi-symmetry (1,2) two-term error: 1.147e-01 --> 3.067e-01 (normalized)\n", - "Aspect ratio: 5.996e+00 --> 6.709e+00 (dimensionless)\n", - "Maximum absolute Force error: 1.345e+05 --> 1.302e+04 (N)\n", - "Minimum absolute Force error: 8.350e+00 --> 2.077e+00 (N)\n", - "Average absolute Force error: 5.462e+03 --> 1.001e+03 (N)\n", - "Maximum absolute Force error: 9.614e-02 --> 9.309e-03 (normalized)\n", - "Minimum absolute Force error: 5.969e-06 --> 1.485e-06 (normalized)\n", - "Average absolute Force error: 3.904e-03 --> 7.158e-04 (normalized)\n", - "R boundary error: 0.000e+00 --> 4.734e-19 (m)\n", - "Z boundary error: 0.000e+00 --> 3.478e-18 (m)\n", - "Fixed pressure profile error: 0.000e+00 --> 0.000e+00 (Pa)\n", - "Fixed Psi error: 0.000e+00 --> 0.000e+00 (Wb)\n", - "Fixed current profile error: 0.000e+00 --> 0.000e+00 (A)\n", - "==============================================================================================================\n" - ] - }, - { - "data": { - "text/plain": [ - "(Equilibrium at 0x7e5688ede8a0 (L=3, M=3, N=3, NFP=2, sym=True, spectral_indexing=ansi),\n", - " message: Maximum number of iterations has been exceeded.\n", - " success: False\n", - " fun: [-6.669e-02 -1.838e-01 ... 1.709e-01 -1.291e+02]\n", - " x: [-2.124e-01 1.388e-01 1.794e-01 -7.720e-02 -1.261e-01\n", - " 4.834e-02 -2.327e-01 -1.485e-01]\n", - " nit: 1\n", - " cost: 8735.080665954583\n", - " v: [ 1.000e+00 1.000e+00 1.000e+00 1.000e+00 1.000e+00\n", - " 1.000e+00 1.000e+00 1.000e+00]\n", - " optimality: 110.41872641325968\n", - " nfev: 4\n", - " njev: 2\n", - " allx: [Array([ 0.000e+00, 0.000e+00, ..., 1.082e-03, -2.543e-03], dtype=float64), Array([ 0.000e+00, 0.000e+00, ..., 1.082e-03, -2.543e-03], dtype=float64)]\n", - " alltr: [Array( 5.665e+02, dtype=float64), np.float64(130.5803471209196), np.float64(32.6450867802299), np.float64(65.29017356045979)]\n", - " history: [[{'R_lmn': Array([-3.535e-03, 1.627e-03, ..., 5.860e-04, 1.585e-04], dtype=float64), 'Z_lmn': Array([-9.096e-04, 1.867e-03, ..., -1.343e-04, 1.075e-03], dtype=float64), 'L_lmn': Array([-2.543e-03, -2.040e-04, ..., -1.109e-03, -1.629e-03], dtype=float64), 'p_l': Array([ 0.000e+00, 0.000e+00, 0.000e+00, 0.000e+00,\n", - " 0.000e+00], dtype=float64), 'i_l': Array([], shape=(0,), dtype=float64), 'c_l': Array([ 0.000e+00, 0.000e+00, 0.000e+00, 0.000e+00,\n", - " 0.000e+00], dtype=float64), 'Psi': Array([ 8.700e-02], dtype=float64), 'Te_l': Array([], shape=(0,), dtype=float64), 'ne_l': Array([], shape=(0,), dtype=float64), 'Ti_l': Array([], shape=(0,), dtype=float64), 'Zeff_l': Array([], shape=(0,), dtype=float64), 'a_lmn': Array([], shape=(0,), dtype=float64), 'Ra_n': Array([ 1.020e+00, 1.971e-01, 2.315e-02, 2.547e-03], dtype=float64), 'Za_n': Array([-2.473e-03, -2.071e-02, -1.521e-01], dtype=float64), 'Rb_lmn': Array([ 2.268e-04, 1.531e-03, ..., 2.246e-03, 1.295e-04], dtype=float64), 'Zb_lmn': Array([ 4.367e-04, 9.219e-04, ..., 1.082e-03, -2.543e-03], dtype=float64), 'I': Array([], shape=(0,), dtype=float64), 'G': Array([], shape=(0,), dtype=float64), 'Phi_mn': Array([], shape=(0,), dtype=float64)}], [{'R_lmn': Array([-3.535e-03, 1.627e-03, ..., 5.860e-04, 1.585e-04], dtype=float64), 'Z_lmn': Array([-9.096e-04, 1.867e-03, ..., -1.343e-04, 1.075e-03], dtype=float64), 'L_lmn': Array([-2.543e-03, -2.040e-04, ..., -1.109e-03, -1.629e-03], dtype=float64), 'p_l': Array([ 0.000e+00, 0.000e+00, 0.000e+00, 0.000e+00,\n", - " 0.000e+00], dtype=float64), 'i_l': Array([], shape=(0,), dtype=float64), 'c_l': Array([ 0.000e+00, 0.000e+00, 0.000e+00, 0.000e+00,\n", - " 0.000e+00], dtype=float64), 'Psi': Array([ 8.700e-02], dtype=float64), 'Te_l': Array([], shape=(0,), dtype=float64), 'ne_l': Array([], shape=(0,), dtype=float64), 'Ti_l': Array([], shape=(0,), dtype=float64), 'Zeff_l': Array([], shape=(0,), dtype=float64), 'a_lmn': Array([], shape=(0,), dtype=float64), 'Ra_n': Array([ 1.020e+00, 1.971e-01, 2.315e-02, 2.547e-03], dtype=float64), 'Za_n': Array([-2.473e-03, -2.071e-02, -1.521e-01], dtype=float64), 'Rb_lmn': Array([ 2.268e-04, 1.531e-03, ..., 2.246e-03, 1.295e-04], dtype=float64), 'Zb_lmn': Array([ 4.367e-04, 9.219e-04, ..., 1.082e-03, -2.543e-03], dtype=float64), 'I': Array([], shape=(0,), dtype=float64), 'G': Array([], shape=(0,), dtype=float64), 'Phi_mn': Array([], shape=(0,), dtype=float64)}], [{'R_lmn': Array([-3.074e-03, 1.531e-03, ..., -1.188e-04, 1.295e-04], dtype=float64), 'Z_lmn': Array([-6.459e-04, 9.544e-04, ..., -7.129e-05, 2.324e-04], dtype=float64), 'L_lmn': Array([ 1.664e-03, 5.507e-04, ..., -2.559e-03, 1.939e-03], dtype=float64), 'p_l': Array([ 0.000e+00, 0.000e+00, 0.000e+00, 0.000e+00,\n", - " 0.000e+00], dtype=float64), 'i_l': Array([], shape=(0,), dtype=float64), 'c_l': Array([ 0.000e+00, 0.000e+00, 0.000e+00, 0.000e+00,\n", - " 0.000e+00], dtype=float64), 'Psi': Array([ 8.700e-02], dtype=float64), 'Te_l': Array([], shape=(0,), dtype=float64), 'ne_l': Array([], shape=(0,), dtype=float64), 'Ti_l': Array([], shape=(0,), dtype=float64), 'Zeff_l': Array([], shape=(0,), dtype=float64), 'a_lmn': Array([], shape=(0,), dtype=float64), 'Ra_n': Array([ 1.050e+00, 1.833e-01, 2.304e-02, 2.564e-03], dtype=float64), 'Za_n': Array([-1.729e-03, -1.924e-02, -1.507e-01], dtype=float64), 'Rb_lmn': Array([ 2.268e-04, 1.531e-03, ..., 2.246e-03, 1.295e-04], dtype=float64), 'Zb_lmn': Array([ 4.367e-04, 9.219e-04, ..., 1.082e-03, -2.543e-03], dtype=float64), 'I': Array([], shape=(0,), dtype=float64), 'G': Array([], shape=(0,), dtype=float64), 'Phi_mn': Array([], shape=(0,), dtype=float64)}]])" - ] - }, - "execution_count": 15, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "eq.optimize(\n", " objective=objective,\n", @@ -717,7 +458,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.12.7" + "version": "3.12.0" } }, "nbformat": 4, diff --git a/tests/test_multidevice.py b/tests/test_multidevice.py index dbfc57a4a9..20ff9ea88f 100644 --- a/tests/test_multidevice.py +++ b/tests/test_multidevice.py @@ -10,6 +10,7 @@ import numpy as np import pytest +from desc import config as desc_config from desc.backend import jax from desc.examples import get from desc.grid import LinearGrid @@ -45,7 +46,9 @@ def test_multidevice_jac(): for obj in [objective1, objective2, objective3, objective4]: obj.build() - obj = jax.device_put(obj, device=obj._device) + obj = jax.device_put( + obj, device=jax.devices(desc_config["kind"])[obj._device_id] + ) objective1.things[0] = eq1 objective2.things[0] = eq1 objective3.things[0] = eq2