foscat 3.0.11__tar.gz → 3.0.13__tar.gz

{foscat-3.0.11 → foscat-3.0.13}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: foscat
-Version: 3.0.11
+Version: 3.0.13
 Summary: Generate synthetic Healpix or 2D data using Cross Scattering Transform
 Home-page: https://github.com/jmdelouis/FOSCAT
 Author: Jean-Marc DELOUIS
@@ -9,12 +9,6 @@ Maintainer: Theo Foulquier
 Maintainer-email: theo.foulquier@ifremer.fr
 License: MIT
 Keywords: Scattering transform,Component separation,denoising
-Requires-Dist: imageio
-Requires-Dist: imagecodecs
-Requires-Dist: matplotlib
-Requires-Dist: numpy
-Requires-Dist: tensorflow
-Requires-Dist: healpy
 
 Utilize the Cross Scattering Transform (described in https://arxiv.org/abs/2207.12527) to synthesize Healpix or 2D data that is suitable for component separation purposes, such as denoising. 
  A demo package for this process can be found at https://github.com/jmdelouis/FOSCAT_DEMO. 

{foscat-3.0.11 → foscat-3.0.13}/setup.py

@@ -3,7 +3,7 @@ from setuptools import setup, find_packages
 
 setup(
     name='foscat',
-    version='3.0.11',
+    version='3.0.13',
     description='Generate synthetic Healpix or 2D data using Cross Scattering Transform' ,
     long_description='Utilize the Cross Scattering Transform (described in https://arxiv.org/abs/2207.12527) to synthesize Healpix or 2D data that is suitable for component separation purposes, such as denoising. \n A demo package for this process can be found at https://github.com/jmdelouis/FOSCAT_DEMO. \n Complete doc can be found at https://foscat-documentation.readthedocs.io/en/latest/index.html. \n\n List of developers : J.-M. Delouis, T. Foulquier, L. Mousset, T. Odaka, F. Paul, E. Allys ' ,
     license='MIT',

foscat-3.0.13/src/foscat/GCNN.py

@@ -0,0 +1,100 @@
+import numpy as np
+import pickle
+import foscat.scat_cov as sc
+  
+
+class GCNN:
+        
+    def __init__(self,
+                 scat_operator=None,
+                 nparam=1,
+                 nscale=1,
+                 chanlist=[],
+                 in_nside=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.x=self.scat_operator.backend.bk_cast(outlist[6])
+        else:
+            self.nscale=nscale
+            self.nbatch=nbatch
+            self.npar=nparam
+            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))
+                exit(0)
+            
+            self.chanlist=chanlist
+            self.KERNELSZ= scat_operator.KERNELSZ
+            self.all_type= scat_operator.all_type
+            self.in_nside=in_nside
+
+            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]
+        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.in_nside**2*self.chanlist[0] \
+            +totnchan*self.KERNELSZ*self.KERNELSZ+self.chanlist[self.nscale]
+
+    def set_weights(self,x):
+        self.x=x
+        
+    def get_weights(self):
+        return self.x
+        
+    def eval(self,param):
+
+        x=self.x
+        
+        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(self.scat_operator.backend.bk_reshape(param,[1,self.npar]),ww)
+        im=self.scat_operator.backend.bk_reshape(im,[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]
+            im=self.scat_operator.healpix_layer_transpose(im,ww)
+            im=self.scat_operator.backend.bk_relu(im)
+            
+        ww=self.scat_operator.backend.bk_reshape(x[nn:],[self.chanlist[self.nscale],1])
+        im=self.scat_operator.backend.bk_matmul(im,ww)
+        
+        return self.scat_operator.backend.bk_reshape(im,[im.shape[0]])
+     

{foscat-3.0.11 → foscat-3.0.13}/src/foscat/Synthesis.py

@@ -49,6 +49,7 @@ class Synthesis:
 
         self.loss_class=loss_list
         self.number_of_loss=len(loss_list)
+        self.__iteration__=1234
         self.nlog=0
         self.m_dw, self.v_dw = 0.0, 0.0
         self.beta1 = beta1
@@ -115,7 +116,7 @@ class Synthesis:
             
         self.nlog=self.nlog+1
         self.itt2=0
-        
+            
         if self.itt%self.EVAL_FREQUENCY==0 and self.mpi_rank==0:
             end = time.time()
             cur_loss='%10.3g ('%(self.ltot[self.ltot!=-1].mean())
@@ -131,6 +132,7 @@ class Synthesis:
                 for k in range(info_gpu.shape[0]):
                     mess=mess+'[GPU%d %.0f/%.0f MB %.0f%%]'%(k,info_gpu[k,0],info_gpu[k,1],info_gpu[k,2])
                 
+            
             print('%sItt %6d L=%s %.3fs %s'%(self.MESSAGE,self.itt,cur_loss,(end-self.start),mess))
             sys.stdout.flush()
             if self.KEEP_TRACK is not None:
@@ -140,13 +142,14 @@ class Synthesis:
             self.start = time.time()
             
         self.itt=self.itt+1
-        
+
     # ---------------------------------------------−---------
     def calc_grad(self,in_x):
         
         g_tot=None
         l_tot=0.0
 
+            
         if self.do_all_noise and self.totalsz>self.batchsz:
             nstep=self.totalsz//self.batchsz
         else:
@@ -158,6 +161,7 @@ class Synthesis:
         
         for istep in range(nstep):
             
+        
             for k in range(self.number_of_loss):
                 if self.loss_class[k].batch is None:
                     l_batch=None
@@ -271,6 +275,7 @@ class Synthesis:
         self.SHOWGPU=SHOWGPU
         self.axis=axis
         self.in_x_nshape=in_x.shape[0]
+        self.seed=1234
 
         np.random.seed(self.mpi_rank*7+1234)
             
@@ -347,7 +352,7 @@ class Synthesis:
         start_x=x.copy()
 
         for iteration in range(NUM_STEP_BIAS):
-
+        
             x,l,i=opt.fmin_l_bfgs_b(self.calc_grad,
                                     x.astype('float64'),
                                     callback=self.info_back,
@@ -357,17 +362,17 @@ class Synthesis:
 
             # update bias input data
             if iteration<NUM_STEP_BIAS-1:
-                if self.mpi_rank==0:
-                    print('%s Hessian restart'%(self.MESSAGE))
+                #if self.mpi_rank==0:
+                #    print('%s Hessian restart'%(self.MESSAGE))
 
                 omap=self.xtractmap(x,axis)
 
                 for k in range(self.number_of_loss):
                     if self.loss_class[k].batch_update is not None:
                         self.loss_class[k].batch_update(self.loss_class[k].batch_data,omap)
+                    if self.loss_class[k].batch is not None:
                         l_batch=self.loss_class[k].batch(self.loss_class[k].batch_data,0,init=True)
                 #x=start_x.copy()
-                    
 
         if self.mpi_rank==0 and SHOWGPU:
             self.stop_synthesis()

{foscat-3.0.11 → foscat-3.0.13}/src/foscat/backend.py

@@ -480,6 +480,41 @@ class foscat_backend:
                 return(self.backend.mean(data,axis))
             if self.BACKEND==self.NUMPY:
                 return(np.mean(data,axis))
+            
+    def bk_reduce_min(self,data,axis=None):
+        
+        if axis is None:
+            if self.BACKEND==self.TENSORFLOW:
+                return(self.backend.reduce_min(data))
+            if self.BACKEND==self.TORCH:
+                return(self.backend.min(data))
+            if self.BACKEND==self.NUMPY:
+                return(np.min(data))
+        else:
+            if self.BACKEND==self.TENSORFLOW:
+                return(self.backend.reduce_min(data,axis=axis))
+            if self.BACKEND==self.TORCH:
+                return(self.backend.min(data,axis))
+            if self.BACKEND==self.NUMPY:
+                return(np.min(data,axis))
+            
+    def bk_random_seed(self,value):
+        
+        if self.BACKEND==self.TENSORFLOW:
+            return(self.backend.random.set_seed(value))
+        if self.BACKEND==self.TORCH:
+            return(self.backend.random.set_seed(value))
+        if self.BACKEND==self.NUMPY:
+            return(np.random.seed(value))
+        
+    def bk_random_uniform(self,shape):
+        
+        if self.BACKEND==self.TENSORFLOW:
+            return(self.backend.random.uniform(shape))
+        if self.BACKEND==self.TORCH:
+            return(self.backend.random.uniform(shape))
+        if self.BACKEND==self.NUMPY:
+            return(np.random.rand(shape))
 
     def bk_reduce_std(self,data,axis=None):
         

{foscat-3.0.11 → foscat-3.0.13}/src/foscat.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: foscat
-Version: 3.0.11
+Version: 3.0.13
 Summary: Generate synthetic Healpix or 2D data using Cross Scattering Transform
 Home-page: https://github.com/jmdelouis/FOSCAT
 Author: Jean-Marc DELOUIS
@@ -9,12 +9,6 @@ Maintainer: Theo Foulquier
 Maintainer-email: theo.foulquier@ifremer.fr
 License: MIT
 Keywords: Scattering transform,Component separation,denoising
-Requires-Dist: imageio
-Requires-Dist: imagecodecs
-Requires-Dist: matplotlib
-Requires-Dist: numpy
-Requires-Dist: tensorflow
-Requires-Dist: healpy
 
 Utilize the Cross Scattering Transform (described in https://arxiv.org/abs/2207.12527) to synthesize Healpix or 2D data that is suitable for component separation purposes, such as denoising. 
  A demo package for this process can be found at https://github.com/jmdelouis/FOSCAT_DEMO. 

{foscat-3.0.11 → foscat-3.0.13}/src/foscat.egg-info/SOURCES.txt

@@ -3,6 +3,7 @@ setup.cfg
 setup.py
 src/foscat/CircSpline.py
 src/foscat/FoCUS.py
+src/foscat/GCNN.py
 src/foscat/GetGPUinfo.py
 src/foscat/Softmax.py
 src/foscat/Spline1D.py