Secure your code as it's written. Use Snyk Code to scan source code in minutes - no build needed - and fix issues immediately.
coffee_design = coffee_design.append(pd.DataFrame(center_points * 2, columns=coffee_design.columns))
coffee_design.index = np.arange(0, len(coffee_design))
model = ' + '.join(coffee_design.columns)
factorial_power = dexpy.power.f_power(model, coffee_design, sn, alpha)
factorial_power.pop(0) # remove intercept
factorial_power = ['{0:.2f}%'.format(i*100) for i in factorial_power] # convert to %
factorial_power = pd.DataFrame(factorial_power,
columns=['Power'],
index=coffee_design.columns)
print("\nPower for fractional factorial:")
print(factorial_power)
twofi_model = "(" + '+'.join(coffee_design.columns) + ")**2"
desc = patsy.ModelDesc.from_formula(twofi_model)
factorial_power = dexpy.power.f_power(twofi_model, coffee_design, sn, alpha)
factorial_power.pop(0) # remove intercept
factorial_power = ['{0:.2f}%'.format(i*100) for i in factorial_power] # convert to %
factorial_power = pd.DataFrame(factorial_power,
columns=['Power'],
index=desc.describe().strip("~ ").split(" + "))
print("\nPower for fractional factorial (2FI model):")
print(factorial_power)
# results of the experiment
coffee_design['taste_rating'] = [
4.4, 5.8, 6.8, 4.6, 2.6, 5, 6.2, 3.4,
5.6, 5, 5.8, 6.6, 6.2, 3.4, 5, 6.4,
6, 6, 6.8, 6, 6, 6.2, 5, 6.4
]
def bootstrap(factor_names, model, run_count):
"""Create a minimal starting design that is non-singular."""
md = ModelDesc.from_formula(model)
model_size = len(md.rhs_termlist)
if run_count == 0:
run_count = model_size
if model_size > run_count:
raise ValueError("Can't build a design of size {} "
"for a model of rank {}. "
"Model: '{}'".format(run_count, model_size, model))
factor_count = len(factor_names)
x0 = np.zeros(factor_count)
# add high/low bounds to constraint matrix
constraint_matrix = np.zeros((factor_count * 2, factor_count))
bounds = np.zeros(factor_count * 2)
c = 0
for f in range(factor_count):
constraint_matrix[c][f] = -1
def _drop_intercept(formula, add_intercept):
"""Drop the intercept from formula if not add_intercept"""
if not add_intercept:
if not isinstance(formula, ModelDesc):
formula = ModelDesc.from_formula(formula)
if INTERCEPT in formula.rhs_termlist:
formula.rhs_termlist.remove(INTERCEPT)
return formula
return formula
def get_terms_in_formula(formula):
model_desc = ModelDesc.from_formula(formula)
return sorted(
set(
factor.name().replace("C(", "").replace(")", "")
for side in [model_desc.lhs_termlist, model_desc.rhs_termlist]
for term in side
for factor in term.factors
)
def _rerp_design(formula, events, eval_env):
# Tricky bit: the specifies a RHS-only formula, but really we have an
# implicit LHS (determined by the event_query). This makes things
# complicated when it comes to e.g. keeping track of which items survived
# NA removal, determining the number of rows in an intercept-only formula,
# etc. Really we want patsy to just treat all this stuff the same way as
# it normally handles a LHS~RHS formula. So, we convert our RHS formula
# into a LHS~RHS formula, using a special LHS that represents each event
# by a placeholder integer!
desc = ModelDesc.from_formula(formula, eval_env)
if desc.lhs_termlist:
raise ValueError("Formula cannot have a left-hand side")
desc.lhs_termlist = [Term([_RangeFactor(len(events))])]
fake_lhs, design = dmatrices(desc, _FormulaEnv(events))
surviving_event_idxes = np.asarray(fake_lhs, dtype=int).ravel()
design_row_idxes = np.empty(len(events), dtype=int)
design_row_idxes.fill(-1)
design_row_idxes[surviving_event_idxes] = np.arange(design.shape[0])
# Now design_row_idxes[i] is -1 if event i was thrown out, and
# otherwise gives the row in 'design' which refers to event 'i'.
return design, design_row_idxes