foscat 3.0.9__tar.gz → 3.0.14__tar.gz

{foscat-3.0.9 → foscat-3.0.14}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: foscat
-Version: 3.0.9
+Version: 3.0.14
 Summary: Generate synthetic Healpix or 2D data using Cross Scattering Transform
 Home-page: https://github.com/jmdelouis/FOSCAT
 Author: Jean-Marc DELOUIS

{foscat-3.0.9 → foscat-3.0.14}/setup.py

@@ -3,7 +3,7 @@ from setuptools import setup, find_packages
 
 setup(
     name='foscat',
-    version='3.0.9',
+    version='3.0.14',
     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.9 → foscat-3.0.14}/src/foscat/FoCUS.py

@@ -27,6 +27,7 @@ class FoCUS:
                  JmaxDelta=0,
                  DODIV=False,
                  InitWave=None,
+                 silent=False,
                  mpi_size=1,
                  mpi_rank=0):
 
@@ -42,20 +43,25 @@ class FoCUS:
         self.mpi_size=mpi_size
         self.mpi_rank=mpi_rank
         self.return_data=return_data
-        
-        print('================================================')
-        print('          START FOSCAT CONFIGURATION')
-        print('================================================')
-        sys.stdout.flush()
+        self.silent=silent
+
+        if not silent:
+            print('================================================')
+            print('          START FOSCAT CONFIGURATION')
+            print('================================================')
+            sys.stdout.flush()
 
         self.TEMPLATE_PATH=TEMPLATE_PATH
         if os.path.exists(self.TEMPLATE_PATH)==False:
-            print('The directory %s to store temporary information for FoCUS does not exist: Try to create it'%(self.TEMPLATE_PATH))
+            if not silent:
+                print('The directory %s to store temporary information for FoCUS does not exist: Try to create it'%(self.TEMPLATE_PATH))
             try:
                 os.system('mkdir -p %s'%(self.TEMPLATE_PATH))
-                print('The directory %s is created')
+                if not silent:
+                    print('The directory %s is created')
             except:
-                print('Impossible to create the directory %s'%(self.TEMPLATE_PATH))
+                if not silent:
+                    print('Impossible to create the directory %s'%(self.TEMPLATE_PATH))
                 exit(0)
                 
         self.number_of_loss=0
@@ -65,13 +71,15 @@ class FoCUS:
         self.padding=padding
             
         if OSTEP!=0:
-            print('OPTION option is deprecated after version 2.0.6. Please use Jmax option')
+            if not silent:
+                print('OPTION option is deprecated after version 2.0.6. Please use Jmax option')
             JmaxDelta=OSTEP
         else:
             OSTEP=JmaxDelta
             
         if JmaxDelta<-1:
-            print('Warning : Jmax can not be smaller than -1')
+            if not silent:
+                print('Warning : Jmax can not be smaller than -1')
             exit(0)
             
         self.OSTEP=JmaxDelta
@@ -103,14 +111,15 @@ class FoCUS:
         
         self.gpupos=(gpupos+mpi_rank)%self.backend.ngpu
 
-        print('============================================================')
-        print('==                                                        ==')
-        print('==                                                        ==')
-        print('==     RUN ON GPU Rank %d : %s                          =='%(mpi_rank,self.gpulist[self.gpupos%self.ngpu]))
-        print('==                                                        ==')
-        print('==                                                        ==')
-        print('============================================================')
-        sys.stdout.flush()
+        if not silent:
+            print('============================================================')
+            print('==                                                        ==')
+            print('==                                                        ==')
+            print('==     RUN ON GPU Rank %d : %s                          =='%(mpi_rank,self.gpulist[self.gpupos%self.ngpu]))
+            print('==                                                        ==')
+            print('==                                                        ==')
+            print('============================================================')
+            sys.stdout.flush()
 
         l_NORIENT=NORIENT
         if DODIV:
@@ -126,6 +135,8 @@ class FoCUS:
             
         self.ww_Real  = {} 
         self.ww_Imag  = {} 
+        self.ww_CNN_Transpose  = {}
+        self.ww_CNN  = {}
         
         wwc=np.zeros([KERNELSZ**2,l_NORIENT]).astype(all_type)
         wws=np.zeros([KERNELSZ**2,l_NORIENT]).astype(all_type)
@@ -210,7 +221,8 @@ class FoCUS:
 
             for i in range(1,6):
                 lout=(2**i)
