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

foscat/CNN.py

@@ -0,0 +1,151 @@
+import pickle
+
+import numpy as np
+
+import foscat.scat_cov as sc
+
+
+class CNN:
+
+    def __init__(
+        self,
+        scat_operator=None,
+        nparam=1,
+        nscale=1,
+        chanlist=[],
+        in_nside=1,
+        n_chan_in=1,
+        nbatch=1,
+        SEED=1234,
+        filename=None,
+    ):
+
+        if filename is not None:
+            outlist = pickle.load(open("%s.pkl" % (filename), "rb"))
+            self.scat_operator = sc.funct(KERNELSZ=outlist[3], all_type=outlist[7])
+            self.KERNELSZ = self.scat_operator.KERNELSZ
+            self.all_type = self.scat_operator.all_type
+            self.npar = outlist[2]
+            self.nscale = outlist[5]
+            self.chanlist = outlist[0]
+            self.in_nside = outlist[4]
+            self.nbatch = outlist[1]
+            self.n_chan_in = outlist[8]
+            self.x = self.scat_operator.backend.bk_cast(outlist[6])
+            self.out_nside = self.in_nside // (2**self.nscale)
+        else:
+            self.nscale = nscale
+            self.nbatch = nbatch
+            self.npar = nparam
+            self.n_chan_in = n_chan_in
+            self.scat_operator = scat_operator
+            if len(chanlist) != nscale + 1:
+                print(
+                    "len of chanlist (here %d) should of nscale+1 (here %d)"
+                    % (len(chanlist), nscale + 1)
+                )
+                return None
+
+            self.chanlist = chanlist
+            self.KERNELSZ = scat_operator.KERNELSZ
+            self.all_type = scat_operator.all_type
+            self.in_nside = in_nside
+            self.out_nside = self.in_nside // (2**self.nscale)
+
+            np.random.seed(SEED)
+            self.x = scat_operator.backend.bk_cast(
+                np.random.randn(self.get_number_of_weights())
+                / (self.KERNELSZ * self.KERNELSZ)
+            )
+
+    def save(self, filename):
+
+        outlist = [
+            self.chanlist,
+            self.nbatch,
+            self.npar,
+            self.KERNELSZ,
+            self.in_nside,
+            self.nscale,
+            self.get_weights().numpy(),
+            self.all_type,
+            self.n_chan_in,
+        ]
+
+        myout = open("%s.pkl" % (filename), "wb")
+        pickle.dump(outlist, myout)
+        myout.close()
+
+    def get_number_of_weights(self):
+        totnchan = 0
+        for i in range(self.nscale):
+            totnchan = totnchan + self.chanlist[i] * self.chanlist[i + 1]
+        return (
+            self.npar * 12 * self.out_nside**2 * self.chanlist[self.nscale]
+            + totnchan * self.KERNELSZ * self.KERNELSZ
+            + self.KERNELSZ * self.KERNELSZ * self.n_chan_in * self.chanlist[0]
+        )
+
+    def set_weights(self, x):
+        self.x = x
+
+    def get_weights(self):
+        return self.x
+
+    def eval(self, im, indices=None, weights=None):
+
+        x = self.x
+        ww = self.scat_operator.backend.bk_reshape(
+            x[0 : self.KERNELSZ * self.KERNELSZ * self.n_chan_in * self.chanlist[0]],
+            [self.KERNELSZ * self.KERNELSZ, self.n_chan_in, self.chanlist[0]],
+        )
+        nn = self.KERNELSZ * self.KERNELSZ * self.n_chan_in * self.chanlist[0]
+
+        im = self.scat_operator.healpix_layer(im, ww)
+        im = self.scat_operator.backend.bk_relu(im)
+
+        for k in range(self.nscale):
+            ww = self.scat_operator.backend.bk_reshape(
+                x[
+                    nn : nn
+                    + self.KERNELSZ
+                    * self.KERNELSZ
+                    * self.chanlist[k]
+                    * self.chanlist[k + 1]
+                ],
+                [self.KERNELSZ * self.KERNELSZ, self.chanlist[k], self.chanlist[k + 1]],
+            )
+            nn = (
+                nn
+                + self.KERNELSZ
+                * self.KERNELSZ
+                * self.chanlist[k]
+                * self.chanlist[k + 1]
+            )
+            if indices is None:
+                im = self.scat_operator.healpix_layer(im, ww)
+            else:
+                im = self.scat_operator.healpix_layer(
+                    im, ww, indices=indices[k], weights=weights[k]
+                )
+            im = self.scat_operator.backend.bk_relu(im)
+            im = self.scat_operator.ud_grade_2(im, axis=0)
+
+        ww = self.scat_operator.backend.bk_reshape(
+            x[
+                nn : nn
+                + self.npar * 12 * self.out_nside**2 * self.chanlist[self.nscale]
+            ],
+            [12 * self.out_nside**2 * self.chanlist[self.nscale], self.npar],
+        )
+
+        im = self.scat_operator.backend.bk_matmul(
+            self.scat_operator.backend.bk_reshape(
+                im, [1, 12 * self.out_nside**2 * self.chanlist[self.nscale]]
+            ),
+            ww,
+        )
+        im = self.scat_operator.backend.bk_reshape(im, [self.npar])
+        im = self.scat_operator.backend.bk_relu(im)
+
+        return im

