def test_branin_2D_mixed(self): n_iter = 20 fun = Branin(ndim=2) xtypes = [INT, FLOAT] xlimits = fun.xlimits criterion = "EI" #'EI' or 'SBO' or 'UCB' xdoe = FullFactorial(xlimits=xlimits)(10) s = KRG(print_global=False) ego = EGO( xdoe=xdoe, n_iter=n_iter, criterion=criterion, xtypes=xtypes, xlimits=xlimits, surrogate=s, ) x_opt, y_opt, _, _, _ = ego.optimize(fun=fun) # 3 optimal points possible: [-pi, 12.275], [pi, 2.275], [9.42478, 2.475] self.assertTrue( np.allclose([[-3, 12.275]], x_opt, rtol=0.2) or np.allclose([[3, 2.275]], x_opt, rtol=0.2) or np.allclose([[9, 2.475]], x_opt, rtol=0.2)) self.assertAlmostEqual(0.494, float(y_opt), delta=1)
def test_mfk(self): self.problems = ["exp", "tanh", "cos"] for fname in self.problems: prob = TensorProduct(ndim=self.ndim, func=fname) sampling = FullFactorial(xlimits=prob.xlimits, clip=True) np.random.seed(0) xt = sampling(self.nt) yt = prob(xt) for i in range(self.ndim): yt = np.concatenate((yt, prob(xt, kx=i)), axis=1) y_lf = 2 * prob(xt) + 2 x_lf = deepcopy(xt) np.random.seed(1) xe = sampling(self.ne) ye = prob(xe) sm = MFK(theta0=[1e-2] * self.ndim) if sm.options.is_declared("xlimits"): sm.options["xlimits"] = prob.xlimits sm.options["print_global"] = False sm.set_training_values(xt, yt[:, 0]) sm.set_training_values(x_lf, y_lf[:, 0], name=0) with Silence(): sm.train() t_error = compute_rms_error(sm) e_error = compute_rms_error(sm, xe, ye) self.assert_error(t_error, 0.0, 1) self.assert_error(e_error, 0.0, 1)
def test_ff_rectify(self): xlimits = np.array([[0.0, 4.0], [0.0, 3.0]]) sampling = FullFactorial(xlimits=xlimits, clip=True) num = 50 x = sampling(num) self.assertEqual((56, 2), x.shape)
def test_branin_2D_parallel(self): n_iter = 10 fun = Branin(ndim=2) n_parallel = 5 xlimits = fun.xlimits criterion = "EI" #'EI' or 'SBO' or 'UCB' xdoe = FullFactorial(xlimits=xlimits)(10) ego = EGO( xdoe=xdoe, n_iter=n_iter, criterion=criterion, xlimits=xlimits, n_parallel=n_parallel, ) x_opt, y_opt, _, _, _ = ego.optimize(fun=fun) # 3 optimal points possible: [-pi, 12.275], [pi, 2.275], [9.42478, 2.475] print(x_opt) self.assertTrue( np.allclose([[-3.14, 12.275]], x_opt, rtol=0.5) or np.allclose([[3.14, 2.275]], x_opt, rtol=0.5) or np.allclose([[9.42, 2.475]], x_opt, rtol=0.5)) print("Branin=", x_opt) self.assertAlmostEqual(0.39, float(y_opt), delta=1)
def run_moe_example_1d(): import numpy as np from smt.applications import MOE from smt.sampling_methods import FullFactorial import matplotlib.pyplot as plt ndim = 1 nt = 35 def function_test_1d(x): import numpy as np # Note: only required by SMT doc testing toolchain x = np.reshape(x, (-1,)) y = np.zeros(x.shape) y[x < 0.4] = x[x < 0.4] ** 2 y[(x >= 0.4) & (x < 0.8)] = 3 * x[(x >= 0.4) & (x < 0.8)] + 1 y[x >= 0.8] = np.sin(10 * x[x >= 0.8]) return y.reshape((-1, 1)) x = np.linspace(0, 1, 100) ytrue = function_test_1d(x) # Training data sampling = FullFactorial(xlimits=np.array([[0, 1]]), clip=True) np.random.seed(0) xt = sampling(nt) yt = function_test_1d(xt) # Mixture of experts print("MOE Experts: ", MOE.AVAILABLE_EXPERTS) # MOE1: Find the best surrogate model on the whole domain moe1 = MOE(n_clusters=1) print("MOE1 enabled experts: ", moe1.enabled_experts) moe1.set_training_values(xt, yt) moe1.train() y_moe1 = moe1.predict_values(x) # MOE2: Set nb of cluster with just KRG, LS and IDW surrogate models moe2 = MOE(smooth_recombination=False, n_clusters=3, allow=["KRG", "LS", "IDW"]) print("MOE2 enabled experts: ", moe2.enabled_experts) moe2.set_training_values(xt, yt) moe2.train() y_moe2 = moe2.predict_values(x) fig, axs = plt.subplots(1) axs.plot(x, ytrue, ".", color="black") axs.plot(x, y_moe1) axs.plot(x, y_moe2) axs.set_xlabel("x") axs.set_ylabel("y") axs.legend(["Training data", "MOE 1 Prediction", "MOE 2 Prediction"]) plt.show()
def test_rosenbrock_2D(self): n_iter = 30 fun = Rosenbrock(ndim=2) xlimits = fun.xlimits criterion = "UCB" #'EI' or 'SBO' or 'UCB' xdoe = FullFactorial(xlimits=xlimits)(10) ego = EGO(xdoe=xdoe, n_iter=n_iter, criterion=criterion, xlimits=xlimits) x_opt, y_opt, _, _, _, _, _ = ego.optimize(fun=fun) self.assertTrue(np.allclose([[1, 1]], x_opt, rtol=0.5)) self.assertAlmostEqual(0.0, float(y_opt), delta=1)
def run_test(self): method_name = inspect.stack()[1][3] pname = method_name.split("_")[1] sname = method_name.split("_")[2] prob = self.problems[pname] sampling = FullFactorial(xlimits=prob.xlimits, clip=True) np.random.seed(0) xt = sampling(self.nt) yt = prob(xt) print(prob(xt, kx=0).shape) for i in range(self.ndim): yt = np.concatenate((yt, prob(xt, kx=i)), axis=1) np.random.seed(1) xe = sampling(self.ne) ye = prob(xe) sm0 = self.sms[sname] sm = sm0.__class__() sm.options = sm0.options.clone() if sm.options.is_declared("xlimits"): sm.options["xlimits"] = prob.xlimits sm.options["print_global"] = False if sname in ["KPLS", "KRG", "KPLSK", "GEKPLS"]: optname = method_name.split("_")[3] sm.options["hyper_opt"] = optname sm.set_training_values(xt, yt[:, 0]) if sm.supports["training_derivatives"]: for i in range(self.ndim): sm.set_training_derivatives(xt, yt[:, i + 1], i) with Silence(): sm.train() t_error = compute_rms_error(sm) e_error = compute_rms_error(sm, xe, ye) if sm.supports["variances"]: sm.predict_variances(xe) if pname == "cos": self.assertLessEqual(e_error, self.e_errors[sname] + 1.5) else: self.assertLessEqual(e_error, self.e_errors[sname] + 1e-4) self.assertLessEqual(t_error, self.t_errors[sname] + 1e-4)
def run_test(self): method_name = inspect.stack()[1][3] sname = method_name.split("_")[1] prob = self.problem sampling = FullFactorial(xlimits=prob.xlimits, clip=False) np.random.seed(0) xt = sampling(self.nt) yt = prob(xt) # dyt = {} # for kx in range(prob.xlimits.shape[0]): # dyt[kx] = prob(xt, kx=kx) np.random.seed(1) xe = sampling(self.ne) ye = prob(xe) sm0 = self.sms[sname] sm = sm0.__class__() sm.options = sm0.options.clone() if sm.options.is_declared("xlimits"): sm.options["xlimits"] = prob.xlimits sm.options["print_global"] = False sm.set_training_values(xt, yt) sm.update_training_values(yt) with Silence(): sm.train() ye0 = sm.predict_values(xe) h = 1e-3 jac_fd = np.zeros((self.ne, self.nt)) for ind in range(self.nt): sm.update_training_values(yt + h * np.eye(self.nt, M=1, k=-ind)) with Silence(): sm.train() ye = sm.predict_values(xe) jac_fd[:, ind] = (ye - ye0)[:, 0] / h jac_fd = jac_fd.reshape((self.ne, self.nt, 1)) jac_an = sm.predict_output_derivatives(xe)[None] if print_output: print(np.linalg.norm(jac_fd - jac_an)) self.assert_error(jac_fd, jac_an, rtol=5e-2)
def test_find_best_point(self): fun = TestEGO.function_test_1d xlimits = np.array([[0.0, 25.0]]) xdoe = FullFactorial(xlimits=xlimits)(3) ydoe = fun(xdoe) ego = EGO(xdoe=xdoe, ydoe=ydoe, n_iter=1, criterion="UCB", xlimits=xlimits, n_start=30) _, _, _, _, _ = ego.optimize(fun=fun) x, _ = ego._find_best_point(xdoe, ydoe) self.assertAlmostEqual(6.5, float(x), delta=1)
def test_ydoe_option(self): n_iter = 10 fun = Branin(ndim=2) xlimits = fun.xlimits criterion = "UCB" #'EI' or 'SBO' or 'UCB' xdoe = FullFactorial(xlimits=xlimits)(10) ydoe = fun(xdoe) ego = EGO( xdoe=xdoe, ydoe=ydoe, n_iter=n_iter, criterion=criterion, xlimits=xlimits ) _, y_opt, _, _, _, _, y_doe = ego.optimize(fun=fun) self.assertAlmostEqual(0.39, float(y_opt), delta=1)
def test_rosenbrock_2D(self): n_iter = 40 fun = Rosenbrock(ndim=2) xlimits = fun.xlimits criterion = "UCB" #'EI' or 'SBO' or 'UCB' xdoe = FullFactorial(xlimits=xlimits)(10) ego = EGO( xdoe=xdoe, n_iter=n_iter, criterion=criterion, xlimits=xlimits, random_state=0, # change seed as it fails on travis macos py3.7 ) x_opt, y_opt, _, _, _ = ego.optimize(fun=fun) self.assertTrue(np.allclose([[1, 1]], x_opt, rtol=0.5)) self.assertAlmostEqual(0.0, float(y_opt), delta=1)
def test_full_factorial(self): import numpy as np import matplotlib.pyplot as plt from smt.sampling_methods import FullFactorial xlimits = np.array([[0.0, 4.0], [0.0, 3.0]]) sampling = FullFactorial(xlimits=xlimits) num = 50 x = sampling(num) print(x.shape) plt.plot(x[:, 0], x[:, 1], "o") plt.xlabel("x") plt.ylabel("y") plt.show()
def test_branin_2d_200(self): self.ndim = 2 self.nt = 200 self.ne = 200 prob = Branin(ndim=self.ndim) # training data sampling = FullFactorial(xlimits=prob.xlimits, clip=True) np.random.seed(0) xt = sampling(self.nt) yt = prob(xt) # mixture of experts moe = MOE(n_clusters=5) moe.set_training_values(xt, yt) moe.options["heaviside_optimization"] = True moe.train() # validation data np.random.seed(1) xe = sampling(self.ne) ye = prob(xe) rms_error = compute_rms_error(moe, xe, ye) self.assert_error(rms_error, 0.0, 1e-1) if TestMOE.plot: import matplotlib.pyplot as plt from mpl_toolkits.mplot3d import Axes3D y = moe.analyse_results(x=xe, operation="predict_values") plt.figure(1) plt.plot(ye, ye, "-.") plt.plot(ye, y, ".") plt.xlabel(r"$y$ actual") plt.ylabel(r"$y$ prediction") fig = plt.figure(2) ax = fig.add_subplot(111, projection="3d") ax.scatter(xt[:, 0], xt[:, 1], yt) plt.title("Branin function") plt.show()
def test_norm1_2d_200(self): self.ndim = 2 self.nt = 200 self.ne = 200 prob = LpNorm(ndim=self.ndim) # training data sampling = FullFactorial(xlimits=prob.xlimits, clip=True) np.random.seed(0) xt = sampling(self.nt) yt = prob(xt) # mixture of experts moe = MOE(smooth_recombination=False, n_clusters=5) moe.set_training_values(xt, yt) moe.train() # validation data np.random.seed(1) xe = sampling(self.ne) ye = prob(xe) rms_error = compute_rms_error(moe, xe, ye) self.assert_error(rms_error, 0., 1e-1) if TestMOE.plot: import matplotlib.pyplot as plt from mpl_toolkits.mplot3d import Axes3D y = moe.predict_values(xe) plt.figure(1) plt.plot(ye, ye, '-.') plt.plot(ye, y, '.') plt.xlabel(r'$y$ actual') plt.ylabel(r'$y$ prediction') fig = plt.figure(2) ax = fig.add_subplot(111, projection='3d') ax.scatter(xt[:, 0], xt[:, 1], yt) plt.title('L1 Norm') plt.show()
def test_qei_criterion_default(self): fun = TestEGO.function_test_1d xlimits = np.array([[0.0, 25.0]]) xdoe = FullFactorial(xlimits=xlimits)(3) ydoe = fun(xdoe) ego = EGO(xdoe=xdoe, ydoe=ydoe, n_iter=1, criterion="SBO", xlimits=xlimits, n_start=30) ego._setup_optimizer(fun) ego.gpr.set_training_values(xdoe, ydoe) ego.gpr.train() xtest = np.array([[10.0]]) # test that default virtual point should be equal to 3sigma lower bound kriging interval expected = float( ego.gpr.predict_values(xtest) - 3 * np.sqrt(ego.gpr.predict_variances(xtest))) actual = float(ego._get_virtual_point(xtest, fun(xtest))[0]) self.assertAlmostEqual(expected, actual)
def test_branin_2d_200(self): self.ndim = 2 self.nt = 200 self.ne = 200 prob = Branin(ndim=self.ndim) # training data sampling = FullFactorial(xlimits=prob.xlimits, clip=True) np.random.seed(0) xt = sampling(self.nt) yt = prob(xt) # mixture of experts moe = MOE(n_clusters=5) moe.set_training_values(xt, yt) moe.options['heaviside_optimization'] = True moe.train() # validation data np.random.seed(1) xe = sampling(self.ne) ye = prob(xe) rms_error = compute_rms_error(moe, xe, ye) self.assert_error(rms_error, 0., 1e-1) if TestMOE.plot: y = moe.analyse_results(x=xe, operation='predict_values') plt.figure(1) plt.plot(ye, ye, '-.') plt.plot(ye, y, '.') plt.xlabel(r'$y$ actual') plt.ylabel(r'$y$ prediction') fig = plt.figure(2) ax = fig.add_subplot(111, projection='3d') ax.scatter(xt[:, 0], xt[:, 1], yt) plt.title('Branin function') plt.show()
def run_MF_test(self): method_name = inspect.stack()[1][3] pname = method_name.split("_")[1] sname = method_name.split("_")[2] prob = self.problems[pname] sampling = FullFactorial(xlimits=prob.xlimits, clip=True) np.random.seed(0) xt = sampling(self.nt) yt = prob(xt) print(prob(xt, kx=0).shape) for i in range(self.ndim): yt = np.concatenate((yt, prob(xt, kx=i)), axis=1) y_lf = 2 * prob(xt) + 2 x_lf = deepcopy(xt) np.random.seed(1) xe = sampling(self.ne) ye = prob(xe) sm0 = self.sms[sname] sm = sm0.__class__() sm.options = sm0.options.clone() if sm.options.is_declared("xlimits"): sm.options["xlimits"] = prob.xlimits sm.options["print_global"] = False sm.set_training_values(xt, yt[:, 0]) sm.set_training_values(x_lf, y_lf[:, 0], name=0) if sm.supports["training_derivatives"]: for i in range(self.ndim): sm.set_training_derivatives(xt, yt[:, i + 1], i) with Silence(): sm.train() t_error = compute_rms_error(sm) e_error = compute_rms_error(sm, xe, ye)
def test_branin_2D(self): n_iter = 20 fun = Branin(ndim=2) xlimits = fun.xlimits criterion = "LCB" #'EI' or 'SBO' or 'LCB' xdoe = FullFactorial(xlimits=xlimits)(10) ego = EGO( xdoe=xdoe, n_iter=n_iter, criterion=criterion, xlimits=xlimits, random_state=42, ) x_opt, y_opt, _, _, _ = ego.optimize(fun=fun) # 3 optimal points possible: [-pi, 12.275], [pi, 2.275], [9.42478, 2.475] self.assertTrue( np.allclose([[-3.14, 12.275]], x_opt, rtol=0.2) or np.allclose([[3.14, 2.275]], x_opt, rtol=0.2) or np.allclose([[9.42, 2.475]], x_opt, rtol=0.2)) self.assertAlmostEqual(0.39, float(y_opt), delta=1)
def compute_grid(self, isp_lim, twr_lim, nb_samp, samp_method='full', criterion='m'): """Compute the sampling grid fro given `Isp` and `twr` limits and sampling scheme. Parameters ---------- isp_lim : iterable Specific impulse lower and upper bounds [s] twr_lim : iterable Thrust/weight ratio lower and upper bounds [-] nb_samp : int Total number of samples. Must be a perfect square if ``full`` is chosen as `samp_method` samp_method : str, optional Sampling scheme, ``lhs`` for Latin Hypercube Sampling or ``full`` for Full-Factorial Sampling. Default is ``full`` criterion : str, optional Criterion used to construct the LHS design among ``center``, ``maximin``, ``centermaximin``, ``correlation``, ``c``, ``m``, ``cm``, ``corr``, ``ese``. ``c``, ``m``, ``cm`` and ``corr`` are abbreviations of ``center``, ``maximin``, ``centermaximin`` and ``correlation``, ``respectively`` Default is ``m`` """ self.limits = np.vstack((np.asarray(isp_lim), np.asarray(twr_lim))) if samp_method == 'lhs': samp = LHS(xlimits=self.limits, criterion=criterion) elif samp_method == 'full': samp = FullFactorial(xlimits=self.limits) else: raise ValueError('samp_method must be either lhs or full') self.x_samp = samp(nb_samp) self.m_prop = np.zeros((nb_samp, 1)) self.failures = np.zeros((nb_samp, 1))
def test_derivatives(self): # Construction of the DOE ndim = 4 fun = Sphere(ndim=ndim) sampling = FullFactorial(xlimits=fun.xlimits) xt = sampling(100) yt = fun(xt) # Compute the training derivatives for i in range(ndim): yd = fun(xt, kx=i) yt = np.concatenate((yt, yd), axis=1) # check KRG models sm_krg_c = KRG(poly="constant", print_global=False) sm_krg_c.set_training_values(xt, yt[:, 0]) sm_krg_c.train() TestKRG._check_derivatives(sm_krg_c, xt, yt, ndim) sm_krg_l = KRG(poly="linear", print_global=False) sm_krg_l.set_training_values(xt, yt[:, 0]) sm_krg_l.train() TestKRG._check_derivatives(sm_krg_l, xt, yt, ndim)
def test_rosenbrock_2D_parallel(self): n_iter = 15 n_parallel = 5 fun = Rosenbrock(ndim=2) xlimits = fun.xlimits criterion = "UCB" #'EI' or 'SBO' or 'UCB' xdoe = FullFactorial(xlimits=xlimits)(10) qEI = "KB" ego = EGO( xdoe=xdoe, n_iter=n_iter, criterion=criterion, xlimits=xlimits, n_parallel=n_parallel, qEI=qEI, evaluator=ParallelEvaluator(), ) x_opt, y_opt, _, _, _ = ego.optimize(fun=fun) print("Rosenbrock: ", x_opt) self.assertTrue(np.allclose([[1, 1]], x_opt, rtol=0.5)) self.assertAlmostEqual(0.0, float(y_opt), delta=1)
def compute_matrix(self, nb_eval=None): """Compute structured matrices for `Isp`, `twr` and `m_prop` to display the training data on a response surface. Parameters ---------- nb_eval : int or ``None`` Number of points included in the matrix if Latin Hypercube Sampling has been used or ``None``. Default is ``None`` Returns ------- isp : ndarray Matrix of specific impulses [s] twr : ndarray Matrix of thrust/weight ratios [-] m_mat : ndarray Matrix of propellant fractions [-] """ if nb_eval is not None: # LHS samp_eval = FullFactorial(xlimits=self.limits) x_eval = samp_eval(nb_eval) m_prop_eval = self.trained.predict_values(x_eval) else: # Full-Factorial nb_eval = np.size(self.m_prop) x_eval = deepcopy(self.x_samp) m_prop_eval = deepcopy(self.m_prop) isp = np.unique(x_eval[:, 0]) twr = np.unique(x_eval[:, 1]) n = int(np.sqrt(nb_eval)) m_mat = np.reshape(m_prop_eval, (n, n)) return isp, twr, m_mat
def test_ff_weights(self): xlimits = np.array([[0.0, 1.0], [0.0, 1.0]]) sampling = FullFactorial(xlimits=xlimits, weights=[0.25, 0.75]) num = 10 x = sampling(num) self.assertEqual((10, 2), x.shape)
def run_test(self): method_name = inspect.stack()[1][3] pname = method_name.split("_")[1] sname = method_name.split("_")[2] prob = self.problems[pname] sampling = FullFactorial(xlimits=prob.xlimits, clip=True) np.random.seed(0) xt = sampling(self.nt) yt = prob(xt) dyt = {} for kx in range(prob.xlimits.shape[0]): dyt[kx] = prob(xt, kx=kx) np.random.seed(1) xe = sampling(self.ne) ye = prob(xe) dye = {} for kx in range(prob.xlimits.shape[0]): dye[kx] = prob(xe, kx=kx) sm0 = self.sms[sname] sm = sm0.__class__() sm.options = sm0.options.clone() if sm.options.is_declared("xlimits"): sm.options["xlimits"] = prob.xlimits sm.options["print_global"] = False sm.set_training_values(xt, yt) with Silence(): sm.train() t_error = compute_rms_error(sm) e_error = compute_rms_error(sm, xe, ye) sm = sm0.__class__() sm.options = sm0.options.clone() if sm.options.is_declared("xlimits"): sm.options["xlimits"] = prob.xlimits sm.options["print_global"] = False sm.set_training_values(xt, yt) for kx in range(prob.xlimits.shape[0]): sm.set_training_derivatives(xt, dyt[kx], kx) with Silence(): sm.train() ge_t_error = compute_rms_error(sm) ge_e_error = compute_rms_error(sm, xe, ye) if print_output: print("%8s %6s %18.9e %18.9e %18.9e %18.9e" % (pname[:6], sname, t_error, e_error, ge_t_error, ge_e_error)) self.assert_error(t_error, 0.0, self.t_errors[sname]) self.assert_error(e_error, 0.0, self.e_errors[sname]) self.assert_error(ge_t_error, 0.0, self.ge_t_errors[sname]) self.assert_error(ge_e_error, 0.0, self.ge_e_errors[sname])
""" Created on Fri Sep 25 22:23:03 2020 Programa creado para el Aspecto 2 del Proyecto Final de IA - Doctorado @author: Marco Ortiz """ #Importamos los módulos que utilizaremos import numpy as np import matplotlib.pyplot as plt import time from smt.sampling_methods import FullFactorial #Tomamos el tiempo al inicio de la ejecución t0 = time.clock() #Definimos un vector (poblacion inicial) para realizar el sampling xlimits = np.array([[0.0, 4.0], [0.0, 3.0]]) sampling = FullFactorial(xlimits=xlimits) num = 50 x = sampling(num) #Tomamos el tiempo al finalizar la ejecución del algoritmo t1 = time.clock() print("El vector de salida tiene forma:", x.shape) #Imprimimos los puntos seleccionados por el sampling plt.plot(x[:, 0], x[:, 1], "o") plt.xlabel("x") plt.ylabel("y") plt.show() print("El tiempo de ejecución del programa fue:", t1 - t0) print("Si se realizan 30K iteraciones:", 30000 * (t1 - t0))
def run_moe_example(): import numpy as np from smt.applications import MOE from smt.problems import LpNorm from smt.sampling_methods import FullFactorial import sklearn import matplotlib.pyplot as plt from matplotlib import colors from mpl_toolkits.mplot3d import Axes3D ndim = 2 nt = 200 ne = 200 # Problem: L1 norm (dimension 2) prob = LpNorm(ndim=ndim) # Training data sampling = FullFactorial(xlimits=prob.xlimits, clip=True) np.random.seed(0) xt = sampling(nt) yt = prob(xt) # Mixture of experts moe = MOE(smooth_recombination=True, n_clusters=5) moe.set_training_values(xt, yt) moe.train() # Validation data np.random.seed(1) xe = sampling(ne) ye = prob(xe) # Prediction y = moe.predict_values(xe) fig = plt.figure(1) fig.set_size_inches(12, 11) # Cluster display colors_ = list(colors.cnames.items()) GMM = moe.cluster weight = GMM.weights_ mean = GMM.means_ if sklearn.__version__ < "0.20.0": cov = GMM.covars_ else: cov = GMM.covariances_ prob_ = moe._proba_cluster(xt) sort = np.apply_along_axis(np.argmax, 1, prob_) xlim = prob.xlimits x0 = np.linspace(xlim[0, 0], xlim[0, 1], 20) x1 = np.linspace(xlim[1, 0], xlim[1, 1], 20) xv, yv = np.meshgrid(x0, x1) x = np.array(list(zip(xv.reshape((-1,)), yv.reshape((-1,))))) prob = moe._proba_cluster(x) plt.subplot(221, projection="3d") ax = plt.gca() for i in range(len(sort)): color = colors_[int(((len(colors_) - 1) / sort.max()) * sort[i])][0] ax.scatter(xt[i][0], xt[i][1], yt[i], c=color) plt.title("Clustered Samples") plt.subplot(222, projection="3d") ax = plt.gca() for i in range(len(weight)): color = colors_[int(((len(colors_) - 1) / len(weight)) * i)][0] ax.plot_trisurf( x[:, 0], x[:, 1], prob[:, i], alpha=0.4, linewidth=0, color=color ) plt.title("Membership Probabilities") plt.subplot(223) for i in range(len(weight)): color = colors_[int(((len(colors_) - 1) / len(weight)) * i)][0] plt.tricontour(x[:, 0], x[:, 1], prob[:, i], 1, colors=color, linewidths=3) plt.title("Cluster Map") plt.subplot(224) plt.plot(ye, ye, "-.") plt.plot(ye, y, ".") plt.xlabel("actual") plt.ylabel("prediction") plt.title("Predicted vs Actual") plt.show()