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

foscat/GCNN.py

@@ -0,0 +1,239 @@
+import pickle
+
+import numpy as np
+
+import foscat.scat_cov as sc
+
+
+class GCNN:
+
+    def __init__(
+        self,
+        scat_operator=None,
+        nparam=1,
+        nscale=1,
+        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
+            self.npar = outlist[2]
+            self.nscale = outlist[5]
+            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.x = self.scat_operator.backend.bk_cast(outlist[6])
+        else:
+            self.nscale = nscale
+            self.nbatch = nbatch
+            self.npar = nparam
+            self.n_chan_out = n_chan_out
+            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.hidden = hidden
+
+            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):
+
+        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,
+            self.npar,
+            self.KERNELSZ,
+            self.in_nside,
+            self.nscale,
+            www,
+            self.all_type,
+            self.n_chan_out,
+            tabh,
+        ]
+
+        myout = open("%s.pkl" % (filename), "wb")
+        pickle.dump(outlist, myout)
+        myout.close()
+
+    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
+
+    def set_weights(self, x):
+        self.x = x
+
+    def get_weights(self):
+        return self.x
+
+    def eval(self, param, indices=None, weights=None, axis=0):
+
+        x = self.x
+
+        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
+
+        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_transpose(im, ww, axis=1)
+            else:
+                im = self.scat_operator.healpix_layer_transpose(
+                    im, ww, indices=indices[k], weights=weights[k], axis=1
+                )
+            im = self.scat_operator.backend.bk_relu(im)
+
+        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,
+            )
+
+        if axis == 0:
+            im = self.scat_operator.backend.bk_reshape(im, [im.shape[1], im.shape[2]])
+        return im

foscat/Softmax.py

@@ -1,50 +1,59 @@
-import tensorflow as tf
-from tensorflow.keras.models import Sequential
+# import tensorflow as tf
 from tensorflow.keras.layers import Dense, Softmax
-import numpy as np
+from tensorflow.keras.models import Sequential
+
 
 class SoftmaxClassifier:
     """
     A classifier based on the softmax function for multi-class classification.
-    
+
     Attributes:
         model (Sequential): A TensorFlow/Keras model comprising a hidden layer and a softmax output layer.
-    
+
     Parameters:
         Nval (int): Number of features in the input dataset.
         Nclass (int): Number of classes to classify the input data into.
         Nhidden (int, optional): Number of neurons in the hidden layer. Defaults to 10.
     """
 
-    def __init__(self, Nval, Nclass, Nhidden=10):
+    def __init__(self, Nval, Nclass, Nhidden=10, Nlevel=1):
         """
         Initializes the SoftmaxClassifier with a specified number of input features, classes, and hidden neurons.
-        
+
         The model consists of a dense hidden layer with ReLU activation and a dense output layer with softmax activation.
-        
+
         Args:
             Nval (int): Number of features in the input dataset.
             Nclass (int): Number of classes for the output classification.
             Nhidden (int): Number of neurons in the hidden layer.
         """
         # Create the model
-        self.model = Sequential([
-            Dense(units=Nhidden, activation='relu', input_shape=(Nval,)),  # A hidden layer with Nhidden neurons
-            Dense(units=Nclass),  # The output layer with Nclass neurons (for Nclass classes)
-            Softmax()  # Softmax activation for classification
-        ])
+        TheModel = [Dense(units=Nhidden, activation="relu", input_shape=(Nval,))]
+
+        for k in range(1, Nlevel):
+            TheModel = TheModel + [
+                Dense(units=Nhidden, activation="relu", input_shape=(Nhidden,))
+            ]
+
+        TheModel = TheModel + [
+            Dense(
+                units=Nclass
+            ),  # The output layer with Nclass neurons (for Nclass classes)
+            Softmax(),  # Softmax activation for classification
+        ]
+        self.model = Sequential(TheModel)
 
         # Model compilation
         self.model.compile(
-            optimizer='adam',  # Adam optimizer
-            loss='sparse_categorical_crossentropy',  # Loss function for Nclass-class classification
-            metrics=['accuracy']  # Evaluation metric: accuracy
+            optimizer="adam",  # Adam optimizer
+            loss="sparse_categorical_crossentropy",  # Loss function for Nclass-class classification
+            metrics=["accuracy"],  # Evaluation metric: accuracy
         )
-        
+
     def fit(self, x_train, y_train, epochs=10):
         """
         Trains the model on the provided dataset.
-        
+
         Args:
             x_train (np.ndarray): Training data features, shape (num_samples, Nval).
             y_train (np.ndarray): Training data labels, shape (num_samples, ).
@@ -56,10 +65,10 @@ class SoftmaxClassifier:
     def predict(self, x_train):
         """
         Predicts the class labels for the given input data.
-        
+
         Args:
             x_train (np.ndarray): Input data for which to predict class labels, shape (num_samples, Nval).
-        
+
         Returns:
             np.ndarray: Predicted class labels for the input data.
         """

foscat/Spline1D.py

@@ -1,42 +1,92 @@
+import numpy as np
 
 class Spline1D:
     def __init__(self, nodes, degree=3):
+        """
+        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 = [0] * (self.degree + 1)
-        for i in range(self.degree + 1):
-            self.norm[i] = pow(-1, i) * (self.degree + 1) / (self._fact_spline(self.degree + 1 - i) * self._fact_spline(i))
-
-    def _fact_spline(self, x):
-        if x <= 1:
-            return 1
-        return x * self._fact_spline(x - 1)
-
-    def yplus_spline1d(self, x):
-        if x < 0.0:
-            return 0.0
-        if self.degree == 0:
-            if x == 0.0:
-                return 0.5
-            else:
-                return 1.0
-        return pow(x, self.degree)
-
-    def calculate(self, x):
-        y = [0] * self.nodes
-        for i in range(self.nodes):
-            tmp = 0
-            tx = (self.nodes - 1) * x - i
-            if x < 0:
-                tx = -i
-            if x > 1.0:
-                tx = (self.nodes - 1) - i
-            for j in range(self.degree + 1):
-                tmp += self.norm[j] * self.yplus_spline1d(tx - j + (self.degree + 1) / 2)
-            if tmp < 0:
-                tmp = 0.0
-            y[i] += tmp
-        total = sum(y)
-        y = [yi / total for yi in y]
-        return y
+        
+        
+    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):
+        """
+        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.
+        """
+        N=self.nodes
+        
+        if isinstance(x, float):
+            # Single scalar input
+            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")
+            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
+
+        # 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 + 3
+        indices[2] = base_idx + 2
+        indices[1] = base_idx + 1
+        indices[0] = base_idx
+
+        # Handle boundary conditions
+        if isinstance(x, float):
+            if indices[0] == 0:
+                indices[0] = 1
+            if indices[1] == 0:
+                indices[1] = 1
+            if indices[2] == N + 1:
+                indices[2] = N
+            if indices[3] == N + 1:
+                indices[3] = N
+            if indices[3] == N + 2:
+                indices[3] = N
+        else:
+            indices[0, indices[0] == 0] = 1
+            indices[1, indices[1] == 0] = 1
+            indices[2, indices[2] >= N + 1] = N
+            indices[3, indices[3] >= N + 1] = N
+
+        # Adjust indices to start from 0
+        indices = indices - 1
+        # Square coefficients and normalize
+        coefficients = coefficients * coefficients
+        coefficients /= np.sum(coefficients, axis=0)
 
+        return indices, coefficients