def tringulation_search_bound_constantK(inter_par, xi, K, ind_min): ''' This function is the core of constant-K continuous search function. :param inter_par: Contains interpolation information w, v. :param xi: The union of xE(Evaluated points) and xU(Support points) :param K: Tuning parameter for constant-K, K = K*K0. K0 is the range of yE. :param ind_min: The correspoding index of minimum of yE. :return: The minimizer, xc, and minimum, yc, of continuous search function. ''' inf = 1e+20 n = xi.shape[0] # Delaunay Triangulation if n == 1: sx = sorted(range(xi.shape[1]), key=lambda x: xi[:, x]) tri = np.zeros((xi.shape[1] - 1, 2)) tri[:, 0] = sx[:xi.shape[1] - 1] tri[:, 1] = sx[1:] tri = tri.astype(np.int32) else: options = 'Qt Qbb Qc' if n <= 3 else 'Qt Qbb Qc Qx' tri = Delaunay(xi.T, qhull_options=options).simplices keep = np.ones(len(tri), dtype=bool) for i, t in enumerate(tri): if abs(np.linalg.det(np.hstack( (xi.T[t], np.ones([1, n + 1]).T)))) < 1E-15: keep[i] = False # Point is coplanar, we don't want to keep it tri = tri[keep] # Search the minimum of the synthetic quadratic model Sc = np.zeros([np.shape(tri)[0]]) Scl = np.zeros([np.shape(tri)[0]]) for ii in range(np.shape(tri)[0]): # R2-circumradius, xc-circumcircle center R2, xc = Utils.circhyp(xi[:, tri[ii, :]], n) # x is the center of the current simplex x = np.dot(xi[:, tri[ii, :]], np.ones([n + 1, 1]) / (n + 1)) Sc[ii] = interpolation.interpolate_val( x, inter_par) - K * (R2 - np.linalg.norm(x - xc)**2) if np.sum(ind_min == tri[ii, :]): Scl[ii] = np.copy(Sc[ii]) else: Scl[ii] = inf # Global one t = np.min(Sc) ind = np.argmin(Sc) R2, xc = Utils.circhyp(xi[:, tri[ind, :]], n) x = np.dot(xi[:, tri[ind, :]], np.ones([n + 1, 1]) / (n + 1)) xm, ym = Constant_K_Search(x, inter_par, xc, R2, K) # Local one t = np.min(Scl) ind = np.argmin(Scl) R2, xc = Utils.circhyp(xi[:, tri[ind, :]], n) # Notice!! ind_min may have a problem as an index x = np.copy(xi[:, ind_min].reshape(-1, 1)) xml, yml = Constant_K_Search(x, inter_par, xc, R2, K) if yml < ym: xm = np.copy(xml) ym = np.copy(yml) xm = xm.reshape(-1, 1) ym = ym[0, 0] return xm, ym
def AdaptiveK_search_cost(x, inter_par, xc, R2, y0, K0): pos_inf = np.array([[1e+15]]) # neg_inf to approximate gradient, Probably has problem. neg_inf = -1e+5 * np.ones(x.shape) x = x.reshape(-1, 1) n = x.shape[0] p = interpolation.interpolate_val(x, inter_par) e = R2 - np.linalg.norm(x - xc)**2 # Optimize - K0 * e(x) / (p(x) - y0); Extreme point doesnt change. if abs(p - y0) < 1e-6: M = np.array([[0]]) DM = np.zeros((n, 1)) # DDM = np.zeros((n, n)) else: M = -e * K0 / (p - y0) # M = (p - y0) / e gp = interpolation.interpolate_grad(x, inter_par) ge = -2 * (x - xc) # gge = - 2 * w.T # ggp = interpolation.interpolate_hessian(x, inter_par) DM = -ge * K0 / (p - y0) + K0 * e * gp / (p - y0)**2 # DDM = -gge * K0/(p-y0) + K0*ge.dot(gp.T)/(p-y0)**2 + (K0*ge.dot(gp.T)+e*K0*ggp)/(p-y0)**2 - (e*K0*2*(p-y0)*np.dot(gp, gp.T))/(p-y0)**4 # method trust-ncg in scipy optimize can't handle constraints nor bounds. # if optm method is chosen as TNC, use DM.T[0] return M, DM.T[0]
def Continuous_search_cost(x, inter_par, xc, R2, K): x = x.reshape(-1, 1) M = interpolation.interpolate_val( x, inter_par) - K * (R2 - np.linalg.norm(x - xc)**2) DM = interpolation.interpolate_grad(x, inter_par) + 2 * K * (x - xc) # if optm method is chosen as TNC, use DM.T[0] return M, DM.T[0]
def AdaptiveK_Search_p(x0, inter_par_asm, bnds): costfun = lambda x: interpolation.interpolate_val(x, inter_par_asm) costjac = lambda x: interpolation.interpolate_grad(x, inter_par_asm) opt = {'disp': False} res = optimize.minimize(costfun, x0.T[0], jac=costjac, method='TNC', bounds=bnds, options=opt) x = res.x y = res.fun return x, y
def adaptivek_search_cost_snopt(x): x = x.reshape(-1, 1) folder = folder_path() var_opt = io.loadmat(folder + "/opt_info.mat") n = var_opt['n'][0, 0] xc = var_opt['xc'] R2 = var_opt['R2'][0, 0] y0 = var_opt['y0'][0, 0] nF = var_opt['nF'][0, 0] A = var_opt['A'] y_safe = var_opt['y_safe'] L_safe = var_opt['L_safe'][0, 0] # Initialize the output F and G. F = np.zeros(nF) method = var_opt['inter_par_method'][0] inter_par = interpolation.Inter_par(method=method) inter_par.w = var_opt['inter_par_w'] inter_par.v = var_opt['inter_par_v'] inter_par.xi = var_opt['inter_par_xi'] p = interpolation.interpolate_val(x, inter_par) e = R2 - np.linalg.norm(x - xc)**2 gp = interpolation.interpolate_grad(x, inter_par) ge = -2 * (x - xc) de = (1e-10 if abs(p - y0) < 1e-10 else p - y0) F[0] = -e / de # K0 = 0 because only at 1st iteration we only have 1 function evaluation. val, idx, x_nn = Utils.mindis(x, inter_par.xi) F[-1] = y_safe[idx] - L_safe * np.linalg.norm(x - x_nn) if n > 1: # nD data has n+1 simplex bounds. F[1:-1] = (np.dot( A, x)).T[0] # broadcast input array from (3,1) into shape (3). DM = -ge / de + e * gp / de**2 G = np.hstack( (DM.flatten(), (-L_safe * (x - x_nn) / np.linalg.norm(x - x_nn)).flatten())) return F, G
def adaptivek_p_cost_snopt(x): x = x.reshape(-1, 1) folder = folder_path() var_opt = io.loadmat(folder + "/opt_info_p.mat") n = var_opt['n'][0, 0] nF = var_opt['nF'][0, 0] A = var_opt['A'] # Initialize the output F and G. F = np.zeros(nF) method = var_opt['inter_par_method'][0] inter_par = interpolation.Inter_par(method=method) inter_par.w = var_opt['inter_par_w'] inter_par.v = var_opt['inter_par_v'] inter_par.xi = var_opt['inter_par_xi'] gp = interpolation.interpolate_grad(x, inter_par) F[0] = interpolation.interpolate_val(x, inter_par) F[1:] = (np.dot( A, x)).T[0] # broadcast input array from (3,1) into shape (3). G = gp.flatten() return F, G
def safe_continuous_constantK_search_1d_plot(xE, xU, fun_eval, safe_eval, L_safe, K, xc_min, Nm): ''' Given evaluated points set xE, and the objective function. Plot the interpolation, uncertainty function and continuous search function. :param xE: :param xU: :param fun_eval: :param safe_eval: :param L_safe: :param K: :param xc_min: :param Nm: :return: ''' N = xE.shape[1] yE = np.zeros(N) for i in range(N): yE[i] = fun_eval(xE[:, i]) inter_par = interpolation.Inter_par(method='NPS') inter_par, _ = interpolation.interpolateparameterization(xE, yE, inter_par) x = np.linspace(0, 1, 1000) y, yp = np.zeros(x.shape), np.zeros(x.shape) for i in range(x.shape[0]): y[i] = fun_eval(x[i]) yp[i] = interpolation.interpolate_val(x[i], inter_par) xi = np.hstack((xE, xU)) sx = sorted(range(xi.shape[1]), key=lambda x: xi[:, x]) tri = np.zeros((xi.shape[1] - 1, 2)) tri[:, 0] = sx[:xi.shape[1] - 1] tri[:, 1] = sx[1:] tri = tri.astype(np.int32) xe_plot = np.zeros((tri.shape[0], 2000)) e_plot = np.zeros((tri.shape[0], 2000)) sc_plot = np.zeros((tri.shape[0], 2000)) n = xE.shape[0] for ii in range(len(tri)): temp_x = np.copy(xi[:, tri[ii, :]]) simplex = xi[:, tri[ii, :]] # Determine if the boundary corner exists or not in simplex exist = 0 for i in range(simplex.shape[1]): vertice = simplex[:, i].reshape(-1, 1) val, _, _ = Utils.mindis(vertice, xE) if val == 0: pass else: exist = 1 break x_ = np.linspace(temp_x[0, 0], temp_x[0, 1], 2000) temp_Sc = np.zeros(len(x_)) temp_e = np.zeros(len(x_)) p = np.zeros(len(x_)) R2, xc = Utils.circhyp(xi[:, tri[ii, :]], n) for jj in range(len(x_)): p[jj] = interpolation.interpolate_val(x_[jj], inter_par) if exist == 0: temp_e[jj] = (R2 - np.linalg.norm(x_[jj] - xc)**2) else: val, _, _ = Utils.mindis(x_[jj], xE) temp_e[jj] = val**(2) # val, idx, vertex = Utils.mindis(x_[jj], xE) # c = 0.1 # temp_e[jj] = (val + c) ** (1/2) - c ** (1/2) temp_Sc[jj] = p[jj] - K * temp_e[jj] e_plot[ii, :] = temp_e xe_plot[ii, :] = x_ sc_plot[ii, :] = temp_Sc # The minimizer of continuous search must be subject to safe constraints. # sc_min = np.min(sc_plot, axis=1) # index_r = np.argmin(sc_min) # index_c = np.argmin(sc_plot[index_r, :]) # sc_min_x = xe_plot[index_r, index_c] # sc_min = min(np.min(sc_plot, axis=1)) safe_plot = {} ## plot the safe region for ii in range(xE.shape[1]): y_safe = safe_eval(xE[:, ii]) safe_index = [] y_safe_plot = [] safe_eval_lip = lambda x: y_safe - L_safe * np.sqrt( np.dot((x - xE[:, ii]).T, x - xE[:, ii])) for i in range(x.shape[0]): safe_val = safe_eval_lip(x[i]) y_safe_plot.append(safe_val[0]) if safe_val > 0: safe_index.append(i) name = str(ii) safe_plot[name] = [safe_index, y_safe_plot] # ================== First plot ================= fig = plt.figure() plt.subplot(2, 1, 1) # plot the essentials for DeltaDOGS plt.plot(x, y, c='k') plt.plot(x, yp, c='b') for i in range(len(tri)): if i == 0 or i == len(tri) - 1: amplify_factor = 3 else: amplify_factor = 50 plt.plot(xe_plot[i, :], sc_plot[i, :], c='r') plt.plot(xe_plot[i, :], amplify_factor * e_plot[i, :] - 5.5, c='g') plt.scatter(xE, yE, c='b', marker='s') yc_min = sc_plot.flat[np.abs(xe_plot - xc_min).argmin()] plt.scatter(xc_min, yc_min, c='r', marker='^') # plot the safe region in cyan xlow, xupp = safe_region_plot(x, safe_plot) y_vertical = np.linspace(-2, 2, 100) xlow_y_vertical = xlow * np.ones(100) xupp_y_vertical = xupp * np.ones(100) plt.plot(xlow_y_vertical, y_vertical, color='cyan', linestyle='--') plt.plot(xupp_y_vertical, y_vertical, color='cyan', linestyle='--') plt.ylim(-6.5, 3.5) plt.gca().axes.get_yaxis().set_visible(False) # ================== Second plot ================= plt.subplot(2, 1, 2) y_safe_all = np.zeros(x.shape) for i in range(x.shape[0]): y_safe_all[i] = safe_eval(x[i]) plt.plot(x, y_safe_all) zero_indicator = np.zeros(x.shape) plt.plot(x, zero_indicator, c='k') x_scatter = np.hstack((xE, xc_min)) y_scatter = np.zeros(x_scatter.shape[1]) for i in range(x_scatter.shape[1]): ind = np.argmin(np.abs(x_scatter[:, i] - x)) y_scatter[i] = y_safe_all[ind] plt.scatter(x_scatter[:, :-1][0], y_scatter[:-1], c='b', marker='s') plt.scatter(x_scatter[:, -1], y_scatter[-1], c='r', marker='^') # plot the safe region xlow, xupp = safe_region_plot(x, safe_plot) low_idx = np.argmin(np.abs(xlow - x)) upp_idx = np.argmin(np.abs(xupp - x)) ylow_vertical = np.linspace(y_safe_all[low_idx], 2, 100) yupp_vertical = np.linspace(y_safe_all[upp_idx], 2, 100) xlow_y_vertical = xlow * np.ones(100) xupp_y_vertical = xupp * np.ones(100) plt.plot(xlow_y_vertical, ylow_vertical, color='cyan', linestyle='--') plt.plot(xupp_y_vertical, yupp_vertical, color='cyan', linestyle='--') plt.ylim(-1, 2.2) plt.gca().axes.get_yaxis().set_visible(False) # plt.show() current_path = os.path.dirname( os.path.abspath(inspect.getfile(inspect.currentframe()))) plot_folder = current_path[:-5] + "/plot/DDOGS/0" num_iter = xE.shape[1] - 1 + math.log(Nm / 8, 2) plt.savefig(plot_folder + '/pic' + str(int(num_iter)) + '.png', format='png', dpi=250) plt.close(fig) return
def continuous_search_1d_plot(xE, fun_eval): ''' Given evaluated points set xE, and the objective function. Plot the interpolation, uncertainty function and continuous search function. :param xE: evaluated points set xE :param fun_eval: obj function :return: ''' N = xE.shape[1] yE = np.zeros(N) for i in range(N): yE[i] = fun_eval(xE[:, i]) inter_par = interpolation.Inter_par(method='NPS') inter_par, _ = interpolation.interpolateparameterization(xE, yE, inter_par) x = np.linspace(0, 1, 1000) y, yp = np.zeros(x.shape), np.zeros(x.shape) for i in range(x.shape[0]): y[i] = fun_eval(x[i]) yp[i] = interpolation.interpolate_val(x[i], inter_par) xi = np.copy(xE) sx = sorted(range(xi.shape[1]), key=lambda x: xi[:, x]) tri = np.zeros((xi.shape[1] - 1, 2)) tri[:, 0] = sx[:xi.shape[1] - 1] tri[:, 1] = sx[1:] tri = tri.astype(np.int32) xe = np.copy(xi) xe_plot = np.zeros((tri.shape[0], 2000)) e_plot = np.zeros((tri.shape[0], 2000)) sc_plot = np.zeros((tri.shape[0], 2000)) n = xE.shape[0] K = 3 for ii in range(len(tri)): temp_x = np.copy(xi[:, tri[ii, :]]) x_ = np.linspace(temp_x[0, 0], temp_x[0, 1], 2000) temp_Sc = np.zeros(len(x_)) temp_e = np.zeros(len(x_)) p = np.zeros(len(x_)) R2, xc = Utils.circhyp(xi[:, tri[ii, :]], n) for jj in range(len(x_)): p[jj] = interpolation.interpolate_val(x_[jj], inter_par) temp_e[jj] = (R2 - np.linalg.norm(x_[jj] - xc)**2) temp_Sc[jj] = p[jj] - K * temp_e[jj] e_plot[ii, :] = temp_e xe_plot[ii, :] = x_ sc_plot[ii, :] = temp_Sc sc_min = np.min(sc_plot, axis=1) index_r = np.argmin(sc_min) index_c = np.argmin(sc_plot[index_r, :]) sc_min_x = xe_plot[index_r, index_c] sc_min = min(np.min(sc_plot, axis=1)) plt.figure() plt.plot(x, y, c='k') plt.plot(x, yp, c='b') for i in range(len(tri)): plt.plot(xe_plot[i, :], sc_plot[i, :], c='r') plt.plot(xe_plot[i, :], 3 * e_plot[i, :] - 2.3, c='g') plt.scatter(xE, yE, c='b', marker='s') plt.scatter(sc_min_x, sc_min, c='r', marker='s') plt.ylim(-2.5, 2) # plt.gca().axes.get_yaxis().set_visible(False) plt.show() return
def triangulation_search_bound_snopt(inter_par, xi, K, ind_min, y_safe, L_safe): # reddir is a vector inf = 1e+20 n = xi.shape[0] # The dimension of the reduced model. xE = inter_par.xi # 0: Build up the Delaunay triangulation based on reduced subspace. if n == 1: sx = sorted(range(xi.shape[1]), key=lambda x: xi[:, x]) tri = np.zeros((xi.shape[1] - 1, 2)) tri[:, 0] = sx[:xi.shape[1] - 1] tri[:, 1] = sx[1:] tri = tri.astype(np.int32) else: options = 'Qt Qbb Qc' if n <= 3 else 'Qt Qbb Qc Qx' tri = Delaunay(xi.T, qhull_options=options).simplices keep = np.ones(len(tri), dtype=bool) for i, t in enumerate(tri): if abs(np.linalg.det(np.hstack( (xi.T[t], np.ones([1, n + 1]).T)))) < 1E-15: keep[i] = False # Point is coplanar, we don't want to keep it tri = tri[keep] # Sc contains the continuous search function value of the center of each Delaunay simplex # 1: Identify the minimizer of adaptive K continuous search function Sc = np.zeros([np.shape(tri)[0]]) Scl = np.zeros([np.shape(tri)[0]]) for ii in range(np.shape(tri)[0]): R2, xc = Utils.circhyp(xi[:, tri[ii, :]], n) if R2 < inf: # initialize with body center of each simplex x = np.dot(xi[:, tri[ii, :]], np.ones([n + 1, 1]) / (n + 1)) exist = unevaluated_vertices_identification(xE, xi[:, tri[ii, :]]) if exist == 0: Sc[ii] = interpolation.interpolate_val( x, inter_par) - K * (R2 - np.linalg.norm(x - xc)**2) else: val, idx, x_nn = Utils.mindis(x, xE) Sc[ii] = interpolation.interpolate_val(x, inter_par) - K * val**2 # discrete min # val, idx, vertex = Utils.mindis(x, xE) # c = 0.1 # e = (val + c) ** (1/2) - c ** (1/2) # Sc[ii] = interpolation.interpolate_val(x, inter_par) - K * e if np.sum(ind_min == tri[ii, :]): Scl[ii] = np.copy(Sc[ii]) else: Scl[ii] = inf else: Scl[ii] = inf Sc[ii] = inf # Global one, the minimum of Sc has the minimum value of all circumcenters. ind = np.argmin(Sc) xm, ym = constantk_search_snopt_min(xi[:, tri[ind, :]], inter_par, K, y_safe, L_safe) # Local one ind = np.argmin(Scl) xml, yml = constantk_search_snopt_min(xi[:, tri[ind, :]], inter_par, K, y_safe, L_safe) if yml < ym: xm = np.copy(xml) ym = np.copy(yml) result = 'local' else: result = 'glob' return xm, ym, result
def constantk_search_cost_snopt(x): x = x.reshape(-1, 1) folder = folder_path() var_opt = io.loadmat(folder + "/opt_info_ck.mat") n = var_opt['n'][0, 0] xc = var_opt['xc'] R2 = var_opt['R2'][0, 0] K = var_opt['K'][0, 0] nF = var_opt['nF'][0, 0] A = var_opt['A'] L_safe = var_opt['L_safe'][0, 0] vertex = var_opt['vertex'] exist = var_opt['exist'][0, 0] # Initialize the output F and G. F = np.zeros(nF) method = var_opt['inter_par_method'][0] inter_par = interpolation.Inter_par(method=method) inter_par.w = var_opt['inter_par_w'] inter_par.v = var_opt['inter_par_v'] inter_par.xi = var_opt['inter_par_xi'] p = interpolation.interpolate_val(x, inter_par) gp = interpolation.interpolate_grad(x, inter_par) if exist == 0: e = R2 - np.linalg.norm(x - xc)**2 ge = -2 * (x - xc) else: # unevaluated boundary corner detected. e = (np.dot((x - vertex).T, x - vertex)) ge = 2 * (x - vertex) # discrete min # c = 0.1 # norm_ = np.linalg.norm(x - vertex) # norm_ = ( 1e-10 if norm_ < 1e-10 else norm_ ) # e = (norm_ + c) ** (1/2) - c ** (1/2) # ge = (1/2) * (norm_ + c) ** (-1/2) * (x - vertex) / norm_ F[0] = p - K * e # K0 = 0 because only at 1st iteration we only have 1 function evaluation. # F[1] = - L_safe * np.linalg.norm(x - vertex) norm2_difference = np.sqrt(np.dot((x - vertex).T, x - vertex)) norm2_difference = (1e-10 if norm2_difference < 1e-10 else norm2_difference) DM = gp - K * ge if n == 1: # TODO multiple safe con. # next line is the safe con F[1] = -L_safe * norm2_difference # next line is the redundant row. F[2] = np.sum(x) else: # nD data has n+1 simplex bounds. F[1:-1] = (np.dot( A, x)).T[0] # broadcast input array from (3,1) into shape (3). F[-1] = -L_safe * norm2_difference G = np.hstack( (DM.flatten(), (-L_safe * (x - vertex) / norm2_difference).flatten())) return F, G
def tringulation_search_bound(inter_par, xi, y0, K0, ind_min): inf = 1e+20 n = xi.shape[0] xm, ym = interpolation.inter_min(xi[:, ind_min], inter_par) sc_min = inf # cse=1 if ym > y0: ym = inf # cse =2 # construct Deluanay tringulation if n == 1: sx = sorted(range(xi.shape[1]), key=lambda x: xi[:, x]) tri = np.zeros((xi.shape[1] - 1, 2)) tri[:, 0] = sx[:xi.shape[1] - 1] tri[:, 1] = sx[1:] tri = tri.astype(np.int32) else: options = 'Qt Qbb Qc' if n <= 3 else 'Qt Qbb Qc Qx' tri = Delaunay(xi.T, qhull_options=options).simplices keep = np.ones(len(tri), dtype=bool) for i, t in enumerate(tri): if abs(np.linalg.det(np.hstack( (xi.T[t], np.ones([1, n + 1]).T)))) < 1E-15: keep[i] = False # Point is coplanar, we don't want to keep it tri = tri[keep] Sc = np.zeros([np.shape(tri)[0]]) Scl = np.zeros([np.shape(tri)[0]]) for ii in range(np.shape(tri)[0]): R2, xc = Utils.circhyp(xi[:, tri[ii, :]], n) # if R2 != np.inf: if R2 < inf: # initialze with body center of each simplex x = np.dot(xi[:, tri[ii, :]], np.ones([n + 1, 1]) / (n + 1)) Sc[ii] = (interpolation.interpolate_val(x, inter_par) - y0) / (R2 - np.linalg.norm(x - xc)**2) if np.sum(ind_min == tri[ii, :]): Scl[ii] = np.copy(Sc[ii]) else: Scl[ii] = inf else: Scl[ii] = inf Sc[ii] = inf # Global one if np.min(Sc) < 0: func = 'p' # The minimum of Sc is negative, minimize p(x) instead. Scp = np.zeros(tri.shape[0]) Scpl = np.zeros(tri.shape[0]) for ii in range(tri.shape[0]): x = np.dot(xi[:, tri[ii, :]], np.ones([n + 1, 1]) / (n + 1)) Scp[ii] = interpolation.interpolate_val(x, inter_par) if np.sum(ind_min == tri[ii, :]): Scpl[ii] = np.copy(Scp[ii]) else: Scpl[ii] = inf else: Scpl[ii] = inf Scp[ii] = inf # Globally minimize p(x) ind = np.argmin(Scp) x = np.dot(xi[:, tri[ind, :]], np.ones([n + 1, 1]) / (n + 1)) simplex_bnds = Utils.search_bounds(xi[:, tri[ind, :]]) xm, ym = AdaptiveK_Search_p(x, inter_par, simplex_bnds) # Locally minimize p(x) ind = np.argmin(Scpl) x = np.dot(xi[:, tri[ind, :]], np.ones([n + 1, 1]) / (n + 1)) simplex_bnds = Utils.search_bounds(xi[:, tri[ind, :]]) xml, yml = AdaptiveK_Search_p(x, inter_par, simplex_bnds) else: func = 'sc' # Minimize sc(x). # Global one, the minimum of Sc has the minimum value of all circumcenters. ind = np.argmin(Sc) R2, xc = Utils.circhyp(xi[:, tri[ind, :]], n) x = np.dot(xi[:, tri[ind, :]], np.ones([n + 1, 1]) / (n + 1)) simplex_bnds = Utils.search_bounds(xi[:, tri[ind, :]]) xm, ym = Adaptive_K_Search(x, inter_par, xc, R2, y0, K0, simplex_bnds) # Local one ind = np.argmin(Scl) R2, xc = Utils.circhyp(xi[:, tri[ind, :]], n) x = np.dot(xi[:, tri[ind, :]], np.ones([n + 1, 1]) / (n + 1)) simplex_bnds = Utils.search_bounds(xi[:, tri[ind, :]]) xml, yml = Adaptive_K_Search(x, inter_par, xc, R2, y0, K0, simplex_bnds) if yml < ym: xm = np.copy(xml) ym = np.copy(yml) result = 'local' else: result = 'glob' xm = xm.reshape(-1, 1) ym = ym[0, 0] return xm, ym, result, func
def triangulation_search_bound_snopt(inter_par, xi, y0, ind_min, y_safe, L_safe): # reddir is a vector inf = 1e+20 n = xi.shape[0] # The dimension of the reduced model. # 0: Build up the Delaunay triangulation based on reduced subspace. if n == 1: sx = sorted(range(xi.shape[1]), key=lambda x: xi[:, x]) tri = np.zeros((xi.shape[1] - 1, 2)) tri[:, 0] = sx[:xi.shape[1] - 1] tri[:, 1] = sx[1:] tri = tri.astype(np.int32) else: options = 'Qt Qbb Qc' if n <= 3 else 'Qt Qbb Qc Qx' tri = Delaunay(xi.T, qhull_options=options).simplices keep = np.ones(len(tri), dtype=bool) for i, t in enumerate(tri): if abs(np.linalg.det(np.hstack( (xi.T[t], np.ones([1, n + 1]).T)))) < 1E-15: keep[i] = False # Point is coplanar, we don't want to keep it tri = tri[keep] # Sc contains the continuous search function value of the center of each Delaunay simplex # 1: Identify the minimizer of adaptive K continuous search function Sc = np.zeros([np.shape(tri)[0]]) Scl = np.zeros([np.shape(tri)[0]]) for ii in range(np.shape(tri)[0]): R2, xc = Utils.circhyp(xi[:, tri[ii, :]], n) if R2 < inf: # initialize with body center of each simplex x = np.dot(xi[:, tri[ii, :]], np.ones([n + 1, 1]) / (n + 1)) Sc[ii] = (interpolation.interpolate_val(x, inter_par) - y0) / (R2 - np.linalg.norm(x - xc)**2) if np.sum(ind_min == tri[ii, :]): Scl[ii] = np.copy(Sc[ii]) else: Scl[ii] = inf else: Scl[ii] = inf Sc[ii] = inf if np.min(Sc) < 0: func = 'p' # The minimum of Sc is negative, minimize p(x) instead. Scp = np.zeros(tri.shape[0]) for ii in range(tri.shape[0]): x = np.dot(xi[:, tri[ii, :]], np.ones([n + 1, 1]) / (n + 1)) Scp[ii] = interpolation.interpolate_val(x, inter_par) # Globally minimize p(x) ind = np.argmin(Scp) x = np.dot(xi[:, tri[ind, :]], np.ones([n + 1, 1]) / (n + 1)) xm, ym = adaptiveK_p_snopt_min(x, inter_par, y_safe, L_safe) result = 'glob' else: func = 'sc' # Global one, the minimum of Sc has the minimum value of all circumcenters. ind = np.argmin(Sc) R2, xc = Utils.circhyp(xi[:, tri[ind, :]], n) # x is the center of this simplex x = np.dot(xi[:, tri[ind, :]], np.ones([n + 1, 1]) / (n + 1)) # First find minimizer xr on reduced model, then find the 2D point corresponding to xr. Constrained optm. A_simplex, b_simplex = Utils.search_simplex_bounds(xi[:, tri[ind, :]]) lb_simplex = np.min(xi[:, tri[ind, :]], axis=1) ub_simplex = np.max(xi[:, tri[ind, :]], axis=1) xm, ym = adaptiveK_search_snopt_min(x, inter_par, xc, R2, y0, K0, A_simplex, b_simplex, lb_simplex, ub_simplex, y_safe, L_safe) # Local one ind = np.argmin(Scl) R2, xc = Utils.circhyp(xi[:, tri[ind, :]], n) x = np.dot(xi[:, tri[ind, :]], np.ones([n + 1, 1]) / (n + 1)) A_simplex, b_simplex = Utils.search_simplex_bounds(xi[:, tri[ind, :]]) lb_simplex = np.min(xi[:, tri[ind, :]], axis=1) ub_simplex = np.max(xi[:, tri[ind, :]], axis=1) xml, yml = adaptiveK_search_snopt_min(x, inter_par, xc, R2, y0, K0, A_simplex, b_simplex, lb_simplex, ub_simplex, y_safe, L_safe) if yml < ym: xm = np.copy(xml) ym = np.copy(yml) result = 'local' else: result = 'glob' return xm, ym, result, func
num_iter += 1 K0 = np.ptp(yE, axis=0) # scale the domain [inter_par, yp ] = interpolation.interpolateparameterization(xE, yE, inter_par) ypmin = np.amin(yp) ind_min = np.argmin(yp) # Calcuate the unevaluated function: yu = np.zeros([1, xU.shape[1]]) if xU.shape[1] != 0: for ii in range(xU.shape[1]): yu[0, ii] = ( interpolation.interpolate_val(xU[:, ii], inter_par) - y0) / Utils.mindis(xU[:, ii], xE)[0] else: yu = np.array([[]]) xi, ind_min = cartesian_grid.add_sup(xE, xU, ind_min) xc, yc, result, func = adaptiveK_snopt_safelearning.triangulation_search_bound_snopt( inter_par, xi, y0, ind_min, y_safe, L_safe) xc_grid = np.round(xc * Nm) / Nm success = Utils.safe_eval_estimate(xE, y_safe, L_safe, xc_grid) xc_eval = (np.copy(xc_grid) if success == 1 else np.copy(xc)) # Dogsplot_sl.safe_continuous_constantK_search_1d_plot(xE, xU, func_eval, safe_eval, L_safe, K, xc_eval, Nm) # The following block represents inactivate step: Shahrouz phd thesis P148. if Utils.mindis(
for kk in range(MeshSize): for k in range(iter_max): num_iter += 1 [inter_par, yp ] = interpolation.interpolateparameterization(xE, yE, inter_par) ypmin = np.amin(yp) ind_min = np.argmin(yp) # Calcuate the unevaluated function: yu = np.zeros([1, xU.shape[1]]) if xU.shape[1] != 0: for ii in range(xU.shape[1]): yu[0, ii] = interpolation.interpolate_val( xU[:, ii], inter_par) - K * Utils.mindis(xU[:, ii], xE)[0] else: yu = np.array([[]]) xi, ind_min = cartesian_grid.add_sup(xE, xU, ind_min) xc, yc, result = constantK_snopt_safelearning.triangulation_search_bound_snopt( inter_par, xi, K, ind_min, y_safe, L_safe) xc_grid = np.round(xc * Nm) / Nm success = Utils.safe_eval_estimate(xE, y_safe, L_safe, xc_grid) xc_eval = (np.copy(xc_grid) if success == 1 else np.copy(xc)) Dogsplot_sl.safe_continuous_constantK_search_1d_plot( xE, xU, func_eval, safe_eval, L_safe, K, xc_eval, Nm) if Utils.mindis(