foscat 3.6.0__py3-none-any.whl → 3.7.0__py3-none-any.whl

foscat/backend.py

@@ -44,6 +44,7 @@ class foscat_backend:
 
         if self.BACKEND == "torch":
             import torch
+            self.torch_device = torch.device("cuda") if torch.cuda.is_available() else torch.device("cpu")
 
             self.BACKEND = self.TORCH
             self.backend = torch
@@ -404,18 +405,53 @@ class foscat_backend:
         if self.BACKEND == self.NUMPY:
             return smat.dot(mat)
 
+    # for tensorflow wrapping only
+    def periodic_pad(self,x, pad_height, pad_width):
+        """
+        Applies periodic ('wrap') padding to a 4D TensorFlow tensor (N, H, W, C).
+        
+        Args:
+        x (tf.Tensor): Input tensor with shape (batch_size, height, width, channels).
+            pad_height (tuple): Tuple (top, bottom) defining the vertical padding size.
+            pad_width (tuple): Tuple (left, right) defining the horizontal padding size.
+
+        Returns:
+            tf.Tensor: Tensor with periodic padding applied.
+        """
+        #Vertical padding: take slices from bottom and top to wrap around
+        top_pad = x[:, -pad_height:, :, :]    # Top padding from the bottom rows
+        bottom_pad = x[:, :pad_height, :, :]  # Bottom padding from the top rows
+        x_padded = self.backend.concat([top_pad, x, bottom_pad], axis=1)  # Concatenate vertically
+
+        #Horizontal padding: take slices from right and left to wrap around
+        left_pad = x_padded[:, :, -pad_width:, :]   # Left padding from right columns
+        right_pad = x_padded[:, :, :pad_width, :]   # Right padding from left columns
+        
+        x_padded = self.backend.concat([left_pad, x_padded, right_pad], axis=2)  # Concatenate horizontally
+
+        return x_padded
+    
     def conv2d(self, x, w, strides=[1, 1, 1, 1], padding="SAME"):
         if self.BACKEND == self.TENSORFLOW:
             kx = w.shape[0]
             ky = w.shape[1]
