foscat 3.0.28__py3-none-any.whl → 3.0.30__py3-none-any.whl

foscat/FoCUS.py

@@ -32,7 +32,7 @@ class FoCUS:
                  mpi_size=1,
                  mpi_rank=0):
 
-        self.__version__ = '3.0.28'
+        self.__version__ = '3.0.30'
         # P00 coeff for normalization for scat_cov
         self.TMPFILE_VERSION=TMPFILE_VERSION
         self.P1_dic = None
@@ -140,6 +140,9 @@ class FoCUS:
         self.ww_Imag  = {} 
         self.ww_CNN_Transpose  = {}
         self.ww_CNN  = {}
+        self.X_CNN  = {}
+        self.Y_CNN  = {}
+        self.Z_CNN  = {}
         
         wwc=np.zeros([KERNELSZ**2,l_NORIENT]).astype(all_type)
         wws=np.zeros([KERNELSZ**2,l_NORIENT]).astype(all_type)
@@ -288,6 +291,9 @@ class FoCUS:
             self.remove_border[lout]=None
             self.ww_CNN_Transpose[lout]=None
             self.ww_CNN[lout]=None
+            self.X_CNN[lout]=None
+            self.Y_CNN[lout]=None
+            self.Z_CNN[lout]=None
 
         self.loss={}
 
@@ -317,72 +323,99 @@ class FoCUS:
     # ---------------------------------------------−---------
     # make the CNN working : index reporjection of the kernel on healpix
     
+    def calc_indices_convol(self,nside,kernel):
+        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:kernel]
+        im=np.ones([12*nside**2])*-1
+        im[idx]=np.arange(len(idx))
+        xc,yc,zc=hp.pix2vec(nside,idx,nest=True)
+
+        vec=np.concatenate([np.expand_dims(x,-1),
+                            np.expand_dims(y,-1),
+                            np.expand_dims(z,-1)],1)
+
+        tc,pc=hp.pix2ang(nside,idx,nest=True)
+
+        indices=np.zeros([12*nside**2*250,2],dtype='int')
+        weights=np.zeros([12*nside**2*250])
+        nn=0
+        for k in range(0,12*nside*nside):
+            if k%(nside*nside)==nside*nside-1:
+                print('Nside=%d KenelSZ=%d %.2f%%'%(nside,kernel,k/(12*nside**2)*100))
+            idx2=hp.query_disc(nside, vec[k], np.pi/nside, inclusive=True,nest=True)
+            t2,p2=hp.pix2ang(nside,idx2,nest=True)
+            rot=[po[k]/np.pi*180.0,90+(-to[k])/np.pi*180.0]
+            r=hp.Rotator(rot=rot)
+            t2,p2=r(t2,p2)
+            idx3=hp.ang2pix(nside,t2,p2,nest=True)
+            ii,ww=hp.get_interp_weights(nside,t2,p2,nest=True)
+
+            ii=im[ii]
+
+            for l in range(4):
+                iii=np.where(ii[l]!=-1)[0]
+                if len(iii)>0:
+                    indices[nn:nn+len(iii),1]=idx2[iii]
+                    indices[nn:nn+len(iii),0]=k*kernel+ii[l,iii]
+                    weights[nn:nn+len(iii)]=ww[l,iii]
+                    nn+=len(iii)
+
+        indices=indices[0:nn]
+        weights=weights[0:nn]
+        print('Nside=%d KenelSZ=%d Total Number of value=%d Ratio of the matrix %.2g%%'%(nside,
+                                                                                         kernel,
+                                                                                         nn,
+                                                                                         100*nn/(kernel*12*nside**2*12*nside**2)))
+        return indices,weights,xc,yc,zc
+
     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))
