def small_nested_blp_simulation() -> SimulationFixture:
"""Solve a simulation with eight markets, linear prices, a linear/nonlinear characteristic, another linear
characteristic, three cost characteristics, and two nesting groups with different nesting parameters.
"""
id_data = build_id_data(T=8, J=18, F=3)
simulation = Simulation(
product_formulations=(Formulation('0 + prices + x + z'),
Formulation('0 + x'),
Formulation('0 + a + b + c')),
product_data={
'market_ids':
id_data.market_ids,
'firm_ids':
id_data.firm_ids,
'nesting_ids':
np.random.RandomState(0).choice(['f', 'g'], id_data.size),
'clustering_ids':
np.random.RandomState(0).choice(range(10), id_data.size)
},
beta=[-5, 1, 2],
sigma=2,
gamma=[2, 1, 1],
rho=[0.1, 0.2],
integration=Integration('product', 3),
xi_variance=0.001,
omega_variance=0.001,
correlation=0.7,
seed=0)
simulation_results = simulation.replace_endogenous()
return simulation, simulation_results, {}, []
def large_nested_logit_simulation() -> SimulationFixture:
"""Solve a simulation with ten markets, a linear constant, linear prices, a linear/cost characteristic, another two
linear characteristics, another three cost characteristics, three nesting groups with the same nesting
parameter, and a log-linear cost specification.
"""
id_data = build_id_data(T=10, J=20, F=9)
simulation = Simulation(
product_formulations=(Formulation('1 + prices + x + y + z'), None,
Formulation('0 + log(x) + a + b + c')),
product_data={
'market_ids':
id_data.market_ids,
'firm_ids':
id_data.firm_ids,
'nesting_ids':
np.random.RandomState(2).choice(['f', 'g', 'h'], id_data.size),
'clustering_ids':
np.random.RandomState(2).choice(range(30), id_data.size)
},
beta=[1, -6, 1, 2, 3],
gamma=[0.1, 0.2, 0.3, 0.5],
rho=0.1,
xi_variance=0.00001,
omega_variance=0.00001,
correlation=0.9,
costs_type='log',
seed=2)
simulation_results = simulation.replace_endogenous()
return simulation, simulation_results, {}, []
def small_blp_simulation() -> SimulationFixture:
"""Solve a simulation with three markets, linear prices, a linear/nonlinear characteristic, two cost
characteristics, and uniform unobserved product characteristics.
"""
id_data = build_id_data(T=3, J=18, F=3)
uniform = 0.001 * np.random.RandomState(0).uniform(size=(id_data.size, 3))
simulation = Simulation(
product_formulations=(Formulation('0 + prices + x'),
Formulation('0 + x'), Formulation('0 + a + b')),
product_data={
'market_ids':
id_data.market_ids,
'firm_ids':
id_data.firm_ids,
'clustering_ids':
np.random.RandomState(0).choice(range(10), id_data.size)
},
beta=[-5, 1],
sigma=2,
gamma=[2, 1],
integration=Integration('product', 3),
xi=uniform[:, 0] + uniform[:, 1],
omega=uniform[:, 0] + uniform[:, 2],
seed=0)
simulation_results = simulation.replace_endogenous()
return simulation, simulation_results, {}, []
def large_logit_simulation() -> SimulationFixture:
"""Solve a simulation with ten markets, a linear constant, linear prices, a linear/cost characteristic, another two
linear characteristics, another two cost characteristics, and a quantity-dependent, log-linear cost specification.
"""
id_data = build_id_data(T=10, J=20, F=9)
simulation = Simulation(product_formulations=(
Formulation('1 + prices + x + y + z'), None,
Formulation('0 + log(x) + a + b + I(0.5 * shares)')),
product_data={
'market_ids':
id_data.market_ids,
'firm_ids':
id_data.firm_ids,
'clustering_ids':
np.random.RandomState(2).choice(
range(30), id_data.size)
},
beta=[1, -6, 1, 2, 3],
gamma=[0.1, 0.2, 0.3, -0.2],
xi_variance=0.00001,
omega_variance=0.00001,
correlation=0.1,
costs_type='log',
seed=2)
simulation_results = simulation.replace_endogenous(constant_costs=False)
return simulation, simulation_results, {}, []
def small_nested_logit_simulation() -> SimulationFixture:
"""Solve a simulation with four markets, linear prices, two linear characteristics, two cost characteristics, and
two nesting groups with different nesting parameters
"""
id_data = build_id_data(T=4, J=18, F=3)
simulation = Simulation(
product_formulations=(Formulation('0 + prices + x + y'), None,
Formulation('0 + a + b')),
product_data={
'market_ids':
id_data.market_ids,
'firm_ids':
id_data.firm_ids,
'nesting_ids':
np.random.RandomState(0).choice(['f', 'g'], id_data.size),
'clustering_ids':
np.random.RandomState(0).choice(range(10), id_data.size)
},
beta=[-5, 1, 1],
gamma=[2, 1],
rho=[0.1, 0.2],
xi_variance=0.001,
omega_variance=0.001,
correlation=0.7,
seed=0)
simulation_results = simulation.replace_endogenous()
return simulation, simulation_results, {}, []
def large_blp_simulation() -> SimulationFixture:
"""Solve a simulation with 20 markets, varying numbers of products per market, a linear constant, log-linear
coefficients on prices, a linear/nonlinear/cost characteristic, another three linear characteristics, another two
cost characteristics, demographics interacted with prices and the linear/nonlinear/cost characteristic, dense
parameter matrices, a log-linear cost specification, and local differentiation instruments.
"""
id_data = build_id_data(T=20, J=20, F=9)
keep = np.arange(id_data.size)
np.random.RandomState(0).shuffle(keep)
id_data = id_data[keep[:int(0.5 * id_data.size)]]
simulation = Simulation(
product_formulations=(Formulation('1 + x + y + z + q'),
Formulation('0 + I(-prices) + x'),
Formulation('0 + log(x) + log(a) + log(b)')),
product_data={
'market_ids':
id_data.market_ids,
'firm_ids':
id_data.firm_ids,
'clustering_ids':
np.random.RandomState(2).choice(range(30), id_data.size)
},
beta=[1, 1, 2, 3, 1],
sigma=[[+0.5, 0], [-0.1, 2]],
pi=[[2, 1, 0], [0, 0, 2]],
gamma=[0.1, 0.2, 0.3],
agent_formulation=Formulation('1 + f + g'),
integration=Integration('product', 4),
xi_variance=0.00001,
omega_variance=0.00001,
correlation=0.9,
distributions=['lognormal', 'normal'],
costs_type='log',
seed=2)
simulation_results = simulation.replace_endogenous()
simulated_data_override = {
'demand_instruments':
np.c_[build_differentiation_instruments(
Formulation('0 + x + y + z + q'), simulation_results.product_data),
build_matrix(Formulation('0 + a + b'), simulation_results.
product_data)],
'supply_instruments':
np.c_[build_differentiation_instruments(
Formulation('0 + x + a + b'), simulation_results.product_data),
build_matrix(Formulation('0 + y + z + q'), simulation_results.
product_data)]
}
simulated_micro_moments = [
FirstChoiceCovarianceMoment(
X2_index=1,
demographics_index=1,
value=0,
market_ids=simulation.unique_market_ids[:5]),
FirstChoiceCovarianceMoment(
X2_index=0,
demographics_index=1,
value=0,
market_ids=simulation.unique_market_ids[-3:])
]
return simulation, simulation_results, simulated_data_override, simulated_micro_moments
def medium_blp_simulation() -> SimulationFixture:
"""Solve a simulation with four markets, linear/nonlinear/cost constants, two linear characteristics, two cost
characteristics, a demographic interacted with second-degree prices, an alternative ownership structure, and a
scaled epsilon.
"""
id_data = build_id_data(T=10, J=25, F=6)
simulation = Simulation(
product_formulations=(Formulation('1 + x + prices'),
Formulation('1 + I(prices**2)'),
Formulation('1 + a + b')),
product_data={
'market_ids':
id_data.market_ids,
'firm_ids':
id_data.firm_ids,
'clustering_ids':
np.random.RandomState(1).choice(range(20), id_data.size),
'ownership':
build_ownership(
id_data, lambda f, g: 1
if f == g else (0.1 if f > 3 and g > 3 else 0))
},
beta=[1, 2, -3],
sigma=[
[0.5, 0],
[0.0, 0],
],
pi=[[+0.0], [-0.1]],
gamma=[1, 1, 2],
agent_formulation=Formulation('0 + f'),
integration=Integration('product', 4),
xi_variance=0.00001,
omega_variance=0.00001,
correlation=0.8,
epsilon_scale=0.7,
seed=1,
)
simulation_results = simulation.replace_endogenous()
simulated_micro_moments = simulation_results.replace_micro_moment_values([
MicroMoment(
name="demographic interaction",
dataset=MicroDataset(
name="inside",
observations=simulation.N,
compute_weights=lambda _, p, a: np.ones((a.size, p.size)),
market_ids=[simulation.unique_market_ids[2]],
),
value=0,
compute_values=lambda _, p, a: p.X2[:, [0]].T * a.
demographics[:, [0]],
)
])
return simulation, simulation_results, {}, simulated_micro_moments
def large_nested_blp_simulation() -> SimulationFixture:
"""Solve a simulation with 20 markets, varying numbers of products per market, a linear constant, log-normal
coefficients on prices, a linear/nonlinear/cost characteristic, another three linear characteristics, another two
cost characteristics, demographics interacted with prices and the linear/nonlinear/cost characteristic, three
nesting groups with the same nesting parameter, and a log-linear cost specification.
"""
id_data = build_id_data(T=20, J=20, F=9)
keep = np.arange(id_data.size)
np.random.RandomState(0).shuffle(keep)
id_data = id_data[keep[:int(0.5 * id_data.size)]]
simulation = Simulation(
product_formulations=(
Formulation('1 + x + y + z + q'),
Formulation('0 + I(-prices) + x'),
Formulation('0 + log(x) + log(a) + log(b)')
),
product_data={
'market_ids': id_data.market_ids,
'firm_ids': id_data.firm_ids,
'nesting_ids': np.random.RandomState(2).choice(['f', 'g', 'h'], id_data.size),
'clustering_ids': np.random.RandomState(2).choice(range(30), id_data.size)
},
beta=[1, 1, 2, 3, 1],
sigma=[
[0.5, 0],
[0.0, 2]
],
pi=[
[2, 1, 0],
[0, 0, 2]
],
gamma=[0.1, 0.2, 0.3],
rho=0.1,
agent_formulation=Formulation('1 + f + g'),
integration=Integration('product', 4),
xi_variance=0.00001,
omega_variance=0.00001,
correlation=0.9,
distributions=['lognormal', 'normal'],
costs_type='log',
seed=2,
)
simulation_results = simulation.replace_endogenous()
simulated_micro_moments = [DemographicExpectationMoment(
product_id=None, demographics_index=1, value=0, market_ids=simulation.unique_market_ids[3:5]
)]
return simulation, simulation_results, {}, simulated_micro_moments
def medium_blp_simulation() -> SimulationFixture:
"""Solve a simulation with four markets, linear/nonlinear/cost constants, two linear characteristics, two cost
characteristics, a demographic interacted with second-degree prices, an alternative ownership structure, and a
scaled epsilon.
"""
id_data = build_id_data(T=4, J=25, F=6)
simulation = Simulation(
product_formulations=(Formulation('1 + x + y'),
Formulation('1 + I(prices**2)'),
Formulation('1 + a + b')),
product_data={
'market_ids':
id_data.market_ids,
'firm_ids':
id_data.firm_ids,
'clustering_ids':
np.random.RandomState(1).choice(range(20), id_data.size),
'ownership':
build_ownership(
id_data, lambda f, g: 1
if f == g else (0.1 if f > 3 and g > 3 else 0))
},
beta=[1, 2, 1],
sigma=[
[0.5, 0],
[0.0, 0],
],
pi=[[+0], [-3]],
gamma=[1, 1, 2],
agent_formulation=Formulation('0 + f'),
integration=Integration('product', 4),
xi_variance=0.0001,
omega_variance=0.0001,
correlation=0.8,
epsilon_scale=0.7,
seed=1,
)
simulation_results = simulation.replace_endogenous()
simulated_micro_moments = [
DemographicCovarianceMoment(
X2_index=0,
demographics_index=0,
value=0,
observations=simulation.N,
market_ids=[simulation.unique_market_ids[2]])
]
return simulation, simulation_results, {}, simulated_micro_moments
def large_blp_simulation() -> SimulationFixture:
"""Solve a simulation with 20 markets, varying numbers of products per market, a linear constant, log-linear
coefficients on prices, a linear/nonlinear/cost characteristic, another three linear characteristics, another two
cost characteristics, demographics interacted with prices and the linear/nonlinear/cost characteristic, dense
parameter matrices, a log-linear cost specification, and local differentiation instruments.
"""
id_data = build_id_data(T=20, J=20, F=9)
keep = np.arange(id_data.size)
np.random.RandomState(0).shuffle(keep)
id_data = id_data[keep[:int(0.5 * id_data.size)]]
product_ids = id_data.market_ids.copy()
for t in np.unique(id_data.market_ids):
product_ids[id_data.market_ids == t] = np.arange(
(id_data.market_ids == t).sum())
simulation = Simulation(
product_formulations=(Formulation('1 + x + y + z + q'),
Formulation('1 + I(-prices) + x'),
Formulation('0 + log(x) + log(a) + log(b)')),
product_data={
'market_ids':
id_data.market_ids,
'firm_ids':
id_data.firm_ids,
'product_ids':
product_ids,
'clustering_ids':
np.random.RandomState(2).choice(range(30), id_data.size)
},
beta=[1, 1, 2, 3, 1],
sigma=[[0, +0.0, 0], [0, +0.5, 0], [0, -0.2, 2]],
pi=[[0, 0, 0], [2, 1, 0], [0, 0, 2]],
gamma=[0.1, 0.2, 0.3],
agent_formulation=Formulation('1 + f + g'),
integration=Integration('product', 4),
xi_variance=0.00001,
omega_variance=0.00001,
correlation=0.9,
distributions=['normal', 'lognormal', 'normal'],
costs_type='log',
seed=2)
simulation_results = simulation.replace_endogenous()
simulated_data_override = {
'demand_instruments':
np.c_[build_differentiation_instruments(
Formulation('0 + x + y + z + q'), simulation_results.product_data),
build_matrix(Formulation('0 + a + b'), simulation_results.
product_data)],
'supply_instruments':
np.c_[build_differentiation_instruments(
Formulation('0 + x + a + b'), simulation_results.product_data),
build_matrix(Formulation('0 + y + z + q'), simulation_results.
product_data)]
}
simulated_micro_moments = [
DemographicExpectationMoment(product_ids=[0],
demographics_index=1,
value=0,
observations=simulation.N),
DemographicExpectationMoment(
product_ids=[None, 0],
demographics_index=1,
value=0,
observations=simulation.N,
market_ids=simulation.unique_market_ids[1:4],
market_weights=[0.2, 0.4, 0.4],
),
DemographicCovarianceMoment(
X2_index=0,
demographics_index=2,
value=0,
observations=simulation.N,
market_ids=simulation.unique_market_ids[3:5]),
DiversionProbabilityMoment(
product_id1=1,
product_id2=0,
value=0,
observations=simulation.N,
market_ids=simulation.unique_market_ids[6:10]),
DiversionProbabilityMoment(
product_id1=None,
product_id2=1,
value=0,
observations=simulation.N,
market_ids=[simulation.unique_market_ids[8]]),
DiversionProbabilityMoment(
product_id1=1,
product_id2=None,
value=0,
observations=simulation.N,
market_ids=[simulation.unique_market_ids[9]]),
DiversionCovarianceMoment(
X2_index1=1,
X2_index2=1,
value=0,
observations=simulation.N,
market_ids=[simulation.unique_market_ids[12]]),
]
return simulation, simulation_results, simulated_data_override, simulated_micro_moments
def large_nested_blp_simulation() -> SimulationFixture:
"""Solve a simulation with 20 markets, varying numbers of products per market, a linear constant, log-normal
coefficients on prices, a linear/nonlinear/cost characteristic, another three linear characteristics, another two
cost characteristics, demographics (including a product-specific one) interacted with prices and the
linear/nonlinear/cost characteristic, three nesting groups with the same nesting parameter, and a log-linear cost
specification.
"""
id_data = build_id_data(T=20, J=20, F=9)
keep = np.arange(id_data.size)
np.random.RandomState(0).shuffle(keep)
id_data = id_data[keep[:int(0.5 * id_data.size)]]
integration = Integration('product', 4)
agent_data = build_integration(integration, 2)
unique_market_ids = np.unique(id_data.market_ids)
max_J = max(i.size for i in get_indices(id_data.market_ids).values())
state = np.random.RandomState(2)
simulation = Simulation(
product_formulations=(Formulation('1 + x + y + z + q'),
Formulation('0 + I(-prices) + x'),
Formulation('0 + log(x) + log(a) + log(b)')),
product_data={
'market_ids': id_data.market_ids,
'firm_ids': id_data.firm_ids,
'nesting_ids': state.choice(['f', 'g', 'h'], id_data.size),
'clustering_ids': state.choice(range(30), id_data.size)
},
agent_data={
'market_ids':
np.repeat(unique_market_ids, agent_data.weights.size),
'agent_ids':
np.tile(np.arange(agent_data.weights.size),
unique_market_ids.size),
'weights':
np.tile(agent_data.weights.flat, unique_market_ids.size),
'nodes':
np.tile(agent_data.nodes, (unique_market_ids.size, 1)),
**{
f'g{j}': state.uniform(size=unique_market_ids.size * agent_data.weights.size)
for j in range(max_J)
},
},
beta=[1, 1, 2, 3, 1],
sigma=[[0.5, 0], [0.0, 2]],
pi=[[2, 1, 0], [0, 0, 2]],
gamma=[0.1, 0.2, 0.3],
rho=0.1,
agent_formulation=Formulation('1 + f + g'),
xi_variance=0.00001,
omega_variance=0.00001,
correlation=0.9,
rc_types=['log', 'linear'],
costs_type='log',
seed=0,
)
simulation_results = simulation.replace_endogenous()
simulated_micro_moments = simulation_results.replace_micro_moment_values([
MicroMoment(
name="expectation for agents 0, 1",
dataset=MicroDataset(
name="agents 0, 1",
observations=simulation.N,
compute_weights=lambda _, p, a: np.tile(
(a.agent_ids == 0) | (a.agent_ids == 1), (1, p.size)),
market_ids=simulation.unique_market_ids[5:6],
),
value=0,
compute_values=lambda _, p, a: np.tile(p.X2[:, 0], (a.size, 1)),
),
MicroMoment(
name="expectation for agent 2",
dataset=MicroDataset(
name="agent 2",
observations=simulation.N,
compute_weights=lambda _, p, a: np.tile((a.agent_ids == 2),
(1, p.size)),
market_ids=simulation.unique_market_ids[6:7],
),
value=0,
compute_values=lambda _, p, a: np.tile(p.X2[:, 0], (a.size, 1)),
),
])
return simulation, simulation_results, {}, simulated_micro_moments
def large_blp_simulation() -> SimulationFixture:
"""Solve a simulation with 20 markets, varying numbers of products per market, a linear constant, log-linear
coefficients on prices, a linear/nonlinear/cost characteristic, another three linear characteristics, another two
cost characteristics, demographics interacted with prices and the linear/nonlinear/cost characteristic, dense
parameter matrices, a log-linear cost specification, and local differentiation instruments.
"""
id_data = build_id_data(T=20, J=20, F=9)
keep = np.arange(id_data.size)
np.random.RandomState(0).shuffle(keep)
id_data = id_data[keep[:int(0.5 * id_data.size)]]
product_ids = id_data.market_ids.copy()
for t in np.unique(id_data.market_ids):
product_ids[id_data.market_ids == t] = np.arange(
(id_data.market_ids == t).sum())
simulation = Simulation(
product_formulations=(Formulation('1 + x + y + z + q'),
Formulation('1 + I(-prices) + x'),
Formulation('0 + log(x) + log(a) + log(b)')),
product_data={
'market_ids':
id_data.market_ids,
'firm_ids':
id_data.firm_ids,
'product_ids':
product_ids,
'clustering_ids':
np.random.RandomState(2).choice(range(30), id_data.size)
},
beta=[1, 1, 2, 3, 1],
sigma=[[0, +0.0, 0], [0, +0.5, 0], [0, -0.2, 2]],
pi=[[0, 0, 0], [2, 1, 0], [0, 0, 2]],
gamma=[0.1, 0.2, 0.3],
agent_formulation=Formulation('1 + f + g'),
integration=Integration('product', 4),
xi_variance=0.00001,
omega_variance=0.00001,
correlation=0.9,
rc_types=['linear', 'log', 'linear'],
costs_type='log',
seed=2,
)
simulation_results = simulation.replace_endogenous()
simulated_data_override = {
'demand_instruments':
np.c_[build_differentiation_instruments(
Formulation('0 + x + y + z + q'), simulation_results.product_data),
build_matrix(Formulation('0 + a + b'), simulation_results.
product_data)],
'supply_instruments':
np.c_[build_differentiation_instruments(
Formulation('0 + x + a + b'), simulation_results.product_data),
build_matrix(Formulation('0 + y + z + q'), simulation_results.
product_data)]
}
inside_diversion_micro_dataset = MicroDataset(
name="diversion from 1",
observations=simulation.N,
compute_weights=lambda _, p, a: np.tile(p.product_ids == 1,
(a.size, 1, 1 + p.size)),
market_ids=simulation.unique_market_ids[6:10],
)
outside_diversion_micro_dataset = MicroDataset(
name="diversion from outside",
observations=simulation.N,
compute_weights=lambda _, p, a: np.concatenate([
np.ones((a.size, 1, 1 + p.size)),
np.zeros((a.size, p.size, 1 + p.size))
],
axis=1),
market_ids=[simulation.unique_market_ids[8]],
)
simulated_micro_moments = simulation_results.replace_micro_moment_values([
MicroMoment(
name="demographic 1 expectation for 0",
dataset=MicroDataset(
name="product 0",
observations=simulation.N,
compute_weights=lambda _, p, a: np.tile(
p.product_ids.flat == 0, (a.size, 1)),
),
value=0,
compute_values=lambda _, p, a: np.tile(a.demographics[:, [1]],
(1, p.size)),
),
MicroMoment(
name="demographic 1 expectation for 0 and outside",
dataset=MicroDataset(
name="product 0 and outside",
observations=simulation.N,
compute_weights=lambda _, p, a: np.c_[
np.ones((a.size, 1)),
np.tile(p.product_ids.flat == 0, (a.size, 1))],
market_ids=simulation.unique_market_ids[1:4],
),
value=0,
compute_values=lambda _, p, a: np.tile(a.demographics[:, [1]],
(1, 1 + p.size)),
),
MicroMoment(
name="1 to 0 diversion ratio",
dataset=inside_diversion_micro_dataset,
value=0,
compute_values=lambda _, p, a: np.concatenate([
np.zeros((a.size, p.size, 1)),
np.tile(p.product_ids.flat == 0, (a.size, p.size, 1))
],
axis=2),
),
MicroMoment(
name="outside to 1 diversion ratio",
dataset=outside_diversion_micro_dataset,
value=0,
compute_values=lambda _, p, a: np.concatenate([
np.zeros((a.size, 1 + p.size, 1)),
np.tile(p.product_ids.flat == 1, (a.size, 1 + p.size, 1))
],
axis=2),
),
MicroMoment(
name="1 to outside diversion ratio",
dataset=inside_diversion_micro_dataset,
value=0,
compute_values=lambda _, p, a: np.concatenate([
np.ones((a.size, p.size, 1)),
np.zeros((a.size, p.size, p.size))
],
axis=2),
),
MicroMoment(
name="diversion interaction",
dataset=MicroDataset(
name="inside first and second",
observations=simulation.N,
compute_weights=lambda _, p, a: np.ones(
(a.size, p.size, p.size)),
market_ids=[simulation.unique_market_ids[12]],
),
value=0,
compute_values=lambda _, p, a:
(np.tile(p.X2[:, [1]],
(a.size, 1, p.size)) * np.tile(p.X2[:, [1]].T,
(a.size, p.size, 1))),
),
])
return simulation, simulation_results, simulated_data_override, simulated_micro_moments
