def build(self, reduction=20):
"""
Generate the design.
"""
gs = gsd(self.levels, reduction)
self.design = pd.DataFrame(gs, columns=self.names)
def doe(self, **kwargs):
reduction = kwargs.get('reduction', self.reduction)
from pyDOE2 import gsd
doeidx = gsd(self.dnums, reduction)
doe = np.empty(doeidx.shape)
for i in range(self.ndvars):
b0, b1 = self.dbounds[i]
fstr = self.dscale[i]
b0 = self._scale(b0, fstr)
b1 = self._scale(b1, fstr)
n = self.dnums[i]
dvals = np.linspace(b0, b1, n)
idx = doeidx.T[i]
doe.T[i] = self._rescale(dvals[idx], fstr)
self._create_design(doe)
def _generate_design(self, size):
"""
Generate a general subset DOE design.
Parameters
----------
size : int
The number of factors for the design.
Returns
-------
ndarray
The design matrix as a size x levels array of indices.
"""
return pyDOE2.gsd(levels=self._get_all_levels(),
reduction=self._reduction,
n=self._n)
def _new_screening_design(self, reduction='auto'):
factor_items = sorted(self.factors.items())
levels = list()
names = list()
dtypes = list()
for name, factor in factor_items:
names.append(name)
if isinstance(factor, CategoricalFactor):
levels.append(factor.values)
dtypes.append(object)
continue
num_levels = factor.screening_levels
spacing = getattr(factor, 'screening_spacing', 'linear')
min_ = factor.min
max_ = factor.max
if not np.isfinite([min_, max_]).all():
raise ValueError(
'Can\'t perform screening with unbounded factors')
space = np.linspace if spacing == 'linear' else np.logspace
values = space(min_, max_, num_levels)
if isinstance(factor, OrdinalFactor):
values = sorted(np.unique(np.round(values)))
dtypes.append(int)
else:
dtypes.append(float)
levels.append(values)
design_matrix = pyDOE2.gsd(
[len(values) for values in levels],
reduction if reduction is not 'auto' else len(levels))
factor_matrix = list()
for i, (values, dtype) in enumerate(zip(levels, dtypes)):
values = np.array(values)[design_matrix[:, i]]
series = pd.Series(values, dtype=dtype)
factor_matrix.append(series)
self._design_matrix = design_matrix
self._design_sheet = pd.concat(factor_matrix, axis=1, keys=names)
return self._design_sheet
import pyDOE2
import numpy as np
import pandas as pd
# batch size: 32, 64, 128, 256, 512, 1024
# num nodes: 1, 2, 3, 4
# memory size: 1024, 1536, 2048
levels = [6, 3, 3]
reduction = 2
df = pd.DataFrame(pyDOE2.gsd(levels, reduction), columns=[
'batch_size', 'num_nodes', 'memory_size'
])
df['batch_size'] = df['batch_size'].map({0: 32, 1: 64, 2: 128, 3: 256, 4: 512, 5: 1024})
df['num_nodes'] = df['num_nodes'].map({0: 1, 1: 2, 2: 4})
df['memory_size'] = df['memory_size'].map({0: 1024, 1: 1536, 2: 2048})
design_with_repeats = pd.DataFrame(np.repeat(df.values, 5, axis=0))
design_with_repeats.to_csv("gsd3.csv")