+            indices=np.load('%s/FOSCAT_%s_I%d_%d_%d_CNNV2.npy'%(self.TEMPLATE_PATH,TMPFILE_VERSION,l_kernel,self.NORIENT,nside))
+            weights=np.load('%s/FOSCAT_%s_W%d_%d_%d_CNNV2.npy'%(self.TEMPLATE_PATH,TMPFILE_VERSION,l_kernel,self.NORIENT,nside))
+            xc=np.load('%s/FOSCAT_%s_X%d_%d_%d_CNNV2.npy'%(self.TEMPLATE_PATH,TMPFILE_VERSION,l_kernel,self.NORIENT,nside))
+            yc=np.load('%s/FOSCAT_%s_Y%d_%d_%d_CNNV2.npy'%(self.TEMPLATE_PATH,TMPFILE_VERSION,l_kernel,self.NORIENT,nside))
+            zc=np.load('%s/FOSCAT_%s_Z%d_%d_%d_CNNV2.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 self.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 self.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 self.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])
+            indices,weights,xc,yc,zc=self.calc_indices_convol(nside,l_kernel)
+            np.save('%s/FOSCAT_%s_I%d_%d_%d_CNNV2.npy'%(self.TEMPLATE_PATH,TMPFILE_VERSION,l_kernel,self.NORIENT,nside),indices)
+            np.save('%s/FOSCAT_%s_W%d_%d_%d_CNNV2.npy'%(self.TEMPLATE_PATH,TMPFILE_VERSION,l_kernel,self.NORIENT,nside),weights)
+            np.save('%s/FOSCAT_%s_X%d_%d_%d_CNNV2.npy'%(self.TEMPLATE_PATH,TMPFILE_VERSION,l_kernel,self.NORIENT,nside),xc)
+            np.save('%s/FOSCAT_%s_Y%d_%d_%d_CNNV2.npy'%(self.TEMPLATE_PATH,TMPFILE_VERSION,l_kernel,self.NORIENT,nside),yc)
+            np.save('%s/FOSCAT_%s_Z%d_%d_%d_CNNV2.npy'%(self.TEMPLATE_PATH,TMPFILE_VERSION,l_kernel,self.NORIENT,nside),zc)
+            if not self.silent:
+                print('Write %s/FOSCAT_%s_W%d_%d_%d_CNNV2.npy'%(self.TEMPLATE_PATH,TMPFILE_VERSION,l_kernel,self.NORIENT,nside))
+
+        self.X_CNN[nside]=xc
+        self.Y_CNN[nside]=yc
+        self.Z_CNN[nside]=zc
+        print(weights.min(),weights.max())
+        self.ww_CNN[nside]=self.backend.bk_SparseTensor(indices,
+                                                        weights,[12*nside*nside*l_kernel,
+                                                                 12*nside*nside])
             
+    # ---------------------------------------------−---------
+    def healpix_layer_coord(self,im):
+        nside=int(np.sqrt(im.shape[0]//12))
+        l_kernel=self.KERNELSZ*self.KERNELSZ
+        if self.ww_CNN[nside] is None:
+            self.init_CNN_index(nside)
+        return self.X_CNN[nside],self.Y_CNN[nside],self.Z_CNN[nside]
+        
     # ---------------------------------------------−---------
     def healpix_layer_transpose(self,im,ww):
-        nside=2*int(np.sqrt(im.shape[0]//12))
+        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_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]]))
+        tmp=self.healpix_layer(im,ww)
+
+        return self.up_grade(tmp,2*nside)
     
     # ---------------------------------------------−---------
     # ---------------------------------------------−---------
@@ -399,6 +432,7 @@ class FoCUS:
             self.init_CNN_index(nside,transpose=False)
             
         tmp=self.backend.bk_sparse_dense_matmul(self.ww_CNN[nside],im)
+        print(tmp.shape)
         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]]))

foscat/backend.py

@@ -684,9 +684,21 @@ class foscat_backend:
                 
         if self.BACKEND==self.TENSORFLOW or self.BACKEND==self.TORCH:
             if axis is None:
-                return(self.backend.concat(data))
+                if data[0].dtype==self.all_cbk_type:
+                    ndata=len(data)
+                    xr=self.backend.concat([self.bk_real(data[k]) for k in range(ndata)])
+                    xi=self.backend.concat([self.bk_imag(data[k]) for k in range(ndata)])
+                    return self.backend.complex(xr,xi)
+                else:
+                    return(self.backend.concat(data))
             else:
-                return(self.backend.concat(data,axis=axis))
+                if data[0].dtype==self.all_cbk_type:
+                    ndata=len(data)
+                    xr=self.backend.concat([self.bk_real(data[k]) for k in range(ndata)],axis=axis)
+                    xi=self.backend.concat([self.bk_imag(data[k]) for k in range(ndata)],axis=axis)
+                    return self.backend.complex(xr,xi)
+                else:
+                    return(self.backend.concat(data,axis=axis))
         else:
             if axis is None:
                 return np.concatenate(data,axis=0)

foscat/scat_cov1D.py

@@ -794,19 +794,19 @@ class scat_cov1D:
     
     # ---------------------------------------------−---------
     def flatten(self):
-        tmp=[self.build_flat(self.P00)]
+        tmp=[self.backend.bk_real(self.build_flat(self.P00))]
         
         if self.S1 is not None:
-            tmp=tmp+[self.build_flat(self.S1)]
+            tmp=tmp+[self.backend.bk_real(self.build_flat(self.S1))]
             
-        tmp=tmp+[self.build_flat(self.C01)]
+        tmp=tmp+[self.backend.bk_real(self.build_flat(self.C01))]
         
         if self.C10 is not None:
-            tmp=tmp+[self.build_flat(self.C10)]
+            tmp=tmp+[self.backend.bk_real(self.build_flat(self.C10))]
             
-        tmp=tmp+[self.build_flat(self.C11)]
-            
-        if isinstance(self.P00,np.ndarray):
+        tmp=tmp+[self.backend.bk_real(self.build_flat(self.C11))]
+        
+        if isinstance(self.C11,np.ndarray):
             return np.concatenate(tmp,1)
         else:
             return self.backend.bk_concat(tmp,1)

