Download total_error_cost/run.py from soundai2016/ADComp: direct link, hf CLI and curl.
- Browser
- Download file 13.7 kB
-
https://huggingface.co/soundai2016/ADComp/resolve/main/total_error_cost/run.py
- Command line
-
hf download hf://soundai2016/ADComp/total_error_cost/run.py
-
curl -L -o run.py https://huggingface.co/soundai2016/ADComp/resolve/main/total_error_cost/run.py
13.7 kB
| #!/usr/bin/env python3 | |
| """Receiver-output cost, including independent construction of each reduced model.""" | |
| import os | |
| for _key in ('OPENBLAS_NUM_THREADS', 'OMP_NUM_THREADS', 'MKL_NUM_THREADS', 'NUMEXPR_NUM_THREADS'): | |
| os.environ[_key] = '2' | |
| import argparse | |
| import hashlib | |
| import importlib.util | |
| import json | |
| import platform | |
| import sys | |
| import time | |
| from pathlib import Path | |
| import numpy as np | |
| import scipy | |
| from scipy import linalg | |
| from scipy.sparse.linalg import expm_multiply | |
| HERE = Path(__file__).resolve().parent | |
| ROOT = HERE.parent | |
| sys.path.insert(0, str(ROOT)) | |
| STAGES = ['assembly', 'basis', 'projection_eigensolve', 'propagation', 'receiver_output'] | |
| def load_module(name, path): | |
| if name in sys.modules: | |
| return sys.modules[name] | |
| spec = importlib.util.spec_from_file_location(name, path) | |
| module = importlib.util.module_from_spec(spec) | |
| sys.modules[name] = module | |
| spec.loader.exec_module(module) | |
| return module | |
| BASE = load_module('same_grid_cost', ROOT / 'accuracy_cost' / 'run.py') | |
| def dependency_hashes(): | |
| paths = [ROOT/'acoustic_core.py', ROOT/'accuracy_cost'/'run.py', ROOT/'accuracy_cost'/'config.json', | |
| ROOT/'propagation'/'chebyshev_reference.py'] | |
| return {str(path.relative_to(ROOT)): hashlib.sha256(path.read_bytes()).hexdigest() for path in paths} | |
| def dump(path, value): | |
| path.write_text(json.dumps(value, indent=2, allow_nan=False) + '\n') | |
| def assemble(n, name, stiffness=True): | |
| if name == 'impedance_interface': | |
| interface = load_module('impedance_kernel_cost', ROOT / 'interface_case' / 'kernel.py') | |
| return interface.assembly(n, need_stiffness=stiffness) | |
| return BASE.assembly(n, name, need_stiffness=stiffness) | |
| def full_receiver(n, name, times, chunk_duration): | |
| stages = {key: 0.0 for key in STAGES} | |
| start = time.perf_counter() | |
| mass, A, J, B, R, rho, bulk = assemble(n, name, stiffness=False) | |
| stages['assembly'] = time.perf_counter() - start | |
| start = time.perf_counter() | |
| state = np.zeros((J.shape[0], B.shape[1])) | |
| state[:n*n] = B | |
| Y = np.empty((len(times), R.shape[1], B.shape[1])) | |
| stages['propagation'] = time.perf_counter() - start | |
| start = time.perf_counter() | |
| Y[0] = R.T @ B | |
| stages['receiver_output'] = time.perf_counter() - start | |
| steps_per_chunk = max(1, int(round(chunk_duration / (times[1] - times[0])))) | |
| energy0 = np.sum(state * state, axis=0) | |
| max_energy_drift = 0.0 | |
| for index in range(0, len(times)-1, steps_per_chunk): | |
| steps = min(steps_per_chunk, len(times)-1-index) | |
| start = time.perf_counter() | |
| block = expm_multiply(J, state, start=0.0, stop=steps*(times[1]-times[0]), | |
| num=steps+1, traceA=0.0) | |
| state = block[-1].copy() | |
| stages['propagation'] += time.perf_counter() - start | |
| start = time.perf_counter() | |
| Y[index+1:index+steps+1] = np.einsum('ir,tis->trs', R, block[1:, :n*n], optimize=True) | |
| stages['receiver_output'] += time.perf_counter() - start | |
| # Diagnostic calculations do not contribute to output-production cost. | |
| max_energy_drift = max(max_energy_drift, float(np.max(np.abs(np.sum(state*state, axis=0)/energy0-1)))) | |
| return {'time': times, 'receiver_pressure': Y}, stages, {'energy_relative_drift': max_energy_drift} | |
| def chebyshev_receiver(n, name, times, tolerance): | |
| stages = {key: 0.0 for key in STAGES} | |
| started = time.perf_counter() | |
| mass, A, J, B, R, rho, bulk = assemble(n, name, stiffness=True) | |
| stages['assembly'] = time.perf_counter()-started | |
| chebyshev = load_module('chebyshev_cost', ROOT/'propagation'/'chebyshev_reference.py') | |
| started = time.perf_counter() | |
| Y, diagnostics = chebyshev.receiver_action(A, B, R, times, tail_tolerance=tolerance) | |
| stages['propagation'] = time.perf_counter()-started | |
| return {'time': times, 'receiver_pressure': Y}, stages, diagnostics | |
| def explicit_receiver(n, name, cfl, times): | |
| stages = {key: 0.0 for key in STAGES} | |
| start = time.perf_counter() | |
| mass, A, J, B, R, rho, bulk = assemble(n, name, stiffness=True) | |
| speed = float(np.sqrt(bulk / rho).max()) | |
| output_dt = float(times[1] - times[0]) | |
| substeps = max(1, int(np.ceil(output_dt * speed * n / cfl))) | |
| dt = output_dt / substeps | |
| # Gershgorin gives a sufficient central-difference stability bound. | |
| maximum_row_sum = float(np.max(np.asarray(np.abs(A).sum(axis=1)))) | |
| if dt * np.sqrt(maximum_row_sum) >= 2: | |
| raise RuntimeError('Explicit time step violates the sufficient spectral stability bound') | |
| stages['assembly'] = time.perf_counter() - start | |
| start = time.perf_counter() | |
| previous = B.copy() | |
| current = B - .5 * dt * dt * (A @ B) | |
| Y = np.empty((len(times), R.shape[1], B.shape[1])) | |
| stages['propagation'] = time.perf_counter() - start | |
| start = time.perf_counter() | |
| Y[0] = R.T @ B | |
| stages['receiver_output'] = time.perf_counter() - start | |
| step = 1 | |
| for output_index in range(1, len(times)): | |
| target_step = output_index * substeps | |
| start = time.perf_counter() | |
| while step < target_step: | |
| following = 2 * current - previous - dt * dt * (A @ current) | |
| previous, current = current, following | |
| step += 1 | |
| stages['propagation'] += time.perf_counter() - start | |
| start = time.perf_counter() | |
| Y[output_index] = R.T @ current | |
| stages['receiver_output'] += time.perf_counter() - start | |
| return {'time': times, 'receiver_pressure': Y}, stages, { | |
| 'requested_cfl': cfl, 'actual_cfl': dt * speed * n, | |
| 'time_step': dt, 'substeps_per_output': substeps, 'time_steps': step, | |
| 'sufficient_stability_product': dt * np.sqrt(maximum_row_sum)} | |
| def reduced_receiver(n, name, m, method, times, return_spatial=False): | |
| stages = {key: 0.0 for key in STAGES} | |
| start = time.perf_counter() | |
| mass, A, J, B, R, rho, bulk = assemble(n, name) | |
| stages['assembly'] = time.perf_counter() - start | |
| start = time.perf_counter() | |
| details = {} | |
| if method == 'craig_bampton': | |
| Q = BASE.cb_basis(n, mass, A, m) | |
| elif method == 'rational_krylov': | |
| Q, details = BASE.rational_basis(mass, A, B, n+2*m) | |
| else: | |
| raise ValueError(method) | |
| stages['basis'] = time.perf_counter() - start | |
| start = time.perf_counter() | |
| Ar = Q.T @ (A @ Q) | |
| Ar = (Ar + Ar.T) / 2 | |
| lam, V = linalg.eigh(Ar, check_finite=False, driver='evd') | |
| minimum = float(lam[0]) | |
| if minimum < -1e-9*max(lam[-1], 1.0): | |
| raise RuntimeError('Projected stiffness is indefinite') | |
| lam[lam < 1e-10] = 0.0 | |
| coefficients = V.T @ (Q.T @ B) | |
| receiver_modes = (R.T @ Q) @ V | |
| stages['projection_eigensolve'] = time.perf_counter() - start | |
| start = time.perf_counter() | |
| modal = np.cos(times[:, None] * np.sqrt(lam)[None, :])[:, :, None] * coefficients[None, :, :] | |
| stages['propagation'] = time.perf_counter() - start | |
| start = time.perf_counter() | |
| Y = np.einsum('ir,trs->tis', receiver_modes, modal, optimize=True) | |
| stages['receiver_output'] = time.perf_counter() - start | |
| # The receiver representation reconstructs all saved traces without storing an N by r basis. | |
| raw = {'time': times, 'receiver_pressure': Y, 'reduced_eigenvalues': lam, | |
| 'receiver_modal_matrix': receiver_modes, 'initial_modal_coefficients': coefficients} | |
| constant = np.sqrt(mass) | |
| constant /= np.linalg.norm(constant) | |
| details.update({'orthonormality_frobenius': float(np.linalg.norm(Q.T @ Q - np.eye(Q.shape[1]))), | |
| 'constant_mode_projection_error': float(np.linalg.norm(constant - Q @ (Q.T @ constant))), | |
| 'initial_projection_relative_error': float(np.linalg.norm(B-Q@(Q.T@B))/np.linalg.norm(B)), | |
| 'minimum_eigenvalue_before_clipping': minimum}) | |
| if return_spatial: | |
| raw['_orthonormal_basis'] = Q | |
| raw['_reduced_eigenvectors'] = V | |
| raw['_mass'] = mass | |
| return raw, stages, details | |
| def summarize(repetitions): | |
| result = {key: float(np.median([row[key] for row in repetitions])) for key in STAGES} | |
| totals = [sum(row.values()) for row in repetitions] | |
| result.update(total_seconds=float(np.median(totals)), | |
| minimum_total_seconds=float(min(totals)), maximum_total_seconds=float(max(totals))) | |
| return result | |
| def execute(cfg, materials, cpus, dry_run=False): | |
| out = HERE / 'results' / 'smooth' | |
| out.mkdir(exist_ok=True, parents=True) | |
| used = None | |
| if hasattr(os, 'sched_getaffinity'): | |
| available = set(os.sched_getaffinity(0)) | |
| chosen = set(cpus) & available | |
| if not chosen: | |
| chosen = set(sorted(available)[:cfg['threads']]) | |
| os.sched_setaffinity(0, chosen) | |
| used = sorted(os.sched_getaffinity(0)) | |
| config_digest = hashlib.sha256((HERE/'config.json').read_bytes()).hexdigest() | |
| code_digest = hashlib.sha256(Path(__file__).read_bytes()).hexdigest() | |
| dependencies = dependency_hashes() | |
| times = np.linspace(0, cfg['timing_time_end'], cfg['samples']) | |
| cases = [] | |
| for name in materials: | |
| for n in cfg['smooth_full_grids']: | |
| cases.append((name, n, None, 'full_sparse_exponential')) | |
| for n in cfg['chebyshev_full_grids']: | |
| cases.append((name, n, None, 'full_chebyshev_bessel')) | |
| for n in cfg['explicit_full_grids']: | |
| for cfl in cfg['explicit_cfl_values']: | |
| cases.append((name, n, cfl, 'full_stormer_verlet')) | |
| for n, ranks in cfg['smooth_reduced_modes'].items(): | |
| for m in ranks: | |
| for method in ('craig_bampton', 'rational_krylov'): | |
| cases.append((name, int(n), m, method)) | |
| if dry_run: | |
| print(json.dumps({'settings': len(cases), 'repetitions': cfg['repetitions'], 'cases': cases}, indent=2)) | |
| return | |
| for previous in out.glob('*_timing.json'): | |
| record = json.loads(previous.read_text()) | |
| if record['config_sha256'] != config_digest or record['code_sha256'] != code_digest or record.get('dependency_sha256') != dependencies: | |
| raise RuntimeError('Existing timings use a different configuration or implementation') | |
| if record['cpu_affinity'] != used: | |
| raise RuntimeError('Existing timings use different CPU affinity') | |
| dump(out/'environment.json', {'platform': platform.platform(), 'python': platform.python_version(), | |
| 'numpy': np.__version__, 'scipy': scipy.__version__, 'cpu_affinity': used, | |
| 'cpu_information': Path('/proc/cpuinfo').read_text().split('\n\n')[0] if Path('/proc/cpuinfo').exists() else platform.processor(), | |
| 'thread_environment': {key: os.environ.get(key) for key in ('OPENBLAS_NUM_THREADS','OMP_NUM_THREADS','MKL_NUM_THREADS')}, | |
| 'threads': cfg['threads'], 'config_sha256': config_digest, 'code_sha256': code_digest, 'dependency_sha256': dependencies, | |
| 'shared_basis_code_sha256': hashlib.sha256((ROOT/'accuracy_cost'/'run.py').read_bytes()).hexdigest(), | |
| 'kernel_sha256': hashlib.sha256((ROOT/'acoustic_core.py').read_bytes()).hexdigest()}) | |
| full_receiver(8, 'rotated_stripes', np.linspace(0, .2, 17), .1) | |
| for method in ('craig_bampton', 'rational_krylov'): | |
| reduced_receiver(8, 'rotated_stripes', 4, method, np.linspace(0, .2, 17)) | |
| explicit_receiver(8, 'rotated_stripes', .25, np.linspace(0, .2, 17)) | |
| chebyshev_receiver(8, 'rotated_stripes', np.linspace(0,.2,17), cfg['chebyshev_tail_tolerance']) | |
| for name, n, m, method in cases: | |
| parameter_suffix = f'_cfl{str(m).replace(".", "p")}' if method == 'full_stormer_verlet' else (f'_m{m}' if m is not None else '') | |
| stem = f'{name}_n{n}_{method}' + parameter_suffix | |
| target = out/f'{stem}_timing.json' | |
| if target.exists(): | |
| continue | |
| interval_start = time.time() | |
| repetitions = [] | |
| for _ in range(cfg['repetitions']): | |
| if method == 'full_chebyshev_bessel': | |
| raw, stages, diagnostics = chebyshev_receiver(n, name, times, cfg['chebyshev_tail_tolerance']) | |
| elif method == 'full_stormer_verlet': | |
| raw, stages, diagnostics = explicit_receiver(n, name, m, times) | |
| elif m is None: | |
| raw, stages, diagnostics = full_receiver(n, name, times, cfg['chunk_duration']) | |
| else: | |
| raw, stages, diagnostics = reduced_receiver(n, name, m, method, times) | |
| repetitions.append(stages) | |
| interval_end = time.time() | |
| np.savez_compressed(out/f'{stem}.npz', **raw) | |
| record = {'material': name, 'grid': n, 'method': method, 'modes_per_patch': m if not method.startswith('full_') else None, | |
| 'requested_cfl': m if method == 'full_stormer_verlet' else None, | |
| 'dimension': n*n if method.startswith('full_') else n+2*m, 'repetitions': repetitions, | |
| 'median': summarize(repetitions), 'diagnostics': diagnostics, | |
| 'cpu_affinity': used, 'config_sha256': config_digest, 'code_sha256': code_digest, 'dependency_sha256': dependencies, | |
| 'timed_interval_unix': [interval_start, interval_end]} | |
| dump(target, record) | |
| print(json.dumps({'case': stem, **record['median']}), flush=True) | |
| def main(): | |
| parser = argparse.ArgumentParser() | |
| parser.add_argument('--materials', nargs='+') | |
| parser.add_argument('--cpus', type=int, nargs='+') | |
| parser.add_argument('--dry-run', action='store_true') | |
| args = parser.parse_args() | |
| cfg = json.loads((HERE/'config.json').read_text()) | |
| execute(cfg, args.materials or cfg['smooth_materials'], args.cpus or cfg['cpu_affinity'], args.dry_run) | |
| if __name__ == '__main__': | |
| main() | |