Added non-linear refinement to inversion, and improved inversion output

akvo/tressel/calcAkvoKernel.py

 
     if len(sys.argv) < 2:
         print ("usage  python calcAkvoKernel.py   AkvoDataset.yaml  Coil1.yaml kparams.yaml  SaveString.yaml " )
+        print ("usage  akvoKO   AkvoDataset.yaml   kparams.yaml  SaveString.yaml " )
         exit()
 
     AKVO = loadAkvoData(sys.argv[1])
             Coil1.SetCurrent(1.)
             Kern.PushCoil( rx.split('.yml')[0], Coil1 )
         else:
-            print("reuse")
+            print("reuse tx coil")
         RX.append( rx.split('.yml')[0] )
     
 

akvo/tressel/invertTA.py

 from matplotlib.colors import Normalize
 
 import cmocean
-from akvo.tressel.lemma_yaml import * 
+from akvo.tressel.lemma_yaml import *
+from akvo.tressel import nonlinearinv as nl 
 
 import pandas as pd
 
     nlay, nq = np.shape(K0)
     nt2 = len(T2Bins)
     nt = len(tg)
-    KQT = np.zeros( ( nq*nt,nt2*nlay) )
+    KQT = np.zeros( ( nq*nt,nt2*nlay), dtype=np.complex128 )
     for iq in range(nq):
         for it in range(nt):
             for ilay in range(nlay):
         K0 = yaml.load(f, Loader=yaml.Loader)
     K = catLayers(K0.K0)
     ifaces = np.array(K0.Interfaces.data)
-    return ifaces, np.abs(K)
+    return ifaces, K
+    #return ifaces, np.abs(K)
 
 
 
     for ik in range(1, len(K0)):
         K0[0] = np.concatenate( (K0[0].T, K0[ik].T) ).T
     K0 = K0[0]
-    #plt.matshow(K0)
+
+    #plt.matshow(np.real(K0))
+    #plt.show()
+    #exit()
 
     ###################    
     # VERY Simple DOI #
-    maxq = np.argmax(K0, axis=1)
-    maxK = .1 *  K0[ np.arange(0,len(ifaces)-1), maxq ] # 10% water is arbitrary  
+    maxq = np.argmax(np.abs(K0), axis=1)
+    maxK = .1 *  np.abs(K0)[ np.arange(0,len(ifaces)-1), maxq ] # 10% water is arbitrary  
     SNR = maxK / (VS[0][0])
 
     #SNR[SNR>1] = 1
     # Build full kernel
     ############################################### 
     T2Bins = np.logspace( np.log10(cont["T2Bins"]["low"]), np.log10(cont["T2Bins"]["high"]), cont["T2Bins"]["number"], endpoint=True, base=10)  
-    KQT = buildKQT(K0,tg,T2Bins)
- 
+    KQT = np.real(buildKQT(np.abs(K0),tg,T2Bins))
+
+    # model resolution matrix 
+    np.linalg.svd(KQT)
+
+    exit()
+
     ###############################################
-    # Invert
+    # Linear Inversion 
     ############################################### 
     print("Calling inversion", flush=True)
-    inv, ibreak, errn, phim, phid, mkappa = logBarrier(KQT, np.ravel(V), T2Bins, "lcurve", MAXITER=150, sigma=np.ravel(VS), alpha=1e6, smooth="Smallest" ) 
+    inv, ibreak, errn, phim, phid, mkappa, Wd, Wm, alphastar = logBarrier(KQT, np.ravel(V), T2Bins, "lcurve", MAXITER=150, sigma=np.ravel(VS), alpha=1e6, smooth="Smallest" ) 
 