-            paddings = self.backend.constant(
-                [[0, 0], [kx // 2, kx // 2], [ky // 2, ky // 2], [0, 0]]
-            )
-            tmp = self.backend.pad(x, paddings, "SYMMETRIC")
-            return self.backend.nn.conv2d(tmp, w, strides=strides, padding="VALID")
-        # to be written!!!
+            x_padded = self.periodic_pad(x, kx // 2, ky // 2) 
+            return self.backend.nn.conv2d(x_padded, w, strides=strides, padding="VALID")
+        
         if self.BACKEND == self.TORCH:
-            return x
+            import torch.nn.functional as F
+            lx = x.permute(0, 3, 1, 2)
+            wx = self.backend.from_numpy(w).to(self.torch_device).permute(3, 2, 0, 1)  # de (5, 5, 1, 4) à (4, 1, 5, 5)
+
+            # Calculer le padding symétrique
+            kx, ky = w.shape[0], w.shape[1]
+            
+            # Appliquer le padding
+            x_padded = F.pad(lx, (ky // 2, ky // 2, kx // 2, kx // 2), mode='circular')
+
+            # Appliquer la convolution
+            return F.conv2d(x_padded, wx, stride=1, padding=0).permute(0,2,3,1)
+        
         if self.BACKEND == self.NUMPY:
             res = np.zeros(
                 [x.shape[0], x.shape[1], x.shape[2], w.shape[3]], dtype=x.dtype
@@ -540,9 +576,10 @@ class foscat_backend:
 
         if self.BACKEND == self.TORCH:
             tmp = self.backend.nn.functional.interpolate(
-                x, size=shape, mode="bilinear", align_corners=False
+                x.permute(0,3,1,2), size=shape, mode="bilinear", align_corners=False
             )
-            return self.bk_cast(tmp)
+            return self.bk_cast(tmp.permute(0,2,3,1))
+        
         if self.BACKEND == self.NUMPY:
             return self.bk_cast(self.backend.image.resize(x, shape, method="bilinear"))
 
@@ -592,7 +629,7 @@ class foscat_backend:
 
     # ---------------------------------------------−---------
     # return a tensor size
-    
+
     def bk_size(self, data):
         if self.BACKEND == self.TENSORFLOW:
             return self.backend.size(data)
@@ -600,7 +637,7 @@ class foscat_backend:
             return data.numel()
         if self.BACKEND == self.NUMPY:
             return data.size
-        
+
     # ---------------------------------------------−---------
 
     def iso_mean(self, x, use_2D=False):
@@ -836,6 +873,14 @@ class foscat_backend:
             return self.backend.constant(data)
         if self.BACKEND == self.NUMPY:
             return data
+        
+    def bk_shape_tensor(self, shape):
+        if self.BACKEND == self.TENSORFLOW:
+            return self.backend.tensor(shape=shape)
+        if self.BACKEND == self.TORCH:
+            return self.backend.tensor(shape=shape)
+        if self.BACKEND == self.NUMPY:
+            return np.zeros(shape)
 
     def bk_complex(self, real, imag):
         if self.BACKEND == self.TENSORFLOW:
@@ -879,10 +924,10 @@ class foscat_backend:
     def bk_repeat(self, data, nn, axis=0):
         return self.backend.repeat(data, nn, axis=axis)
 
-    def bk_tile(self, data, nn,axis=0):
+    def bk_tile(self, data, nn, axis=0):
         if self.BACKEND == self.TENSORFLOW:
             return self.backend.tile(data, [nn])
-        
+
         return self.backend.tile(data, nn)
 
     def bk_roll(self, data, nn, axis=0):
@@ -939,30 +984,30 @@ class foscat_backend:
             else:
                 return np.concatenate(data, axis=axis)
 
-    def bk_zeros(self, shape,dtype=None):
+    def bk_zeros(self, shape, dtype=None):
         if self.BACKEND == self.TENSORFLOW:
-            return self.backend.zeros(shape,dtype=dtype)
+            return self.backend.zeros(shape, dtype=dtype)
         if self.BACKEND == self.TORCH:
-            return self.backend.zeros(shape,dtype=dtype)
+            return self.backend.zeros(shape, dtype=dtype)
         if self.BACKEND == self.NUMPY:
-            return np.zeros(shape,dtype=dtype)
+            return np.zeros(shape, dtype=dtype)
 
-    def bk_gather(self, data,idx):
+    def bk_gather(self, data, idx):
         if self.BACKEND == self.TENSORFLOW:
-            return self.backend.gather(data,idx)
+            return self.backend.gather(data, idx)
         if self.BACKEND == self.TORCH:
             return data[idx]
         if self.BACKEND == self.NUMPY:
             return data[idx]
-        
-    def bk_reverse(self, data,axis=0):
+
+    def bk_reverse(self, data, axis=0):
         if self.BACKEND == self.TENSORFLOW:
-            return self.backend.reverse(data,axis=[axis])
+            return self.backend.reverse(data, axis=[axis])
         if self.BACKEND == self.TORCH:
-            return self.backend.reverse(data,axis=axis)
+            return self.backend.reverse(data, axis=axis)
         if self.BACKEND == self.NUMPY:
-            return np.reverse(data,axis=axis)
-        
+            return np.reverse(data, axis=axis)
+
     def bk_fft(self, data):
         if self.BACKEND == self.TENSORFLOW:
             return self.backend.signal.fft(data)
@@ -970,7 +1015,7 @@ class foscat_backend:
             return self.backend.fft(data)
         if self.BACKEND == self.NUMPY:
             return self.backend.fft.fft(data)
-        
+
     def bk_rfft(self, data):
         if self.BACKEND == self.TENSORFLOW:
             return self.backend.signal.rfft(data)
@@ -978,6 +1023,15 @@ class foscat_backend:
             return self.backend.rfft(data)
         if self.BACKEND == self.NUMPY:
             return self.backend.fft.rfft(data)
+
+    def bk_irfft(self, data):
+        if self.BACKEND == self.TENSORFLOW:
+            return self.backend.signal.irfft(data)
+        if self.BACKEND == self.TORCH:
+            return self.backend.irfft(data)
+        if self.BACKEND == self.NUMPY:
+            return self.backend.fft.irfft(data)
+
     def bk_conjugate(self, data):
 
         if self.BACKEND == self.TENSORFLOW:
@@ -1020,6 +1074,19 @@ class foscat_backend:
         if self.BACKEND == self.NUMPY:
             return (x > 0) * x
 
+    def bk_clip_by_value(self, x,xmin,xmax):
+        if isinstance(x, np.ndarray):
+            x = np.clip(x,xmin,xmax)
+        if self.BACKEND == self.TENSORFLOW:
+            return self.backend.clip_by_value(x,xmin,xmax)
+        if self.BACKEND == self.TORCH:
+            x = self.backend.tensor(x, dtype=self.backend.float32) if not isinstance(x, self.backend.Tensor) else x
+            xmin = self.backend.tensor(xmin, dtype=self.backend.float32) if not isinstance(xmin, self.backend.Tensor) else xmin
+            xmax = self.backend.tensor(xmax, dtype=self.backend.float32) if not isinstance(xmax, self.backend.Tensor) else xmax
+            return self.backend.clamp(x, min=xmin, max=xmax)
+        if self.BACKEND == self.NUMPY:
+            return self.backend.clip(x,xmin,xmax)
+
     def bk_cast(self, x):
         if isinstance(x, np.float64):
             if self.all_bk_type == "float32":
@@ -1055,7 +1122,19 @@ class foscat_backend:
             else:
                 out_type = self.all_bk_type
 
-            return x.type(out_type)
+            return x.type(out_type).to(self.torch_device)
 
         if self.BACKEND == self.NUMPY:
             return x.astype(out_type)
+        
+    def to_numpy(self,x):
+        if isinstance(x, np.ndarray):
+            return x
+        
+        if self.BACKEND == self.NUMPY:
+            return x
+        if self.BACKEND == self.TENSORFLOW:
+            return x.numpy()
+
+        if self.BACKEND == self.TORCH:
+            return x.cpu().numpy()