{foscat-3.0.28.dist-info → foscat-3.0.30.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: foscat
-Version: 3.0.28
+Version: 3.0.30
 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.28.dist-info → foscat-3.0.30.dist-info}/RECORD

@@ -1,13 +1,13 @@
 foscat/CNN.py,sha256=BVf-uD5K-_Tb_Q9xdckLF7PZq-Wcs6qexP9J2K8KCq0,4231
 foscat/CircSpline.py,sha256=610sgsWeZzRXYh7gYEqUmGQVrXoHSaFGKjH5mCdh4jU,1684
-foscat/FoCUS.py,sha256=m8HWydQiXnENagPRz24RCAwNNvSGNBgOVn7y4BA9IKo,67309
+foscat/FoCUS.py,sha256=A_rppGtJOcxZ96sNa6cyWpFWjNDFkVrTYDcI0Dxt_d0,68791
 foscat/GCNN.py,sha256=TEW81DGRM4WL7RzH50VKQ-_oHbl5i3iQKuhdkkgKEO8,3831
 foscat/GetGPUinfo.py,sha256=6sJWKO_OeiA0SoGQQdCT_h3D8rZtrv_4hpBc8H3nZls,731
 foscat/Softmax.py,sha256=UDc8Kbl0qWfH1bqDDwfLnkxhON7p93ueZ-Qg2oY4Ke4,2874
 foscat/Spline1D.py,sha256=9oeM8SSHjpfUE5z72YxGt1RVt22vJYM1zhHbNBW8phw,1232
 foscat/Synthesis.py,sha256=oYtHFVTqalVzBQs5okJBnP4pzXFhBMds-pytdEm4Bqs,12611
 foscat/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-foscat/backend.py,sha256=AZaMJSGoRGUSnjLKN8FF1tS16DmQZ70BjDl8zCDU9yg,30346
+foscat/backend.py,sha256=43Q-OtWlB-S14LH5IiUTxg9j_1WvOBZea3DkuEET7aY,31066
 foscat/backend_tens.py,sha256=zEFZ71j0nMNP9_91tz21ZVBTayr75l-sfONOLkJ8DyI,1432
 foscat/loss_backend_tens.py,sha256=WbGC4vy1pBg_bxUXnlCRiXX9WszN6MaUWUc_lUvZNvQ,1667
 foscat/loss_backend_torch.py,sha256=Fj_W3VwGgeD79eQ4jOxOmhZ548UKDRUb3JjUo2-gSWM,1755
@@ -15,11 +15,11 @@ foscat/scat.py,sha256=Ht_xyo7XKJJrUIbQIeucjhIrJo4RGrE63EyhTH8IYig,60061
 foscat/scat1D.py,sha256=fiGxyWSASGik9BimBKz_Z07jSPywJckLXaHDB_v5HHQ,45847
 foscat/scat2D.py,sha256=Xtisjc5KsbLQAlbn71P0Xg1UIu3r1gUKXoYG2vIMK1M,523
 foscat/scat_cov.py,sha256=uST8ij9o1sJh2AKhFffxMUr0WFQX9vz3VK4LGfiSOlE,110188
-foscat/scat_cov1D.py,sha256=CU10BUXuptFlaTE-12xFsETTy0br1hAzvaGERi6Ext4,60485
+foscat/scat_cov1D.py,sha256=I2GgEo7ASkb7JW443SAp25tmI2Rvuy4xggW8WMHI-L4,60591
 foscat/scat_cov2D.py,sha256=8_XvC-lOEVUWP9vT3Wx10G_ATeVeh0SdrSWuBV7Xf5k,536
 foscat/scat_cov_map.py,sha256=ocU2xd41GtJhiU9S3dEv38KfPCvz0tJKY2f8lPxpm5c,2729
 foscat/scat_cov_map2D.py,sha256=t4llIt7DVIyU1b_u-dJSX4lBr2FhDict8RnNnHpRvHM,2754
-foscat-3.0.28.dist-info/METADATA,sha256=fjwg9VZzTyfzTAFiZ3xvHUpVhTxCoI55NrljG1q6AEU,1013
-foscat-3.0.28.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
-foscat-3.0.28.dist-info/top_level.txt,sha256=AGySXBBAlJgb8Tj8af6m_F-aiNg2zNTcybCUPVOKjAg,7
-foscat-3.0.28.dist-info/RECORD,,
+foscat-3.0.30.dist-info/METADATA,sha256=5w2eBts5NhenffKMyMXGVM7_G5nzt62aimtutSjsNjM,1013
+foscat-3.0.30.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
+foscat-3.0.30.dist-info/top_level.txt,sha256=AGySXBBAlJgb8Tj8af6m_F-aiNg2zNTcybCUPVOKjAg,7
+foscat-3.0.30.dist-info/RECORD,,

{foscat-3.0.28.dist-info → foscat-3.0.30.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.43.0)
+Generator: bdist_wheel (0.42.0)
 Root-Is-Purelib: true
 Tag: py3-none-any