foscat 2025.5.2__py3-none-any.whl → 2025.6.3__py3-none-any.whl

foscat/GCNN.py

@@ -9,22 +9,17 @@ class GCNN:
 
     def __init__(
         self,
-        scat_operator=None,
         nparam=1,
-        nscale=1,
+        KERNELSZ=3,
+        NORIENT=4,
         chanlist=[],
         in_nside=1,
-        n_chan_out=1,
-        nbatch=1,
         SEED=1234,
-        hidden=None,
         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
@@ -33,51 +28,34 @@ class GCNN:
             self.chanlist = outlist[0]
             self.in_nside = outlist[4]
             self.nbatch = outlist[1]
-            self.n_chan_out = outlist[8]
-            if len(outlist[9]) > 0:
-                self.hidden = outlist[9]
-            else:
-                self.hidden = None
-
+            self.NORIENT = 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.nscale = len(chanlist)-1
             self.npar = nparam
-            self.n_chan_out = n_chan_out
+            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
+            if self.scat_operator is None:
+                self.scat_operator = sc.funct(
+                    KERNELSZ=KERNELSZ,
+                    NORIENT=NORIENT)
 
             self.chanlist = chanlist
-            self.KERNELSZ = scat_operator.KERNELSZ
-            self.all_type = scat_operator.all_type
+            self.KERNELSZ = self.scat_operator.KERNELSZ
+            self.NORIENT = self.scat_operator.NORIENT
+            self.all_type = self.scat_operator.all_type
             self.in_nside = in_nside
-            self.hidden = hidden
-
+            self.out_nside = self.in_nside * (2**self.nscale)
+            self.backend = self.scat_operator.backend
             np.random.seed(SEED)
-            self.x = scat_operator.backend.bk_cast(
-                np.random.randn(self.get_number_of_weights())
-                / (self.KERNELSZ * self.KERNELSZ)
+            self.x = self.scat_operator.backend.bk_cast(
+                np.random.rand(self.get_number_of_weights())
+                / (self.KERNELSZ * (self.KERNELSZ//2+1)*self.NORIENT)
             )
 
     def save(self, filename):
 
-        if self.hidden is None:
-            tabh = []
-        else:
-            tabh = self.hidden
-
-        www = self.get_weights()
-
-        if not isinstance(www, np.ndarray):
-            www = www.numpy()
-
         outlist = [
             self.chanlist,
             self.nbatch,
@@ -85,10 +63,9 @@ class GCNN:
             self.KERNELSZ,
             self.in_nside,
             self.nscale,
-            www,
+            self.get_weights().numpy(),
             self.all_type,
-            self.n_chan_out,
-            tabh,
+            self.NORIENT,
         ]
 
         myout = open("%s.pkl" % (filename), "wb")
@@ -97,25 +74,13 @@ class GCNN:
 
     def get_number_of_weights(self):
         totnchan = 0
-        szk = self.KERNELSZ * self.KERNELSZ
-        if self.hidden is not None:
-            totnchan = totnchan + self.hidden[0] * self.npar
-            for i in range(1, len(self.hidden)):
-                totnchan = totnchan + self.hidden[i] * self.hidden[i - 1]
-            totnchan = (
-                totnchan
-                + self.hidden[len(self.hidden) - 1]
-                * 12
-                * self.in_nside**2
-                * self.chanlist[0]
-            )
-        else:
-            totnchan = self.npar * 12 * self.in_nside**2 * self.chanlist[0]
-
         for i in range(self.nscale):
-            totnchan = totnchan + self.chanlist[i] * self.chanlist[i + 1] * szk
-
-        return totnchan + self.chanlist[i + 1] * self.n_chan_out * szk
+            totnchan = totnchan + self.chanlist[i] * self.chanlist[i + 1]
+        return (
+            self.npar * 12 * self.in_nside**2 * self.chanlist[0]
+            + totnchan * self.KERNELSZ * (self.KERNELSZ//2+1)
+            + self.KERNELSZ * (self.KERNELSZ//2+1) * self.chanlist[nscale]
+        )
 
     def set_weights(self, x):
         self.x = x
@@ -123,117 +88,50 @@ class GCNN:
     def get_weights(self):
         return self.x
 
-    def eval(self, param, indices=None, weights=None, axis=0):
+    def eval(self, im, indices=None, weights=None):
 
         x = self.x
+        
+        ww = self.backend.bk_reshape(
+            x[0:self.npar * 12 * self.in_nside**2 * self.chanlist[0]],
+            [self.npar,12 * self.in_nside**2 * self.chanlist[0]],
+        )
 
-        if axis == 0:
-            nval = 1
-        else:
-            nval = param.shape[0]
-
-        nn = 0
-        im = self.scat_operator.backend.bk_reshape(param, [nval, self.npar])
-        if self.hidden is not None:
-            ww = self.scat_operator.backend.bk_reshape(
-                x[nn : nn + self.npar * self.hidden[0]], [self.npar, self.hidden[0]]
-            )
-            im = self.scat_operator.backend.bk_matmul(im, ww)
-            im = self.scat_operator.backend.bk_relu(im)
-            nn += self.npar * self.hidden[0]
-
-            for i in range(1, len(self.hidden)):
-                ww = self.scat_operator.backend.bk_reshape(
-                    x[nn : nn + self.hidden[i] * self.hidden[i - 1]],
-                    [self.hidden[i - 1], self.hidden[i]],
-                )
-                im = self.scat_operator.backend.bk_matmul(im, ww)
-                im = self.scat_operator.backend.bk_relu(im)
-                nn += self.hidden[i] * self.hidden[i - 1]
-
-            ww = self.scat_operator.backend.bk_reshape(
-                x[
-                    nn : nn
-                    + self.hidden[len(self.hidden) - 1]
-                    * 12
-                    * self.in_nside**2
-                    * self.chanlist[0]
-                ],
-                [
-                    self.hidden[len(self.hidden) - 1],
-                    12 * self.in_nside**2 * self.chanlist[0],
-                ],
-            )
-            im = self.scat_operator.backend.bk_matmul(im, ww)
-            im = self.scat_operator.backend.bk_reshape(
-                im, [nval, 12 * self.in_nside**2, self.chanlist[0]]
-            )
-            im = self.scat_operator.backend.bk_relu(im)
-            nn += (
-                self.hidden[len(self.hidden) - 1]
-                * 12
-                * self.in_nside**2
-                * self.chanlist[0]
-            )
-
-        else:
-            ww = self.scat_operator.backend.bk_reshape(
-                x[0 : self.npar * 12 * self.in_nside**2 * self.chanlist[0]],
-                [self.npar, 12 * self.in_nside**2 * self.chanlist[0]],
-            )
-            im = self.scat_operator.backend.bk_matmul(im, ww)
-            im = self.scat_operator.backend.bk_reshape(
-                im, [nval, 12 * self.in_nside**2, self.chanlist[0]]
-            )
-            im = self.scat_operator.backend.bk_relu(im)
-
-            nn = self.npar * 12 * self.chanlist[0] * self.in_nside**2
-
+        im = self.scat_operator.backend.bk_matmul(im,ww)
+        
+        im = self.backend.bk_reshape(im,[im.shape[0],self.chanlist[0],12 * self.in_nside**2])
+        
+        nn = self.npar * 12 * self.in_nside**2 * self.chanlist[0]
+        
         for k in range(self.nscale):
             ww = self.scat_operator.backend.bk_reshape(
                 x[
                     nn : nn
                     + self.KERNELSZ
-                    * self.KERNELSZ
+                    * (self.KERNELSZ//2+1)
                     * self.chanlist[k]
                     * self.chanlist[k + 1]
                 ],
-                [self.KERNELSZ * self.KERNELSZ, self.chanlist[k], self.chanlist[k + 1]],
+                [self.chanlist[k], self.KERNELSZ * (self.KERNELSZ//2+1),  self.chanlist[k + 1]],
             )
             nn = (
                 nn
                 + self.KERNELSZ
-                * self.KERNELSZ
+                * (self.KERNELSZ//2)
                 * self.chanlist[k]
                 * self.chanlist[k + 1]
             )
             if indices is None:
-                im = self.scat_operator.healpix_layer_transpose(im, ww, axis=1)
+                im = self.scat_operator.healpix_layer(im, ww)
             else:
-                im = self.scat_operator.healpix_layer_transpose(
-                    im, ww, indices=indices[k], weights=weights[k], axis=1
+                im = self.scat_operator.healpix_layer(
+                    im, ww, indices=indices[k], weights=weights[k]
                 )
             im = self.scat_operator.backend.bk_relu(im)
+            
+            im = self.backend.bk_reshape(self.scat_operator.backend.bk_repeat(im,4),[im.shape[0],im.shape[1],im.shape[2]*4])
 
-        ww = self.scat_operator.backend.bk_reshape(
-            x[nn:],
-            [
-                self.KERNELSZ * self.KERNELSZ,
-                self.chanlist[self.nscale],
-                self.n_chan_out,
-            ],
-        )
-        if indices is None:
-            im = self.scat_operator.healpix_layer(im, ww, axis=1)
-        else:
-            im = self.scat_operator.healpix_layer(
-                im,
-                ww,
-                indices=indices[self.nscale],
-                weights=weights[self.nscale],
-                axis=1,
-            )
+        #im = self.scat_operator.backend.bk_reshape(im, [self.npar])
+        #im = self.scat_operator.backend.bk_relu(im)
 
-        if axis == 0:
-            im = self.scat_operator.backend.bk_reshape(im, [im.shape[1], im.shape[2]])
         return im

foscat/Softmax.py

@@ -60,6 +60,7 @@ class SoftmaxClassifier:
             epochs (int, optional): Number of epochs to train the model. Defaults to 10.
         """
         # Train the model
+        self.model.build(input_shape=(None, x_train.shape[1]))
         self.model.fit(x_train, y_train, epochs=epochs)
 
     def predict(self, x_train):

foscat/alm.py

@@ -558,8 +558,8 @@ class alm:
         Nonetheless, it utilizes TensorFlow and can be integrated into gradient computations.
 
         Input:
-        - `im`: a vector of size ([12 \times \text{Nside}^2]) for scalar data, or of size ([2, 12 \times \text{Nside}^2]) for Q,U polar data,
-        or of size ([3, 12 \times \text{Nside}^2]) for I,Q,U polar data.
+        - `im`: a vector of size ([N_image, 12 \times \text{Nside}^2]) for scalar data, or of size ([N_image, 2, 12 \times \text{Nside}^2]) for Q,U polar data,
+        or of size ([N_image,3, 12 \times \text{Nside}^2]) for I,Q,U polar data.
         - `map2` (optional): a vector of size ([12 \times \text{Nside}^2]) for scalar data, or of size
         ([3, 12 \times \text{Nside}^2]) for polar data. If provided, cross power spectra will be computed.
         - `nest=True`: alters the ordering of the input maps.