foscat/CircSpline.py

@@ -1,51 +1,119 @@
+import numpy as np
 
-import math
 
 class CircSpline:
     def __init__(self, nodes, degree=3):
         """
-        Initialize the circular spline with the given number of nodes and degree.
+        Initializes the Spline1D instance.
+
+        Parameters:
+        - nodes (int): The number of nodes in the spline.
+        - degree (int): The degree of the spline. Default is 3.
         """
         self.degree = degree
         self.nodes = nodes
-        self.norm = [self._compute_norm(i) for i in range(degree + 1)]
-
-    def _compute_norm(self, i):
+        
+        
+    def cubic_spline_function(self,x):
         """
-        Compute normalization factor for the ith element.
+        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 pow(-1, i) * (self.degree + 1) / (math.factorial(self.degree + 1 - i) * math.factorial(i))
+        return -2 * x**3 + 3 * x**2
 
-    def yplus(self, x):
+
+    def eval(self,x):
         """
-        Compute yplus value for a given x based on the spline's degree.
+        Compute a 3rd-degree cubic spline with 4-point support.
+    
+        Args:
+            x (float or array): Input value(s) to compute the spline.
+
+        Returns:
+            indices (array): Indices of the spline support points.
+            coefficients (array): Normalized spline coefficients.
         """
-        if x < 0.0:
-            return 0.0
-        if self.degree == 0:
-            return 0.5 if x == 0.0 else 1.0
-        return pow(x, self.degree)
+        N=self.nodes
+        
+        if isinstance(x, float):
+            # Single scalar input
+            base_idx = int(x * (N))
+            indices = np.zeros([4], dtype="int")
+            coefficients = np.zeros([4])
+        else:
+            # Array input
+            base_idx = (x * (N)).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) - base_idx
+
+        # Compute spline coefficients for 4 support points
+        coefficients[3] = self.cubic_spline_function(fractional_part / 2) / 2
+        coefficients[2] = self.cubic_spline_function(0.5 + fractional_part / 2) / 2
+        coefficients[1] = self.cubic_spline_function(1 - fractional_part / 2) / 2
+        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
 
-    def calculate(self, x):
+        # Square coefficients and normalize
+        coefficients = coefficients * coefficients
+        coefficients /= np.sum(coefficients, axis=0)
+
+        return indices, coefficients
+
+    
+    def eval_N(self,x,N):
         """
-        Calculate circular spline values for a given x.
+        Compute a 3rd-degree cubic spline with 4-point support.
+    
+        Args:
+            x (float or array): Input value(s) to compute the spline.
+
+        Returns:
+            indices (array): Indices of the spline support points.
+            coefficients (array): Normalized spline coefficients.
         """
-        y = [0] * self.nodes
-        for i in range(self.nodes + self.degree // 2 + 1):
-            tmp = 0
-            tx = self.nodes * math.fmod(x, 2 * math.pi) / (math.pi * 2) - i
-            for j in range(self.degree + 1):
-                tmp += self.norm[j] * self.yplus(tx - j + (self.degree + 1) // 2)
-            if tmp < 0:
-                tmp = 0.0
-            y[i % self.nodes] += tmp
-        for i in range(self.degree // 2):
-            tmp = 0
-            tx = self.nodes * math.fmod(x, 2 * math.pi) / (math.pi * 2) + 1 + i
-            for j in range(self.degree + 1):
-                tmp += self.norm[j] * self.yplus(tx - j + (self.degree + 1) // 2)
-            if tmp < 0:
-                tmp = 0.0
-            y[self.nodes - 1 - i] += tmp
-        return y
+        
+        if isinstance(x, float):
+            # Single scalar input
+            base_idx = int(x * (N))
+            indices = np.zeros([4], dtype="int")
+            coefficients = np.zeros([4])
+        else:
+            # Array input
+            base_idx = (x * (N)).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) - base_idx
+
+        # Compute spline coefficients for 4 support points
+        coefficients[3] = self.cubic_spline_function(fractional_part / 2) / 2
+        coefficients[2] = self.cubic_spline_function(0.5 + fractional_part / 2) / 2
+        coefficients[1] = self.cubic_spline_function(1 - fractional_part / 2) / 2
+        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
+
+        # Adjust indices to start from 0
+        # Square coefficients and normalize
+        coefficients = coefficients * coefficients
+        coefficients /= np.sum(coefficients, axis=0)
 
+        return indices, coefficients