reflectorch 1.3.0__tar.gz → 1.4.0__tar.gz

reflectorch-1.4.0/CONTRIBUTING.md

@@ -0,0 +1,28 @@
+# Contributing to Reflectorch
+
+## 1. Reporting Issues
+
+If you encounter bugs, want to suggest features, or have questions, please open an issue using the [GitHub issue tracker](https://github.com/schreiber-lab/reflectorch/issues).
+
+When reporting a bug, please include:
+- A clear description of the issue
+- Steps to reproduce the bug (if applicable)
+- Any relevant error messages or screenshots
+
+## 2. Contributing Code
+
+To contribute code:
+
+1. **Fork** the repository.
+2. Make your changes in a new branch.
+3. Ensure your code is clear and well-documented.
+4. If applicable, add or update tests.
+5. Submit a [pull request](https://github.com/schreiber-lab/reflectorch/pulls) with a description of your changes.
+
+### Documentation
+
+If your changes affect user-facing features, please update the documentation accordingly. Documentation is built using [Jupyter Book](https://jupyterbook.org/). You can build it locally using:
+
+```bash
+jupyter-book build documentation
+```

{reflectorch-1.3.0 → reflectorch-1.4.0}/PKG-INFO

@@ -1,10 +1,9 @@
 Metadata-Version: 2.4
 Name: reflectorch
-Version: 1.3.0
+Version: 1.4.0
 Summary: A Pytorch-based package for the analysis of reflectometry data
 Author-email: Vladimir Starostin <vladimir.starostin@uni-tuebingen.de>, Valentin Munteanu <valentin.munteanu@uni-tuebingen.de>
 Maintainer-email: Valentin Munteanu <valentin.munteanu@uni-tuebingen.de>, Vladimir Starostin <vladimir.starostin@uni-tuebingen.de>, Alexander Hinderhofer <alexander.hinderhofer@uni-tuebingen.de>
-License-Expression: MIT
 Project-URL: Source, https://github.com/schreiber-lab/reflectorch/
 Project-URL: Issues, https://github.com/schreiber-lab/reflectorch/issues
 Project-URL: Documentation, https://schreiber-lab.github.io/reflectorch/
@@ -106,6 +105,8 @@ Configuration files and the corresponding pretrained model weights are hosted on
 <!-- [![Docker](https://img.shields.io/badge/Docker-2496ED.svg?style=flat&logo=docker&logoColor=white)](https://hub.docker.com/)
 Docker images for reflectorch *will* be hosted on Dockerhub. -->
 
+## Contributing
+If you'd like to contribute to the package, please see our [Contributing Guidelines](CONTRIBUTING.md) for details.
 
 ## Citation
 If you find our work useful in your research, please cite as follows:

{reflectorch-1.3.0 → reflectorch-1.4.0}/README.md

@@ -64,6 +64,8 @@ Configuration files and the corresponding pretrained model weights are hosted on
 <!-- [![Docker](https://img.shields.io/badge/Docker-2496ED.svg?style=flat&logo=docker&logoColor=white)](https://hub.docker.com/)
 Docker images for reflectorch *will* be hosted on Dockerhub. -->
 
+## Contributing
+If you'd like to contribute to the package, please see our [Contributing Guidelines](CONTRIBUTING.md) for details.
 
 ## Citation
 If you find our work useful in your research, please cite as follows:

{reflectorch-1.3.0 → reflectorch-1.4.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "reflectorch"
-version = "1.3.0"
+version = "1.4.0"
 authors = [{name = "Vladimir Starostin", email = "vladimir.starostin@uni-tuebingen.de"},
            {name = "Valentin Munteanu", email = "valentin.munteanu@uni-tuebingen.de"}
 ]
@@ -17,14 +17,14 @@ maintainers = [
 description = "A Pytorch-based package for the analysis of reflectometry data"
 keywords = ["reflectometry", "machine learning"]
 readme = "README.md"
-license = "MIT"
+license = {file = "LICENSE"}
 classifiers = [
     "Programming Language :: Python :: 3",
     "Operating System :: OS Independent",
     "Environment :: GPU :: NVIDIA CUDA",
     "Development Status :: 4 - Beta",
     "Topic :: Scientific/Engineering :: Physics",
-    "Intended Audience :: Science/Research"
+    "Intended Audience :: Science/Research",
 ]
 requires-python = ">=3.7"
 dependencies = [

{reflectorch-1.3.0 → reflectorch-1.4.0}/reflectorch/data_generation/__init__.py

@@ -29,6 +29,7 @@ from reflectorch.data_generation.q_generator import (
     ConstantQ,
     VariableQ,
     EquidistantQ,
+    MaskedVariableQ,
 )
 from reflectorch.data_generation.noise import (
     QNoiseGenerator,
@@ -78,6 +79,7 @@ __all__ = [
     "ConstantQ",
     "VariableQ",
     "EquidistantQ",
+    "MaskedVariableQ",
     "QNoiseGenerator",
     "IntensityNoiseGenerator",
     "MultiplicativeLogNormalNoiseGenerator",

{reflectorch-1.3.0 → reflectorch-1.4.0}/reflectorch/data_generation/priors/parametric_models.py

@@ -37,7 +37,7 @@ class ParametricModel(object):
         self.max_num_layers = max_num_layers
         self._sampler_strategy = self._init_sampler_strategy(**kwargs)
 
-    def _init_sampler_strategy(self, **kwargs):
+    def _init_sampler_strategy(self, nuisance_params_dim: int = 0, **kwargs):
         return BasicSamplerStrategy(**kwargs)
 
     @property

{reflectorch-1.3.0 → reflectorch-1.4.0}/reflectorch/data_generation/q_generator.py

@@ -16,6 +16,7 @@ __all__ = [
     "VariableQ",
     "EquidistantQ",
     "ConstantAngle",
+    "MaskedVariableQ",
 ]
 
 
@@ -124,6 +125,11 @@ class VariableQ(QGenerator):
             q = torch.linspace(0, 1, n_q, device=self.device, dtype=self.dtype)
         elif self.mode == 'random':
             q = torch.rand(n_q, device=self.device, dtype=self.dtype).sort().values
+        elif self.mode == 'logspace':
+            q = torch.logspace(
+                start=torch.log10(torch.tensor(1e-4, dtype=self.dtype, device=self.device)),
+                end=torch.log10(torch.tensor(1.0, dtype=self.dtype, device=self.device)),
+                steps=n_q, dtype=self.dtype, device=self.device)
 
         q = q_min[:, None] + q * (q_max - q_min)[:, None]
         
@@ -198,49 +204,77 @@ class EquidistantQ(QGenerator):
         return qs
 
 
-class TransformerQ(QGenerator):
+class MaskedVariableQ:
     def __init__(self,
-                 q_max: float = 0.2,
-                 num_values: Union[int, Tuple[int, int]] = (30, 512),
-                 min_dq_ratio: float = 5.,
-                 device=None,
-                 dtype=torch.float64,
-                 ):
-        self.min_dq_ratio = min_dq_ratio
-        self.q_max = q_max
-        self._dq_range = q_max / num_values[1], q_max / num_values[0]
-        self._num_values = num_values
+                 q_min_range=(0.01, 0.03),
+                 q_max_range=(0.1, 0.5),
+                 n_q_range=(64, 256),
+                 mode='equidistant',
+                 shuffle_mask=False,
+                 total_thickness_constraint=True,
+                 min_points_per_fringe=4,
+                 device=DEFAULT_DEVICE,
+                 dtype=DEFAULT_DTYPE):
+        self.q_min_range = q_min_range
+        self.q_max_range = q_max_range
+        self.n_q_range = n_q_range
         self.device = device
         self.dtype = dtype
-
-    def get_batch(self, batch_size: int, context: dict = None) -> Tensor:
+        self.mode = mode
+        self.shuffle_mask = shuffle_mask
+        self.total_thickness_constraint = total_thickness_constraint
+        self.min_points_per_fringe = min_points_per_fringe
+    
+    def get_batch(self, batch_size, context):
         assert context is not None
 
-        params: BasicParams = context['params']
-        total_thickness = params.thicknesses.sum(-1)
-
-        assert total_thickness.shape[0] == batch_size
-
-        min_dqs = torch.clamp(
-            2 * np.pi / total_thickness / self.min_dq_ratio, self._dq_range[0], self._dq_range[1] * 0.9
-        )
-
-        dqs = torch.rand_like(min_dqs) * (self._dq_range[1] - min_dqs) + min_dqs
-
-        num_q_values = torch.clamp(self.q_max // dqs, *self._num_values).to(torch.int)
+        q_min = torch.rand(batch_size, device=self.device, dtype=self.dtype) * (self.q_min_range[1] - self.q_min_range[0]) + self.q_min_range[0]
+        q_max = torch.rand(batch_size, device=self.device, dtype=self.dtype) * (self.q_max_range[1] - self.q_max_range[0]) + self.q_max_range[0]
 
-        q_values, mask = generate_q_padding_mask(num_q_values, self.q_max)
+        max_n_q = self.n_q_range[1]
 
-        context['tgt_key_padding_mask'] = mask
-        context['num_q_values'] = num_q_values
+        if self.mode == 'equidistant':
+            positions = torch.linspace(0, 1, max_n_q, device=self.device, dtype=self.dtype).expand(batch_size, max_n_q)
+        elif self.mode == 'random':
+            positions = torch.rand(batch_size, max_n_q, device=self.device, dtype=self.dtype)
+            positions, _ = positions.sort(dim=-1)
+        elif self.mode == 'mixed':
+            positions = torch.empty(batch_size, max_n_q, device=self.device, dtype=self.dtype)
+
+            half = batch_size // 2 # half batch gets equidistant
+            eq_pos = torch.linspace(0, 1, max_n_q, device=self.device, dtype=self.dtype).expand(half, max_n_q)
+            positions[:half] = eq_pos
+
+            rand_pos = torch.rand(batch_size - half, max_n_q, device=self.device, dtype=self.dtype) # other half gets sorted random
+            rand_pos, _ = rand_pos.sort(dim=-1)
+            positions[half:] = rand_pos
+        else:
+            raise ValueError(f"Unknown spacing mode: {self.mode}")
+
+        q = q_min[:, None] + positions * (q_max - q_min)[:, None]
+
+        n_qs = torch.randint(self.n_q_range[0], self.n_q_range[1] + 1, (batch_size,), device=self.device)
+
+        if 'params' in context and self.total_thickness_constraint: ### N_points > 1 + (Q_spread * total_thickness * min_np_per_kiessing_fringe) / (2*pi)
+            d_total = context['params'].thicknesses.sum(-1)
+            limit = 1 + ((q_max - q_min) * d_total * self.min_points_per_fringe) / (2*np.pi)
+            limit = limit.ceil().int()
+            n_qs = torch.maximum(n_qs, limit)
+            n_qs = torch.clamp(n_qs, max=self.n_q_range[1])
+
+        indices = torch.arange(max_n_q, device=self.device).expand(batch_size, max_n_q)
+        valid_mask = indices < n_qs[:, None] # right side padding
+        
+        if self.shuffle_mask: # shuffle valid positions (inter-spread padding)
+            perm = torch.argsort(torch.rand(batch_size, max_n_q, device=self.device), dim=-1)
+            valid_mask = torch.gather(valid_mask, dim=1, index=perm)
 
-        return q_values
+        context['key_padding_mask'] = valid_mask
+        context['n_points'] = valid_mask.sum(dim=-1)
 
+        return q
+    
+    def scale_q(self, q):
+        scaled_q_01 = (q - self.q_min_range[0]) / (self.q_max_range[1] - self.q_min_range[0]) 
 
-def generate_q_padding_mask(num_q_values: Tensor, q_max: float):
-    batch_size = num_q_values.shape[0]
-    dqs = (q_max / num_q_values)[:, None]
-    q_values = torch.arange(1, num_q_values.max().item() + 1)[None].repeat(batch_size, 1) * dqs
-    mask = (q_values > q_max + dqs / 2)
-    q_values[mask] = 0.
-    return q_values, mask
+        return 2.0 * (scaled_q_01 - 0.5)

{reflectorch-1.3.0 → reflectorch-1.4.0}/reflectorch/data_generation/utils.py

@@ -163,6 +163,7 @@ def get_density_profiles(
     else:
         if ambient_sld.ndim == 1:
             ambient_sld = ambient_sld.unsqueeze(-1)
+        ambient_sld = ambient_sld.expand(bs, 1)
 
     slds_all = torch.cat([ambient_sld, slds], dim=-1)  # new dimension: n+2
     d_rhos = torch.diff(slds_all, dim=-1)  # (bs, n+1)