-                print('Init Wave ',lout)
+                if not silent:
+                    print('Init Wave ',lout)
                 
                 if self.InitWave is None:
                     wr,wi,ws,widx=self.init_index(lout)
@@ -271,6 +283,8 @@ class FoCUS:
             self.nest2R4[lout]=None
             self.inv_nest2R[lout]=None
             self.remove_border[lout]=None
+            self.ww_CNN_Transpose[lout]=None
+            self.ww_CNN[lout]=None
 
         self.loss={}
 
@@ -296,7 +310,97 @@ class FoCUS:
         res=x
         res[idx]=y[idx]
         return(res)
+
+    # ---------------------------------------------−---------
+    # make the CNN working : index reporjection of the kernel on healpix
+    
+    def init_CNN_index(self,nside,transpose=False):
+        l_kernel=int(self.KERNELSZ*self.KERNELSZ)
+        weights=self.backend.bk_cast(np.ones([12*nside*nside*l_kernel],dtype='float'))
+        try:
+            if transpose:
+                indices=np.load('%s/FOSCAT_%s_W%d_%d_%d_CNN_Transpose.npy'%(self.TEMPLATE_PATH,TMPFILE_VERSION,l_kernel,self.NORIENT,nside))
+            else:
+                indices=np.load('%s/FOSCAT_%s_W%d_%d_%d_CNN.npy'%(self.TEMPLATE_PATH,TMPFILE_VERSION,l_kernel,self.NORIENT,nside))
+        except:
+            to,po=hp.pix2ang(nside,np.arange(12*nside*nside),nest=True)
+            x,y,z=hp.pix2vec(nside,np.arange(12*nside*nside),nest=True)
+
+            idx=np.argsort((x-1.0)**2+y**2+z**2)[0:l_kernel]
+            tc,pc=hp.pix2ang(nside,idx,nest=True)
+            
+            indices=np.zeros([12*nside*nside,l_kernel,2],dtype='int')
+            for k in range(12*nside*nside):
+                if k%(nside*nside)==0:
+                    if not silent:
+                        print('Pre-compute nside=%6d %.2f%%'%(nside,100*k/(12*nside*nside)))
+        
+                rot=[po[k]/np.pi*180.0,90+(-to[k])/np.pi*180.0]
+                r=hp.Rotator(rot=rot).get_inverse()            
+                # get the coordinate
+                ty,tx=r(tc,pc)
+    
+                indices[k,:,0]=k*l_kernel+np.arange(l_kernel).astype('int')
+                indices[k,:,1]=hp.ang2pix(nside,ty,tx,nest=True)
+            if transpose:
+                indices[:,:,1]=indices[:,:,1]//4
+                np.save('%s/FOSCAT_%s_W%d_%d_%d_CNN_Transpose.npy'%(self.TEMPLATE_PATH,TMPFILE_VERSION,l_kernel,self.NORIENT,nside),indices)
+                if not silent:
+                    print('Write %s/FOSCAT_%s_W%d_%d_%d_CNN_Transpose.npy'%(self.TEMPLATE_PATH,TMPFILE_VERSION,l_kernel,self.NORIENT,nside))
+            else:
+                np.save('%s/FOSCAT_%s_W%d_%d_%d_CNNnpy'%(self.TEMPLATE_PATH,TMPFILE_VERSION,l_kernel,self.NORIENT,nside),indices)
+                if not silent:
+                    print('Write %s/FOSCAT_%s_W%d_%d_%d_CNN.npy'%(self.TEMPLATE_PATH,TMPFILE_VERSION,l_kernel,self.NORIENT,nside))
+
+                
+        if transpose:
+            self.ww_CNN_Transpose[nside]=self.backend.bk_SparseTensor(indices.reshape(12*nside*nside*l_kernel,2),
+                                                                      weights,[12*nside*nside*l_kernel,
+                                                                                         3*nside*nside])
+        else:
+            self.ww_CNN[nside]=self.backend.bk_SparseTensor(indices.reshape(12*nside*nside*l_kernel,2),
+                                                            weights,[12*nside*nside*l_kernel,
+                                                                     12*nside*nside])
+            
+    # ---------------------------------------------−---------
+    def healpix_layer_transpose(self,im,ww):
+        nside=2*int(np.sqrt(im.shape[0]//12))
+        l_kernel=self.KERNELSZ*self.KERNELSZ
+            
+        if im.shape[1]!=ww.shape[1]:
+            if not self.silent:
+                print('Weights channels should be equal to the input image channels')
+            return -1
+        
+        if self.ww_CNN_Transpose[nside] is None:
+            self.init_CNN_index(nside,transpose=True)
+            
+        tmp=self.backend.bk_sparse_dense_matmul(self.ww_CNN_Transpose[nside],im)
+        
+        density=self.backend.bk_reshape(tmp,[12*nside*nside,l_kernel*im.shape[1]])
+        
+        return self.backend.bk_matmul(density,self.backend.bk_reshape(ww,[l_kernel*im.shape[1],ww.shape[2]]))
+    
+    # ---------------------------------------------−---------
+    # ---------------------------------------------−---------
+    def healpix_layer(self,im,ww):
+        nside=int(np.sqrt(im.shape[0]//12))
+        l_kernel=self.KERNELSZ*self.KERNELSZ
+            
+        if im.shape[1]!=ww.shape[1]:
+            if not self.silent:
+                print('Weights channels should be equal to the input image channels')
+            return -1
+        
+        if self.ww_CNN[nside] is None:
+            self.init_CNN_index(nside,transpose=False)
+            
+        tmp=self.backend.bk_sparse_dense_matmul(self.ww_CNN[nside],im)
+        density=self.backend.bk_reshape(tmp,[12*nside*nside,l_kernel*im.shape[1]])
         
+        return self.backend.bk_matmul(density,self.backend.bk_reshape(ww,[l_kernel*im.shape[1],ww.shape[2]]))
+    # ---------------------------------------------−---------
+    
     # ---------------------------------------------−---------
     def get_rank(self):
         return(self.rank)
@@ -332,7 +436,8 @@ class FoCUS:
         if self.use_2D:
             ishape=list(im.shape)
             if len(ishape)<axis+2:
-                print('Use of 2D scat with data that has less than 2D')
+                if not self.silent:
+                    print('Use of 2D scat with data that has less than 2D')
                 exit(0)
                 
             npix=im.shape[axis]
@@ -392,7 +497,8 @@ class FoCUS:
         if self.use_2D:
             ishape=list(im.shape)
             if len(ishape)<axis+2:
-                print('Use of 2D scat with data that has less than 2D')
+                if not self.silent:
+                    print('Use of 2D scat with data that has less than 2D')
                 exit(0)
                 
             if nouty is None:
@@ -434,7 +540,8 @@ class FoCUS:
             lout=int(np.sqrt(im.shape[axis]//12))
             
             if self.pix_interp_val[lout][nout] is None:
-                print('compute lout nout',lout,nout)
+                if not self.silent:
+                    print('compute lout nout',lout,nout)
                 th,ph=hp.pix2ang(nout,np.arange(12*nout**2,dtype='int'),nest=True)
                 p, w = hp.get_interp_weights(lout,th,ph,nest=True)
                 del th
@@ -791,7 +898,8 @@ class FoCUS:
                     
                 for k in range(12*nside*nside):
                     if k%(nside*nside)==0:
-                        print('Pre-compute nside=%6d %.2f%%'%(nside,100*k/(12*nside*nside)))
+                        if not self.silent:
+                            print('Pre-compute nside=%6d %.2f%%'%(nside,100*k/(12*nside*nside)))
                     if nside>scale*2:
                         lidx=hp.get_all_neighbours(nside//scale,th[k//(scale*scale)],ph[k//(scale*scale)],nest=True)
                         lidx=np.concatenate([lidx,np.array([(k//(scale*scale))])],0)
@@ -843,7 +951,8 @@ class FoCUS:
                 wav=w.flatten()
                 wwav=wwav.flatten()
                 
-                print('Write FOSCAT_%s_W%d_%d_%d_PIDX.npy'%(TMPFILE_VERSION,self.KERNELSZ**2,self.NORIENT,nside))
+                if not self.silent:
+                    print('Write FOSCAT_%s_W%d_%d_%d_PIDX.npy'%(TMPFILE_VERSION,self.KERNELSZ**2,self.NORIENT,nside))
                 np.save('%s/FOSCAT_%s_W%d_%d_%d_PIDX.npy'%(self.TEMPLATE_PATH,TMPFILE_VERSION,self.KERNELSZ**2,self.NORIENT,nside),indice)
                 np.save('%s/FOSCAT_%s_W%d_%d_%d_WAVE.npy'%(self.TEMPLATE_PATH,TMPFILE_VERSION,self.KERNELSZ**2,self.NORIENT,nside),wav)
                 np.save('%s/FOSCAT_%s_W%d_%d_%d_PIDX2.npy'%(self.TEMPLATE_PATH,TMPFILE_VERSION,self.KERNELSZ**2,self.NORIENT,nside),indice2)
@@ -857,7 +966,8 @@ class FoCUS:
                         self.comp_idx_w25(nside)
                 else:
                     if self.rank==0:
-                        print('Only 3x3 and 5x5 kernel have been developped for Healpix and you ask for %dx%d'%(KERNELSZ,KERNELSZ))
+                        if not self.silent:
+                            print('Only 3x3 and 5x5 kernel have been developped for Healpix and you ask for %dx%d'%(KERNELSZ,KERNELSZ))
                         exit(0)
 
         self.barrier()  
@@ -882,6 +992,7 @@ class FoCUS:
                 return tmp
             
         return wr,wi,ws,tmp
+
         
     # ---------------------------------------------−---------
     # Compute x [....,a,....] to [....,a*a,....]
@@ -1140,7 +1251,8 @@ class FoCUS:
             
             ishape=list(in_image.shape)
             if len(ishape)<axis+2:
-                print('Use of 2D scat with data that has less than 2D')
+                if not self.silent:
+                    print('Use of 2D scat with data that has less than 2D')
                 exit(0)
                 
             npix=ishape[axis]
@@ -1264,7 +1376,8 @@ class FoCUS:
             
             ishape=list(in_image.shape)
             if len(ishape)<axis+2:
-                print('Use of 2D scat with data that has less than 2D')
+                if not self.silent:
+                    print('Use of 2D scat with data that has less than 2D')
                 exit(0)
                 
             npix=ishape[axis]

foscat-3.0.14/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.9 → foscat-3.0.14}/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.9 → foscat-3.0.14}/src/foscat/backend.py

@@ -297,9 +297,14 @@ class foscat_backend:
         if self.BACKEND==self.TENSORFLOW:
             return self.backend.nn.conv1d(x,w, stride=[1,1,1], padding='SAME')
         if self.BACKEND==self.TORCH:
+            # Torch not yet done !!!
             return self.backend.nn.conv1d(x,w, stride=1, padding='SAME')
         if self.BACKEND==self.NUMPY:
-            return self.backend.nn.conv1d(x,w, stride=1, padding='SAME')
+            res=np.zeros([x.shape[0],x.shape[1],w.shape[1]],dtype=x.dtype)
+            for k in range(w.shape[1]):
+                for l in range(w.shape[2]):
+                    res[:,:,l]+=self.scipy.ndimage.convolve1d(x[:,:,k],w[:,k,l],axis=1)
+            return res
 
     def bk_flattenR(self,x):
         if self.BACKEND==self.TENSORFLOW or self.BACKEND==self.TORCH:
@@ -480,6 +485,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.9 → foscat-3.0.14}/src/foscat/scat_cov.py

@@ -1491,8 +1491,111 @@ class funct(FOC.FoCUS):
             
         return scat_cov(mS0, mP00, mC01, mC11, s1=mS1,c10=mC10,backend=self.backend), \
             scat_cov(sS0, sP00, sC01, sC11, s1=sS1,c10=sC10,backend=self.backend)
+
+    # compute local direction to make the statistical analysis more efficient
+    def stat_cfft(self,im,image2=None,upscale=False,smooth_scale=0):
+        tmp=im
+        if image2 is not None:
+            tmpi2=image2
+        if upscale:
+            l_nside=int(np.sqrt(tmp.shape[1]//12))
+            tmp=self.up_grade(tmp,l_nside*2,axis=1)
+            if image2 is not None:
+                tmpi2=self.up_grade(tmpi2,l_nside*2,axis=1)
+            
+        l_nside=int(np.sqrt(tmp.shape[1]//12))
+        nscale=int(np.log(l_nside)/np.log(2))
+        cmat={}
+        cmat2={}
+        for k in range(nscale):
+            sim=self.backend.bk_abs(self.convol(tmp,axis=1))
+            if image2 is not None:
+                sim=self.backend.bk_real(self.backend.bk_L1(self.convol(tmp,axis=1)*self.backend.bk_conjugate(self.convol(tmpi2,axis=1))))
+            else:
+                sim=self.backend.bk_abs(self.convol(tmp,axis=1))
+                
+            cc=self.backend.bk_reduce_mean(sim[:,:,0]-sim[:,:,2],0)
+            ss=self.backend.bk_reduce_mean(sim[:,:,1]-sim[:,:,3],0)
+            for m in range(smooth_scale):
+                if cc.shape[0]>12:
+                    cc=self.ud_grade_2(self.smooth(cc))
+                    ss=self.ud_grade_2(self.smooth(ss))
+            if cc.shape[0]!=tmp.shape[0]:
+                ll_nside=int(np.sqrt(tmp.shape[1]//12))
+                cc=self.up_grade(cc,ll_nside)
+                ss=self.up_grade(ss,ll_nside)
+            phase=np.fmod(np.arctan2(ss.numpy(),cc.numpy())+2*np.pi,2*np.pi)
+            iph=(4*phase/(2*np.pi)).astype('int')
+            alpha=(4*phase/(2*np.pi)-iph)
+            mat=np.zeros([sim.shape[1],4*4])
+            lidx=np.arange(sim.shape[1])
+            for l in range(4):
+                mat[lidx,4*((l+iph)%4)+l]=1.0-alpha
+                mat[lidx,4*((l+iph+1)%4)+l]=alpha
+            
+            cmat[k]=self.backend.bk_cast(mat.astype('complex64'))
+            
+            mat2=np.zeros([k+1,sim.shape[1],4,4*4])
+            
+            for k2 in range(k+1):
+                tmp2=self.backend.bk_repeat(sim,4,axis=-1)
+                sim2=self.backend.bk_reduce_sum(self.backend.bk_reshape(mat.reshape(1,mat.shape[0],16)*tmp2,
+                                                                  [sim.shape[0],cmat[k].shape[0],4,4]),2)
+                sim2=self.backend.bk_abs(self.convol(sim2,axis=1))
+                
+                cc=self.smooth(self.backend.bk_reduce_mean(sim2[:,:,0]-sim2[:,:,2],0))
+                ss=self.smooth(self.backend.bk_reduce_mean(sim2[:,:,1]-sim2[:,:,3],0))
+                for m in range(smooth_scale):
+                    if cc.shape[0]>12:
+                        cc=self.ud_grade_2(self.smooth(cc))
+                        ss=self.ud_grade_2(self.smooth(ss))
+                if cc.shape[0]!=sim.shape[1]:
+                    ll_nside=int(np.sqrt(sim.shape[1]//12))
+                    cc=self.up_grade(cc,ll_nside)
+                    ss=self.up_grade(ss,ll_nside)
+                    
+                phase=np.fmod(np.arctan2(ss.numpy(),cc.numpy())+2*np.pi,2*np.pi)
+                """
+                for k in range(4):
+                    hp.mollview(np.fmod(phase+np.pi,2*np.pi),cmap='jet',nest=True,hold=False,sub=(2,2,1+k))
+                plt.show()
+                exit(0)
+                """
+                iph=(4*phase/(2*np.pi)).astype('int')
+                alpha=(4*phase/(2*np.pi)-iph)
+                lidx=np.arange(sim.shape[1])
+                for m in range(4):
+                    for l in range(4):
+                        mat2[k2,lidx,m,4*((l+iph[:,m])%4)+l]=1.0-alpha[:,m]
+                        mat2[k2,lidx,m,4*((l+iph[:,m]+1)%4)+l]=alpha[:,m]
+                
+            cmat2[k]=self.backend.bk_cast(mat2.astype('complex64'))
+            """
+            tmp=self.backend.bk_repeat(sim[0],4,axis=1)
+            sim2=self.backend.bk_reduce_sum(self.backend.bk_reshape(mat*tmp,[12*nside**2,4,4]),1)
+            
+            cc2=(sim2[:,0]-sim2[:,2])
+            ss2=(sim2[:,1]-sim2[:,3])
+            phase2=np.fmod(np.arctan2(ss2.numpy(),cc2.numpy())+2*np.pi,2*np.pi)
+            
+            plt.figure()
+            hp.mollview(phase,cmap='jet',nest=True,hold=False,sub=(2,2,1))
+            hp.mollview(np.fmod(phase2+np.pi,2*np.pi),cmap='jet',nest=True,hold=False,sub=(2,2,2))
+            plt.figure()
+            for k in range(4):
+                hp.mollview((sim[0,:,k]).numpy().real,cmap='jet',nest=True,hold=False,sub=(2,4,1+k),min=-10,max=10)
+                hp.mollview((sim2[:,k]).numpy().real,cmap='jet',nest=True,hold=False,sub=(2,4,5+k),min=-10,max=10)
+        
+            plt.show()
+            """
+        
+            if k<l_nside-1:
+                tmp=self.ud_grade_2(tmp,axis=1)
+                if image2 is not None:
+                    tmpi2=self.ud_grade_2(tmpi2,axis=1)
+        return cmat,cmat2
     
-    def eval(self, image1, image2=None, mask=None, norm=None, Auto=True, calc_var=False):
+    def eval(self, image1, image2=None, mask=None, norm=None, Auto=True, calc_var=False,cmat=None,cmat2=None):
         """
         Calculates the scattering correlations for a batch of images. Mean are done over pixels.
         mean of modulus:
@@ -1677,6 +1780,11 @@ class funct(FOC.FoCUS):
             ####### S1 and P00
             ### Make the convolution I1 * Psi_j3
             conv1 = self.convol(I1, axis=1)  # [Nbatch, Npix_j3, Norient3]
+
+            if cmat is not None:
+                tmp2=self.backend.bk_repeat(conv1,4,axis=-1)
+                conv1=self.backend.bk_reduce_sum(self.backend.bk_reshape(cmat[j3]*tmp2,[1,cmat[j3].shape[0],4,4]),2)
+                
             ### Take the module M1 = |I1 * Psi_j3|
             M1_square = conv1*self.backend.bk_conjugate(conv1) # [Nbatch, Npix_j3, Norient3]
             M1 = self.backend.bk_L1(M1_square)  # [Nbatch, Npix_j3, Norient3]
@@ -1749,6 +1857,9 @@ class funct(FOC.FoCUS):
             else:  # Cross
                 ### Make the convolution I2 * Psi_j3
                 conv2 = self.convol(I2, axis=1)  # [Nbatch, Npix_j3, Norient3]
+                if cmat is not None:
+                    tmp2=self.backend.bk_repeat(conv2,4,axis=-1)
+                    conv2=self.backend.bk_reduce_sum(self.backend.bk_reshape(cmat[j3]*tmp2,[1,cmat[j3].shape[0],4,4]),2)
                 ### Take the module M2 = |I2 * Psi_j3|
                 M2_square = conv2*self.backend.bk_conjugate(conv2)  # [Nbatch, Npix_j3, Norient3]
                 M2 = self.backend.bk_L1(M2_square)  # [Nbatch, Npix_j3, Norient3]
@@ -1852,19 +1963,19 @@ class funct(FOC.FoCUS):
                 ### C01_auto = < (I1 * Psi)_j3 x (|I1 * Psi_j2| * Psi_j3)^* >_pix
                 if not cross:
                     if calc_var:
-                        c01,vc01 = self._compute_C01(j2,
+                        c01,vc01 = self._compute_C01(j2,j3,
                                                      conv1,
                                                      vmask,
                                                      M1_dic,
                                                      M1convPsi_dic,
-                                                     calc_var=True)  # [Nbatch, Nmask, Norient3, Norient2]
+                                                     calc_var=True,cmat2=cmat2)  # [Nbatch, Nmask, Norient3, Norient2]
                     else:
-                        c01 = self._compute_C01(j2,
+                        c01 = self._compute_C01(j2,j3,
                                                 conv1,
                                                 vmask,
                                                 M1_dic,
                                                 M1convPsi_dic,
-                                                return_data=return_data)  # [Nbatch, Nmask, Norient3, Norient2]
+                                                return_data=return_data,cmat2=cmat2)  # [Nbatch, Nmask, Norient3, Norient2]
                         
                     if return_data:
                         if C01[j3] is None:
@@ -1892,31 +2003,31 @@ class funct(FOC.FoCUS):
                 ### C10_cross = < (I2 * Psi)_j3 x (|I1 * Psi_j2| * Psi_j3)^* >_pix
                 else:
                     if calc_var:
-                        c01,vc01 = self._compute_C01(j2,
+                        c01,vc01 = self._compute_C01(j2,j3,
                                                      conv1,
                                                      vmask,
                                                      M2_dic,
                                                      M2convPsi_dic,
-                                                     calc_var=True)
-                        c10,vc10 = self._compute_C01(j2,
+                                                     calc_var=True,cmat2=cmat2)
+                        c10,vc10 = self._compute_C01(j2,j3,
                                                      conv2,
                                                      vmask,
                                                      M1_dic,
                                                      M1convPsi_dic,
-                                                     calc_var=True)
+                                                     calc_var=True,cmat2=cmat2)
                     else: 
-                        c01 = self._compute_C01(j2,
+                        c01 = self._compute_C01(j2,j3,
                                                 conv1,
                                                 vmask,
                                                 M2_dic,
                                                 M2convPsi_dic,
-                                                return_data=return_data)
-                        c10 = self._compute_C01(j2,
+                                                return_data=return_data,cmat2=cmat2)
+                        c10 = self._compute_C01(j2,j3,
                                                 conv2,
                                                 vmask,
                                                 M1_dic,
                                                 M1convPsi_dic,
-                                                return_data=return_data)
+                                                return_data=return_data,cmat2=cmat2)
                     
                     if return_data:
                         if C01[j3] is None:
@@ -2077,11 +2188,12 @@ class funct(FOC.FoCUS):
         self.P2_dic = None
         return
 
-    def _compute_C01(self, j2, conv,
+    def _compute_C01(self, j2, j3,conv,
                      vmask, M_dic,
                      MconvPsi_dic,
                      calc_var=False,
-                     return_data=False):
+                     return_data=False,
+                     cmat2=None):
         """
         Compute the C01 coefficients (auto or cross)
         C01 = < (Ia * Psi)_j3 x (|Ib * Psi_j2| * Psi_j3)^* >_pix
@@ -2094,7 +2206,10 @@ class funct(FOC.FoCUS):
         ### Compute |I1 * Psi_j2| * Psi_j3 = M1_j2 * Psi_j3
         # Warning: M1_dic[j2] is already at j3 resolution [Nbatch, Npix_j3, Norient3]
         MconvPsi = self.convol(M_dic[j2], axis=1)  # [Nbatch, Npix_j3, Norient3, Norient2]
-
+        if cmat2 is not None:
+            tmp2=self.backend.bk_repeat(MconvPsi,4,axis=-1)
+            MconvPsi=self.backend.bk_reduce_sum(self.backend.bk_reshape(cmat2[j3][j2]*tmp2,[1,cmat2[j3].shape[1],4,4,4]),3)
+        
         # Store it so we can use it in C11 computation
         MconvPsi_dic[j2] = MconvPsi  # [Nbatch, Npix_j3, Norient3, Norient2]
 
@@ -2306,13 +2421,13 @@ class funct(FOC.FoCUS):
     """
     @tf.function
     """
-    def eval_comp_fast(self, image1, image2=None,mask=None,norm=None, Auto=True):
+    def eval_comp_fast(self, image1, image2=None,mask=None,norm=None, Auto=True,cmat=None,cmat2=None):
 
-        res=self.eval(image1, image2=image2,mask=mask,Auto=Auto)
+        res=self.eval(image1, image2=image2,mask=mask,Auto=Auto,cmat=cmat,cmat2=cmat2)
         return res.S0,res.P00,res.S1,res.C01,res.C11,res.C10
 
-    def eval_fast(self, image1, image2=None,mask=None,norm=None, Auto=True):
-        s0,p0,s1,c01,c11,c10=self.eval_comp_fast(image1, image2=image2,mask=mask,Auto=Auto)
+    def eval_fast(self, image1, image2=None,mask=None,norm=None, Auto=True,cmat=None,cmat2=None):
+        s0,p0,s1,c01,c11,c10=self.eval_comp_fast(image1, image2=image2,mask=mask,Auto=Auto,cmat=cmat,cmat2=cmat2)
         return scat_cov(s0, p0,  c01, c11, s1=s1,c10=c10,backend=self.backend)
         
         

{foscat-3.0.9 → foscat-3.0.14}/src/foscat.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: foscat
-Version: 3.0.9
+Version: 3.0.14
 Summary: Generate synthetic Healpix or 2D data using Cross Scattering Transform
 Home-page: https://github.com/jmdelouis/FOSCAT
 Author: Jean-Marc DELOUIS

{foscat-3.0.9 → foscat-3.0.14}/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