nmrdenoise 0.1.0__py3-none-any.whl

nmrdenoise-0.1.0.dist-info/METADATA

@@ -0,0 +1,14 @@
+Metadata-Version: 2.4
+Name: nmrdenoise
+Version: 0.1.0
+Summary: A Python API for denoising NMR spectra
+Author-email: Your Name <your.email@example.com>
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.20.0
+Requires-Dist: scipy>=1.7.0
+Dynamic: license-file

nmrdenoise-0.1.0.dist-info/RECORD

@@ -0,0 +1,7 @@
+nmrdenoise-0.1.0.dist-info/licenses/LICENSE,sha256=4W8VliAYUP1KY2gLJ_YDy2TmcXYVm-PY7XikQD_bFwA,2
+src/nmrdenoise/__init__.py,sha256=iDU5mduNyIHCTQT-u9kgl5SP-bsuCfydLGzngLAKNMs,141
+src/nmrdenoise/core.py,sha256=m09GuotAnlA8dpjS6UmZ6QN4uFY0SfKpyiWFJz9_Vvk,7235
+nmrdenoise-0.1.0.dist-info/METADATA,sha256=Pj8snHx_aZHeWme-hjWub4-8rgOCqAoHzvqGG4CjgLM,461
+nmrdenoise-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+nmrdenoise-0.1.0.dist-info/top_level.txt,sha256=74rtVfumQlgAPzR5_2CgYN24MB0XARCg0t-gzk6gTrM,4
+nmrdenoise-0.1.0.dist-info/RECORD,,

nmrdenoise-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

nmrdenoise-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1 @@
+ 

nmrdenoise-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+src

src/nmrdenoise/__init__.py

@@ -0,0 +1,4 @@
+ # src/nmrdenoise/__init__.py
+from .core import read_bruker, load_denoising_checkpoint, denoise_component, Autoencoder
+
+__version__ = "0.1.0"

src/nmrdenoise/core.py

