def __init__(self, resolution=40, out_type="total_avg"): """ INPUTS: """ V = get_space(resolution) dofs = len(V.dofmap().dofs()) self.solver = Fin(V) self.phi = np.loadtxt('data/basis_five_param.txt', delimiter=",") self.phi = self.phi[:, 0:10] self.model = load_parametric_model('relu', Adam, 0.004, 6, 50, 150, 600) self.out_type = out_type if out_type == "total_avg": out_dim = 1 elif out_type == "subfin_avg": out_dim = 5 elif out_type == "rand_pt": out_dim = 1 elif out_type == "rand_pts": out_dim = 5 mm.PyModPiece.__init__(self, [5], [out_dim])
def __init__(self, V, chol, randobs): ''' Parameters: V - FEniCS FunctionSpace chol - Covariance matrix to define Gaussian field over V ''' self._V = V self._solver = Fin(self._V, randobs) self._pred_k = dl.Function(self._V) # Setup synthetic observations self.k_true = dl.Function(self._V) # Random Gaussian field as true function # norm = np.random.randn(len(chol)) # nodal_vals = np.exp(0.5 * chol.T @ norm) nodal_vals = np.load('res_x.npy') self.k_true.vector().set_local(nodal_vals) w, y, A, B, C = self._solver.forward(self.k_true) self.obs_data = self._solver.qoi_operator(w) # Setup DL error model # self._err_model = load_parametric_model_avg('elu', Adam, #0.0003, 5, 58, 200, 2000, V.dim()) self._err_model = load_bn_model(randobs) # Initialize reduced order model self.phi = np.loadtxt('../data/basis_nine_param.txt', delimiter=",") self._solver_r = AffineROMFin(self._V, self._err_model, self.phi, randobs) self._solver_r.set_data(self.obs_data)
class FOM_forward(mm.PyModPiece): """ Solves the thermal fin steady state problem with a full order model """ def __init__(self, resolution=40, out_type="total_avg"): """ INPUTS: """ V = get_space(resolution) dofs = len(V.dofmap().dofs()) self.solver = Fin(V) self.out_type = out_type if out_type == "total_avg": out_dim = 1 elif out_type == "subfin_avg": out_dim = 5 elif out_type == "rand_pt": out_dim = 1 elif out_type == "rand_pts": out_dim = 5 mm.PyModPiece.__init__(self, [5], [out_dim]) def EvaluateImpl(self, inputs): """ Performs the forward solve and returns observations. """ z = inputs[0] x, y, A, B, C = self.solver.forward_five_param(z) output = self.solver.qoi_operator(x) self.outputs = [output]
def generate(dataset_size, resolution=40): ''' Create a tensorflow dataset where the features are thermal conductivity parameters and the labels are the differences in the quantity of interest between the high fidelity model and the reduced order model (this is the ROM error) Arguments: dataset_size - number of feature-label pairs resolution - finite element mesh resolution for the high fidelity model Returns: dataset - Tensorflow dataset created from tensor slices ''' V = get_space(resolution) dofs = len(V.dofmap().dofs()) # TODO: Improve this by using mass matrix covariance. Bayesian prior may work well too z_s = np.random.uniform(0.1, 1, (dataset_size, dofs)) phi = np.loadtxt('data/basis.txt', delimiter=",") solver = Fin(V) errors = np.zeros((dataset_size, 1)) m = Function(V) for i in range(dataset_size): m.vector().set_local(z_s[i, :]) w, y, A, B, C = solver.forward(m) psi = np.dot(A, phi) A_r, B_r, C_r, x_r, y_r = solver.reduced_forward(A, B, C, psi, phi) errors[i][0] = y - y_r dataset = tf.data.Dataset.from_tensor_slices((z_s, errors)) return dataset
class DL_ROM_forward(mm.PyModPiece): """ Solves the thermal fin steady state problem with projection based ROM with a given basis and augments QoI prediction with deep learning prediciton. """ def __init__(self, resolution=40, out_type="total_avg"): """ INPUTS: """ V = get_space(resolution) dofs = len(V.dofmap().dofs()) self.solver = Fin(V) self.phi = np.loadtxt('data/basis_five_param.txt', delimiter=",") self.phi = self.phi[:, 0:10] self.model = load_parametric_model('relu', Adam, 0.004, 6, 50, 150, 600) self.out_type = out_type if out_type == "total_avg": out_dim = 1 elif out_type == "subfin_avg": out_dim = 5 elif out_type == "rand_pt": out_dim = 1 elif out_type == "rand_pts": out_dim = 5 mm.PyModPiece.__init__(self, [5], [out_dim]) def EvaluateImpl(self, inputs): """ Performs the forward solve and returns observations. """ z = inputs[0] A_r, B_r, C_r, x_r, y_r = self.solver.r_fwd_no_full_5_param( z, self.phi) e_NN = self.model.predict(z.reshape((1, 5))) if self.out_type == "total_avg": output = np.array([y_r + e_NN[0, 0]]) else: # The QoI operator determines whether we look at subfin averages # or random points on the boundary or domain output = self.solver.reduced_qoi_operator(x_r) + e_NN[0] self.outputs = [output]
def gen_affine_avg_rom_dataset(dataset_size, resolution=40, genrand=False): V = get_space(resolution) dofs = len(V.dofmap().dofs()) z = Function(V) solver = Fin(V, genrand) phi = np.loadtxt('../data/basis_nine_param.txt', delimiter=",") chol = make_cov_chol(V, length=1.6) # prior_cov = np.load('../bayesian_inference/prior_covariance_0.07_0.07.npy') # L = np.linalg.cholesky(prior_cov) # err_model = load_parametric_model_avg('elu', Adam, 0.0003, 5, 58, 200, 2000, V.dim()) err_model = res_bn_fc_model(ELU(), Adam, 3e-5, 3, 100, 1446, solver.n_obs) solver_r = AffineROMFin(V, err_model, phi, genrand) qoi_errors = np.zeros((dataset_size, solver_r.n_obs)) qois = np.zeros((dataset_size, solver_r.n_obs)) # TODO: Needs to be fixed for higher order functions z_s = np.zeros((dataset_size, V.dim())) for i in tqdm(range(dataset_size)): # draw = np.random.randn(dofs) # nodal_vals = np.exp(np.dot(L, draw)) norm = np.random.randn(V.dim()) nodal_vals = np.exp(0.5 * chol.T @ norm) z.vector().set_local(nodal_vals) z_s[i, :] = nodal_vals x, y, A, B, C = solver.forward(z) w_r = solver_r.forward_reduced(z) qoi = solver.qoi_operator(x) qoi_r = solver_r.qoi_reduced(w_r) qoi_errors[i, :] = qoi - qoi_r qois[i, :] = qoi if (dataset_size > 1000): np.save('../data/z_aff_avg_tr_avg_obs_3', z_s) np.save('../data/errors_aff_avg_tr_avg_obs_3', qoi_errors) np.save('../data/qois_avg_tr_avg_obs_3', qois) if (dataset_size < 600): np.save('../data/z_aff_avg_eval_avg_obs_3', z_s) np.save('../data/errors_aff_avg_eval_avg_obs_3', qoi_errors) np.save('../data/qois_avg_eval_avg_obs_3', qois) return (z_s, qoi_errors)
def generate_and_save_dataset(dataset_size, resolution=40): V = get_space(resolution) dofs = len(V.dofmap().dofs()) z_s = np.random.uniform(0.1, 1, (dataset_size, dofs)) phi = np.loadtxt('data/basis.txt', delimiter=",") solver = Fin(V) errors = np.zeros((dataset_size, 1)) m = Function(V) for i in range(dataset_size): m.vector().set_local(z_s[i, :]) w, y, A, B, C = solver.forward(m) psi = np.dot(A, phi) A_r, B_r, C_r, x_r, y_r = solver.reduced_forward(A, B, C, psi, phi) errors[i][0] = y - y_r np.savetxt('../data/z_s_train.txt', z_s, delimiter=",") np.savetxt('../data/errors_train.txt', errors, delimiter=",")
def generate_five_param_np(dataset_size, resolution=40): V = get_space(resolution) z_s = np.random.uniform(0.1, 1, (dataset_size, 5)) phi = np.loadtxt('data/basis_five_param.txt', delimiter=",") phi = phi[:, 0:10] solver = Fin(V) errors = np.zeros((dataset_size, 1)) y_s = np.zeros((dataset_size, 1)) y_r_s = np.zeros((dataset_size, 1)) for i in range(dataset_size): w, y, A, B, C = solver.forward_five_param(z_s[i, :]) y_s[i][0] = y psi = np.dot(A, phi) A_r, B_r, C_r, x_r, y_r = solver.reduced_forward(A, B, C, psi, phi) y_r_s[i][0] = y_r errors[i][0] = y - y_r return (z_s, errors)
def __init__(self, resolution=40, out_type="total_avg"): """ INPUTS: """ V = get_space(resolution) dofs = len(V.dofmap().dofs()) self.solver = Fin(V) self.out_type = out_type if out_type == "total_avg": out_dim = 1 elif out_type == "subfin_avg": out_dim = 5 elif out_type == "rand_pt": out_dim = 1 elif out_type == "rand_pts": out_dim = 5 mm.PyModPiece.__init__(self, [5], [out_dim])
def generate_DL_only_dataset(dataset_size, resolution=40): ''' Create dataset where the features are thermal conductivity parameters and the labels are the quantities of interest of the HFM Arguments: dataset_size - number of feature-label pairs resolution - finite element mesh resolution for the high fidelity model Returns: (z, qois) - pairs of conductivity and qois ''' V = get_space(resolution) dofs = len(V.dofmap().dofs()) prior_cov = np.load('bayesian_inference/prior_covariance.npy') L = np.linalg.cholesky(prior_cov) # TODO: Improve this by using mass matrix covariance. Bayesian prior may work well too z_s = np.zeros((dataset_size, dofs)) solver = Fin(V, True) qois = np.zeros((dataset_size, 40)) k = Function(V) for i in range(dataset_size): draw = np.random.randn(dofs) prior_draw = np.dot(L, draw) k.vector().set_local(prior_draw) w, _, _, _, _ = solver.forward(k) qois[i, :] = solver.qoi_operator(w) z_s[i, :] = prior_draw if (dataset_size > 1000): np.savetxt('data/z_dlo_tr.txt', z_s, delimiter=",") np.savetxt('data/qois_dlo_tr.txt', qois, delimiter=",") if (dataset_size < 400): np.savetxt('data/z_dlo_eval.txt', z_s, delimiter=",") np.savetxt('data/qois_dlo_eval.txt', qois, delimiter=",") return (z_s, qois)
def gen_affine_avg_rom_dataset(dataset_size, resolution=40, genrand=False): V = get_space(resolution) chol = make_cov_chol(V, length=1.6) z = Function(V) solver = Fin(V, genrand) phi = np.loadtxt('../data/basis_nine_param.txt', delimiter=",") # err_model = load_parametric_model_avg('elu', Adam, 0.0003, 5, 58, 200, 2000, V.dim()) err_model = res_bn_fc_model(ELU(), Adam, 3e-5, 3, 200, 1446, 40) solver_r = AffineROMFin(V, err_model, phi, genrand) qoi_errors = np.zeros((dataset_size, solver_r.n_obs)) # TODO: Needs to be fixed for higher order functions z_s = np.zeros((dataset_size, V.dim())) for i in tqdm(range(dataset_size)): norm = np.random.randn(len(chol)) nodal_vals = np.exp(0.5 * chol.T @ norm) z.vector().set_local(nodal_vals) z_s[i, :] = nodal_vals x, y, A, B, C = solver.forward(z) w_r = solver_r.forward_reduced(z) qoi = solver.qoi_operator(x) qoi_r = solver_r.qoi_reduced(w_r) qoi_errors[i, :] = qoi - qoi_r if (dataset_size > 1000): np.savetxt('../data/z_aff_avg_tr.txt', z_s, delimiter=",") np.savetxt('../data/errors_aff_avg_tr.txt', qoi_errors, delimiter=",") if (dataset_size < 400): np.savetxt('../data/z_aff_avg_eval.txt', z_s, delimiter=",") np.savetxt('../data/errors_aff_avg_eval.txt', qoi_errors, delimiter=",") return (z_s, qoi_errors)
def gen_avg_rom_dataset(dataset_size, resolution=40): V = get_space(resolution) chol = make_cov_chol(V) z = Function(V) solver = Fin(V) phi = np.loadtxt('data/basis_nine_param.txt', delimiter=",") qoi_errors = np.zeros((dataset_size, 5)) # TODO: Needs to be fixed for higher order functions z_s = np.zeros((dataset_size, V.dim())) for i in range(dataset_size): norm = np.random.randn(len(chol)) nodal_vals = np.exp(0.5 * chol.T @ norm) z.vector().set_local(nodal_vals) z_s[i, :] = nodal_vals A_r, B_r, C_r, x_r, y_r = solver.averaged_forward(z, phi) x, y, A, B, C = solver.forward(z) qoi = solver.qoi_operator(x) qoi_r = solver.reduced_qoi_operator(x_r) qoi_errors[i, :] = qoi - qoi_r if (dataset_size > 1000): np.savetxt('data/z_avg_tr.txt', z_s, delimiter=",") np.savetxt('data/errors_avg_tr.txt', qoi_errors, delimiter=",") if (dataset_size < 400): np.savetxt('data/z_avg_eval.txt', z_s, delimiter=",") np.savetxt('data/errors_avg_eval.txt', qoi_errors, delimiter=",") return (z_s, qoi_errors)
def generate_five_param(dataset_size, resolution=40): V = get_space(resolution) dofs = len(V.dofmap().dofs()) # TODO: Improve this by using mass matrix covariance. Bayesian prior may work well too z_s = np.random.uniform(0.1, 1, (dataset_size, 5)) phi = np.loadtxt('data/basis_five_param.txt', delimiter=",") phi = phi[:, 0:20] solver = Fin(V) errors = np.zeros((dataset_size, 1)) for i in range(dataset_size): w, y, A, B, C = solver.forward_five_param(z_s[i, :]) psi = np.dot(A, phi) A_r, B_r, C_r, x_r, y_r = solver.reduced_forward(A, B, C, psi, phi) errors[i][0] = y - y_r # np.savetxt('data/z_s_eval.txt', z_s, delimiter=",") # np.savetxt('data/errors_eval.txt', errors, delimiter=",") dataset = tf.data.Dataset.from_tensor_slices((z_s, errors)) return dataset
def gen_five_param_subfin_avg(dataset_size, resolution=40): V = get_space(resolution) z_s = np.random.uniform(0.1, 1, (dataset_size, 5)) phi = np.loadtxt('data/basis_five_param.txt', delimiter=",") phi = phi[:, 0:10] solver = Fin(V) errors = np.zeros((dataset_size, 5)) avgs = np.zeros((dataset_size, 5)) avgs_r = np.zeros((dataset_size, 5)) for i in range(dataset_size): w, y, A, B, C = solver.forward_five_param(z_s[i, :]) avgs[i] = solver.qoi_operator(w) psi = np.dot(A, phi) A_r, B_r, C_r, x_r, y_r = solver.reduced_forward(A, B, C, psi, phi) avgs_r[i] = solver.reduced_qoi_operator(x_r) errors[i] = avgs[i] - avgs_r[i] return (z_s, errors)
from deep_learning.dl_model import load_bn_model, load_dataset_avg_rom from tensorflow.keras.optimizers import Adam from fom.forward_solve import Fin from fom.thermal_fin import get_space from rom.averaged_affine_ROM import AffineROMFin from dolfin import * # model = load_parametric_model('relu', Adam, 0.004, 6, 50, 150, 600) model = load_bn_model() z_train, errors_train, z_val, errors_val = load_dataset_avg_rom() # z_val = np.loadtxt('data/z_avg_v.txt', delimiter=',') # errors_val = np.loadtxt('data/err_avg_v.txt', delimiter=',') V = get_space(40) phi = np.loadtxt('../data/basis_nine_param.txt', delimiter=",") # phi = phi[:,0:10] solver = Fin(V) solver_r = AffineROMFin(V, model, phi) avgs_f = np.zeros((len(z_val), 9)) avgs_r = np.zeros((len(z_val), 9)) avgs_d = np.zeros((len(z_val), 9)) err_pred = np.zeros((len(z_val), 9)) z = Function(V) for i in range(len(z_val)): z.vector().set_local(z_val[i, :]) z_nodal = z_val[i, :].reshape((1, 1446)) w, y, A, B, C = solver.forward(z) w_r = solver_r.forward_reduced(z) avgs_f[i] = solver.qoi_operator(w) avgs_r[i] = solver_r.qoi_reduced(w_r)
import numpy as np import matplotlib.pyplot as plt import dolfin as dl dl.set_log_level(40) # ROMML imports from fom.forward_solve import Fin from fom.thermal_fin import get_space from rom.averaged_affine_ROM import AffineROMFin from deep_learning.dl_model import load_parametric_model_avg from gaussian_field import make_cov_chol resolution = 40 V = get_space(resolution) chol = make_cov_chol(V, length=1.2) solver = Fin(V) class SolverWrapper: def __init__(self, solver, data): self.solver = solver self.data = data self.z = dl.Function(V) def cost_function(self, z_v): self.z.vector().set_local(z_v) w, y, A, B, C = self.solver.forward(self.z) y = self.solver.qoi_operator(w) cost = 0.5 * np.linalg.norm( y - self.data)**2 #+ dl.assemble(self.solver.reg) return cost
# Create a fin geometry geometry = Rectangle(Point(2.5, 0.0), Point(3.5, 4.0)) \ + Rectangle(Point(0.0, 0.75), Point(2.5, 1.0)) \ + Rectangle(Point(0.0, 1.75), Point(2.5, 2.0)) \ + Rectangle(Point(0.0, 2.75), Point(2.5, 3.0)) \ + Rectangle(Point(0.0, 3.75), Point(2.5, 4.0)) \ + Rectangle(Point(3.5, 0.75), Point(6.0, 1.0)) \ + Rectangle(Point(3.5, 1.75), Point(6.0, 2.0)) \ + Rectangle(Point(3.5, 2.75), Point(6.0, 3.0)) \ + Rectangle(Point(3.5, 3.75), Point(6.0, 4.0)) \ mesh = generate_mesh(geometry, 40) V = FunctionSpace(mesh, 'CG', 1) dofs = len(V.dofmap().dofs()) solver = Fin(V) ##########################################################3 # Basis initialization with dummy solves and POD ##########################################################3 samples = 10 Y = np.zeros((samples, dofs)) for i in range(0,samples): if i == 0: m = interpolate(Expression("0.1 + exp(-(pow(x[0] - 0.5, 2) + pow(x[1], 2)) / 0.01)", degree=2),V) elif i == 1: m = interpolate(Expression("2*x[0] + 0.1", degree=2), V) elif i == 2: m = interpolate(Expression("1 + sin(x[0])* sin(x[0])", degree=2), V) elif i == 3:
import sys sys.path.append('../') import dolfin as dl import numpy as np import matplotlib.pyplot as plt from fom.forward_solve import Fin from fom.thermal_fin import get_space from bayesian_inference.gaussian_field import make_cov_chol # Setup solver V = get_space(40) solver = Fin(V) phi = np.loadtxt('data/basis_five_param.txt', delimiter=",") # Obtain synthetic data chol = make_cov_chol(V, length=0.8) k_true = dl.Function(V) norm = np.random.randn(len(chol)) nodal_vals = np.exp(0.5 * chol.T @ norm) k_true.vector().set_local(nodal_vals) w, y, A, B, C = solver.forward(k_true) data = solver.qoi_operator(w) # Comparing reduced and full w, y, A, B, C = solver.forward(k_true) A_r, B_r, C_r, w_r, y_r = solver.averaged_forward(k_true, phi) k_true_averaged = solver.nine_param_to_function(solver.subfin_avg_op(k_true)) p = dl.plot(k_true_averaged)
resolution = 40 V = get_space(resolution) chol = make_cov_chol(V, length=1.6) # Setup DL error model # err_model = load_parametric_model_avg('elu', Adam, 0.0003, 5, 58, 200, 2000, V.dim()) err_model = load_bn_model(randobs) surrogate_model = load_surrogate_model(randobs) # Initialize reduced order model phi = np.loadtxt('../data/basis_nine_param.txt',delimiter=",") solver_r = AffineROMFin(V, err_model, phi, randobs) # Setup synthetic observations solver = Fin(V, randobs) z_true = dl.Function(V) prior_covariance = np.load('prior_covariance_0.07_0.07.npy') L = np.linalg.cholesky(prior_covariance) # draw = np.random.randn(V.dim()) # nodal_vals = np.dot(L, draw) #Load random Gaussian field nodal_vals = np.load('res_x.npy') # nodal_vals = np.exp(nodal_vals)/np.sum(np.exp(nodal_vals)) + 1.0 # For exp parametrization # nodal_vals = np.log(nodal_vals)
import matplotlib.pyplot as plt import numpy as np from dolfin import Function from tensorflow.keras.optimizers import Adam, RMSprop, Adadelta from deep_learning.dl_model import load_parametric_model_avg from fom.forward_solve import Fin, get_space z_val = np.loadtxt('../data/z_avg_eval.txt', delimiter=',') errors_val = np.loadtxt('../data/errors_avg_eval.txt', delimiter=',') V = get_space(40) model = load_parametric_model_avg('elu', Adam, 0.129, 3, 58, 64, 466, V.dim()) phi = np.loadtxt('../data/basis_five_param.txt', delimiter=",") # phi = phi[:,0:10] solver = Fin(V) avgs_f = np.zeros((len(z_val), 5)) avgs_r = np.zeros((len(z_val), 5)) avgs_d = np.zeros((len(z_val), 5)) avgs_c = np.zeros((len(z_val), 5)) err_pred = np.zeros((len(z_val), 5)) z = Function(V) err_pred = model.predict(z_val) print("Average validation error in pred: {}".format( np.average(np.divide(np.abs(errors_val - err_pred), np.abs(errors_val))))) for i in range(len(z_val)): nodal_vals = z_val[i, :] z.vector().set_local(nodal_vals) _, _, _, x_r, y_r = solver.averaged_forward(z, phi) x, y, A, B, C = solver.forward(z)
class SqError: ''' Wrapper class interfacing Theano operators and ROMML to compute forward solves and parameter gradients ''' def __init__(self, V, chol, randobs): ''' Parameters: V - FEniCS FunctionSpace chol - Covariance matrix to define Gaussian field over V ''' self._V = V self._solver = Fin(self._V, randobs) self._pred_k = dl.Function(self._V) # Setup synthetic observations self.k_true = dl.Function(self._V) # Random Gaussian field as true function # norm = np.random.randn(len(chol)) # nodal_vals = np.exp(0.5 * chol.T @ norm) nodal_vals = np.load('res_x.npy') self.k_true.vector().set_local(nodal_vals) w, y, A, B, C = self._solver.forward(self.k_true) self.obs_data = self._solver.qoi_operator(w) # Setup DL error model # self._err_model = load_parametric_model_avg('elu', Adam, #0.0003, 5, 58, 200, 2000, V.dim()) self._err_model = load_bn_model(randobs) # Initialize reduced order model self.phi = np.loadtxt('../data/basis_nine_param.txt', delimiter=",") self._solver_r = AffineROMFin(self._V, self._err_model, self.phi, randobs) self._solver_r.set_data(self.obs_data) def err_grad_FOM(self, pred_k): ''' For a given parameter, computes the high fidelity forward solution and the gradient with respect to the cost function ''' self._pred_k.vector().set_local(pred_k) w, y, a, b, c = self._solver.forward(self._pred_k) qoi = self._solver.qoi_operator(w) err = np.square(qoi - self.obs_data).sum() / 2.0 grad = self._solver.gradient(self._pred_k, self.obs_data) return err, grad def err_grad_ROM(self, pred_k): ''' For a given parameter, computes the reduced-order forward solution and the gradient with respect to the cost function ''' self._pred_k.vector().set_local(pred_k) w_r = self._solver_r.forward_reduced(self._pred_k) qoi_r = self._solver_r.qoi_reduced(w_r) err_r = np.square(qoi_r - self.obs_data).sum() / 2.0 grad_r = self._solver_r.grad_reduced(self._pred_k) return err_r, grad_r def err_grad_ROMML(self, pred_k): ''' For a given parameter, computes the reduced-order + ML forward solution and the gradient with respect to the cost function ''' self._pred_k.vector().set_local(pred_k) # w_r = self._solver_r.forward_reduced(self._pred_k) # qoi_r = self._solver_r.qoi_reduced(w_r) # err_NN = self._err_model.predict([[pred_k]])[0] # qoi_t = qoi_r + err_NN # err_t = np.square(qoi_t - self.obs_data).sum()/2.0 grad_t, err_t = self._solver_r.grad_romml(self._pred_k) return err_t, grad_t
# ROMML imports from fom.forward_solve import Fin, get_space from muq_mod_five_param import ROM_forward, DL_ROM_forward, FOM_forward resolution = 40 r_fwd = ROM_forward(resolution, out_type="subfin_avg") d_fwd = DL_ROM_forward(resolution, out_type="subfin_avg") f_fwd = FOM_forward(resolution, out_type="subfin_avg") #z_true = np.random.uniform(0.1,1, (1,5)) z_true = np.array( [[0.41126864, 0.61789679, 0.75873243, 0.96527541, 0.22348076]]) V = get_space(resolution) full_solver = Fin(V) w, y, A, B, C = full_solver.forward_five_param(z_true[0, :]) qoi = full_solver.qoi_operator(w) obsData = qoi def MCMC_sample(fwd): # Define prior logPriorMu = 0.5 * np.ones(5) logPriorCov = 0.5 * np.eye(5) logPrior = mm.Gaussian(logPriorMu, logPriorCov).AsDensity() # Likelihood noiseVar = 1e-4 noiseCov = noiseVar * np.eye(obsData.size)
from tensorflow.keras.layers import * from tensorflow.python.framework import ops tf.keras.backend.set_floatx('float64') tf.compat.v1.disable_eager_execution() from fom.forward_solve import Fin from fom.thermal_fin import get_space import dolfin as dl dl.set_log_level(40) # Create FunctionSpace V = get_space(40) # Create FEniCS forward solver with surface obs as QoI solver = Fin(V, True) U_func = dl.Function(V) def _py_func_with_gradient(func, inp, Tout, stateful=True, name=None, grad_func=None): """ PyFunc defined as given by Tensorflow :param func: Custom Function :param inp: Function Inputs :param Tout: Ouput Type of out Custom Function :param stateful: Calculate Gradients when stateful is True