def BG(gamma=np.pi / 4, MaxObs=4, w=0.001, V=1):
if V == 4:
BG_Coef = L_Solvers.BG_Precomp_MaxObs_V4(Context,
Observation,
gamma=gamma,
w=w,
MaxObs=MaxObs)
elif V == 3:
BG_Coef = L_Solvers.BG_Precomp_MaxObs_V3_b(Context,
Observation,
gamma=gamma,
w=w,
MaxObs=MaxObs)
elif V == 2:
BG_Coef = L_Solvers.BG_Precomp_MaxObs_V2(Context,
Observation,
gamma=gamma,
w=w,
MaxObs=MaxObs)
else:
BG_Coef = L_Solvers.BG_Precomp_MaxObs(Context,
Observation,
gamma=gamma,
w=w,
MaxObs=MaxObs)
Sol = [
BG_Coef.dot(Observation['Tb']['H']),
BG_Coef.dot(Observation['Tb']['V'])
]
RMSE = L_Syn_Img.RMSE_M(TbV, Sol[1], Context)
print("RMSE: %.5f\n*****************************************" % RMSE)
return Sol, RMSE
def main():
#%%###################
## PREPROCESSING
#%%
#Load Context
damp = 1.0
Context = L_Context.Load_Context(wdir)
#Load ellipses and compute synthetic observation
Observation, tita = L_ReadObs.Load_PKL_Obs(
HDFfilename, Context, Band) #Load Observations & Kernels
#Compute cell in the grid considered as MARGIN-CELLS (for correct error estimation)
L_Syn_Img.Set_Margins(Context)
for i in range(10):
#Create Synthetic Image
TbH = L_Syn_Img.Create_Random_Synth_Img(Context, sgm=10)
TbV = L_Syn_Img.Create_Random_Synth_Img(Context, sgm=100)
Observation = L_Syn_Img.Simulate_PMW(
TbH, TbV, Context, Observation,
Obs_error_std=damp) #Simulate SynObs
#Print Synth Image stats
tita = L_ParamEst.recompute_param([TbH, TbV], Observation, tita)
L_ParamEst.pr(tita, 'Synthetic Image')
#%###################################################
## SOLVE SYSTEM with real parameters
Sol = L_Solvers.Solve(Context, Observation, Method, tita, damp=damp)
#%##################################################
#%
#Compare Original and Reconstructed
tita = L_ParamEst.recompute_param([TbH, TbV], Observation, tita)
L_ParamEst.pr(tita, 'Synthetic Image')
sH0_o = np.sqrt(tita['H']['sigma2'][0])
sH1_o = np.sqrt(tita['H']['sigma2'][1])
sV0_o = np.sqrt(tita['V']['sigma2'][0])
sV1_o = np.sqrt(tita['V']['sigma2'][1])
tita = L_ParamEst.recompute_param(Sol, Observation, tita)
L_ParamEst.pr(tita, 'Reconstructed Image')
sH0_c = np.sqrt(tita['H']['sigma2'][0])
sH1_c = np.sqrt(tita['H']['sigma2'][1])
sV0_c = np.sqrt(tita['V']['sigma2'][0])
sV1_c = np.sqrt(tita['V']['sigma2'][1])
print("\nSummary:\n--------")
print("RMSE H: %.3f" % (L_Syn_Img.RMSE_M(TbH, Sol[0], Context)))
print("RMSE V: %.3f" % (L_Syn_Img.RMSE_M(TbV, Sol[1], Context)))
MSG = "Orig: %.2f, \t%.2f, \t%.2f, \t%.2f" % (sH0_o, sH1_o, sV0_o,
sV1_o)
print(MSG)
logging.info(MSG)
MSG = "Comp: %.2f, \t%.2f, \t%.2f, \t%.2f" % (sH0_c, sH1_c, sV0_c,
sV1_c)
print(MSG)
logging.info(MSG)
MSG = "Quot: %.2f, \t%.2f, \t%.2f, \t%.2f" % (
sH0_c / sH0_o, sH1_c / sH1_o, sV0_c / sV0_o, sV1_c / sV1_o)
print(MSG)
logging.info(MSG)
def BG(gamma=0, MaxObs=4, w=0.001):
print("Computing %.5f" % gamma)
X.append(gamma)
BG_Coef = L_Solvers.BG_Precomp_MaxObs(Context,
Observation,
gamma=gamma,
w=w,
MaxObs=MaxObs)
Sol = [
BG_Coef.dot(Observation['Tb']['H']),
BG_Coef.dot(Observation['Tb']['V'])
]
RMSE = L_Syn_Img.RMSE_M(TbH, Sol[0], Context)
print("RMSE: %.5f\n*****************************************" % RMSE)
return RMSE
def RMSE_BG(Tb,
Context,
Observation,
omega=0.001,
gamma=np.pi / 4,
error_std=1,
max_obs=4):
Sol = BG(Context,
Observation,
omega=omega,
gamma=gamma,
error_std=error_std,
max_obs=max_obs)
RMSE = L_Syn_Img.RMSE_M(Tb, Sol[1], Context)
print("RMSE: %.5f\n*****************************************" % RMSE)
return RMSE
import L_ParamEst
import L_Syn_Img
import numpy as np
import pandas as pd
import time
import matplotlib.pyplot as plt
# INICIALIZO LOS VALORES A EXPERIMENTAR:
#%%
HDFfilename = 'GW1AM2_201207310439_227D_L1SGBTBR_2210210'
Bands = ['X', 'K', 'KU', 'KA', 'C']
Bands = ['KA', 'KU', 'K', 'X', 'C']
Context = L_Context.Load_Context(wdir)
L_Syn_Img.Set_Margins(Context)
np.random.seed(1)
#%%
#FIND Ws
#%%
BestW = {}
BestG = {}
BestRH = {}
BestRV = {}
MaxObsS = [3, 4, 6, 9, 12, 16, 20, 25]
OUT_FN = wdir + "Best_GammaW_ManyObs.txt"
for MaxObs in MaxObsS:
BestW[MaxObs] = {}
BestG[MaxObs] = {}
return XF, YF, Error
#%%
np.random.seed(1)
#cols = ['km','Band','MaxObs','w','Gamma','RMSE']
cols = ['km', 'Band', 'MaxObs', 'w', 'Gamma', 'RMSE', 'Error']
df = pd.DataFrame(columns=cols)
i = 0
for MAPA in MAPAS:
wdir = BASE_DIR + 'Mapas/%s/' % MAPA
Context = L_Context.Load_Context(wdir, NeighborsBehaviour)
L_Syn_Img.Set_Margins(Context)
km = int(MAPA[4:6])
omega = dic_omega[km]
distances_path = wdir + 'distance'
if not L_Files.exists(distances_path):
distances = L_Solvers.precompute_all_optimized(Context)
L_Solvers.save_distances(distances_path, distances)
distances = L_Solvers.load_distances(distances_path)
for rep in range(tot_img_samples):
TbH = L_Syn_Img.Create_Random_Synth_Img(Context)
TbV = L_Syn_Img.Create_Trig_Synth_Img(Context)
titaReal = copy.deepcopy(L_ParamEst.Compute_param([TbH, TbV], Context))
for Band in Bands:
Observation, tita = L_ReadObs.Load_Band_Kernels(
import L_Output
import L_Solvers
import L_ParamEst
import L_Syn_Img
import numpy as np
import pandas as pd
import time
import matplotlib.pyplot as plt
import pickle
Band = 'KA'
HDFfilename = 'GW1AM2_201207310439_227D_L1SGBTBR_2210210'
Context = L_Context.Load_Context(wdir)
L_Syn_Img.Set_Margins(Context)
Observation, tita = L_ReadObs.Load_Band_Kernels(HDFfilename, Context, Band)
np.random.seed(1)
TbH = L_Syn_Img.Create_Random_Synth_Img(Context)
np.random.seed(1)
TbV = L_Syn_Img.Create_Trig_Synth_Img(Context)
Observation = L_Syn_Img.Simulate_PMW(TbH,
TbV,
Context,
Observation,
Obs_error_std=1.0)
def BG(gamma=np.pi / 4, MaxObs=4, w=0.001, V=1):
if V == 4:
MAPAS = ['LCA_50000m', 'LCA_25000m', 'LCA_12500m']
#MAPAS=['LCA_12500m']
Bands = ['KA', 'KU', 'K', 'X', 'C']
#Bands=['KA']
tot_img_samples = 1 #CANTIDAD DE IMAGENES SINTETICAS GENERADAS
#%%
np.random.seed(1)
#cols = ['km','Band','MaxObs','w','Gamma','RMSE']
i = 0
for MAPA in MAPAS:
wdir = BASE_DIR + 'Mapas/%s/' % MAPA
Context = L_Context.Load_Context(wdir, NeighborsBehaviour)
L_Syn_Img.Set_Margins(Context)
km = int(MAPA[4:6])
omega = dic_omega[km]
distances_path = wdir + 'distance'
if not L_Files.exists(distances_path):
distances = L_Solvers.precompute_all_optimized(Context)
L_Solvers.save_distances(distances_path, distances)
distances = L_Solvers.load_distances(distances_path)
for Band in Bands:
Observation, tita = L_ReadObs.Load_Band_Kernels(
HDFfilename, Context, Band)
key = Band + str(km)
max_obs = dic_maxObs[key]
omega = dic_omega[km]
import L_ParamEst
import L_Syn_Img
import numpy as np
import pandas as pd
import time
import matplotlib.pyplot as plt
# INICIALIZO LOS VALORES A EXPERIMENTAR:
#%%
HDFfilename = 'GW1AM2_201207310439_227D_L1SGBTBR_2210210'
Bands = ['KA', 'KU', 'K', 'X', 'C']
#Bands=['KA','K','C']
Observations = {}
Context = L_Context.Load_Context(wdir)
L_Syn_Img.Set_Margins(Context)
D = {}
for Band in Bands:
Observations[Band], tita = L_ReadObs.Load_Band_Kernels(
HDFfilename, Context, Band)
D[Band] = {}
D[Band]['RMSEHs'] = []
D[Band]['RMSEVs'] = []
D[Band]['STDHo0'] = []
D[Band]['STDHo1'] = []
D[Band]['STDVo0'] = []
D[Band]['STDVo1'] = []
D[Band]['Ty_RMSEHs'] = []
D[Band]['Ty_RMSEVs'] = []
def main():
#%%###################
## PREPROCESSING
#%%
#Load Context
damp = 1.0
Context = L_Context.Load_Context(wdir)
#Create Synthetic Image
TbH = Create_Random_Synth_Img(Context, sgm=10)
TbV = Create_Random_Synth_Img(Context, sgm=.6)
#[5,2,1,...]
#Export Synthetic Image Map
#L_Output.Export_Solution([TbH,TbV], Context, Band, "SynthImg")
#Load ellipses and compute synthetic observation
Observation, tita = L_ReadObs.Load_Band_Kernels(
HDFfilename, Context, Band) #Load Observations & Kernels
Observation = L_Syn_Img.Simulate_PMW(TbH,
TbV,
Context,
Observation,
Obs_error_std=damp) #Simulate SynObs
#print("LandType approximation error:%.2f, %.2f"%(Observation['LSQRSols']['H']['norm'],Observation['LSQRSols']['V']['norm']))
#Observation['LSQRSols']={'H':lsqr(M,Observation['Tb']['H']),'V':lsqr(M,Observation['Tb']['V'])}
#Compute cell in the grid considered as MARGIN-CELLS (for correct error estimation)
L_Syn_Img.Set_Margins(Context)
titaOrig = copy.deepcopy(
L_ParamEst.recompute_param([TbH, TbV], Observation, tita))
L_ParamEst.pr(titaOrig, 'Synthetic Image')
K = Observation['Wt']
Tbh = Observation['Tb']['H']
Tbv = Observation['Tb']['V']
VType = Observation['VType']
#%%
STDs = np.exp(
np.arange(-10, 8.001, .1)
) #[np.exp(-10),np.exp(-5),np.exp(-4),np.exp(-2),np.exp(-1),np.exp(0),np.exp(1),np.exp(2),np.exp(3),np.exp(4),np.exp(5)]#,3,5,7,9,11,13,15]
STDh0 = []
STDv0 = []
STDh1 = []
STDv1 = []
RSEh = []
PEh = []
RSEv = []
PEv = []
LLh = []
LLv = []
ll = []
for std in STDs:
tita = copy.deepcopy(titaOrig)
for pol in ['H', 'V']:
for lt in [0, 1]:
tita[pol]['sigma2'][lt] = std * std
Sol = L_Solvers.Solve(Context, Observation, "Rodgers", tita, damp=damp)
tita = copy.deepcopy(titaOrig)
for pol in ['H', 'V']:
for lt in [0, 1]:
tita[pol]['sigma2'][lt] = std * std
difH = Tbh - K.dot(Sol[0])
difV = Tbv - K.dot(Sol[1])
#sn=np.sqrt(Tbh.shape[0])
RSEh.append(-np.linalg.norm(difH)**2)
RSEv.append(-np.linalg.norm(difV)**2)
err_str = "RMSE, H:%.2f, V:%.2f " % (RSEh[-1], RSEv[-1])
#RSE.append([RSEh,RSEv])
ONE = 0 * TbH + 1
mu = ONE * ((VType == 0) * tita['H']['mu'][0] +
(VType == 1) * tita['H']['mu'][1])
std = ONE * np.sqrt((VType == 0) * tita['H']['sigma2'][0] +
(VType == 1) * tita['H']['sigma2'][1])
l = np.log(std).sum()
PEh.append(-np.linalg.norm((Sol[0] - mu) / std)**2 - l)
mu = ONE * ((VType == 0) * tita['V']['mu'][0] +
(VType == 1) * tita['V']['mu'][1])
std = ONE * np.sqrt((VType == 0) * tita['V']['sigma2'][0] +
(VType == 1) * tita['V']['sigma2'][1])
l = np.log(std).sum()
PEv.append(-np.linalg.norm((Sol[1] - mu) / std)**2 - l)
LLh.append(RSEh[-1] + PEh[-1])
LLv.append(RSEv[-1] + PEv[-1])
#PE.append([PEh,PEv])
tita = L_ParamEst.recompute_param(Sol, Observation, tita)
STDh0.append(np.sqrt(tita['H']['sigma2'][0]))
STDh1.append(np.sqrt(tita['H']['sigma2'][1]))
STDv0.append(np.sqrt(tita['V']['sigma2'][0]))
STDv1.append(np.sqrt(tita['V']['sigma2'][1]))
L_ParamEst.pr(tita, 'Reconstructed Image')
#%%
import matplotlib.pyplot as plt
plt.clf()
llplot(STDs, STDs)
llplot(STDs, STDh0)
llplot(STDs, STDh1)
llplot_diag_crux(np.sqrt(titaOrig['H']['sigma2'][0]), e=2)
llplot_diag_crux(np.sqrt(titaOrig['H']['sigma2'][1]), e=2)
plt.figure()
llplot(STDs, STDs)
llplot(STDs, STDv0)
llplot(STDs, STDv1)
llplot_diag_crux(np.sqrt(titaOrig['V']['sigma2'][0]), e=2)
llplot_diag_crux(np.sqrt(titaOrig['V']['sigma2'][1]), e=2)
#%
plt.figure()
lplot(STDs, PEh)
lplot(STDs, RSEh)
lplot(STDs, LLh)
#%
plt.figure()
lplot(STDs, PEv)
lplot(STDs, RSEv)
lplot(STDs, LLv)
#%%
plt.figure()
llplot(STDs, STDs)
llplot(STDs, STDh0)
lplot(STDs, [l / 10000 for l in LLh])
'CellSize', 'Method', 'Band', 'mix_ratio', 'Img_num', 'Obs_num',
'Obs_std_error', 'RMSE', 'CoefCorr', 'time'
] #el 0 y el 1 correspondonen al LT
df = pd.DataFrame(columns=columnas)
for MAPA in MAPAS:
wdir = BASE_DIR + 'Mapas/%s/' % MAPA
Context = L_Context.Load_Context(wdir, NeighborsBehaviour)
print("Contexto cargado en", wdir)
#print("Context", Context)
#print("Keys: ", Context.keys())
#print("sdfsdf: ", Context['Dict_Vars'].keys())
VType = Context['Dict_Vars']["VType"]
neighbors = Context["Neighbors"]
L_Syn_Img.Set_Margins(Context)
print("Margenes setados para mapa", MAPA)
km = int(MAPA[4:6])
Observations = {}
titas = {}
v_errs = {}
extras = {
"neighbors": neighbors,
"obsstd": 1.0,
}
for Band in Bands:
Observation, tita = L_ReadObs.Load_PKL_or_Compute_Kernels(HDFfilename,
Context,
Band,
GC=True)
#csv_name ='exBGF_GammaW_25_ka_step'
# ESTA FIJADO CON RUIDO CUYA VARIANZA 1.
#%%
columnas = ['Method','Band','Pol','Img_num','gamma','w','Mu_real_0','Sigma2_real_0','Mu_real_1','Sigma2_real_1','Mu_0','Sigma2_0','Mu_1','Sigma2_1','RSME','CoefCorr','time'] #el 0 y el 1 correspondonen al LT
df = pd.DataFrame(columns=columnas)
for Band in Bands:
#Load Context
Context=L_Context.Load_Context(wdir, NeighborsBehaviour)
#Compute cell in the grid considered as MARGIN-CELLS (for correct error estimation)
L_Syn_Img.Set_Margins(Context)
Observation, tita=L_ReadObs.Load_PKL_or_Compute_Kernels(HDFfilename,Context,Band,GC=False)
TITA_Synth={}
TITA={}
RMSE={}
COEF_CORR = {}
Obs_error_std = 1
# Genero el df al que le voy a ir appendeando la info
for rep in range(Img_rep): # En cada repeticion arma una imagen sintetica distinta para cada banda, esta sería l nueva verdad del terreno.
#Create Synthetic Image
def main():
#%%###################
## PREPROCESSING
#Load Context
Context = L_Context.Load_Context(wdir)
#Load Observation
Observation, tita = L_ReadObs.Load_PKL_Obs(HDFfilename, Context,
Band) #Lee obs y nucleos
#Create Synthetic Image
TbH = L_Syn_Img.Create_Trig_Synth_Img(Context)
TbV = L_Syn_Img.Create_Random_Synth_Img(Context)
#Export Synthetic Image Map
L_Output.Export_Solution([TbH, TbV], Context, Band, "SynthImg")
#Print Synth Image stats
tita = L_ParamEst.recompute_param([TbH, TbV], Observation, tita)
L_ParamEst.pr(tita, 'Synthetic Image')
Observation = L_Syn_Img.Simulate_PMW(TbH,
TbV,
Context,
Observation,
error_var=1.0)
#Compute cell in the grid considered as MARGIN-CELLS
L_Syn_Img.Set_Margins(Context)
#%%##################################################
## SOLVE SYSTEM with real parameters
#%%##################################################
## Export solution
L_Output.Export_Solution(SolR, Context, Band, "SolSynthImg_%s" % Method)
#Evaluate error (with and without margins)
print("RMSE H: %.3f,%.3f" % (L_Syn_Img.RMSE_M(
TbH, SolR[0], Context), L_Syn_Img.RMSE(TbH, SolR[0])))
print("RMSE V: %.3f,%.3f" % (L_Syn_Img.RMSE_M(
TbV, SolR[1], Context), L_Syn_Img.RMSE(TbV, SolR[1])))
#%%##################################################
## EROR ANALYSIS for Rodgers Method
#Error covariance
SH = L_Solvers.Rodgers_Compute_Covarince(Context, Observation, tita, 'H')
EH = np.sqrt(SH.diagonal())
SV = L_Solvers.Rodgers_Compute_Covarince(Context, Observation, tita, 'V')
EV = np.sqrt(SV.diagonal())
L_Output.Export_Solution([EH, EV], Context, Band, "SolSynthImg_Std")
#Export 5 first error eigenvectors
EigH = np.linalg.eig(SH)
EigV = np.linalg.eig(SV)
for i in range(5): #(EigH[0].shape[0]):
ViH = EigH[1][:, i] * EigH[0][i]
ViV = EigV[1][:, i] * EigV[0][i]
L_Output.Export_Solution([ViH, ViV], Context, Band,
"SolSynthImg_Pattern_" + str(i))
#%%#################################################################
## SOLVE SYSTEM WITH ITERATIVE METHOD
#Print Synth Image stats
tita = L_ParamEst.recompute_param([TbH, TbV], Observation, tita)
L_ParamEst.pr(tita)
#Solve system
SolR = L_Solvers.Solve(Context, Observation, "Rodgers_IT", tita)
#Evaluate error (with and without margins)
print("RMSE H: %.3f,%.3f" % (L_Syn_Img.RMSE_M(
TbH, SolR[0], Context), L_Syn_Img.RMSE(TbH, SolR[0])))
print("RMSE V: %.3f,%.3f" % (L_Syn_Img.RMSE_M(
TbV, SolR[1], Context), L_Syn_Img.RMSE(TbV, SolR[1])))
#Export solution
L_Output.Export_Solution(SolR, Context, Band,
"Sol20120811_SynthImg_Rod_IT_1noise")
#%%
#main()
import L_ParamEst import L_Syn_Img import numpy as np import pandas as pd import time import matplotlib.pyplot as plt # INICIALIZO LOS VALORES A EXPERIMENTAR: #%% HDFfilename = 'GW1AM2_201207310439_227D_L1SGBTBR_2210210' Band = 'K' Context = L_Context.Load_Context(wdir) Observation, tita = L_ReadObs.Load_Band_Kernels(HDFfilename, Context, Band) L_Syn_Img.Set_Margins(Context) #%% RMSEHs = [] RMSEVs = [] STDHi0 = [] STDVi0 = [] STDHo0 = [] STDVo0 = [] STDHi1 = [] STDVi1 = [] STDHo1 = [] STDVo1 = [] STDs = [10**i for i in np.arange(-1, 1.1, .01)] for std in STDs:
