foscat 3.6.1__py3-none-any.whl → 3.7.1__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
@@ -382,7 +383,7 @@ class foscat_backend:
         if self.BACKEND == self.TENSORFLOW:
             return self.backend.SparseTensor(indice, w, dense_shape=dense_shape)
         if self.BACKEND == self.TORCH:
-            return self.backend.sparse_coo_tensor(indice.T, w, dense_shape)
+            return self.backend.sparse_coo_tensor(indice.T, w, dense_shape).to_sparse_csr().to(self.torch_device)
         if self.BACKEND == self.NUMPY:
             return self.scipy.sparse.coo_matrix(
                 (w, (indice[:, 0], indice[:, 1])), shape=dense_shape
@@ -392,7 +393,7 @@ class foscat_backend:
         if self.BACKEND == self.TENSORFLOW:
             return self.backend.stack(list, axis=axis)
         if self.BACKEND == self.TORCH:
-            return self.backend.stack(list, axis=axis)
+            return self.backend.stack(list, axis=axis).to(self.torch_device)
         if self.BACKEND == self.NUMPY:
             return self.backend.stack(list, axis=axis)
 
@@ -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
@@ -516,6 +552,15 @@ class foscat_backend:
                 return np.concatenate([x.real.flatten(), x.imag.flatten()], 0)
             else:
                 return x.flatten()
+                
+    
+    def bk_flatten(self, x):
+        if self.BACKEND == self.TENSORFLOW:
+            return self.backend.flatten(x)
+        elif self.BACKEND == self.TORCH:
+            return self.backend.flatten(x)
+        else:
+            return x.flatten()
 
     def bk_flatten(self, x):
         if self.BACKEND == self.TENSORFLOW:
@@ -540,9 +585,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 +638,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 +646,7 @@ class foscat_backend:
             return data.numel()
         if self.BACKEND == self.NUMPY:
             return data.size
-        
+
     # ---------------------------------------------−---------
 
     def iso_mean(self, x, use_2D=False):
@@ -833,15 +879,23 @@ class foscat_backend:
         if self.BACKEND == self.TENSORFLOW:
             return self.backend.constant(data)
         if self.BACKEND == self.TORCH:
-            return self.backend.constant(data)
+            return self.backend.constant(data).to(self.torch_device)
         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).to(self.torch_device)
+        if self.BACKEND == self.NUMPY:
+            return np.zeros(shape)
 
     def bk_complex(self, real, imag):
         if self.BACKEND == self.TENSORFLOW:
             return self.backend.dtypes.complex(real, imag)
         if self.BACKEND == self.TORCH:
-            return self.backend.complex(real, imag)
+            return self.backend.complex(real, imag).to(self.torch_device)
         if self.BACKEND == self.NUMPY:
             return real + 1j * imag
 
@@ -879,10 +933,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):
@@ -918,7 +972,7 @@ class foscat_backend:
                     xi = self.backend.concat(
                         [self.bk_imag(data[k]) for k in range(ndata)]
                     )
-                    return self.backend.complex(xr, xi)
+                    return self.bk_complex(xr, xi)
                 else:
                     return self.backend.concat(data)
             else:
@@ -930,7 +984,7 @@ class foscat_backend:
                     xi = self.backend.concat(
                         [self.bk_imag(data[k]) for k in range(ndata)], axis=axis
                     )
-                    return self.backend.complex(xr, xi)
+                    return self.bk_complex(xr, xi)
                 else:
                     return self.backend.concat(data, axis=axis)
         else:
@@ -939,30 +993,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).to(self.torch_device)
         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 +1024,23 @@ class foscat_backend:
             return self.backend.fft(data)
         if self.BACKEND == self.NUMPY:
             return self.backend.fft.fft(data)
-        
+            
+    def bk_fftn(self, data,dim=None):
+        if self.BACKEND == self.TENSORFLOW:
+            return self.backend.signal.fftn(data)
+        if self.BACKEND == self.TORCH:
+            return self.backend.fft.fftn(data,dim=dim)
+        if self.BACKEND == self.NUMPY:
+            return self.backend.fft.fftn(data)
+
+    def bk_ifftn(self, data,dim=None,norm=None):
+        if self.BACKEND == self.TENSORFLOW:
+            return self.backend.signal.ifftn(data)
+        if self.BACKEND == self.TORCH:
+            return self.backend.fft.ifftn(data,dim=dim,norm=norm)
+        if self.BACKEND == self.NUMPY:
+            return self.backend.fft.ifftn(data)
+
     def bk_rfft(self, data):
         if self.BACKEND == self.TENSORFLOW:
             return self.backend.signal.rfft(data)
@@ -979,7 +1049,6 @@ class foscat_backend:
         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)
@@ -987,7 +1056,7 @@ class foscat_backend:
             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:
@@ -1022,7 +1091,7 @@ class foscat_backend:
             if x.dtype == self.all_cbk_type:
                 xr = self.backend.nn.relu(self.bk_real(x))
                 xi = self.backend.nn.relu(self.bk_imag(x))
-                return self.backend.complex(xr, xi)
+                return self.bk_complex(xr, xi)
             else:
                 return self.backend.nn.relu(x)
         if self.BACKEND == self.TORCH:
@@ -1030,6 +1099,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":
@@ -1041,6 +1123,16 @@ class foscat_backend:
                 return np.float64(x)
             else:
                 return x
+        if isinstance(x, np.complex128):
+            if self.all_bk_type == "float32":
+                return np.complex64(x)
+            else:
+                return x
+        if isinstance(x, np.complex64):
+            if self.all_bk_type == "float64":
+                return np.complex128(x)
+            else:
+                return x
 
         if isinstance(x, np.int32) or isinstance(x, np.int64) or isinstance(x, int):
             if self.all_bk_type == "float64":
@@ -1058,14 +1150,26 @@ class foscat_backend:
 
         if self.BACKEND == self.TORCH:
             if isinstance(x, np.ndarray):
-                x = self.backend.from_numpy(x)
+                x = self.backend.from_numpy(x).to(self.torch_device)
 
             if x.dtype.is_complex:
                 out_type = self.all_cbk_type
             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()