@@ -0,0 +1,185 @@
+import sys
+import io
+import nmrglue as ng
+from nmrglue.fileio.bruker import scale_pdata
+import numpy as np
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from importlib import resources
+import os
+
+
+# Define the Autoencoder model
+class Autoencoder(nn.Module):
+    def __init__(self):
+        super(Autoencoder, self).__init__()
+        # Encoder
+        self.encoder = nn.Sequential(
+            nn.Conv1d(1, 64, kernel_size=3, padding=1), #1 is for channels
+            nn.LeakyReLU(negative_slope=0.2),
+            nn.Conv1d(64, 128, kernel_size=3, stride=2, padding=1),
+            nn.LeakyReLU(negative_slope=0.2),
+            nn.Conv1d(128, 256, kernel_size=3, stride=2, padding=1),
+            nn.LeakyReLU(negative_slope=0.2),
+            nn.Conv1d(256, 512, kernel_size=3, stride=2, padding=1),  # Added layer
+            nn.LeakyReLU(negative_slope=0.2)
+        )
+
+        # Decoder
+        self.decoder = nn.Sequential(
+            nn.ConvTranspose1d(512, 512, kernel_size=3, stride=2, padding=1, output_padding=1),  # Added layer
+            nn.LeakyReLU(negative_slope=0.2),
+            nn.ConvTranspose1d(512, 256, kernel_size=3, stride=2, padding=1, output_padding=1),
+            nn.LeakyReLU(negative_slope=0.2),
+            nn.ConvTranspose1d(256, 128, kernel_size=3, stride=2, padding=1, output_padding=1),
+            nn.LeakyReLU(negative_slope=0.2),
+            nn.Conv1d(128, 64, kernel_size=3, padding=1),
+            nn.LeakyReLU(negative_slope=0.2),
+            nn.Conv1d(64, 1, kernel_size=3, padding=0),
+            nn.Tanh()  # Output layer with Tanh to keep values between -1 and 1
+        )
+
+    def forward(self, x):
+        orig_len = x.shape[-1]
+
+        # Compute how much padding is needed
+        remainder = orig_len % 8
+        if remainder != 0:
+            pad_len = 8 - remainder
+        else:
+            pad_len = 0
+
+        # Pad only on the right
+        x = F.pad(x, (0, pad_len), mode='constant', value=0)
+
+        encoded = self.encoder(x)
+        decoded = self.decoder(encoded)
+
+        # Crop to original length
+        decoded = decoded[:, :, :orig_len]
+
+        return decoded
+
+
+
+def load_denoising_checkpoint(model_name="autoencoder_20000_bruker_ver_135_percent_noise_with_noshuffle_v4_rm_spikelets_with_lb_5.pt"):
+    with resources.path("nmrdenoise.checkpoints", model_name) as checkpoint_path:
+        print(f"Loading checkpoint from: {checkpoint_path}")
+
+        return str(checkpoint_path)
+
+def read_bruker(dir_path):
+    dic, fid = ng.bruker.read(dir_path)
+    path_name = os.path.basename(os.path.basename(os.path.dirname(dir_path)))
+    base_name = os.path.basename(dir_path)
+
+
+    dic['acqus']['DTYPA'] = 2        # 2 = float64 - denosiing results in very small decimal values hence we have to set the acqus to float
+
+    try:
+        group_delay = dic['acqus'].get('GRPDLY', None)
+        if group_delay >= 0:
+            fid = ng.bruker.remove_digital_filter(dic, fid)
+            dic['acqus']['GRPDLY'] = 0  # Mark as corrected
+            print(" Digital filter removed and GRPDLY set to 0.")
+    except Exception as e:
+        print(f"Skipping filter removal: {e}")
+
+
+    print("1d from fid")
+    data = ng.process.proc_base.fft(fid)
+
+    scaled_data = scale_pdata(dic, data) * 2
+    dic['procs']['NC_proc'] = 0
+
+
+    enable_fid_functionality = True
+
+    sw = dic['acqus']['SW_h']     # Sweep Width in Hz
+    sfo1 = dic['acqus']['SFO1']   # Transmitter Frequency Offset in MHz
+    o1 = dic['acqus']['O1']       # Frequency Offset in Hz
+
+    uc = ng.fileiobase.unit_conversion(data.size,True,sw,sfo1,o1) #Convert spectra to PPM
+    frq = uc.ppm_scale()
+
+    sw = dic['acqus']['SW_h']   # spectral width in Hz
+    o1 = dic['acqus']['O1']     # carrier freq
+    size = data.shape
+
+    abs_scaled_data = abs(scaled_data)
+    phase_scaled_data = np.angle(scaled_data)
+    imag_scaled_data = np.imag(scaled_data)
+    real_scaled_data = np.real(scaled_data)
+
+    abs_data = abs(data)
+    phase_data = np.angle(data)
+
+    imag_data = np.imag(data)
+    real_data = np.real(data)
+    return frq, real_data, imag_data
+    
+def denoise_component(component, autoencoder_path):
+        channels = 1 #the data is 1d
+        max_data = np.max(component)
+        min_data = np.min(component)
+
+        max_intensity = max(abs(max_data), abs(min_data))
+        # Normalize
+        norm_data = component / max_intensity
+        test_inp = norm_data
+        input_length = np.shape(norm_data)[0]
+
+        #test_inp = norm_data
+        device = torch.device("cpu")
+
+        # Reshape to (1, input_length)
+        test_inp = test_inp.reshape(1, input_length)
+
+
+        # Reshape test data if the shape is incorrect
+        if test_inp.shape == (1, input_length):
+            test_inp = np.reshape(test_inp, (1, input_length, 1))  # Reshape to (batch_size, input_length, channels)
+
+
+        # Alternatively, if you have shape (batch_size, 1, input_length), transpose to the correct shape
+        if test_inp.shape == (1, 1, input_length):
+            test_inp = np.transpose(test_inp, (0, 2, 1))  # Transpose to shape (batch_size, input_length, channels)
+
+
+        #autoencoder_path = os.path.join(base_path, "checkpoints", "autoencoder_20000_bruker_ver_135_percent_noise_with_noshuffle_v4_rm_spikelets_with_lb_5.pt")
+
+        autoencoder = Autoencoder().to(device)
+        try:
+            autoencoder.load_state_dict(torch.load(autoencoder_path, map_location=torch.device('cpu')))
+            autoencoder.eval()  # Set model to evaluation mode
+            print("Autoencoder model loaded successfully.")
+        except Exception as e:
+            raise RuntimeError(f"Error loading autoencoder model: {e}")            
+            
+        # Select a test sample to reconstruct
+        test_inp_sample = torch.tensor(test_inp.reshape(1, input_length, channels), dtype=torch.float32).to(device)  # Shape: (1, 16384, 1)
+
+        # Correct input shape for Conv1d: (batch_size, channels, input_length)
+        test_inp_sample = test_inp_sample.permute(0, 2, 1)  # (1, 16384, 1) -> (1, 1, 16384) example size conversion
+
+        # Use the autoencoder to reconstruct the signal
+        with torch.no_grad():  # No need to calculate gradients during evaluation
+            # Pass through encoder and decoder
+            encoded = autoencoder.encoder(test_inp_sample)  # Encode input
+            reconstructed_signal = autoencoder(test_inp_sample)
+            # Feature-wise norm (or you can use var or entropy)
+            confidence_latent = encoded.norm(p=2, dim=1, keepdim=True)  # shape: [1, 1, 4503]
+
+        confidence_upsampled = F.interpolate(confidence_latent, size=np.shape(test_inp_sample)[2], mode='linear', align_corners=True)
+        confidence = confidence_upsampled.squeeze().cpu().detach().numpy()  # shape: [36027]
+        confidence = (confidence - confidence.min()) / (confidence.max() - confidence.min() + 1e-6)
+
+        # Flatten the arrays for plotting
+        #test_inp_flat = test_inp_sample.cpu().numpy().flatten()
+        reconstructed_signal_flat = reconstructed_signal.cpu().numpy().flatten()
+
+        #clipped = reconstructed_signal_flat
+
+        recovered_data = reconstructed_signal_flat * max_intensity
+        return recovered_data, confidence