foscat 3.6.1__tar.gz → 3.7.1__tar.gz

{foscat-3.6.1/src/foscat.egg-info → foscat-3.7.1}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: foscat
-Version: 3.6.1
+Version: 3.7.1
 Summary: Generate synthetic Healpix or 2D data using Cross Scattering Transform
 Author-email: Jean-Marc DELOUIS <jean.marc.delouis@ifremer.fr>
 Maintainer-email: Theo Foulquier <theo.foulquier@ifremer.fr>
@@ -18,7 +18,14 @@ Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown
-License-File: LICENCE
+License-File: LICENSE
+Requires-Dist: imageio
+Requires-Dist: imagecodecs
+Requires-Dist: matplotlib
+Requires-Dist: numpy
+Requires-Dist: tensorflow
+Requires-Dist: healpy
+Requires-Dist: spherical
 
 # foscat
 

{foscat-3.6.1 → foscat-3.7.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "foscat"
-version = "3.6.1"
+version = "3.7.1"
 description = "Generate synthetic Healpix or 2D data using Cross Scattering Transform"
 readme = "README.md"
 license = { text = "BSD-3-Clause" }

{foscat-3.6.1 → foscat-3.7.1}/src/foscat/CircSpline.py

@@ -12,25 +12,23 @@ class CircSpline:
         """
         self.degree = degree
         self.nodes = nodes
-        
-        
-    def cubic_spline_function(self,x):
+
+    def cubic_spline_function(self, x):
         """
         Evaluate the cubic spline basis function.
-    
+
         Args:
             x (float or array): Input value(s) to evaluate the spline basis function.
-    
+
         Returns:
             float or array: Result of the cubic spline basis function.
         """
         return -2 * x**3 + 3 * x**2
 
-
-    def eval(self,x):
+    def eval(self, x):
         """
         Compute a 3rd-degree cubic spline with 4-point support.
-    
+
         Args:
             x (float or array): Input value(s) to compute the spline.
 
@@ -38,8 +36,8 @@ class CircSpline:
             indices (array): Indices of the spline support points.
             coefficients (array): Normalized spline coefficients.
         """
-        N=self.nodes
-        
+        N = self.nodes
+
         if isinstance(x, float):
             # Single scalar input
             base_idx = int(x * (N))
@@ -61,10 +59,10 @@ class CircSpline:
         coefficients[0] = self.cubic_spline_function(0.5 - fractional_part / 2) / 2
 
         # Assign indices for the support points
-        indices[3] = (base_idx + 2+N)%N
-        indices[2] = (base_idx + 1+N)%N
-        indices[1] = (base_idx + N  )%N
-        indices[0] = (base_idx + N-1)%N
+        indices[3] = (base_idx + 2 + N) % N
+        indices[2] = (base_idx + 1 + N) % N
+        indices[1] = (base_idx + N) % N
+        indices[0] = (base_idx + N - 1) % N
 
         # Square coefficients and normalize
         coefficients = coefficients * coefficients
@@ -72,11 +70,10 @@ class CircSpline:
 
         return indices, coefficients
 
-    
-    def eval_N(self,x,N):
+    def eval_N(self, x, N):
         """
         Compute a 3rd-degree cubic spline with 4-point support.
-    
+
         Args:
             x (float or array): Input value(s) to compute the spline.
 
@@ -84,7 +81,7 @@ class CircSpline:
             indices (array): Indices of the spline support points.
             coefficients (array): Normalized spline coefficients.
         """
-        
+
         if isinstance(x, float):
             # Single scalar input
             base_idx = int(x * (N))
@@ -106,10 +103,10 @@ class CircSpline:
         coefficients[0] = self.cubic_spline_function(0.5 - fractional_part / 2) / 2
 
         # Assign indices for the support points
-        indices[3] = (base_idx + 2+N)%N
-        indices[2] = (base_idx + 1+N)%N
-        indices[1] = (base_idx + N  )%N
-        indices[0] =( base_idx + N-1)%N
+        indices[3] = (base_idx + 2 + N) % N
+        indices[2] = (base_idx + 1 + N) % N
+        indices[1] = (base_idx + N) % N
+        indices[0] = (base_idx + N - 1) % N
 
         # Adjust indices to start from 0
         # Square coefficients and normalize

{foscat-3.6.1 → foscat-3.7.1}/src/foscat/FoCUS.py

@@ -12,33 +12,32 @@ TMPFILE_VERSION = "V4_0"
 
 class FoCUS:
     def __init__(
-        self,
-        NORIENT=4,
-        LAMBDA=1.2,
-        KERNELSZ=3,
-        slope=1.0,
-        all_type="float64",
-        nstep_max=16,
-        padding="SAME",
-        gpupos=0,
-        mask_thres=None,
-        mask_norm=False,
-        OSTEP=0,
-        isMPI=False,
-        TEMPLATE_PATH="data",
-        BACKEND="tensorflow",
-        use_2D=False,
-        use_1D=False,
-        return_data=False,
-        JmaxDelta=0,
-        DODIV=False,
-        InitWave=None,
-        silent=False,
-        mpi_size=1,
-        mpi_rank=0,
+            self,
+            NORIENT=4,
+            LAMBDA=1.2,
+            KERNELSZ=3,
+            slope=1.0,
+            all_type="float32",
+            nstep_max=16,
+            padding="SAME",
+            gpupos=0,
+            mask_thres=None,
+            mask_norm=False,
+            isMPI=False,
+            TEMPLATE_PATH="data",
+            BACKEND="tensorflow",
+            use_2D=False,
+            use_1D=False,
+            return_data=False,
+            JmaxDelta=0,
+            DODIV=False,
+            InitWave=None,
+            silent=True,
+            mpi_size=1,
+            mpi_rank=0,
     ):
 
-        self.__version__ = "3.6.1"
+        self.__version__ = "3.7.1"
         # P00 coeff for normalization for scat_cov
         self.TMPFILE_VERSION = TMPFILE_VERSION
         self.P1_dic = None
@@ -47,7 +46,7 @@ class FoCUS:
         self.mask_thres = mask_thres
         self.mask_norm = mask_norm
         self.InitWave = InitWave
-
+        self.mask_mask=None
         self.mpi_size = mpi_size
         self.mpi_rank = mpi_rank
         self.return_data = return_data
@@ -83,18 +82,11 @@ class FoCUS:
         self.nlog = 0
         self.padding = padding
 
-        if OSTEP != 0:
+        if JmaxDelta != 0:
             if not self.silent:
                 print(
-                    "OPTION option is deprecated after version 2.0.6. Please use Jmax option"
+                    "OPTION JmaxDelta is not avialable anymore after version 3.6.2. Please use Jmax option in eval function"
                 )
-            JmaxDelta = OSTEP
-        else:
-            OSTEP = JmaxDelta
-
-        if JmaxDelta < -1:
-            if not self.silent:
-                print("Warning : Jmax can not be smaller than -1")
             return None
 
         self.OSTEP = JmaxDelta
@@ -163,6 +155,9 @@ class FoCUS:
         self.Y_CNN = {}
         self.Z_CNN = {}
 
+        self.filters_set={}
+        self.edge_masks={}
+        
         wwc = np.zeros([KERNELSZ**2, l_NORIENT]).astype(all_type)
         wws = np.zeros([KERNELSZ**2, l_NORIENT]).astype(all_type)
 
@@ -197,13 +192,15 @@ class FoCUS:
             w_smooth = w_smooth.flatten()
         else:
             for i in range(NORIENT):
-                a = i / float(NORIENT) * np.pi
-                xx = (3 / float(KERNELSZ)) * LAMBDA * (x * np.cos(a) + y * np.sin(a))
-                yy = (3 / float(KERNELSZ)) * LAMBDA * (x * np.sin(a) - y * np.cos(a))
-
+                a = (NORIENT-1-i) / float(NORIENT) * np.pi # get the same angle number than scattering lib
+                if KERNELSZ<5:
+                    xx = (3 / float(KERNELSZ)) * LAMBDA * (x * np.cos(a) + y * np.sin(a))
+                    yy = (3 / float(KERNELSZ)) * LAMBDA * (x * np.sin(a) - y * np.cos(a))
+                else:
+                    xx = (3 /5) * LAMBDA * (x * np.cos(a) + y * np.sin(a))
+                    yy = (3 /5) * LAMBDA * (x * np.sin(a) - y * np.cos(a))
                 if KERNELSZ == 5:
-                    # w_smooth=np.exp(-2*((3.0/float(KERNELSZ)*xx)**2+(3.0/float(KERNELSZ)*yy)**2))
-                    w_smooth = np.exp(-(xx**2 + yy**2))
+                    w_smooth=np.exp(-2*((3.0/float(KERNELSZ)*xx)**2+(3.0/float(KERNELSZ)*yy)**2))
                 else:
                     w_smooth = np.exp(-0.5 * (xx**2 + yy**2))
                 tmp1 = np.cos(yy * np.pi) * w_smooth
@@ -211,7 +208,8 @@ class FoCUS:
 
                 wwc[:, i] = tmp1.flatten() - tmp1.mean()
                 wws[:, i] = tmp2.flatten() - tmp2.mean()
-                sigma = np.sqrt((wwc[:, i] ** 2).mean())
+                #sigma = np.sqrt((wwc[:, i] ** 2).mean())
+                sigma = np.mean(w_smooth)
                 wwc[:, i] /= sigma
                 wws[:, i] /= sigma
 
@@ -224,7 +222,8 @@ class FoCUS:
 
                     wwc[:, NORIENT] = tmp1.flatten() - tmp1.mean()
                     wws[:, NORIENT] = tmp2.flatten() - tmp2.mean()
-                    sigma = np.sqrt((wwc[:, NORIENT] ** 2).mean())
+                    #sigma = np.sqrt((wwc[:, NORIENT] ** 2).mean())
+                    sigma = np.mean(w_smooth)
 
                     wwc[:, NORIENT] /= sigma
                     wws[:, NORIENT] /= sigma
@@ -233,11 +232,13 @@ class FoCUS:
 
                     wwc[:, NORIENT + 1] = tmp1.flatten() - tmp1.mean()
                     wws[:, NORIENT + 1] = tmp2.flatten() - tmp2.mean()
-                    sigma = np.sqrt((wwc[:, NORIENT + 1] ** 2).mean())
+                    #sigma = np.sqrt((wwc[:, NORIENT + 1] ** 2).mean())
+                    sigma = np.mean(w_smooth)
                     wwc[:, NORIENT + 1] /= sigma
                     wws[:, NORIENT + 1] /= sigma
 
                 w_smooth = w_smooth.flatten()
+            
         if self.use_1D:
             KERNELSZ = 5
 
@@ -1776,14 +1777,14 @@ class FoCUS:
             if self.padding == "VALID":
                 l_mask = l_mask[
                     :,
-                    self.KERNELSZ // 2 : -self.KERNELSZ // 2 + 1,
-                    self.KERNELSZ // 2 : -self.KERNELSZ // 2 + 1,
+                    self.KERNELSZ // 2 : -self.KERNELSZ // 2+1,
+                    self.KERNELSZ // 2 : -self.KERNELSZ // 2+1,
                 ]
                 if shape[axis] != l_mask.shape[1]:
                     l_mask = l_mask[
                         :,
-                        self.KERNELSZ // 2 : -self.KERNELSZ // 2 + 1,
-                        self.KERNELSZ // 2 : -self.KERNELSZ // 2 + 1,
+                        self.KERNELSZ // 2 : -self.KERNELSZ // 2+1,
+                        self.KERNELSZ // 2 : -self.KERNELSZ // 2+1,
                     ]
 
             ichannel = 1
@@ -1850,8 +1851,12 @@ class FoCUS:
             l_mask = self.backend.bk_complex(l_mask, self.backend.bk_cast(0.0 * l_mask))
 
         if self.use_2D:
+            #if self.padding == "VALID":
             mtmp = l_mask
             vtmp = l_x
+            #else:
+            #    mtmp = l_mask[:,self.KERNELSZ // 2 : -self.KERNELSZ // 2,self.KERNELSZ // 2 : -self.KERNELSZ // 2,:]
+            #    vtmp = l_x[:,self.KERNELSZ // 2 : -self.KERNELSZ // 2,self.KERNELSZ // 2 : -self.KERNELSZ // 2,:]
 
             v1 = self.backend.bk_reduce_sum(
                 self.backend.bk_reduce_sum(mtmp * vtmp, axis=2), 2
@@ -2684,7 +2689,12 @@ class FoCUS:
 
     # ---------------------------------------------−---------
     def get_ww(self, nside=1):
-        return (self.ww_Real[nside], self.ww_Imag[nside])
+        if self.use_2D:
+            
+            return (self.ww_RealT[1].reshape(self.KERNELSZ*self.KERNELSZ,self.NORIENT),
+                    self.ww_ImagT[1].reshape(self.KERNELSZ*self.KERNELSZ,self.NORIENT))
+        else:
+            return (self.ww_Real[nside], self.ww_Imag[nside])
 
     # ---------------------------------------------−---------
     def plot_ww(self):
@@ -2696,11 +2706,11 @@ class FoCUS:
         for i in range(c.shape[1]):
             plt.subplot(2, c.shape[1], 1 + i)
             plt.imshow(
-                c[:, i].reshape(npt, npt), cmap="jet", vmin=-c.max(), vmax=c.max()
+                c[:, i].reshape(npt, npt), cmap="viridis", vmin=-c.max(), vmax=c.max()
             )
             plt.subplot(2, c.shape[1], 1 + i + c.shape[1])
             plt.imshow(
-                s[:, i].reshape(npt, npt), cmap="jet", vmin=-c.max(), vmax=c.max()
+                s[:, i].reshape(npt, npt), cmap="viridis", vmin=-c.max(), vmax=c.max()
             )
             sys.stdout.flush()
         plt.show()

{foscat-3.6.1 → foscat-3.7.1}/src/foscat/Spline1D.py

@@ -1,5 +1,6 @@
 import numpy as np
 
+
 class Spline1D:
     def __init__(self, nodes, degree=3):
         """
@@ -11,25 +12,23 @@ class Spline1D:
         """
         self.degree = degree
         self.nodes = nodes
-        
-        
-    def cubic_spline_function(self,x):
+
+    def cubic_spline_function(self, x):
         """
         Evaluate the cubic spline basis function.
-    
+
         Args:
             x (float or array): Input value(s) to evaluate the spline basis function.
-    
+
         Returns:
             float or array: Result of the cubic spline basis function.
         """
         return -2 * x**3 + 3 * x**2
 
-
-    def eval(self,x):
+    def eval(self, x):
         """
         Compute a 3rd-degree cubic spline with 4-point support.
-    
+
         Args:
             x (float or array): Input value(s) to compute the spline.
 
@@ -37,21 +36,21 @@ class Spline1D:
             indices (array): Indices of the spline support points.
             coefficients (array): Normalized spline coefficients.
         """
-        N=self.nodes
-        
+        N = self.nodes
+
         if isinstance(x, float):
             # Single scalar input
-            base_idx = int(x * (N-1))
+            base_idx = int(x * (N - 1))
             indices = np.zeros([4], dtype="int")
             coefficients = np.zeros([4])
         else:
             # Array input
-            base_idx = (x * (N-1)).astype("int")
+            base_idx = (x * (N - 1)).astype("int")
             indices = np.zeros([4, x.shape[0]], dtype="int")
             coefficients = np.zeros([4, x.shape[0]])
 
         # Compute the fractional part of the input
-        fractional_part = x * (N-1) - base_idx
+        fractional_part = x * (N - 1) - base_idx
 
         # Compute spline coefficients for 4 support points
         coefficients[3] = self.cubic_spline_function(fractional_part / 2) / 2

{foscat-3.6.1 → foscat-3.7.1}/src/foscat/Synthesis.py

@@ -23,6 +23,7 @@ class Loss:
 
         self.loss_function = function
         self.scat_operator = scat_operator
+        self.to_numpy = scat_operator.backend.to_numpy
         self.args = param
         self.name = name
         self.batch = batch
@@ -47,12 +48,13 @@ class Loss:
             else:
                 return self.loss_function(x, batch, self.scat_operator, self.args)
 
-    def set_id_loss(self,id_loss):
+    def set_id_loss(self, id_loss):
         self.id_loss = id_loss
-        
-    def get_id_loss(self,id_loss):
+
+    def get_id_loss(self, id_loss):
         return self.id_loss
-    
+
+
 class Synthesis:
     def __init__(
         self,
@@ -66,10 +68,10 @@ class Synthesis:
 
         self.loss_class = loss_list
         self.number_of_loss = len(loss_list)
-        
+
         for k in range(self.number_of_loss):
             self.loss_class[k].set_id_loss(k)
-            
+
         self.__iteration__ = 1234
         self.nlog = 0
         self.m_dw, self.v_dw = 0.0, 0.0
@@ -83,6 +85,7 @@ class Synthesis:
         self.curr_gpu = 0
         self.event = Event()
         self.operation = loss_list[0].scat_operator
+        self.to_numpy = self.operation.backend.to_numpy
         self.mpi_size = self.operation.mpi_size
         self.mpi_rank = self.operation.mpi_rank
         self.KEEP_TRACK = None
@@ -222,24 +225,24 @@ class Synthesis:
                 else:
                     g_tot = g_tot + g
 
-                l_tot = l_tot + l_loss.numpy()
+                l_tot = l_tot + self.to_numpy(l_loss)
 
                 if self.l_log[self.mpi_rank * self.MAXNUMLOSS + k] == -1:
                     self.l_log[self.mpi_rank * self.MAXNUMLOSS + k] = (
-                        l_loss.numpy() / nstep
+                        self.to_numpy(l_loss) / nstep
                     )
                 else:
                     self.l_log[self.mpi_rank * self.MAXNUMLOSS + k] = (
                         self.l_log[self.mpi_rank * self.MAXNUMLOSS + k]
-                        + l_loss.numpy() / nstep
+                        + self.to_numpy(l_loss) / nstep
                     )
 
         grd_mask = self.grd_mask
 
         if grd_mask is not None:
-            g_tot = grd_mask * g_tot.numpy()
+            g_tot = grd_mask * self.to_numpy(g_tot)
         else:
-            g_tot = g_tot.numpy()
+            g_tot = self.to_numpy(g_tot)
 
         g_tot[np.isnan(g_tot)] = 0.0
 
@@ -389,7 +392,7 @@ class Synthesis:
         self.oshape = list(x.shape)
 
         if not isinstance(x, np.ndarray):
-            x = x.numpy()
+            x = self.to_numpy(x)
 
         x = x.flatten()
 
@@ -423,7 +426,7 @@ class Synthesis:
                 factr=factr,
                 maxiter=maxitt,
             )
-
+            print('Final Loss ',loss)
             # update bias input data
             if iteration < NUM_STEP_BIAS - 1:
                 # if self.mpi_rank==0: