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_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 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_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, and an alternative ownership structure.
"""
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')),
beta=[1, 2, 1],
sigma=[
[0.5, 0],
[0.0, 0],
],
gamma=[1, 1, 2],
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))
},
agent_formulation=Formulation('0 + f'),
pi=[[+0], [-3]],
integration=Integration('product', 4),
xi_variance=0.0001,
omega_variance=0.0001,
correlation=0.8,
seed=1)
return simulation, simulation.solve()
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 small_logit_simulation() -> SimulationFixture:
"""Solve a simulation with two markets, a linear constant, linear prices, a linear characteristic, a cost
characteristic, and an acquisition.
"""
id_data = build_id_data(T=2, J=18, F=3, mergers=[{1: 0}])
simulation = Simulation(
product_formulations=(
Formulation('1 + prices + x'),
None,
Formulation('0 + a')
),
beta=[1, -5, 1],
sigma=None,
gamma=2,
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)
},
xi_variance=0.001,
omega_variance=0.001,
correlation=0.7,
seed=0
)
return simulation, simulation.solve()
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 three cost characteristics, 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')),
beta=[1, -6, 1, 2, 3],
sigma=None,
gamma=[0.1, 0.2, 0.3, 0.5],
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)
},
xi_variance=0.00001,
omega_variance=0.00001,
correlation=0.1,
costs_type='log',
seed=2)
return simulation, simulation.solve()
def large_simulation():
"""Solve a simulation with ten markets, linear/nonlinear prices, a linear constant, a cost/linear/nonlinear
characteristic, another three cost characteristics, another two linear characteristics, demographics interacted with
prices and the cost/linear/nonlinear characteristic, dense parameter matrices, an acquisition, a triple acquisition,
and a log-linear cost specification.
"""
simulation = Simulation(
product_formulations=(Formulation('1 + prices + x + y + z'),
Formulation('0 + prices + x'),
Formulation('0 + log(x) + a + b + c')),
beta=[1, -6, 1, 2, 3],
sigma=[[1, -0.1], [0, 2]],
gamma=[0.1, 0.2, 0.3, 0.5],
product_data=build_id_data(
T=10, J=20, F=9, mergers=[{f: 4 + int(f > 0)
for f in range(4)}]),
agent_formulation=Formulation('0 + f + g'),
pi=[[1, 0], [0, 2]],
integration=Integration('product', 4),
xi_variance=0.00001,
omega_variance=0.00001,
correlation=0.9,
linear_costs=False,
seed=2)
clustering_ids = np.random.choice(['a', 'b', 'c', 'd'], simulation.N)
product_data = np.lib.recfunctions.rec_append_fields(
simulation.solve(), 'clustering_ids', clustering_ids)
return simulation, product_data
def small_blp_simulation() -> SimulationFixture:
"""Solve a simulation with three markets, linear prices, a linear/nonlinear characteristic, two cost
characteristics, and an acquisition.
"""
id_data = build_id_data(T=3, J=18, F=3, mergers=[{1: 0}])
simulation = Simulation(
product_formulations=(
Formulation('0 + prices + x'),
Formulation('0 + x'),
Formulation('0 + a + b')
),
beta=[-5, 1],
sigma=2,
gamma=[2, 1],
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)
},
integration=Integration('product', 3),
xi_variance=0.001,
omega_variance=0.001,
correlation=0.7,
seed=0
)
return simulation, simulation.solve()
def medium_simulation():
"""Solve a simulation with four markets, a nonlinear/cost constant, two linear characteristics, two cost
characteristics, a demographic interacted with prices, a double acquisition, and a non-standard ownership structure.
"""
id_data = build_id_data(T=4, J=25, F=6, mergers=[{f: 2 for f in range(2)}])
simulation = Simulation(
product_formulations=(
Formulation('0 + x + y'),
Formulation('1 + prices'),
Formulation('1 + a + b')
),
beta=[2, 1],
sigma=[
[0.5, 0],
[0, 0],
],
gamma=[1, 1, 2],
product_data={
'market_ids': id_data.market_ids,
'firm_ids': id_data.firm_ids,
'ownership': build_ownership(id_data, lambda f, g: 1 if f == g else (0.1 if f > 3 and g > 3 else 0))
},
agent_formulation=Formulation('0 + f'),
pi=[
[ 0],
[-3]
],
integration=Integration('product', 4),
xi_variance=0.0001,
omega_variance=0.0001,
correlation=0.8,
seed=1
)
return simulation, simulation.solve()
def small_logit_simulation() -> SimulationFixture:
"""Solve a simulation with two markets, a linear constant, linear prices, a linear characteristic, a cost
characteristic, and a scaled epsilon.
"""
id_data = build_id_data(T=2, J=18, F=3)
simulation = Simulation(
product_formulations=(Formulation('1 + prices + x'), None,
Formulation('0 + a')),
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=[1, -5, 1],
gamma=2,
xi_variance=0.001,
omega_variance=0.001,
correlation=0.7,
epsilon_scale=0.5,
seed=0,
)
simulation_results = simulation.replace_exogenous('x', 'a')
return simulation, simulation_results, {}, []
def small_simulation():
"""Solve a simulation with two markets, linear prices, a nonlinear characteristic, a cost characteristic, and an
acquisition.
"""
simulation = Simulation(product_formulations=(Formulation('0 + prices'),
Formulation('0 + x'),
Formulation('0 + a')),
beta=-5,
sigma=1,
gamma=2,
product_data=build_id_data(T=2,
J=18,
F=3,
mergers=[{
1: 0
}]),
integration=Integration('product', 3),
xi_variance=0.001,
omega_variance=0.001,
correlation=0.7,
seed=0)
clustering_ids = np.random.choice(['a', 'b'], simulation.N)
product_data = np.lib.recfunctions.rec_append_fields(
simulation.solve(), 'clustering_ids', clustering_ids)
return simulation, product_data
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, linear/nonlinear
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 on the demand side.
"""
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 + prices + x + y + z + q'),
Formulation('0 + prices + x'),
Formulation('0 + log(x) + log(a) + log(b)')),
beta=[1, -10, 1, 2, 3, 1],
sigma=[[1, -0.1], [0, +2.0]],
gamma=[0.1, 0.2, 0.3],
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)
},
agent_formulation=Formulation('0 + f + g'),
pi=[[1, 0], [0, 2]],
integration=Integration('product', 4),
xi_variance=0.00001,
omega_variance=0.00001,
correlation=0.9,
costs_type='log',
seed=2)
simulation_results = simulation.solve()
differentiation_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
)]
simulation_results.product_data = update_matrices(
simulation_results.product_data, {
'demand_instruments':
(differentiation_instruments,
simulation_results.product_data.demand_instruments.dtype)
})
return simulation, simulation_results
def large_nested_blp_simulation() -> SimulationFixture:
"""Solve a simulation with 20 markets, varying numbers of products per market, a linear constant, linear/nonlinear
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 + prices + x + y + z + q'),
Formulation('0 + 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, -10, 1, 2, 3, 1],
sigma=[[1, 0], [0, 2]],
pi=[[1, 0], [0, 2]],
gamma=[0.1, 0.2, 0.3],
rho=0.1,
agent_formulation=Formulation('0 + f + g'),
integration=Integration('product', 4),
xi_variance=0.00001,
omega_variance=0.00001,
correlation=0.9,
costs_type='log',
seed=2)
simulation_results = simulation.solve()
simulated_micro_moments = [
ProductsAgentsCovarianceMoment(X2_index=0,
demographics_index=0,
value=0),
ProductsAgentsCovarianceMoment(X2_index=1,
demographics_index=1,
value=0)
]
return simulation, simulation_results, simulated_micro_moments
def small_simulation():
"""Solve a simulation with two markets, linear prices, a nonlinear characteristic, a cost characteristic, and an
acquisition.
"""
simulation = Simulation(
product_formulations=(
Formulation('0 + prices'),
Formulation('0 + x'),
Formulation('0 + a')
),
beta=-5,
sigma=1,
gamma=2,
product_data=build_id_data(T=2, J=18, F=3, mergers=[{1: 0}]),
integration=Integration('product', 3),
xi_variance=0.001,
omega_variance=0.001,
correlation=0.7,
seed=0
)
return simulation, simulation.solve()
def large_nested_blp_simulation() -> SimulationFixture:
"""Solve a simulation with ten markets, a linear constant, linear/nonlinear prices, a linear/nonlinear/cost
characteristic, another three linear characteristics, another four cost characteristics, demographics interacted
with prices and the linear/nonlinear/cost characteristic, three nesting groups with the same nesting parameter, an
acquisition, a triple acquisition, and a log-linear cost specification.
"""
id_data = build_id_data(T=10, J=20, F=9, mergers=[{f: 4 + int(f > 0) for f in range(4)}])
simulation = Simulation(
product_formulations=(
Formulation('1 + prices + x + y + z + q'),
Formulation('0 + prices + x'),
Formulation('0 + log(x) + a + b + c + d')
),
beta=[1, -10, 1, 2, 3, 1],
sigma=[
[1, 0],
[0, 2]
],
gamma=[0.1, 0.2, 0.3, 0.1, 0.3],
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)
},
agent_formulation=Formulation('0 + f + g'),
pi=[
[1, 0],
[0, 2]
],
integration=Integration('product', 4),
rho=0.05,
xi_variance=0.00001,
omega_variance=0.00001,
correlation=0.9,
costs_type='log',
seed=2
)
return simulation, simulation.solve()
def run_simulation(n_firms,betas,gammas,kappa=0,maverick=False):
config_data=pyblp.build_id_data(T=1, J=n_firms, F=n_firms)
mutable_id_data = {k: config_data[k] for k in config_data.dtype.names}
mutable_id_data['ownership']=construct_ownership(n_firms,kappa,maverick)
simulation = pyblp.Simulation(product_formulations=(pyblp.Formulation('1 + prices+x1'), None, pyblp.Formulation('1+x1')),
beta=betas, sigma=None, gamma=gammas,xi_variance=1e-6, omega_variance=1e-6,
product_data=mutable_id_data, seed=0)
# solve the simulation for P+Q
prod_data=simulation.replace_endogenous()
# Construct a Problem and Solve
# Don't estimate a model since we know the answers and only want to do counterfactuals
res=prod_data.to_problem().solve(beta=betas,gamma=gammas,sigma=None,optimization=pyblp.Optimization('return'))
# Pull the calculated P,Q,Profits,Diversion,etc
inside_share=np.sum(prod_data.product_data['shares'])
prices=np.mean(prod_data.product_data['prices'])
og_diversion=np.mean(np.diag(res.compute_diversion_ratios()))
own_elas=np.diag(res.compute_elasticities()).mean()
total_pi=res.compute_profits().sum()
return (inside_share,prices,og_diversion,own_elas,total_pi)
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
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,
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
