def get_nevo_nested():
tick()
problem_nl = pyblp.Problem(**nl_options)
results_nl = problem_nl.solve(rho=0.375,optimization=pyblp.Optimization('return'))
save_pyblp_results(results_nl, problem_nl,filename_nl)
tock()
return results_nl
def load_blp_base(problem, filename):
base_res = np.load(filename, allow_pickle=True)
dict_W = base_res.item().get('W')
dict_delta = base_res.item().get('delta')
dict_gamma = base_res.item().get('gamma')
dict_beta = base_res.item().get('beta')
dict_sigma = base_res.item().get('sigma')
dict_pi = base_res.item().get('pi')
## Use these to quickly get the exact results as estimation
fast_options = dict(method='1s',
check_optimality='gradient',
costs_bounds=(0.001, None),
W_type='clustered',
se_type='clustered',
initial_update=False,
iteration=pyblp.Iteration('squarem', {'atol': 1e-14}),
optimization=pyblp.Optimization('return'),
scale_objective=False,
W=dict_W,
delta=dict_delta,
beta=dict_beta,
gamma=dict_gamma,
sigma=dict_sigma,
pi=dict_pi)
results_fast = problem.solve(**fast_options)
return results_fast
def solve_nl_nevo(df, rho=0.375):
groups = df.groupby(['market_ids', 'nesting_ids'])
df['demand_instruments20'] = groups['shares'].transform(np.size)
nl_formulation = pyblp.Formulation('0 + prices')
problem = pyblp.Problem(nl_formulation, df)
res = problem.solve(rho=rho, optimization=pyblp.Optimization('return'))
og = res.extract_diagonals(res.compute_diversion_ratios()).mean()
print(og)
return problem, res
def fakeBLP():
product_data = pd.read_csv(pyblp.data.NEVO_PRODUCTS_LOCATION)
X1_formulation = pyblp.Formulation('0 + prices', absorb='C(product_ids)')
X2_formulation = pyblp.Formulation('1 + prices + sugar + mushy')
product_formulations = (X1_formulation, X2_formulation)
mc_integration = pyblp.Integration('monte_carlo', size=50, seed=0)
pr_integration = pyblp.Integration('product', size=5)
mc_problem = pyblp.Problem(product_formulations,
product_data,
integration=mc_integration)
pr_problem = pyblp.Problem(product_formulations,
product_data,
integration=pr_integration)
bfgs = pyblp.Optimization('bfgs')
results1 = mc_problem.solve(sigma=np.eye(4), optimization=bfgs)
elasticities = results1.compute_elasticities()
diversions = results1.compute_diversion_ratios()
print(results1)
print(diversions)
single_market = product_data['market_ids'] == 'C01Q1'
plt.colorbar(plt.matshow(diversions[single_market]))
def runBLP(parms, data):
X1_formulation = pyblp.Formulation('0 + prices', absorb='C(product_ids)')
X2_formulation = pyblp.Formulation('1 + prices + protein + fat')
product_formulations = (X1_formulation, X2_formulation)
mc_integration = pyblp.Integration('monte_carlo', size=50, seed=0)
pr_integration = pyblp.Integration('product', size=5)
mc_problem = pyblp.Problem(product_formulations,
data,
integration=mc_integration)
pr_problem = pyblp.Problem(product_formulations,
data,
integration=pr_integration)
# this is not the ideal optimizer and needs to be changed once the code has been proven to work
opt = pyblp.Optimization('l-bfgs-b')
#results1 = mc_problem.solve(sigma=np.ones((4, 4)), optimization=bfgs)
results1 = mc_problem.solve(sigma=np.eye(4), optimization=opt)
print(results1)
elasticities = results1.compute_elasticities()
diversions = results1.compute_diversion_ratios()
single_market = data['market_ids'] == 18
plt.colorbar(plt.matshow(elasticities[single_market]))
plt.colorbar(plt.matshow(diversions[single_market]))
plt.show()
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)
# In[5]:
product_data.describe()
# In[6]:
X1_formulation = pyblp.Formulation('0 + quality + prices + satellite + wired')
X2_formulation = pyblp.Formulation('0 + satellite + wired')
product_formulations = (X1_formulation, X2_formulation)
SIGMA0 = np.eye(2)
SIGMA_BOUNDS = ([[-1e2, -1e2], [-1e2, -1e2]], [[1e2, 1e2], [1e2, 1e2]])
BETA_BOUNDS = ([1e-3, -1e2, 1e-3, 1e-3], [1e2, -1e-3, 1e2, 1e2])
INTEGRATION = pyblp.Integration('product', size=17)
OPTI = pyblp.Optimization('l-bfgs-b', {'gtol': 1e-6})
# In[7]:
# estimate the model
problem = pyblp.Problem(product_formulations,
product_data,
integration=INTEGRATION)
results_demand = problem.solve(sigma=SIGMA0,
optimization=OPTI,
sigma_bounds=SIGMA_BOUNDS,
beta_bounds=BETA_BOUNDS)
# In[8]:
# update the results with optimal instruments
forms = (x1_form, x2_form)
agent_form = blp.Formulation('0 + income + income_sq + age + child')
# simulate 20 individuals
"""
There appear to be some irregularities in the 'v' and 'demog' data from
Nevo--they don't appear to represent what the document says they do;
load the Nevo data directly to get sensible results
"""
demog = pd.read_csv(blp.data.NEVO_AGENTS_LOCATION)
agent_form = blp.Formulation('0 + income + income_squared + age + child')
problem = blp.Problem(forms, ps3, agent_form, demog)
# make initial guess for sigma and pi
sigma0 = np.diag([0.3302, 2.4526, 0.0163, 0.2441])
pi0 = np.array([[5.4819, 0, 0.2037, 0], [15.8935, -1.2000, 0, 2.6342],
[-0.2506, 0, 0.0511, 0], [1.2650, 0, -0.8091, 0]])
# specify optimization options
bfgs = blp.Optimization('bfgs', {'gtol': 1e-5})
# solve the model
blp_results = problem.solve(sigma0, pi0, optimization=bfgs, method='1s')
blp_results
# calculate markups and marginal costs
mc = blp_results.compute_costs()
markups = blp_results.compute_markups(costs=mc)
nl_results2.beta[0] / (1 - nl_results2.rho)
# nonlinear parts
X1_formulation = pyblp.Formulation('0 + prices', absorb='C(product_ids)')
X2_formulation = pyblp.Formulation('1 + prices + sugar + mushy')
product_formulations = (X1_formulation, X2_formulation)
# This part specifies integration technique.
# This version specifies MC over 50 consumers
mc_integration = pyblp.Integration('monte_carlo',
size=50,
specification_options={'seed': 0})
mc_problem = pyblp.Problem(product_formulations,
product_data,
integration=mc_integration)
bfgs = pyblp.Optimization('bfgs', {'gtol': 1e-4})
results1 = mc_problem.solve(sigma=np.ones((4, 4)), optimization=bfgs)
# Restricted Sigma to be diagonal
results3 = mc_problem.solve(sigma=np.eye(4), optimization=bfgs)
agent_data = pd.read_csv(pyblp.data.NEVO_AGENTS_LOCATION)
agent_formulation = pyblp.Formulation(
'0 + income + income_squared + age + child')
nevo_problem = pyblp.Problem(product_formulations, product_data,
agent_formulation, agent_data)
initial_sigma = np.diag([0.3302, 2.4526, 0.0163, 0.2441])
initial_pi = np.array([[5.4819, 0, 0.2037, 0], [15.8935, -1.2000, 0, 2.6342],
[-0.2506, 0, 0.0511, 0], [1.2650, 0, -0.8091, 0]])
tighter_bfgs = pyblp.Optimization('bfgs', {'gtol': 1e-5})
nevo_results = nevo_problem.solve(initial_sigma,
tab_dir = main_dir / 'tables'
fig_dir = main_dir / 'figures'
from aux_plot_config import *
from aux_table_functions import draw_blp_agents, load_blp_base, do_single_market, do_single_market_indiv, reshape_wtp
from aux_nevo_cases import get_nevo_base
## Generic Options
solve_options = dict(
#costs_bounds=(0.001, None),
#W_type='clustered',
#se_type='clustered',
initial_update=True,
iteration=pyblp.Iteration('squarem', {'atol': 1e-14}),
optimization=pyblp.Optimization('bfgs', {'gtol': 1e-5}),
scale_objective=True,
method='2s',
)
# %%
################
### Nevo problem
################
# Import the Best Practices RESULTS OBJECT
nevo_products = pd.read_parquet(raw_dir / 'nevo_product_data_opt.parquet')
nevo_agents = pd.read_csv(pyblp.data.NEVO_AGENTS_LOCATION)
nevo_agents['draw_ids'] = np.tile(range(0, 20), 94)