| import numpy as np |
|
|
| PRIMES = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53] |
|
|
| def radical_inverse(base, n): |
| val = 0 |
| inv_base = 1.0 / base |
| inv_base_n = inv_base |
| while n > 0: |
| digit = n % base |
| val += digit * inv_base_n |
| n //= base |
| inv_base_n *= inv_base |
| return val |
|
|
| def halton_sequence(dim, n): |
| return [radical_inverse(PRIMES[dim], n) for dim in range(dim)] |
|
|
| def hammersley_sequence(dim, n, num_samples): |
| return [n / num_samples] + halton_sequence(dim - 1, n) |
|
|
| def sphere_hammersley_sequence(n, num_samples, offset=(0, 0), remap=False): |
| u, v = hammersley_sequence(2, n, num_samples) |
| u += offset[0] / num_samples |
| v += offset[1] |
| if remap: |
| u = 2 * u if u < 0.25 else 2 / 3 * u + 1 / 3 |
| theta = np.arccos(1 - 2 * u) - np.pi / 2 |
| phi = v * 2 * np.pi |
| return [phi, theta] |
|
|
| def set_random_seed(seed: int, deterministic: bool = False) -> None: |
| """Best-effort seeding for reproducibility across common RNGs.""" |
| import os |
| import random |
| import torch |
| if seed is None: |
| return |
| seed = int(seed) |
| os.environ["PYTHONHASHSEED"] = str(seed) |
| random.seed(seed) |
| np.random.seed(seed) |
| torch.manual_seed(seed) |
| if torch.cuda.is_available(): |
| torch.cuda.manual_seed_all(seed) |
|
|
| if deterministic: |
| torch.backends.cudnn.benchmark = False |
| torch.backends.cudnn.deterministic = True |
| try: |
| |
| torch.use_deterministic_algorithms(True, warn_only=True) |
| except TypeError: |
| torch.use_deterministic_algorithms(True) |
| except Exception: |
| pass |
