# %% # 1. Sobol sequence dimension = 2 size = 1024 sequence = ot.SobolSequence(2) sample = sequence.generate(size) graph = ot.Graph("Sobol", "", "", True, "") cloud = ot.Cloud(sample) graph.add(cloud) view = viewer.View(graph) # %% # 2. Halton sequence dimension = 2 sequence = ot.HaltonSequence(2) sample = sequence.generate(size) graph = ot.Graph("Halton", "", "", True, "") cloud = ot.Cloud(sample) graph.add(cloud) view = viewer.View(graph) # %% # 3. Reverse Halton sequence sequence = ot.ReverseHaltonSequence(dimension) sample = sequence.generate(size) print('discrepancy=', ot.LowDiscrepancySequenceImplementation.ComputeStarDiscrepancy(sample)) graph = ot.Graph("Reverse Halton", "", "", True, "") cloud = ot.Cloud(sample) graph.add(cloud)
fig.set_size_inches(6, 6) # %% # We have elementary intervals in 2 dimensions, each having a volume equal to 1/8. Since there are 32 points, the Sobol' sequence is so that each elementary interval contains exactly 32/8 = 4 points. Notice that each elementary interval is closed on the left (or bottom) and open on the right (or top). # %% # Halton low discrepancy sequence # ------------------------------- # %% dim = 2 distribution = ot.ComposedDistribution([ot.Uniform()]*dim) bounds = distribution.getRange() # %% sequence = ot.HaltonSequence(dim) # %% samplesize = 2**2 * 3**2 # Halton sequence uses prime numbers 2 and 3 in two dimensions. experiment = ot.LowDiscrepancyExperiment(sequence, distribution, samplesize, False) sample = experiment.generate() # %% samplesize # %% subdivisions = [2**2, 3] fig = otv.PlotDesign(sample, bounds, subdivisions); fig.set_size_inches(6, 6) # %%
def __init__(self, n_samples, bounds, kind, dists=None, discrete=None): """Initialize the DOE generation. In case of :attr:`kind` is ``uniform``, :attr:`n_samples` is decimated in order to have the same number of points in all dimensions. If :attr:`kind` is ``discrete``, a join distribution between a discrete uniform distribution is made with continuous distributions. Another possibility is to set a list of PDF to sample from. Thus one can do: `dists=['Uniform(15., 60.)', 'Normal(4035., 400.)']`. If not set, uniform distributions are used. :param int n_samples: number of samples. :param array_like bounds: Space's corners [[min, n dim], [max, n dim]] :param str kind: Sampling Method if string can be one of ['halton', 'sobol', 'faure', '[o]lhs[c]', 'sobolscramble', 'uniform', 'discrete'] otherwize can be a list of openturns distributions. :param lst(str) dists: List of valid openturns distributions as string. :param int discrete: Position of the discrete variable. """ self.n_samples = n_samples self.bounds = np.asarray(bounds) self.kind = kind self.dim = self.bounds.shape[1] self.scaler = preprocessing.MinMaxScaler() self.scaler.fit(self.bounds) if dists is None: dists = [ot.Uniform(float(self.bounds[0][i]), float(self.bounds[1][i])) for i in range(self.dim)] else: dists = bat.space.dists_to_ot(dists) if discrete is not None: # Creating uniform discrete distribution for OT disc_list = [[i] for i in range(int(self.bounds[0, discrete]), int(self.bounds[1, discrete] + 1))] disc_dist = ot.UserDefined(disc_list) dists.pop(discrete) dists.insert(discrete, disc_dist) # Join distribution self.distribution = ot.ComposedDistribution(dists) if self.kind == 'halton': self.sequence_type = ot.LowDiscrepancyExperiment(ot.HaltonSequence(), self.distribution, self.n_samples) elif self.kind == 'sobol': self.sequence_type = ot.LowDiscrepancyExperiment(ot.SobolSequence(), self.distribution, self.n_samples) elif self.kind == 'faure': self.sequence_type = ot.LowDiscrepancyExperiment(ot.FaureSequence(), self.distribution, self.n_samples) elif (self.kind == 'lhs') or (self.kind == 'lhsc'): self.sequence_type = ot.LHSExperiment(self.distribution, self.n_samples) elif self.kind == 'olhs': lhs = ot.LHSExperiment(self.distribution, self.n_samples) self.sequence_type = ot.SimulatedAnnealingLHS(lhs, ot.GeometricProfile(), ot.SpaceFillingC2()) elif self.kind == 'saltelli': # Only relevant for computation of Sobol' indices size = self.n_samples // (2 * self.dim + 2) # N(2*dim + 2) self.sequence_type = ot.SobolIndicesExperiment(self.distribution, size, True).generate()
# %% # 1. Sobol sequence dimension = 2 size = 1024 sequence = ot.SobolSequence(dimension) sample = sequence.generate(size) graph = ot.Graph("Sobol", "", "", True, "") cloud = ot.Cloud(sample) graph.add(cloud) view = viewer.View(graph) # %% # 2. Halton sequence dimension = 2 sequence = ot.HaltonSequence(dimension) sample = sequence.generate(size) graph = ot.Graph("Halton", "", "", True, "") cloud = ot.Cloud(sample) graph.add(cloud) view = viewer.View(graph) # %% # 3. Halton sequence in high dimension: bad filling in upper dimensions dimension = 20 sequence = ot.HaltonSequence(dimension) sample = sequence.generate(size).getMarginal([dimension - 2, dimension - 1]) graph = ot.Graph( "Halton (" + str(dimension - 2) + "," + str(dimension - 1) + ")", "dim " + str(dimension - 2), "dim " + str(dimension - 1), True, "") cloud = ot.Cloud(sample)
def myHaltonLowDiscrepancyExperiment(distribution, size, model): sequence = ot.HaltonSequence(distribution.getDimension()) experiment = ot.LowDiscrepancyExperiment(sequence, distribution, size) sensitivity_algorithm = ot.SaltelliSensitivityAlgorithm(experiment, model) return sensitivity_algorithm
def __init__(self): # Load data df = pd.read_stata('sample.dta') # x1 variables enter the linear part of the estimation self.x1 = df.as_matrix(['var8', 'price', 'char1', 'char2']) # x2 variables enter the non-linear part self.x2 = df.as_matrix(['char1', 'char2']) # number of random coefficients self.nrc = self.x2.shape[1] # number of simulated "indviduals" per market self.ns = 200 # number of markets, mktid = 1, 2, ..., 100 self.nmkt = df['mktid'].max() - df['mktid'].min() + 1 # number of brands per market. if the numebr differs by market this requires some "accounting" vector self.num_prod = df[['prodid', 'mktid' ]].groupby(['mktid']).agg(['count']).as_matrix() # this vector relates each observation to the market it is in self.cdid = np.kron( np.array([i for i in range(self.nmkt)], ndmin=2).T, np.ones((100, 1))) self.cdid = self.cdid.reshape(self.cdid.shape[0]).astype('int') # this vector provides for each index the of the last observation # in the data used here all brands appear in all markets. if this # is not the case the two vectors, cdid and cdindex, have to be # created in a different fashion but the rest of the program works fine. # cdindex = [nbrn:nbrn:nbrn*nmkt]'; self.cdindex = np.array( [i for i in range((100 - 1), 100 * self.nmkt, 100)]) # the market share of product j in market t self.s_jt = df.as_matrix(['sjt']) # the outside option share of product j in market t self.s_0t = df.as_matrix(['s0t']) # Load IV for the instruments and the x's. self.IV = df.as_matrix([ 'var8', 'char1', 'char2', 'z1', 'z2', 'z3', 'z4', 'z5', 'z6', 'z7', 'z8', 'z9', 'z10' ]) # create initial weight matrix self.invA = np.linalg.inv(self.IV.T @ self.IV) # The following codes compute logit results and save the mean utility as initial values for the search below # compute logit results and save the mean utility as initial values for the search below y = np.log(self.s_jt / self.s_0t) mid = self.x1.T @ self.IV @ self.invA @ self.IV.T self.init_theta = np.linalg.inv(mid @ self.x1) @ mid @ y self.old_delta = self.x1 @ self.init_theta self.old_delta_exp = np.exp(self.old_delta) self.V_names = ['Constant', 'Price', 'Char1', 'Char2'] self.df_logit_iv = pd.DataFrame(self.init_theta, index=self.V_names) self.df_logit_iv.columns = ['Coef.'] # create initial values for random coefficients, price, char1, char2 # np.random.seed(1) # self.init_theta2 = np.absolute(np.random.normal(0, 1 , (self.nrc,1))) self.init_theta2 = np.ones((self.nrc, 1)) # drawing from Halton sequence with self.ns draws across self.nrc, the number of random coefficients # x = halton_sequence(self.ns + 1, self.nrc) # v = np.asarray(x) # drawing from Halton sequence with self.ns draws across self.nrc, the number of random coefficients self.v = np.array(ot.HaltonSequence(self.nrc).generate(self.ns)) # convert halton sequence into normal dist. draws self.vi = norm.ppf(self.v) self.gmmvalold = 0 self.gmmdiff = 1 self.iter = 0 # self.theta2 = self.theta2_init self.delta = self.meanval(self.init_theta2) self.gmmresid = self.delta - self.x1 @ self.init_theta