def lnprior(Y_array, *args):
"""
Log-Prior function for mapping
Parameters
----------
Returns
-------
"""
# Unpack args
Obs_ij, Obsnoise_ij, Kernel_il, regularization, n_regparam, flip, verbose, n_type, n_slice = args
n_band = len(Obs_ij[0])
# Parameter conversion
if (n_regparam > 0):
X_albd_kj, X_area_lk = reparameterize.transform_Y2X(Y_array[:-1*n_regparam], n_type, n_band, n_slice )
else:
X_albd_kj, X_area_lk = reparameterize.transform_Y2X(Y_array, n_type, n_band, n_slice )
# Flat prior for albedo
Y_albd_kj = Y_array[0:n_type*n_band].reshape([n_type, n_band])
ln_prior_albd = prior.get_ln_prior_albd( Y_albd_kj )
# flat prior for area fraction
Y_area_lk = Y_array[n_type*n_band:n_type*n_band+n_slice*(n_type-1)].reshape([n_slice, n_type-1])
ln_prior_area = prior.get_ln_prior_area_new( Y_area_lk, X_area_lk[:,:-1] )
# flat ordering prior for labeling degeneracy
ln_prior_order = prior.get_ln_prior_ordering(X_albd_kj, X_area_lk)
# regularization
if regularization is not None:
if ( regularization == 'Tikhonov' ):
# ---Tikhonov Regularization
regparam = Y_array[-1*n_regparam]
regterm_area = prior.regularize_area_tikhonov( X_area_lk, regparam )
elif ( regularization == 'GP' ):
# ---Gaussian Process
regparam = ( Y_array[-1*n_regparam], Y_array[-1*n_regparam+1], Y_array[-1*n_regparam+2] )
regterm_area = prior.regularize_area_GP( X_area_lk, regparam )
elif ( regularization == 'GP2' ):
# ---Gaussian Process without constraint
regparam = ( Y_array[-1*n_regparam], Y_array[-1*n_regparam+1] )
regterm_area = prior.regularize_area_GP2( X_area_lk, regparam )
# ---Others
else :
regterm_area = 0.
answer = ln_prior_albd + ln_prior_area + ln_prior_order + regterm_area
# Check for nans
if np.isnan(answer):
answer = -np.inf
if flip :
return -1. * answer
else :
return answer
def lnprob(Y_array, *args):
"""
Misfit-function to be minimized
"""
Obs_ij, Obsnoise_ij, Kernel_il, n_regparam, flip, verbose = args
n_band = len(Obs_ij[0])
# parameter conversion
if ( n_regparam > 0 ):
X_albd_kj, X_area_lk = transform_Y2X(Y_array[:-1*n_regparam], N_TYPE, n_band, N_SLICE)
else:
X_albd_kj, X_area_lk = transform_Y2X(Y_array, N_TYPE, n_band, N_SLICE)
# making matrix...
Model_ij = np.dot(Kernel_il, np.dot(X_area_lk, X_albd_kj))
Diff_ij = ( Obs_ij - Model_ij ) / Obsnoise_ij
Chi2_i = np.diag(np.dot( Diff_ij, Diff_ij.T ))
chi2 = np.sum( Chi2_i )
# flat prior for albedo
Y_albd_kj = Y_array[0:N_TYPE*n_band].reshape([N_TYPE, n_band])
ln_prior_albd = prior.get_ln_prior_albd( Y_albd_kj )
# flat prior for area fraction
Y_area_lk = Y_array[N_TYPE*n_band:N_TYPE*n_band+N_SLICE*(N_TYPE-1)].reshape([N_SLICE, N_TYPE-1])
ln_prior_area = prior.get_ln_prior_area_new( Y_area_lk, X_area_lk[:,:-1] )
# regularization
# ---Tikhonov Regularization
if 'REGULARIZATION' in globals():
if ( REGULARIZATION == 'Tikhonov' ):
regparam = Y_array[-1*N_REGPARAM]
regterm_area = prior.regularize_area_tikhonov( X_area_lk, regparam )
# ---Gaussian Process
elif ( REGULARIZATION == 'GP' ):
regparam = ( Y_array[-1*N_REGPARAM], Y_array[-1*N_REGPARAM+1], Y_array[-1*N_REGPARAM+2] )
regterm_area = prior.regularize_area_GP( X_area_lk, regparam )
# ---Gaussian Process without constraint
elif ( REGULARIZATION == 'GP2' ):
regparam = ( Y_array[-1*N_REGPARAM], Y_array[-1*N_REGPARAM+1] )
regterm_area = prior.regularize_area_GP2( X_area_lk, regparam )
# ---Others
else :
regterm_area = 0.
# verbose
if verbose :
print 'chi2', chi2 - ln_prior_albd - ln_prior_area, chi2, ln_prior_albd, ln_prior_area
print 'chi2/d.o.f.', chi2 / (len(Y_array)*1.-1.), len(Y_array)
answer = - chi2 + ln_prior_albd + ln_prior_area + regterm_area
if flip :
return -1. * answer
else :
return answer
def lnprob(Y_array, *args):
"""
Log-probability function for mapping
Parameters
----------
Returns
-------
"""
# Unpack args
Obs_ij, Obsnoise_ij, Kernel_il, regularization, n_regparam, flip, verbose, n_type, n_slice = args
n_band = len(Obs_ij[0])
# Parameter conversion
if (n_regparam > 0):
X_albd_kj, X_area_lk = reparameterize.transform_Y2X(Y_array[:-1*n_regparam], n_type, n_band, n_slice )
else:
X_albd_kj, X_area_lk = reparameterize.transform_Y2X(Y_array, n_type, n_band, n_slice )
# Model
Model_ij = np.dot(Kernel_il, np.dot(X_area_lk, X_albd_kj))
# Chi-squared statistic
Diff_ij = ( Obs_ij - Model_ij ) / Obsnoise_ij
Chi2_i = np.diag(np.dot( Diff_ij, Diff_ij.T ))
chi2 = np.sum(Chi2_i)
# Flat prior for albedo
Y_albd_kj = Y_array[0:n_type*n_band].reshape([n_type, n_band])
ln_prior_albd = prior.get_ln_prior_albd( Y_albd_kj )
# flat prior for area fraction
Y_area_lk = Y_array[n_type*n_band:n_type*n_band+n_slice*(n_type-1)].reshape([n_slice, n_type-1])
ln_prior_area = prior.get_ln_prior_area_new( Y_area_lk, X_area_lk[:,:-1] )
# flat ordering prior for labeling degeneracy
ln_prior_order = prior.get_ln_prior_ordering(X_albd_kj, X_area_lk)
# regularization
if regularization is not None:
if ( regularization == 'Tikhonov' ):
# ---Tikhonov Regularization
regparam = Y_array[-1*n_regparam]
regterm_area = prior.regularize_area_tikhonov( X_area_lk, regparam )
elif ( regularization == 'GP' ):
# ---Gaussian Process
regparam = ( Y_array[-1*n_regparam], Y_array[-1*n_regparam+1], Y_array[-1*n_regparam+2] )
regterm_area = prior.regularize_area_GP( X_area_lk, regparam )
elif ( regularization == 'GP2' ):
# ---Gaussian Process without constraint
regparam = ( Y_array[-1*n_regparam], Y_array[-1*n_regparam+1] )
regterm_area = prior.regularize_area_GP2( X_area_lk, regparam )
# ---Others
else :
regterm_area = 0.
# verbose
if verbose :
print 'chi2', chi2 - ln_prior_albd - ln_prior_area, chi2, ln_prior_albd, ln_prior_area
print 'chi2/d.o.f.', chi2 / (len(Y_array)*1.-1.), len(Y_array)
answer = - chi2 + ln_prior_albd + ln_prior_area + ln_prior_order + regterm_area
# Check for nans
if np.isnan(answer):
answer = -np.inf
if flip :
return -1. * answer
else :
return answer, Model_ij
def lnprob(Y_array, *args):
"""
Misfit-function to be minimized
"""
# Unpack args
Obs_ij, Obsnoise_ij, Kernel_il, N_REGPARAM, flip, verbose = args
n_slice = len(Obs_ij)
n_band = len(Obs_ij[0])
# Parameter conversion
if (N_REGPARAM > 0):
X_albd_kj, X_area_lk = reparameterize.transform_Y2X(
Y_array[:-1 * N_REGPARAM], N_TYPE, n_band, n_slice)
else:
X_albd_kj, X_area_lk = reparameterize.transform_Y2X(
Y_array, N_TYPE, n_band, n_slice)
# Model
Model_ij = np.dot(Kernel_il, np.dot(X_area_lk, X_albd_kj))
# Chi-squared statistic
Diff_ij = (Obs_ij - Model_ij) / Obsnoise_ij
Chi2_i = np.diag(np.dot(Diff_ij, Diff_ij.T))
chi2 = np.sum(Chi2_i)
# Flat prior for albedo
Y_albd_kj = Y_array[0:N_TYPE * n_band].reshape([N_TYPE, n_band])
ln_prior_albd = prior.get_ln_prior_albd(Y_albd_kj)
# flat prior for area fraction
Y_area_lk = Y_array[N_TYPE * n_band:N_TYPE * n_band + n_slice *
(N_TYPE - 1)].reshape([n_slice, N_TYPE - 1])
ln_prior_area = prior.get_ln_prior_area_new(Y_area_lk, X_area_lk[:, :-1])
# flat ordering prior for labeling degeneracy
ln_prior_order = prior.get_ln_prior_ordering(X_albd_kj, X_area_lk)
# regularization
# ---Tikhonov Regularization
if REGULARIZATION is not None:
if (REGULARIZATION == 'Tikhonov'):
regparam = Y_array[-1 * N_REGPARAM]
regterm_area = prior.regularize_area_tikhonov(X_area_lk, regparam)
# ---Gaussian Process
elif (REGULARIZATION == 'GP'):
regparam = (Y_array[-1 * N_REGPARAM], Y_array[-1 * N_REGPARAM + 1],
Y_array[-1 * N_REGPARAM + 2])
regterm_area = prior.regularize_area_GP(X_area_lk, regparam)
# ---Gaussian Process without constraint
elif (REGULARIZATION == 'GP2'):
regparam = (Y_array[-1 * N_REGPARAM], Y_array[-1 * N_REGPARAM + 1])
regterm_area = prior.regularize_area_GP2(X_area_lk, regparam)
# ---Others
else:
regterm_area = 0.
# verbose
if verbose:
print 'chi2', chi2 - ln_prior_albd - ln_prior_area, chi2, ln_prior_albd, ln_prior_area
print 'chi2/d.o.f.', chi2 / (len(Y_array) * 1. - 1.), len(Y_array)
answer = -chi2 + ln_prior_albd + ln_prior_area + ln_prior_order + regterm_area
# Check for nans
if np.isnan(answer):
answer = -np.inf
if flip:
return -1. * answer
else:
return answer, Model_ij
def lnprob_atmosphere(Y_array, *args):
"""
Log-probability function for mapping
Parameters
----------
Returns
-------
"""
# Unpack args
Obs_ij, Obsnoise_ij, Kernel_il, regularization, n_regparam, flip, verbose, n_type, n_slice, use_grey, use_global = args
n_band = len(Obs_ij[0])
# Parameter conversion
if (n_regparam > 0):
X_albd_kj, X_area_lk = reparameterize.transform_Y2X_atmosphere(
Y_array[:-1 * n_regparam],
n_type,
n_band,
n_slice,
use_grey=use_grey,
use_global=use_global)
else:
X_albd_kj, X_area_lk = reparameterize.transform_Y2X_atmosphere(
Y_array,
n_type,
n_band,
n_slice,
use_grey=use_grey,
use_global=use_global)
# Model
Model_ij = np.dot(Kernel_il, np.dot(X_area_lk, X_albd_kj))
# Chi-squared statistic
Diff_ij = (Obs_ij - Model_ij) / Obsnoise_ij
Chi2_i = np.diag(np.dot(Diff_ij, Diff_ij.T))
chi2 = np.sum(Chi2_i)
# Flat prior for albedo
Y_albd_kj = Y_array[0:n_type * n_band].reshape([n_type, n_band])
ln_prior_albd = prior.get_ln_prior_albd(Y_albd_kj)
# Extract Y_area_lk from Y_array
if use_grey and use_global:
Y_area_lk = Y_array[(n_type - 1) * n_band:(n_type - 1) * n_band +
n_slice * (n_type - 2)].reshape(
[n_slice, n_type - 2])
elif use_grey and not use_global:
Y_area_lk = Y_array[(n_type - 1) * n_band:(n_type - 1) * n_band +
n_slice * (n_type - 1)].reshape(
[n_slice, n_type - 1])
elif use_global and not use_grey:
Y_area_lk = Y_array[n_type * n_band:n_type * n_band + n_slice *
(n_type - 2)].reshape([n_slice, n_type - 2])
else:
Y_area_lk = Y_array[n_type * n_band:(n_type) * n_band + n_slice *
(n_type - 1)].reshape([n_slice, n_type - 1])
# flat prior for area fraction
ln_prior_area = prior.get_ln_prior_area_new(Y_area_lk, X_area_lk[:, :-1])
# flat ordering prior for labeling degeneracy
ln_prior_order = prior.get_ln_prior_ordering(X_albd_kj, X_area_lk)
# atmosphere prior
#ln_prior_atmosphere = prior.get_ln_prior_atmosphere(X_albd_kj, X_area_lk, use_grey, use_global, max_dev = max_dev)
# regularization
if regularization is not None:
if (regularization == 'Tikhonov'):
# ---Tikhonov Regularization
regparam = Y_array[-1 * n_regparam]
regterm_area = prior.regularize_area_tikhonov(X_area_lk, regparam)
elif (regularization == 'GP'):
# ---Gaussian Process
regparam = (Y_array[-1 * n_regparam], Y_array[-1 * n_regparam + 1],
Y_array[-1 * n_regparam + 2])
regterm_area = prior.regularize_area_GP(X_area_lk, regparam)
elif (regularization == 'GP2'):
# ---Gaussian Process without constraint
regparam = (Y_array[-1 * n_regparam], Y_array[-1 * n_regparam + 1])
regterm_area = prior.regularize_area_GP2(X_area_lk, regparam)
# ---Others
else:
regterm_area = 0.
# verbose
if verbose:
print 'chi2', chi2 - ln_prior_albd - ln_prior_area, chi2, ln_prior_albd, ln_prior_area
print 'chi2/d.o.f.', chi2 / (len(Y_array) * 1. - 1.), len(Y_array)
answer = - chi2 \
+ ln_prior_albd \
+ ln_prior_area \
+ ln_prior_order \
+ regterm_area
# Check for nans
if np.isnan(answer):
answer = -np.inf
if flip:
return -1. * answer
else:
return answer, Model_ij
def lnprior(Y_array, *args):
"""
Log-Prior function for mapping
Parameters
----------
Returns
-------
"""
# Unpack args
Obs_ij, Obsnoise_ij, Kernel_il, regularization, n_regparam, flip, verbose, n_type, n_slice = args
n_band = len(Obs_ij[0])
# Parameter conversion
if (n_regparam > 0):
X_albd_kj, X_area_lk = reparameterize.transform_Y2X(
Y_array[:-1 * n_regparam], n_type, n_band, n_slice)
else:
X_albd_kj, X_area_lk = reparameterize.transform_Y2X(
Y_array, n_type, n_band, n_slice)
# Flat prior for albedo
Y_albd_kj = Y_array[0:n_type * n_band].reshape([n_type, n_band])
ln_prior_albd = prior.get_ln_prior_albd(Y_albd_kj)
# flat prior for area fraction
Y_area_lk = Y_array[n_type * n_band:n_type * n_band + n_slice *
(n_type - 1)].reshape([n_slice, n_type - 1])
ln_prior_area = prior.get_ln_prior_area_new(Y_area_lk, X_area_lk[:, :-1])
# flat ordering prior for labeling degeneracy
ln_prior_order = prior.get_ln_prior_ordering(X_albd_kj, X_area_lk)
# regularization
if regularization is not None:
if (regularization == 'Tikhonov'):
# ---Tikhonov Regularization
regparam = Y_array[-1 * n_regparam]
regterm_area = prior.regularize_area_tikhonov(X_area_lk, regparam)
elif (regularization == 'GP'):
# ---Gaussian Process
regparam = (Y_array[-1 * n_regparam], Y_array[-1 * n_regparam + 1],
Y_array[-1 * n_regparam + 2])
regterm_area = prior.regularize_area_GP(X_area_lk, regparam)
elif (regularization == 'GP2'):
# ---Gaussian Process without constraint
regparam = (Y_array[-1 * n_regparam], Y_array[-1 * n_regparam + 1])
regterm_area = prior.regularize_area_GP2(X_area_lk, regparam)
# ---Others
else:
regterm_area = 0.
answer = ln_prior_albd + ln_prior_area + ln_prior_order + regterm_area
# Check for nans
if np.isnan(answer):
answer = -np.inf
if flip:
return -1. * answer
else:
return answer
def lnprob(Y_array, *args):
"""
Misfit-function to be minimized
"""
Obs_ij, Obsnoise_ij, Kernel_il, N_REGPARAM, n_type, flip, verbose = args
#n_slice = len(Obs_ij)
n_slice = len(Kernel_il[0])
n_band = len(Obs_ij[0])
# parameter conversion
if (N_REGPARAM > 0):
X_albd_kj, X_area_lk = reparameterize.transform_Y2X(Y_array[:-1*N_REGPARAM], n_type, n_band, n_slice )
else:
X_albd_kj, X_area_lk = reparameterize.transform_Y2X(Y_array, n_type, n_band, n_slice )
# making matrix...
Model_ij = np.dot(Kernel_il, np.dot(X_area_lk, X_albd_kj))
Diff_ij = ( Obs_ij - Model_ij ) / Obsnoise_ij
Chi2_i = np.diag(np.dot( Diff_ij, Diff_ij.T ))
chi2 = np.sum(Chi2_i)
# flat prior for albedo
Y_albd_kj = Y_array[0:n_type*n_band].reshape([n_type, n_band])
ln_prior_albd = prior.get_ln_prior_albd( Y_albd_kj )
# flat prior for area fraction
if (N_REGPARAM > 0):
Y_area_lk = Y_array[n_type*n_band:-1*N_REGPARAM].reshape([n_slice, n_type-1])
else:
Y_area_lk = Y_array[n_type*n_band:].reshape([n_slice, n_type-1])
ln_prior_area = prior.get_ln_prior_area_new( Y_area_lk, X_area_lk[:,:-1] )
# regularization
# ---Tikhonov Regularization
if REGULARIZATION is not None:
if ( REGULARIZATION == 'Tikhonov' ):
regparam = Y_array[-1*N_REGPARAM]
regterm_area = prior.regularize_area_tikhonov( X_area_lk, regparam )
# ---Gaussian Process
elif ( REGULARIZATION == 'GP' ):
regparam = ( Y_array[-1*N_REGPARAM], Y_array[-1*N_REGPARAM+1], Y_array[-1*N_REGPARAM+2] )
regterm_area = prior.regularize_area_GP( X_area_lk, regparam )
# ---Gaussian Process without constraint
elif ( REGULARIZATION == 'GP2' ):
regparam = ( Y_array[-1*N_REGPARAM], Y_array[-1*N_REGPARAM+1] )
regterm_area = prior.regularize_area_GP2( X_area_lk, regparam )
# ---Gaussian Process
elif ( REGULARIZATION == 'GP3' ):
regparam = ( Y_array[-1*N_REGPARAM], Y_array[-1*N_REGPARAM+1] )
regterm_area = prior.regularize_area_GP3( X_area_lk, regparam )
# ---Gaussian Process
elif ( REGULARIZATION == 'GP4' ):
regparam = ( SIGMA_Y, -10., np.pi/180.*120. )
# regparam = ( 0.01, -10., np.pi/180.*120. )
# regparam = ( 0.0001, -10., np.pi/180.*60. )
regterm_area = prior.regularize_area_GP( X_area_lk, regparam )
# ---Others
else :
regterm_area = 0.
# verbose
if verbose :
print 'chi2', chi2 - ln_prior_albd - ln_prior_area, chi2, ln_prior_albd, ln_prior_area
print 'chi2/d.o.f.', chi2 / (len(Y_array)*1.-1.), len(Y_array)
answer = - chi2 + ln_prior_albd + ln_prior_area + regterm_area
if flip :
return -1. * answer
else :
return answer
def lnprob(Y_array, *args):
"""
Misfit-function to be minimized
"""
# Unpack args
Obs_ij, Obsnoise_ij, Kernel_il, N_REGPARAM, flip, verbose = args
n_slice = len(Obs_ij)
n_band = len(Obs_ij[0])
# Parameter conversion
if (N_REGPARAM > 0):
X_albd_kj, X_area_lk = reparameterize.transform_Y2X(Y_array[:-1*N_REGPARAM], N_TYPE, n_band, n_slice )
else:
X_albd_kj, X_area_lk = reparameterize.transform_Y2X(Y_array, N_TYPE, n_band, n_slice )
# Model
Model_ij = np.dot(Kernel_il, np.dot(X_area_lk, X_albd_kj))
# Chi-squared statistic
Diff_ij = ( Obs_ij - Model_ij ) / Obsnoise_ij
Chi2_i = np.diag(np.dot( Diff_ij, Diff_ij.T ))
chi2 = np.sum(Chi2_i)
# Flat prior for albedo
Y_albd_kj = Y_array[0:N_TYPE*n_band].reshape([N_TYPE, n_band])
ln_prior_albd = prior.get_ln_prior_albd( Y_albd_kj )
# flat prior for area fraction
Y_area_lk = Y_array[N_TYPE*n_band:N_TYPE*n_band+n_slice*(N_TYPE-1)].reshape([n_slice, N_TYPE-1])
ln_prior_area = prior.get_ln_prior_area_new( Y_area_lk, X_area_lk[:,:-1] )
# flat ordering prior for labeling degeneracy
ln_prior_order = prior.get_ln_prior_ordering(X_albd_kj, X_area_lk)
# regularization
# ---Tikhonov Regularization
if REGULARIZATION is not None:
if ( REGULARIZATION == 'Tikhonov' ):
regparam = Y_array[-1*N_REGPARAM]
regterm_area = prior.regularize_area_tikhonov( X_area_lk, regparam )
# ---Gaussian Process
elif ( REGULARIZATION == 'GP' ):
regparam = ( Y_array[-1*N_REGPARAM], Y_array[-1*N_REGPARAM+1], Y_array[-1*N_REGPARAM+2] )
regterm_area = prior.regularize_area_GP( X_area_lk, regparam )
# ---Gaussian Process without constraint
elif ( REGULARIZATION == 'GP2' ):
regparam = ( Y_array[-1*N_REGPARAM], Y_array[-1*N_REGPARAM+1] )
regterm_area = prior.regularize_area_GP2( X_area_lk, regparam )
# ---Others
else :
regterm_area = 0.
# verbose
if verbose :
print 'chi2', chi2 - ln_prior_albd - ln_prior_area, chi2, ln_prior_albd, ln_prior_area
print 'chi2/d.o.f.', chi2 / (len(Y_array)*1.-1.), len(Y_array)
answer = - chi2 + ln_prior_albd + ln_prior_area + ln_prior_order + regterm_area
# Check for nans
if np.isnan(answer):
answer = -np.inf
if flip :
return -1. * answer
else :
return answer, Model_ij