+    ###############################################
+    # Non-linear refinement! 
+    ###############################################   
+ 
+    KQTc = buildKQT(K0, tg, T2Bins)
+    prec = np.abs(np.dot(KQTc, inv))
+    phidc = np.linalg.norm(np.dot(Wd,prec-np.ravel(V)))**2
+    #PREc = np.reshape( prec, np.shape(V)  )
+    print("PHID linear=", errn, "PHID complex=", phidc/len(np.ravel(V)))
+    
+    res = nl.nonlinearinversion(inv, Wd, KQTc, np.ravel(V), Wm, alphastar )   
+    if res.success == True:    
+        INVc = np.reshape(res.x, (len(ifaces)-1,cont["T2Bins"]["number"]) )
+        prec = np.abs(np.dot(KQTc, res.x))
+        phidc = np.linalg.norm(np.dot(Wd,prec-np.ravel(V)))**2
+        #PREc = np.reshape( prec, np.shape(V)  )
+        print("PHID linear=", errn, "PHID nonlinear=", phidc/len(np.ravel(V)))
+   
+    # Perform second fit around results of first  
+    res = nl.nonlinearinversion(res.x, Wd, KQTc, np.ravel(V), Wm, alphastar )   
+    if res.success == True:    
+        INVc = np.reshape(res.x, (len(ifaces)-1,cont["T2Bins"]["number"]) )
+        prec = np.abs(np.dot(KQTc, res.x))
+        phidc = np.linalg.norm(np.dot(Wd,prec-np.ravel(V)))**2
+        #PREc = np.reshape( prec, np.shape(V)  )
+        print("PHID linear=", errn, "PHID nonlinear=", phidc/len(np.ravel(V)))
+
+    #plt.matshow(INVc)
+    #KQTc = buildKQT(K0,tg,T2Bins)
+
+    #plt.matshow(PREc, cmap='Blues')
+    #plt.gca().set_title("complex predicted")
+    #plt.colorbar()
 
     ###############################################
     # Appraise
     ###############################################
+
+
+
+
  
     pre = np.dot(KQT,inv) 
     PRE = np.reshape( pre, np.shape(V)  )
     plt.gca().set_title("observed")
     plt.colorbar()
 
+
     T2Bins = np.append( T2Bins, T2Bins[-1] + (T2Bins[-1]-T2Bins[-2]) )
-    
     INV = np.reshape(inv, (len(ifaces)-1,cont["T2Bins"]["number"]) )
 
     #alphas = np.tile(SNR, (len(T2Bins)-1,1))
 
     #greys = np.full((*(INV.T).shape, 3), 70, dtype=np.uint8)
 
+    ##############  LINEAR RESULT   ##########################
+
     Y,X = meshgrid( ifaces, T2Bins )
     fig = plt.figure( figsize=(pc2in(20.0),pc2in(22.)) )
     ax1 = fig.add_axes( [.2,.15,.6,.7] )
 
     plt.savefig("akvoInversion.pdf")
 
+
+    ##############  NONLINEAR RESULT   ##########################
+
+    Y,X = meshgrid( ifaces, T2Bins )
+    fig = plt.figure( figsize=(pc2in(20.0),pc2in(22.)) )
+    ax1 = fig.add_axes( [.2,.15,.6,.7] )
+    im = ax1.pcolor(X, Y, INVc.T, cmap=cmocean.cm.tempo) #cmap='viridis')
+    #im = ax1.pcolor(X[0:SNRidx,:], Y[0:SNRidx,:], INV.T[0:SNRidx,:], cmap=cmocean.cm.tempo) #cmap='viridis')
+    #im = ax1.pcolor(X[SNRidx::,:], Y[SNRidx::,:], INV.T[SNRidx::,:], cmap=cmocean.cm.tempo, alpha=.5) #cmap='viridis')
+    #im = ax1.pcolormesh(X, Y, INV.T, alpha=alphas) #, cmap=cmocean.cm.tempo) #cmap='viridis')
+    #im = ax1.pcolormesh(X, Y, INV.T, alpha=alphas) #, cmap=cmocean.cm.tempo) #cmap='viridis')
+    #ax1.axhline( y=ifaces[SNRidx], xmin=T2Bins[0], xmax=T2Bins[-1], color='black'  )
+    im.set_edgecolor('face')
+    ax1.set_xlim( T2Bins[0], T2Bins[-1] )
+    ax1.set_ylim( ifaces[-1], ifaces[0] )
+    cb = plt.colorbar(im, label = u"PWC (m$^3$/m$^3$)") #, format='%1.1f')
+    cb.locator = MaxNLocator( nbins = 4)
+    cb.ax.yaxis.set_offset_position('left')                         
+    cb.update_ticks()
+ 
+    ax1.set_xlabel(u"$T_2^*$ (ms)")
+    ax1.set_ylabel(u"depth (m)")
+    
+    ax1.get_xaxis().set_major_formatter(FormatStrFormatter('%1.0f'))
+    ax1.get_yaxis().set_major_formatter(FormatStrFormatter('%1.0f'))
+    ax1.xaxis.set_major_locator( MaxNLocator(nbins = 4) )   
+
+    #ax1.xaxis.set_label_position('top') 
+
+    ax2 = ax1.twiny()
+    ax2.plot( np.sum(INVc, axis=1), (ifaces[1:]+ifaces[0:-1])/2 ,  color='red' )
+    ax2.set_xlabel(u"total water (m$^3$/m$^3$)")
+    ax2.set_ylim( ifaces[-1], ifaces[0] )
+    ax2.xaxis.set_major_locator( MaxNLocator(nbins = 3) )   
+    ax2.get_xaxis().set_major_formatter(FormatStrFormatter('%0.2f'))
+    #ax2.axhline( y=ifaces[SNRidx], xmin=0, xmax=1, color='black', linestyle='dashed'  )
+    #ax2.xaxis.set_label_position('bottom') 
+    fig.suptitle("Non linear inversion")
+    plt.savefig("akvoInversionNL.pdf")
+
+
+
     #############
     # water plot#
 
     ax.set_ylim( ifaces[-1], ifaces[0] )
     ax.set_xlim( 0, ax.get_xlim()[1] )
     
