Clip input values before normaliztion

[wi-xu]

Hi, and thanks for sharing your code.

I am currently using Moxel to generate energy maps. I noticed that in the lastest update (see issue #10), the voxels are now filled with raw energy values instead of Boltzmann-weighted or clipped values.

As a result, some inputs can contain extremely high energy values, which causes the model to fail during training.

Could you give an example of how to clip the values in the transformation, before normaliztion, in the example?

Best regards,
William

[adosar]

Hi William,

You can clip the energy values with np.clip. For example if you want to clip them in [-1000K, 1000K] (the energy values are in K), then np.clip(voxels, -1e3, 1e3). If you want to fill the voxels with the Boltzmann factor (e.g. for T = 298K), then np.exp((-1 / 298) * voxels)).

[fxcoudert]

Hi @adosar and thanks for getting back to us so quickly :)

What we were trying to understand is how to go from np.clip to the PyTorch transform, so we can put it into the transforms.Compose. Is that possible?

Otherwise, is your recommendation to alter directly the X_train and X_val numpy arrays?

[adosar]

Hi @fxcoudert,

Please note that from version >=0.2.0 the voxels (of individual materials) are stored as plain .npy files under a directory, so the current code for training might not work.

So, my recommendation is to use a custom PyTorch dataset that loads a given .npy file (the voxels of a given material), does its preprocessing (e.g. clipping, augmentation etc) and returns the transformed voxels (and optionally the label of the material for a supervised learning task). You can start by modifying the __getitem__ method of CustomDataset.

In any case, you can define the transformations as callable instances of classes and pass them to Compose:

class ClipVoxels:
    def __init__(self, vmin: float, vmax: float):
        self.vmin = vmin
        self.vmax = vmax
    def __call__(self, x):
        return torch.clip(x, self.vmin, self.vmax)  # Or np.clip if you opt for Numpy.


class BoltzmannFactor:
    def __init__(self, temperature: float = 298):
        self.temperature = temperature
    def __call__(self, x):
        return torch.exp((-1 / self.temperature) * x)  # Or np.exp if you opt for Numpy.


transformation = Compose([.., ClipVoxels(-1e3, 1e3)])

Note

I strongly recommend all the transformations to be defined with PyTorch, especially those using some randomness under the hood (e.g. augmentation).