def obtenerTratamientos(niveles): num_factores = len(niveles) niveles_factor = {} for k in niveles: niveles_factor[k] = len(niveles[k]) tratamientos = fullfact(niveles_factor.values()) return tratamientos
def FactorialGenerator(levels, VarRanges): sampling = pyDOE.fullfact( levels) #for each variable you input the level you want Designs = np.zeros([len(sampling), len(levels)]) for i in range(0, len(levels)): Designs[:, i] = VarRanges[i, 0] + sampling[:, i] * (VarRanges[i, 1] - VarRanges[i, 0]) return Designs
def two_effect_data(e1=2, e2=2, n=3, **kwargs): x = np.linspace(-1, 1)[:, None] # y = np.zeros((50,(e1+e2)*n)) effect = np.array(pyDOE.fullfact([e1, e2]).tolist() * n).astype(int) y = np.zeros((50, effect.shape[0])) m = gpfanova.fanova.FANOVA(x, y, effect, **kwargs) y, f_samples = m.samplePrior() return x, y, effect, f_samples
def generate(conf): """Generate base design by calling pyDOE""" # build list containing number levels for each factor (argument to pyDOE) levels = list() for factor in conf["factors"].keys(): levels.append(len(conf["factors"][factor])) # call pyDOE method corresponding to conf["design"] if conf["design"] == "fullfact": base = pyDOE.fullfact(levels) return base
def two_effect_data(e1=2,e2=2,n=3,**kwargs): x = np.linspace(-1,1)[:,None] # y = np.zeros((50,(e1+e2)*n)) effect = np.array(pyDOE.fullfact([e1,e2]).tolist()*n).astype(int) y = np.zeros((50,effect.shape[0])) m = gpfanova.fanova.FANOVA(x,y,effect,**kwargs) y,f_samples = m.samplePrior() return x,y,effect,f_samples
def init(self): num_levels = [] dvar = self.param_variation_model.design_variables for attr_name, variability in dvar.items(): if not isinstance( variability, (memosampler.NumericalLevels, memosampler.NonNumericalLevels)): raise ValueError('FullFactorial can only handle ' '"NumericalLevels" or "NonNumericalLevels" ' 'types of variability') num_levels.append(len(variability.levels)) self.design = doe.fullfact(num_levels)
def multiple_effects(effects=[2,2],m=3,n=50,fullFactorial=True,seed=False,**kwargs): x = np.linspace(-1,1,n)[:,None] # y = np.zeros((50,(e1+e2)*n)) if seed: np.random.seed(123) if fullFactorial: effect = np.array(pyDOE.fullfact(effects).tolist()*m).astype(int) else: effect = np.array([[np.random.choice(range(e)) for e in effects] for i in range(m)]) y = np.zeros((n,effect.shape[0])) m = gpfanova.fanova.FANOVA(x,y,effect,**kwargs) y,f_samples = m.samplePrior() return x,y,effect,f_samples
def fullfact(self,name=None,levels=[]): try: import pyDOE except ImportError as exc: sys.stderr.write("Warning: failed to import pyDOE module. ({})".format(exc)) return if len(levels) == 0: levels = numpy.array([p.nvals for p in self.pars.values()]) elif len(levels) != len(self.pars): print "Error: Length of levels ("+str(len(levels))+") not equal to number of parameters ("+str(len(self.pars))+")" return else: levels = numpy.array(levels) ds = pyDOE.fullfact(levels) mns = numpy.array(self.parmins) mxs = numpy.array(self.parmaxs) parsets = mns + ds/(levels-1)*(mxs-mns) return self.create_sampleset(parsets, name=name)
def doematrix(self): nf = self.spinBox.value() self.appExcel = xw.App() wb = xw.books.active sht = wb.sheets[0] if self.factorialradioButton.isChecked(): mdoe = ff2n(nf) elif self.fullradioButton.isChecked(): seq = self.lineEdit.text seq = seq.split(',') factors = len(seq) levels = [] for i in range(factors): levels.extend({int(float(seq[i]))}) mdoe = fullfact(levels) elif self.pbradioButton.isChecked(): mdoe = pbdesign(nf) sht.range('A1').value = mdoe
def generate(self, out_name='parameters.csv'): if os.path.exists(out_name): self.df = pd.read_csv(out_name) else: doe_option = self.DOE if doe_option == "one-to-one": self.max_len = max( [len(para.values) for para in self.para_list]) map(self.append_one2one, self.para_list) elif doe_option == "factorial": index_array = pyDOE.fullfact( [len(para.values) for para in self.para_list]) for ip, para in enumerate(self.para_list): para.run_values = [ para.values[int(x)] for x in index_array[:, ip] ] elif "lhs" in doe_option: nsamples = int(doe_option.split(',')[1]) #scales = find_precision(nsamples)[0] scales = 5 frac_array = pyDOE.lhs( len(self.para_list), samples=nsamples) ## CDF values for norm(0, 1) for ip, para in enumerate(self.para_list): para.run_values = [ round(para.min_ + x * (para.max_ - para.min_), scales) for x in frac_array[:, ip] ] else: print("I do nothing.") data = dict([(para.nickname, para.run_values) for para in self.para_list]) self.df = pd.DataFrame(data=data) self.df.to_csv(out_name, index=False) print("\n****Generated List of Parameters***") print(self.df.head()) print("\n") return self.df.shape
def multiple_effects(effects=[2, 2], m=3, n=50, fullFactorial=True, seed=False, **kwargs): x = np.linspace(-1, 1, n)[:, None] # y = np.zeros((50,(e1+e2)*n)) if seed: np.random.seed(123) if fullFactorial: effect = np.array(pyDOE.fullfact(effects).tolist() * m).astype(int) else: effect = np.array([[np.random.choice(range(e)) for e in effects] for i in range(m)]) y = np.zeros((n, effect.shape[0])) m = gpfanova.fanova.FANOVA(x, y, effect, **kwargs) y, f_samples = m.samplePrior() return x, y, effect, f_samples
import pyDOE as doe import numpy as np import pandas as pd from helperFunction.Func import createSeries if __name__ == "__main__": layerThickness = range(150, 225, 25) linearVelocity = [25, 50, 75] rot = range(10, 180, 30) num = [len(layerThickness), len(linearVelocity), len(rot)] spread = np.array(doe.fullfact(num)) layerThicknessSeries = createSeries(spread[0:, 0], layerThickness) linearVelocitySeries = createSeries(spread[0:, 1], linearVelocity) rotSeries = createSeries(spread[0:, 2], rot) d = { 'layer_thickness': layerThicknessSeries, 'linear_velocity': linearVelocitySeries, 'rotation': rotSeries } df = pd.DataFrame(d) writer = pd.ExcelWriter('./bin/BinderJet.xlsx') df.to_excel(writer, 'Sheet1') writer.save() print(df)
def test_fullfact_numpy_float64_issue(): doe.fullfact([2]*3)
def exhaustive(parameters, translator, tile_fixed_values): """ This function generates the doe plan for the experiment using of the whole design space Parameters: - parameters: the list of parameters generated by build_doe_space - translator: the translator dictionary generated by build_doe_space Return: - the plan of the execution composed as a dictionary: keys: the name of the build values: a list of tuples, where each tuple represents a single experiment """ # do not enforse constraints on parameter levels # count how many parameters have at least two levels dynamic_parameters = [] constant_parameters = [] levels = [] for index, p in enumerate(parameters): if len(p) >= 2: dynamic_parameters.append(index) levels.append(len(p)) else: constant_parameters.append(index) # prune the tile space constrained_parameters = {} for tile_p in tile_fixed_values: try: # consider the case where the tile size is fixed value = int(tile_fixed_values[tile_p]) if translator['optimizations'][tile_p] in dynamic_parameters: dynamic_parameters.remove(translator['optimizations'][tile_p]) constant_parameters.append(translator['optimizations'][tile_p]) parameters[translator['optimizations'][tile_p]] = [value] except ValueError: # consider the case where the tile value depends on another tile if translator['optimizations'][tile_p] in dynamic_parameters: dynamic_parameters.remove(translator['optimizations'][tile_p]) constrained_parameters[tile_p] = translator['optimizations'][tile_fixed_values[tile_p]] # generate the experiment matrix experiments = doe.fullfact(levels) # compose the plan plan = {} for e in experiments: # get the value of all the dynamic values values = {} for index, v in enumerate(e): real_index = dynamic_parameters[index] values[real_index] = str(parameters[real_index][int(v)]) # add back the tile values for tile_p in constrained_parameters: values[translator['optimizations'][tile_p]] = values[constrained_parameters[tile_p]] # add the constants for c in constant_parameters: values[c] = str(parameters[c][0]) # TODO: MPIbuild, take from MPI ? if values[c] == 'omp_threads': values[c] = values[translator['omp_threads']['omp']] if values[c] == 'mpi_procs': values[c] = values[translator['mpi_procs']['mpi']] # create the run list with the right values run = ['' for x in values] for key in values: run[int(key)] = values[key] # perform the flag translation make_args, exe_args, openmp_flag, mpi_command, name1, name2 = value_to_flag_translation(run, translator) # add it to the plan try: plan[make_args].append((exe_args, openmp_flag, mpi_command, name1, name2)) except KeyError as itsok: plan[make_args] = [(exe_args, openmp_flag, mpi_command, name1, name2)] except: raise # return the plan return plan
def compute_stat(list_points, weights, Nbin=200, rangeBin=None, DoInterp=True, DoHisto=False): """ Compute the marginalized proba 1D and 2D for N-dimensions - with an interpolation on a grid option - or simple histogram option Note ---- - Main fuction for the triangular plot (c.f. plot_triangular) Parameters ---------- list_points : array_like[nPoints,NDIM,] Contain the sample of points. weights : array_like[nPoints,] The weights of each points. Nbin : Optional[int] Dimention of the final grid. DoInterp : Optional[bool] Interpolate the weights on a grid of dimention power(Nbin,NDIM) DoHisto : Optional[bool] Project on the weights on a grid of dimention power(Nbin,NDIM) rangeBin : Optional[array_like[NDIM,2,]] The range of each dimentions. Returns ------- list_bins : list of the bins used for each axis. ND_pdf : The power(Nbin,NDIM) cube of the pdf TwoD_proba : All the 2D pdf. OneD_proba : All the 1D pdf. axe_marg_2D.astype(int) : The order of axis used in the 2D pdf. axe_marg_1D.astype(int) : The order of axis used in the 1D pdf. Raises ------ None """ DIM = len(list_points) ### Create bins of each dim list_bins = np.zeros([DIM, Nbin]) for i, pts in enumerate(list_points): try: if rangeBin == None: list_bins[i] = np.linspace(pts.min(), pts.max(), num=Nbin) except ValueError: list_bins[i] = np.linspace(rangeBin[0, i], rangeBin[1, i], num=Nbin) if DoInterp: ### FOR GRID ESTIMATIONS ### ND mesh YYY = np.mgrid[[ slice(m, M, Nbin * 1j) for m, M in zip(list_bins.min(axis=1), list_bins.max(axis=1)) ]] ### ND parametter interpolate space ND_proba = griddata(list_points.T, weights, YYY.T, method='linear', fill_value=0., rescale=True) ### nearest ### linear elif DoHisto: ### FOR MCMC CHAINS #print("IN DO HISTOGRAM") list_bins_tmp = np.zeros([DIM, Nbin + 1]) for i, pts in enumerate(list_points): try: if rangeBin == None: list_bins_tmp[i] = np.linspace(pts.min(), pts.max(), num=Nbin + 1) except ValueError: list_bins_tmp[i] = np.linspace(rangeBin[0, i], rangeBin[1, i], num=Nbin + 1) ND_proba, _ = np.histogramdd(list_points.T, weights=weights, bins=list_bins_tmp) ND_proba = ND_proba.T else: ### WHEN THE PROBA IS ALREADY COMPUTE #ND_proba = weights.reshape( [Nbin, Nbin, Nbin, Nbin, Nbin] ) ND_proba = weights.reshape(np.ones(DIM, dtype=int) * Nbin) ND_proba[np.isnan(ND_proba)] = 0. ### just in case print('NORMALIZATION FACTOR :', ND_proba.sum()) ND_pdf = ND_proba.T / ND_proba.sum() ### normalisation ### 2D planes : marginalised proba = n(n-1)/2 TwoD_proba = np.zeros([DIM * (DIM - 1) // 2, Nbin, Nbin]) axe_marg_2D = np.zeros([DIM * (DIM - 1) // 2, 2]) t = pyDOE.fullfact(np.arange(3, DIM + 1)) if DIM > 3: select = np.where( np.product(np.array([(t[:, d] < t[:, d + 1]) for d in range(t.shape[1] - 1)]), axis=0))[0] tselect = t[select] else: tselect = t for i, ax in enumerate(tselect): TwoD_proba[i] = np.squeeze( np.apply_over_axes(np.sum, ND_pdf, ax.astype(int))) axe_marg_2D[i] = np.setdiff1d(range(DIM), ax) ### 1D : marginalised proba = n OneD_proba = np.zeros([DIM, Nbin]) axe_marg_1D = np.zeros(DIM) t = pyDOE.fullfact(np.arange(2, DIM + 1)) if DIM > 2: select = np.where( np.product(np.array([(t[:, d] < t[:, d + 1]) for d in range(t.shape[1] - 1)]), axis=0))[0] tselect else: tselect = t for i, ax in enumerate(tselect): OneD_proba[i] = np.squeeze( np.apply_over_axes(np.sum, ND_pdf, ax.astype(int))) axe_marg_1D[i] = np.setdiff1d(range(DIM), ax) return list_bins, ND_pdf, TwoD_proba, OneD_proba, axe_marg_2D.astype( int), axe_marg_1D.astype(int)
##opt.set_inequality_constraint() #print opt.optimize(params) from scipy.optimize import * #print ARLogLikelihood(t, s, p) #print fmin_slsqp(objective, red_params(init_params), fprime=objective_grad, f_ieqcons=constraint, iter=1000) #print minimize(loglikelihood, np.random.rand(Np), jac=lambda x: loglikelihood(x, True), method='BFGS', options={'maxiter':100}) bounds = np.vstack((np.hstack((-10 * np.ones((p, 1)), 10 * np.ones( (p, 1)))), np.hstack((0 * np.ones((n - 1, 1)), 1 * np.ones( (n - 1, 1)))), np.array([[0.1, 10]]))) npoints = 10 points = np.linspace(0, 1, npoints + 2)[1:-1] import pyDOE designs = pyDOE.fullfact([npoints] * (n + p)).astype(np.int32) data = [] import cPickle as pkl params = [red_params(init_params)] for i, des in enumerate(designs): print i param = [] for j in range(0, n + p): param.append(bounds[j][0] + points[des[j]] * (bounds[j][1] - bounds[j][0])) if constraint(param) < 0: continue #result = objective(np.array(param)) try: result = objective(np.array(param)) data.append([param, result, constraint(param)])
def DesOpt(SysEq, x0, xU, xL, xDis=[], gc=[], hc=[], SensEq=[], Alg="SLSQP", SensCalc="FD", DesVarNorm=True, deltax=1e-3, StatusReport=False, ResultReport=False, Video=False, DoE=False, SBDO=False, Debug=False, PrintOut=True, OptNameAdd="", AlgOptions=[], Alarm=True): #----------------------------------------------------------------------------------------------------------------------- # Define optimization problem and optimization options #----------------------------------------------------------------------------------------------------------------------- """ :type OptNode: object """ if Debug is True: StatusReport = False if StatusReport is True: print "Debug is set to True; overriding StatusReport" if ResultReport is True: print "Debug is set to True; overriding ResultReport" ResultReport = False computerName = platform.uname()[1] operatingSystem = platform.uname()[0] architecture = platform.uname()[4] nProcessors = str(multiprocessing.cpu_count()) userName = getpass.getuser() OptTime0 = time.time() OptNodes = "all" MainDir = os.getcwd() if operatingSystem != 'Windows': DirSplit = "/" homeDir = "/home/" else: DirSplit = "\\" homeDir = "c:\\Users\\" OptModel = os.getcwd().split(DirSplit)[-1] try: OptAlg = eval("pyOpt." + Alg + '()') pyOptAlg = True except: OptAlg = Alg pyOptAlg = False if hasattr(SensEq, '__call__'): SensCalc = "OptSensEq" print "Function for sensitivity analysis has been provided, overriding SensCalc to use function" else: pass StartTime = datetime.datetime.now() loctime = time.localtime() today = time.strftime("%B", time.localtime()) + ' ' + str(loctime[2]) + ', ' + str(loctime[0]) if SBDO is True: OptNameAdd = OptNameAdd + "_SBDO" OptName = OptModel + OptNameAdd + "_" + Alg + "_" + StartTime.strftime("%Y%m%d%H%M%S") global nEval nEval = 0 LocalRun = True ModelDir = os.getcwd()[:-(len(OptModel) + 1)] ModelFolder = ModelDir.split(DirSplit)[-1] DesOptDir = ModelDir[:-(len(ModelFolder) + 1)] ResultsDir = DesOptDir + os.sep + "Results" RunDir = DesOptDir + os.sep + "Run" try: inform except NameError: inform = ["Running"] if LocalRun is True and Debug is False: try: os.mkdir(ResultsDir) except: pass os.mkdir(ResultsDir + DirSplit + OptName) os.mkdir(ResultsDir + os.sep + OptName + os.sep + "ResultReport" + os.sep) shutil.copytree(os.getcwd(), RunDir + os.sep + OptName) #if SensCalc == "ParaFD": # import OptSensParaFD # os.system("cp -r ParaPythonFn " + homeDir + userName + "/DesOptRun/" + OptName) if LocalRun is True and Debug is False: os.chdir("../../Run/" + OptName + "/") sys.path.append(os.getcwd()) #----------------------------------------------------------------------------------------------------------------------- # Print start-up splash to output screen #----------------------------------------------------------------------------------------------------------------------- if PrintOut is True: print("--------------------------------------------------------------------------------") PrintDesOptPy() print("") print("Optimization model: " + OptModel) try: print("Optimization algorithm: " + Alg) except: pass print("Optimization start: " + StartTime.strftime("%Y%m%d%H%M")) print("Optimization name: " + OptName) print("--------------------------------------------------------------------------------") #----------------------------------------------------------------------------------------------------------------------- # Optimization problem #----------------------------------------------------------------------------------------------------------------------- #----------------------------------------------------------------------------------------------------------------------- # Define functions: system equation, normalization, etc. #----------------------------------------------------------------------------------------------------------------------- def OptSysEq(x): x = np.array(x) # NSGA2 gives a list back, this makes a float! TODO Inquire why it does this! f, g = SysEq(x, gc) fail = 0 global nEval nEval += 1 if StatusReport == True: OptHis2HTML.OptHis2HTML(OptName, OptAlg, DesOptDir, xL, xU, DesVarNorm, inform[0], OptTime0) if len(xDis) > 0: nD = len(xDis) gDis = [[]]*2*nD for ii in range(nD): gDis[ii+0] = np.sum(x[-1*xDis[ii]:])-1 gDis[ii+1] = 1-np.sum(x[-1*xDis[ii]:]) gNew = np.concatenate((g, gDis), 0) g = copy.copy(gNew) # TODO add print out for optimization development!! return f, g, fail def OptSysEqNorm(xNorm): xNorm = np.array(xNorm) # NSGA2 gives a list back, this makes a float! TODO Inquire why it does this! x = denormalize(xNorm, xL, xU, DesVarNorm) f, g, fail = OptSysEq(x) return f, g, fail def OptPenSysEq(x): f, g, fail = OptSysEq(x) fpen = f return fpen def OptSensEq(x, f, g): dfdx, dgdx = SensEq(x, f, g, gc) dfdx = dfdx.reshape(1,len(x)) fail = 0 return dfdx, dgdx, fail def OptSensEqNorm(xNorm, f, g): x = denormalize(xNorm, xL, xU, DesVarNorm) dfxdx, dgxdx, fail = OptSensEq(x, f, g) dfdx = dfxdx * (xU - xL) # TODO not general for all normalizations! needs to be rewritten if dgxdx != []: dgdx = dgxdx * np.tile((xU - xL), [len(g), 1]) # TODO not general for all normalizations! needs to be rewritten else: dgdx = [] return dfdx, dgdx, fail def OptSensEqParaFD(x, f, g): global nEval dfdx, dgdx, nb = OptSensParaFD.Para(x, f, g, deltax, OptName, OptNodes) nEval += nb fail = 0 return dfdx, dgdx, fail def OptSensEqParaFDNorm(xNorm, f, g): x = denormalize(xNorm, xL, xU, DesVarNorm) dfxdx, dgxdx, fail = OptSensEqParaFD(x, f, g) dfdx = dfxdx * (xU - xL) # TODO not general for all normalizations! needs to be rewritten dgdx = dgxdx * (np.tile((xU - xL), [len(g), 1])) # TODO not general for all normalizations! needs to be rewritten return dfdx, dgdx, fail #----------------------------------------------------------------------------------------------------------------------- # Surrogate-based optimization (not fully functioning yet!!!!) #----------------------------------------------------------------------------------------------------------------------- # TODO SBDO in a separate file??? if SBDO is not False: if DoE > 0: import pyDOE try: n_gc = len(gc) except: n_gc = 1 SampleCorners = True if SampleCorners is True: xTemp = np.ones(np.size(xL)) * 2 xSampFF = pyDOE.fullfact(np.array(xTemp, dtype=int)) # Kriging needs boundaries too!! xSampLH = pyDOE.lhs(np.size(xL), DoE) xDoE_Norm = np.concatenate((xSampFF, xSampLH), axis=0) else: xDoE_Norm = pyDOE.lhs(np.size(xL), DoE) xDoE = np.zeros(np.shape(xDoE_Norm)) fDoE = np.zeros([np.size(xDoE_Norm, 0), 1]) gDoE = np.zeros([np.size(xDoE_Norm, 0), n_gc]) for ii in range(np.size(xDoE_Norm, 0)): xDoE[ii] = denormalize(xDoE_Norm[ii], xL, xU, DesVarNorm) fDoEii, gDoEii, fail = OptSysEqNorm(xDoE_Norm[ii]) fDoE[ii] = fDoEii gDoE[ii, :] = gDoEii n_theta = np.size(x0) + 1 ApproxObj = "QuadReg" ApproxObj = "GaussianProcess" if ApproxObj == "GaussianProcess": from sklearn.gaussian_process import GaussianProcess approx_f = GaussianProcess(regr='quadratic', corr='squared_exponential', normalize=True, theta0=0.1, thetaL=1e-4, thetaU=1e+1, optimizer='fmin_cobyla') elif ApproxObj == "QuadReg": # from PolyReg import * approx_f = PolyReg() approx_f.fit(xDoE, fDoE) from sklearn.gaussian_process import GaussianProcess gDoEr = np.zeros(np.size(xDoE_Norm, 0)) approx_g = [[]] * n_gc gpRegr = ["quadratic"] * n_gc gpCorr = ["squared_exponential"] * n_gc for ii in range(n_gc): for iii in range(np.size(xDoE_Norm, 0)): gDoEii = gDoE[iii] gDoEr[iii] = gDoEii[ii] approx_g[ii] = GaussianProcess(regr=gpRegr[ii], corr=gpCorr[ii], theta0=0.01, thetaL=0.0001, thetaU=10., optimizer='fmin_cobyla') approx_g[ii].fit(xDoE, gDoEr) DoE_Data = {} DoE_Data['xDoE_Norm'] = xDoE_Norm DoE_Data['gDoE'] = gDoE DoE_Data['fDoE'] = fDoE output = open(OptName + "_DoE.pkl", 'wb') pickle.dump(DoE_Data, output) output.close() else: Data = pickle.load(open("Approx.pkl")) approx_f = Data["approx_f"] approx_g = Data["approx_g"] def ApproxOptSysEq(x): f = approx_f.predict(x) g = np.zeros(len(gc)) for ii in range(len(gc)): # exec("g[ii], MSE = gp_g"+str(ii)+".predict(x, eval_MSE=True)") g[ii] = approx_g[ii].predict(x) # sigma = np.sqrt(MSE) fail = 0 return f, g, fail def ApproxOptSysEqNorm(xNorm): xNorm = xNorm[0:np.size(xL), ] x = denormalize(xNorm, xL, xU, DesVarNorm) f = approx_f.predict(x) g = np.zeros(len(gc)) for ii in range(len(gc)): # exec("g[ii], MSE = gp_g"+str(ii)+".predict(x, eval_MSE=True)") g[ii] = approx_g[ii].predict(x) # sigma = np.sqrt(MSE) fail = 0 return f, g, fail if xDis is not []: for ii in range(np.size(xDis, 0)): xExpand0 = np.ones(xDis[ii]) * 1./xDis[ii] # Start at uniform of all materials etc. xNew0 = np.concatenate((x0, xExpand0), 0) xExpandL = np.ones(xDis[ii]) * 0.0001 xNewL = np.concatenate((xL, xExpandL), 0) xExpandU = np.ones(xDis[ii]) xNewU = np.concatenate((xU, xExpandU), 0) x0 = copy.copy(xNew0) xL = copy.copy(xNewL) xU = copy.copy(xNewU) gcNew = np.concatenate((gc, np.ones(2,)), 0) gc = copy.copy(gcNew) if DesVarNorm in ["None", None, False]: x0norm = x0 xLnorm = xL xUnorm = xU DefOptSysEq = OptSysEq else: [x0norm, xLnorm, xUnorm] = normalize(x0, xL, xU, DesVarNorm) DefOptSysEq = OptSysEqNorm nx = np.size(x0) ng = np.size(gc) #----------------------------------------------------------------------------------------------------------------------- # pyOpt optimization #----------------------------------------------------------------------------------------------------------------------- if pyOptAlg is True: if SBDO is not False and DesVarNorm in ["xLxU", True, "xLx0", "x0", "xU"]: #in ["None", None, False]: OptProb = pyOpt.Optimization(OptModel, ApproxOptSysEqNorm, obj_set=None) elif SBDO is not False and DesVarNorm in ["None", None, False]: OptProb = pyOpt.Optimization(OptModel, ApproxOptSysEq, obj_set=None) else: OptProb = pyOpt.Optimization(OptModel, DefOptSysEq) if np.size(x0) == 1: OptProb.addVar('x', 'c', value=x0norm, lower=xLnorm, upper=xUnorm) elif np.size(x0) > 1: for ii in range(np.size(x0)): OptProb.addVar('x' + str(ii + 1), 'c', value=x0norm[ii], lower=xLnorm[ii], upper=xUnorm[ii]) OptProb.addObj('f') if np.size(gc) == 1: OptProb.addCon('g', 'i') ng = 1 elif np.size(gc) > 1: for ii in range(len(gc)): OptProb.addCon('g' + str(ii + 1), 'i') ng = ii + 1 if np.size(hc) == 1: OptProb.addCon('h', 'i') elif np.size(hc) > 1: for ii in range(ng): OptProb.addCon('h' + str(ii + 1), 'i') if AlgOptions == []: AlgOptions = OptAlgOptions.setDefault(Alg) OptAlg = OptAlgOptions.setUserOptions(AlgOptions, Alg, OptName, OptAlg) #if AlgOptions == []: # OptAlg = OptAlgOptions.setDefaultOptions(Alg, OptName, OptAlg) #else: # OptAlg = OptAlgOptions.setUserOptions(AlgOptions, Alg, OptName, OptAlg) if PrintOut is True: print(OptProb) if Alg in ["MMA", "FFSQP", "FSQP", "GCMMA", "CONMIN", "SLSQP", "PSQP", "KSOPT", "ALGENCAN", "NLPQLP", "IPOPT"]: if SensCalc == "OptSensEq": if DesVarNorm not in ["None", None, False]: [fOpt, xOpt, inform] = OptAlg(OptProb, sens_type=OptSensEqNorm, store_hst=OptName) else: [fOpt, xOpt, inform] = OptAlg(OptProb, sens_type=OptSensEq, store_hst=OptName) elif SensCalc == "ParaFD": # Michi Richter if DesVarNorm not in ["None", None, False]: [fOpt, xOpt, inform] = OptAlg(OptProb, sens_type=OptSensEqParaFDNorm, store_hst=OptName) else: [fOpt, xOpt, inform] = OptAlg(OptProb, sens_type=OptSensEqParaFD, store_hst=OptName) else: # Here FD (finite differencing) [fOpt, xOpt, inform] = OptAlg(OptProb, sens_type=SensCalc, sens_step=deltax, store_hst=OptName) elif Alg in ["SDPEN", "SOLVOPT"]: [fOpt, xOpt, inform] = OptAlg(OptProb) else: [fOpt, xOpt, inform] = OptAlg(OptProb, store_hst=OptName) if PrintOut is True: try: print(OptProb.solution(0)) except: pass if Alg not in ["PSQP", "SOLVOPT", "MIDACO", "SDPEN", "ralg"] and PrintOut is True: print(OptAlg.getInform(0)) #----------------------------------------------------------------------------------------------------------------------- # OpenOpt optimization -- not fully implemented in this framework and not yet working... #----------------------------------------------------------------------------------------------------------------------- elif Alg == "ralg": from openopt import NLP f, g = lambda x: OptSysEq(x) # g = lambda x: OptSysEq(x)[1][0] p = NLP(f, x0, c=g, lb=xL, ub=xU, iprint=50, maxIter=10000, maxFunEvals=1e7, name='NLP_1') r = p.solve(Alg, plot=0) print(OptAlg.getInform(1)) #----------------------------------------------------------------------------------------------------------------------- # pyCMAES #----------------------------------------------------------------------------------------------------------------------- elif Alg == "pycmaes": print "CMA-ES == not fully implemented in this framework" print " no constraints" import cma def CMA_ES_ObjFn(x): f, g, fail = OptSysEq(x) return f OptRes = cma.fmin(CMA_ES_ObjFn, x0, sigma0=1) xOpt = OptRes[0] fOpt = OptRes[1] nEval = OptRes[4] nIter = OptRes[5] #----------------------------------------------------------------------------------------------------------------------- # MATLAB fmincon optimization -- not fully implemented in this framework and not yet working... #----------------------------------------------------------------------------------------------------------------------- elif Alg == "fmincon": # not fully implemented in this framework def ObjFn(x): f, g, fail = OptSysEqNorm(xNorm) return f, [] from mlabwrap import mlab mlab._get(ObjFn) mlab.fmincon(mlab._get("ObjFn"), x) # g,h, dgdx = mlab.fmincon(x.T,cg,ch, nout=3) #----------------------------------------------------------------------------------------------------------------------- # PyGMO optimization #----------------------------------------------------------------------------------------------------------------------- elif Alg[:5] == "PyGMO": DesVarNorm = "None" #print nindiv dim = np.size(x0) # prob = OptSysEqPyGMO(dim=dim) prob = OptSysEqPyGMO(SysEq=SysEq, xL=xL, xU=xU, gc=gc, dim=dim, OptName=OptName, Alg=Alg, DesOptDir=DesOptDir, DesVarNorm=DesVarNorm, StatusReport=StatusReport, inform=inform, OptTime0=OptTime0) # prob = problem.death_penalty(prob_old, problem.death_penalty.method.KURI) if AlgOptions == []: AlgOptions = OptAlgOptions.setDefault(Alg) OptAlg = OptAlgOptions.setUserOptions(AlgOptions, Alg, OptName, OptAlg) #algo = eval("PyGMO.algorithm." + Alg[6:]+"()") #de (gen=100, f=0.8, cr=0.9, variant=2, ftol=1e-06, xtol=1e-06, screen_output=False) #NSGAII (gen=100, cr=0.95, eta_c=10, m=0.01, eta_m=10) #sga_gray.__init__(gen=1, cr=0.95, m=0.02, elitism=1, mutation=PyGMO.algorithm._algorithm._gray_mutation_type.UNIFORM, selection=PyGMO.algorithm._algorithm._gray_selection_type.ROULETTE, crossover=PyGMO.algorithm._algorithm._gray_crossover_type.SINGLE_POINT) #nsga_II.__init__(gen=100, cr=0.95, eta_c=10, m=0.01, eta_m=10) #emoa (hv_algorithm=None, gen=100, sel_m=2, cr=0.95, eta_c=10, m=0.01, eta_m=10) #pade (gen=10, max_parallelism=1, decomposition=PyGMO.problem._problem._decomposition_method.BI, solver=None, T=8, weights=PyGMO.algorithm._algorithm._weight_generation.LOW_DISCREPANCY, z=[]) #nspso (gen=100, minW=0.4, maxW=1.0, C1=2.0, C2=2.0, CHI=1.0, v_coeff=0.5, leader_selection_range=5, diversity_mechanism=PyGMO.algorithm._algorithm._diversity_mechanism.CROWDING_DISTANCE) #corana: (iter=10000, Ts=10, Tf=0.1, steps=1, bin_size=20, range=1) #if Alg[6:] in ["de", "bee_colony", "nsga_II", "pso", "pso_gen", "cmaes", "py_cmaes", # "spea2", "nspso", "pade", "sea", "vega", "sga", "sga_gray", "de_1220", # "mde_pbx", "jde"]: # algo.gen = ngen #elif Alg[6:] in ["ihs", "monte_carlo", "sa_corana"]: # algo.iter = ngen #elif Alg[6:] == "sms_emoa": # print "sms_emoa not working" #else: # sys.exit("improper PyGMO algorithm chosen") #algo.f = 1 #algo.cr=1 #algo.ftol = 1e-3 #algo.xtol = 1e-3 #algo.variant = 2 #algo.screen_output = False #if Alg == "PyGMO_de": # algo = PyGMO.algorithm.de(gen=ngen, f=1, cr=1, variant=2, # ftol=1e-3, xtol=1e-3, screen_output=False) #else: # algo = PyGMO.algorithm.de(gen=ngen, f=1, cr=1, variant=2, # ftol=1e-3, xtol=1e-3, screen_output=False) #pop = PyGMO.population(prob, nIndiv) #pop = PyGMO.population(prob, nIndiv, seed=13598) # Seed fixed for random generation of first individuals #algo.evolve(pop) isl = PyGMO.island(OptAlg, prob, AlgOptions.nIndiv) isl.evolve(1) isl.join() xOpt = isl.population.champion.x # fOpt = isl.population.champion.f[0] nEval = isl.population.problem.fevals nGen = int(nEval/AlgOptions.nIndiv) # currently being overwritten and therefore not being used StatusReport = False # turn off status report, so not remade (and destroyed) in following call! fOpt, gOpt, fail = OptSysEq(xOpt) # verification of optimal solution as values above are based on penalty! #----------------------------------------------------------------------------------------------------------------------- # SciPy optimization #----------------------------------------------------------------------------------------------------------------------- elif Alg[:5] == "scipy": import scipy.optimize as sciopt bounds = [[]]*len(x0) for ii in range(len(x0)): bounds[ii] = (xL[ii], xU[ii]) print bounds if Alg[6:] == "de": sciopt.differential_evolution(DefOptSysEq, bounds, strategy='best1bin', maxiter=None, popsize=15, tol=0.01, mutation=(0.5, 1), recombination=0.7, seed=None, callback=None, disp=False, polish=True, init='latinhypercube') #----------------------------------------------------------------------------------------------------------------------- # Simple optimization algorithms to demonstrate use of custom algorithms #----------------------------------------------------------------------------------------------------------------------- #TODO: add history to these elif Alg == "SteepestDescentSUMT": from CustomAlgs import SteepestDescentSUMT fOpt, xOpt, nIter, nEval = SteepestDescentSUMT(DefOptSysEq, x0, xL, xU) elif Alg == "NewtonSUMT": from CustomAlgs import NewtonSUMT fOpt, xOpt, nIter, nEval = NewtonSUMT(DefOptSysEq, x0, xL, xU) #----------------------------------------------------------------------------------------------------------------------- # #----------------------------------------------------------------------------------------------------------------------- else: sys.exit("Error on line 694 of __init__.py: algorithm misspelled or not supported") #----------------------------------------------------------------------------------------------------------------------- # Optimization post-processing #----------------------------------------------------------------------------------------------------------------------- if StatusReport == 1: OptHis2HTML.OptHis2HTML(OptName, OptAlg, DesOptDir, xL, xU, DesVarNorm, inform.values()[0], OptTime0) OptTime1 = time.time() loctime0 = time.localtime(OptTime0) hhmmss0 = time.strftime("%H", loctime0)+' : '+time.strftime("%M", loctime0)+' : '+time.strftime("%S", loctime0) loctime1 = time.localtime(OptTime1) hhmmss1 = time.strftime("%H", loctime1)+' : '+time.strftime("%M", loctime1)+' : '+time.strftime("%S", loctime1) diff = OptTime1 - OptTime0 h0, m0, s0 = (diff // 3600), int((diff / 60) - (diff // 3600) * 60), diff % 60 OptTime = "%02d" % (h0) + " : " + "%02d" % (m0) + " : " + "%02d" % (s0) #----------------------------------------------------------------------------------------------------------------------- # Read in results from history files #----------------------------------------------------------------------------------------------------------------------- OptHist = pyOpt.History(OptName, "r") fAll = OptHist.read([0, -1], ["obj"])[0]["obj"] xAll = OptHist.read([0, -1], ["x"])[0]["x"] gAll = OptHist.read([0, -1], ["con"])[0]["con"] if Alg == "NLPQLP": gAll = [x * -1 for x in gAll] gGradIter = OptHist.read([0, -1], ["grad_con"])[0]["grad_con"] fGradIter = OptHist.read([0, -1], ["grad_obj"])[0]["grad_obj"] failIter = OptHist.read([0, -1], ["fail"])[0]["fail"] if Alg == "COBYLA" or Alg == "NSGA2" or Alg[:5] == "PyGMO": fIter = fAll xIter = xAll gIter = gAll else: fIter = [[]] * len(fGradIter) xIter = [[]] * len(fGradIter) gIter = [[]] * len(fGradIter) # SuIter = [[]] * len(fGradIter) for ii in range(len(fGradIter)): Posdg = OptHist.cues["grad_con"][ii][0] Posf = OptHist.cues["obj"][ii][0] iii = 0 while Posdg > Posf: iii = iii + 1 try: Posf = OptHist.cues["obj"][iii][0] except: Posf = Posdg + 1 iii = iii - 1 fIter[ii] = fAll[iii] xIter[ii] = xAll[iii] gIter[ii] = gAll[iii] OptHist.close() #----------------------------------------------------------------------------------------------------------------------- # Convert all data to numpy arrays #----------------------------------------------------------------------------------------------------------------------- fIter = np.asarray(fIter) xIter = np.asarray(xIter) gIter = np.asarray(gIter) gGradIter = np.asarray(gGradIter) fGradIter = np.asarray(fGradIter) #----------------------------------------------------------------------------------------------------------------------- # Denormalization of design variables #----------------------------------------------------------------------------------------------------------------------- xOpt = np.resize(xOpt[0:np.size(xL)], np.size(xL)) if DesVarNorm in ["None", None, False]: x0norm = [] xIterNorm = [] xOptNorm = [] else: xOpt = np.resize(xOpt, [np.size(xL), ]) xOptNorm = xOpt xOpt = denormalize(xOptNorm.T, xL, xU, DesVarNorm) try: xIterNorm = xIter[:, 0:np.size(xL)] xIter = np.zeros(np.shape(xIterNorm)) for ii in range(len(xIterNorm)): xIter[ii] = denormalize(xIterNorm[ii], xL, xU, DesVarNorm) except: x0norm = [] xIterNorm = [] xOptNorm = [] nIter = np.size(fIter) if np.size(fIter) > 0: if fIter[0] != 0: fIterNorm = fIter / fIter[0] # fIterNorm=(fIter-fIter[nEval-1])/(fIter[0]-fIter[nEval-1]) else: fIterNorm = fIter else: fIterNorm = [] #----------------------------------------------------------------------------------------------------------------------- # Active constraints for use in the calculation of the Lagrangian multipliers and optimality criterion #----------------------------------------------------------------------------------------------------------------------- epsActive = 1e-3 xL_ActiveIndex = (xOpt - xL) / xU < epsActive xU_ActiveIndex = (xU - xOpt) / xU < epsActive xL_Grad = -np.eye(nx) xU_Grad = np.eye(nx) xL_GradActive = xL_Grad[:, xL_ActiveIndex] xU_GradActive = xU_Grad[:, xU_ActiveIndex] # or the other way around! xGradActive = np.concatenate((xL_GradActive, xU_GradActive), axis=1) # TODO change so that 1D optimization works! try: xL_Active = xL[xL_ActiveIndex] except: xL_Active = np.array([]) try: xU_Active = xU[xU_ActiveIndex] except: xU_Active = np.array([]) if len(xL_Active)==0: xActive = xU_Active elif len(xU_Active)==0: xActive = xL_Active else: xActive = np.concatenate((xL_Active, xU_Active)) if np.size(xL) == 1: if xL_ActiveIndex == False: xL_Active = np.array([]) else: xL_Active = xL if xU_ActiveIndex == False: xU_Active = np.array([]) else: xU_Active = xU else: xL_Active = xL[xL_ActiveIndex] xU_Active = np.array(xU[xU_ActiveIndex]) if len(xL_Active)==0: xLU_Active = xU_Active elif len(xU_Active)==0: xLU_Active = xL_Active else: xLU_Active = np.concatenate((xL_Active, xU_Active)) #TODO needs to be investigated for PyGMO! # are there nonlinear constraints active, in case equality constraints are added later, this must also be added if np.size(gc) > 0 and Alg[:5] != "PyGMO": gMaxIter = np.zeros([nIter]) for ii in range(len(gIter)): gMaxIter[ii] = max(gIter[ii]) gOpt = gIter[nIter - 1] gOptActiveIndex = gOpt > -epsActive gOptActive = gOpt[gOpt > -epsActive] elif np.size(gc) == 0: gOptActiveIndex = [[False]] * len(gc) gOptActive = np.array([]) gMaxIter = np.array([] * nIter) gOpt = np.array([]) else: gMaxIter = np.zeros([nIter]) for ii in range(len(gIter)): gMaxIter[ii] = max(gIter[ii]) gOptActiveIndex = gOpt > -epsActive gOptActive = gOpt[gOpt > -epsActive] if len(xLU_Active)==0: g_xLU_OptActive = gOptActive elif len(gOptActive)==0: g_xLU_OptActive = xLU_Active else: if np.size(xLU_Active) == 1 and np.size(gOptActive) == 1: g_xLU_OptActive = np.array([xLU_Active, gOptActive]) else: g_xLU_OptActive = np.concatenate((xLU_Active, gOptActive)) if np.size(fGradIter) > 0: #fGradOpt = fGradIter[nIter - 1] fGradOpt = fGradIter[-1] if np.size(gc) > 0: gGradOpt = gGradIter[nIter - 1] gGradOpt = gGradOpt.reshape([ng, nx]).T gGradOptActive = gGradOpt[:, gOptActiveIndex == True] try: cOptActive = gc[gOptActiveIndex == True] cActiveType = ["Constraint"]*np.size(cOptActive) except: cOptActive = [] cActiveType = [] if np.size(xGradActive) == 0: g_xLU_GradOptActive = gGradOptActive c_xLU_OptActive = cOptActive c_xLU_ActiveType = cActiveType elif np.size(gGradOptActive) == 0: g_xLU_GradOptActive = xGradActive c_xLU_OptActive = xActive c_xLU_ActiveType = ["Bound"]*np.size(xActive) else: g_xLU_GradOptActive = np.concatenate((gGradOptActive, xGradActive), axis=1) c_xLU_OptActive = np.concatenate((cOptActive, xActive)) xActiveType = ["Bound"]*np.size(xActive) c_xLU_ActiveType = np.concatenate((cActiveType, xActiveType)) else: g_xLU_GradOptActive = xGradActive gGradOpt = np.array([]) c_xLU_OptActive = np.array([]) g_xLU_GradOptActive = np.array([]) c_xLU_ActiveType = np.array([]) else: fGradOpt = np.array([]) gGradOpt = np.array([]) g_xLU_GradOptActive = np.array([]) c_xLU_OptActive = np.array([]) c_xLU_ActiveType = np.array([]) #----------------------------------------------------------------------------------------------------------------------- # § Post-processing of optimization solution #----------------------------------------------------------------------------------------------------------------------- lambda_c, SPg, OptRes, Opt1Order, KKTmax = OptPostProc(fGradOpt, gc, gOptActiveIndex, g_xLU_GradOptActive, c_xLU_OptActive, c_xLU_ActiveType, DesVarNorm) #----------------------------------------------------------------------------------------------------------------------- # § Save optimizaiton solution to file #----------------------------------------------------------------------------------------------------------------------- OptSolData = {} OptSolData['x0'] = x0 OptSolData['xOpt'] = xOpt OptSolData['xOptNorm'] = xOptNorm OptSolData['xIter'] = xIter OptSolData['xIterNorm'] = xIterNorm OptSolData['fOpt'] = fOpt OptSolData['fIter'] = fIter OptSolData['fIterNorm'] = fIterNorm OptSolData['gIter'] = gIter OptSolData['gMaxIter'] = gMaxIter OptSolData['gOpt'] = gOpt OptSolData['fGradIter'] = fGradIter OptSolData['gGradIter'] = gGradIter OptSolData['fGradOpt'] = fGradOpt OptSolData['gGradOpt'] = gGradOpt OptSolData['OptName'] = OptName OptSolData['OptModel'] = OptModel OptSolData['OptTime'] = OptTime OptSolData['loctime'] = loctime OptSolData['today'] = today OptSolData['computerName'] = computerName OptSolData['operatingSystem'] = operatingSystem OptSolData['architecture'] = architecture OptSolData['nProcessors'] = nProcessors OptSolData['userName'] = userName OptSolData['Alg'] = Alg OptSolData['DesVarNorm'] = DesVarNorm OptSolData['KKTmax'] = KKTmax OptSolData['lambda_c'] = lambda_c OptSolData['nEval'] = nEval OptSolData['nIter'] = nIter OptSolData['SPg'] = SPg OptSolData['gc'] = gc #OptSolData['OptAlg'] = OptAlg OptSolData['SensCalc'] = SensCalc OptSolData['xIterNorm'] = xIterNorm OptSolData['x0norm'] = x0norm OptSolData['xL'] = xL OptSolData['xU'] = xU OptSolData['ng'] = ng OptSolData['nx'] = nx OptSolData['Opt1Order'] = Opt1Order OptSolData['hhmmss0'] = hhmmss0 OptSolData['hhmmss1'] = hhmmss1 #----------------------------------------------------------------------------------------------------------------------- # § Save in Python format #----------------------------------------------------------------------------------------------------------------------- output = open(OptName + "_OptSol.pkl", 'wb') pickle.dump(OptSolData, output) output.close() np.savez(OptName + "_OptSol", x0, xOpt, xOptNorm, xIter, xIterNorm, xIter, xIterNorm, fOpt, fIter, fIterNorm, gIter, gMaxIter, gOpt, fGradIter, gGradIter, fGradOpt, gGradOpt, OptName, OptModel, OptTime, loctime, today, computerName, operatingSystem, architecture, nProcessors, userName, Alg, DesVarNorm, KKTmax) #----------------------------------------------------------------------------------------------------------------------- # §5.2 Save in MATLAB format #----------------------------------------------------------------------------------------------------------------------- #OptSolData['OptAlg'] = [] spio.savemat(OptName + '_OptSol.mat', OptSolData, oned_as='row') #----------------------------------------------------------------------------------------------------------------------- # #----------------------------------------------------------------------------------------------------------------------- os.chdir(MainDir) if LocalRun is True and Debug is False: try: shutil.move(RunDir + os.sep + OptName, ResultsDir + os.sep + OptName + os.sep + "RunFiles" + os.sep) # except WindowsError: except: print "Run files not deleted from " + RunDir + os.sep + OptName shutil.copytree(RunDir + os.sep + OptName, ResultsDir + os.sep + OptName + os.sep + "RunFiles" + os.sep) #----------------------------------------------------------------------------------------------------------------------- # § Graphical post-processing #----------------------------------------------------------------------------------------------------------------------- if ResultReport is True: print("Entering preprocessing mode") OptResultReport.OptResultReport(OptName, OptAlg, DesOptDir, diagrams=1, tables=1, lyx=1) # try: OptResultReport.OptResultReport(OptName, diagrams=1, tables=1, lyx=1) # except: print("Problem with generation of Result Report. Check if all prerequisites are installed") if Video is True: OptVideo.OptVideo(OptName) #----------------------------------------------------------------------------------------------------------------------- # § Print out #----------------------------------------------------------------------------------------------------------------------- if PrintOut is True: print("") print("--------------------------------------------------------------------------------") print("Optimization results - DesOptPy") print("--------------------------------------------------------------------------------") print("Optimization with " + Alg) print("g* = " + str(gOpt)) print("x* = " + str(xOpt.T)) print("f* = " + str(fOpt)) print("Lagrangian multipliers = " + str(lambda_c)) print("Shadow prices = " + str(SPg)) try: print("nGen = " + str(nGen)) except: print("nIter = " + str(nIter)) print("nEval = " + str(nEval)) print("Time of optimization [h:m:s] = " + OptTime) if Debug is False: print("See results directory: " + ResultsDir + os.sep + OptName + os.sep) else: print("Local run, no results saved to results directory") print("--------------------------------------------------------------------------------") if operatingSystem == "Linux" and Alarm is True: t = 1 freq = 350 os.system('play --no-show-progress --null --channels 1 synth %s sine %f' % (t, freq)) return xOpt, fOpt, SPg
""" Created on Tue May 18 20:43:05 2021 @author: denis """ from random import randint from math import floor, log import pandas as pd import numpy as np from pyDOE import fullfact import seaborn as sns import matplotlib.pyplot as plt #Se crea el experimento factorial y se guarda en una matriz fd = fullfact([3, 3, 3]) fd = fd / 2 repeticion = 10 #Usamos la matriz del experimento factorial FS = [] for f in fd: for replica in range(repeticion): modelos = pd.read_csv('digits.txt', sep=' ', header=None) modelos = modelos.replace({'n': f[0], 'g': f[1], 'b': f[2]}) r, c = 7, 5 dim = r * c tasa = 0.15 tranqui = 0.99 tope = 24