-    ax.axhline( y=ifaces[SNRidx], xmin=0, xmax=1, color='black', linestyle='dashed'  )
+    #ax.axhline( y=ifaces[SNRidx], xmin=0, xmax=1, color='black', linestyle='dashed'  )
     
     plt.savefig("akvoInversionWC.pdf")
     plt.legend()  

akvo/tressel/logbarrier.py

     ALPHA = []
     ALPHA.append(alpha)
     #ALPHA = np.linspace( alpha, 1, MAXITER  )
+    print ("{:^10} {:^15} {:^15} {:^15} {:^15} {:^10} {:^10}".format("iteration",  "lambda", "phi_d", "phi_m","phi","kappa","kappa dist."), flush=True) 
+    print ("{:^10} {:>15} {:<15} {:<15} {:<15} {:<10} {:<10}".format("----------", "---------------", "---------------","---------------","---------------","----------","----------"), flush=True) 
     for i in range(MAXITER):
         #alpha = ALPHA[i]
 
         PHID.append(phid)      
         MOD.append(np.copy(x))  
 
+        tphi = phid + alpha*phim
+
         # determine alpha
         scale = 1.5*(len(b)/phid)
         #alpha *= np.sqrt(scale)
         ALPHA.append(alpha)
         #alpha = ALPHA[i+1]
             
-        print("inversion progress", i, alpha, np.sqrt(phid/len(b)), phim, flush=True)       
+        #print("inversion progress", i, alpha, np.sqrt(phid/len(b)), phim, flush=True)      
+        #print ("{:<8} {:<15} {:<10} {:<10}".format(i, alpha, np.sqrt(phid/len(b)), phim), flush=True) 
         
+        if i < 4:        
+            print ("{:^10} {:>15.4f} {:>15.4f} {:>15.4f} {:>15.4f}".format(i, alpha, np.sqrt(phid/len(b)), phim, tphi ), flush=True) 
 
 #         if np.sqrt(phid/len(b)) < 0.97: 
 #             ibreak = -1
             if i > 4: 
                 kappa = curvaturefd(np.log(np.array(PHIM)), np.log(np.array(PHID)), ALPHA[0:i+1])#ALPHA[0:-1])
                 #kappa = curvatureg(np.log(np.array(PHIM)), np.log(np.array(PHID)))
-                print("max kappa", np.argmax(kappa), "distance from", i-np.argmax(kappa)) 
+                #print("max kappa", np.argmax(kappa), "distance from", i-np.argmax(kappa)) 
+                print ("{:^10} {:>15.4f} {:>15.4f} {:>15.4f} {:>15.4f} {:^10} {:^10}".format(i, alpha, np.sqrt(phid/len(b)), phim, tphi, np.argmax(kappa), i-np.argmax(kappa)), flush=True) 
             if i > 4 and (i-np.argmax(kappa)) > 4: # ((np.sqrt(phid_old/len(b))-np.sqrt(phid/len(b))) < 1e-4) : 
             #if np.sqrt(phid/len(b)) < 3.0 and ((np.sqrt(phid_old/len(b))-np.sqrt(phid/len(b))) < 1e-3): 
                 ibreak = 1
                 MOD = np.array(MOD)
-                print ("###########################") #slow convergence", alpha, "phid_old", np.sqrt(phid_old/len(b)), "phid", np.sqrt(phid/len(b)), ibreak)
+                print ("################################") #slow convergence", alpha, "phid_old", np.sqrt(phid_old/len(b)), "phid", np.sqrt(phid/len(b)), ibreak)
                 print ("Using L-curve criteria") 
                 #kappa = curvaturefd(np.log(np.array(PHIM)), np.log(np.array(PHID)), ALPHA[0:-1])
                 #kappa2 = curvatureg(np.log(np.array(PHIM)), np.log(np.array(PHID)))
                 #kappa = curvature( np.array(PHIM), np.array(PHID))
                 x = MOD[ np.argmax(kappa) ]
+                alphastar = ALPHA[ np.argmax(kappa) ]
                 b_pre = np.dot(A, x)
                 phid = np.linalg.norm( np.dot(Wd, (b-b_pre)))**2
                 phim = np.linalg.norm( np.dot(Phim_base, (x-xr)) )**2
                 mu1 = ((phid + alpha*phim) / phib) 
-                print ("L-curve selected", alpha, "phid_old", np.sqrt(phid_old/len(b)), "phid", np.sqrt(phid/len(b)), ibreak)
-                print ("###########################")
+                print ("L-curve selected: iteration=", np.argmax(kappa)) #, " lambda*=", alpha, "phid_old=", np.sqrt(phid_old/len(b)), "phid=", np.sqrt(phid/len(b)), ibreak)
+                print ("################################")
                 if np.sqrt(phid/len(b)) <= 1:
                     ibreak=0
 
         mu1 = ((phid + alpha*phim) / phib) 
 
     if lambdastar == "lcurve":
-        return x, ibreak, np.sqrt(phid/len(b)), PHIM, PHID/len(b), np.argmax(kappa)
+        #print("Returning L curve result")
+        return x, ibreak, np.sqrt(phid/len(b)), PHIM, PHID/len(b), np.argmax(kappa), Wd, Phim_base, alphastar
     else:
+        print("")
         return x, ibreak, np.sqrt(phid/len(b))
 
 

akvo/tressel/nonlinearinv.py

+import numpy as np
+import scipy.optimize as so 
+
+def phid(Wd, K, m, d_obs):
+    """
+        Wd = data weighting matrix 
+        K = complex valued forward model kernel 
+        m = model 
+        d_obs = observed data 
+    """
+    #print("phid=", np.linalg.norm(np.dot(Wd, np.abs(np.dot(K,m)) - d_obs))**2 / len(d_obs) )
+    return np.linalg.norm(np.dot(Wd, np.abs(np.dot(K,m)) - d_obs))**2
+
+def phim(Wm, m):
+    """
+        Wm = model weighting matrix 
+        x = model 
+    """
+    return np.linalg.norm(np.dot(Wm, m))**2
+
+def PHI(m, Wd, K, d_obs, Wm, alphastar):
+    """
+        Global objective function 
+        x = model to be fit 
+        Wd = data weighting matrix 
+        K = complex forward modelling kernel 
+        d_obs = observed data (modulus)
+        Wm = model weighting matrix 
+        alphastar = regularisation to use
+    """
+    return phid(Wd, K, m, d_obs) + alphastar*phim(Wm, m)
+
+# main 
+def nonlinearinversion( x0, Wd, K, d_obs, Wm, alphastar):
+    print("Performing non-linear inversion")
+    args = (Wd, K, d_obs, Wm, alphastar)
+    #return so.minimize(PHI, np.zeros(len(x0)), args, 'Nelder-Mead')
+    bounds = np.zeros((len(x0),2))
+    bounds[:,0] = x0*0.75
+    bounds[:,1] = x0*1.25
+    return so.minimize(PHI, x0, args, 'L-BFGS-B', bounds=bounds)     # Works well 
+    #return so.minimize(PHI, x0, args, 'Powell', bounds=bounds)       # Slow but works 
+    #return so.minimize(PHI, x0, args, 'trust-constr', bounds=bounds) # very Slow 
+    #return so.minimize(PHI, x0, args, 'TNC', bounds=bounds)          # slow 
+    #return so.minimize(PHI, x0, args, 'SLSQP', bounds=bounds)        # slow 

setup.py

 with open("README.md", "r") as fh:
     long_description = fh.read()
 
-setup(name='Akvo',
-      version='1.5.2',
-      python_requires='>3.7.0', # due to pyLemma
+setup(name='Akvo',     
+      version='1.5.2', 
+      python_requires='>3.7.0', # due to pyLemma 
       description='Surface nuclear magnetic resonance workbench',
       long_description=long_description,
       long_description_content_type='text/markdown',
           'pyLemma >= 0.4.0'
       ],
       packages=['akvo', 'akvo.tressel', 'akvo.gui'],
-      license=['GPL 4.0'],
+      license='GPL 4.0',
       entry_points = {
               'console_scripts': [
                   'akvo = akvo.gui.akvoGUI:main',