def calibrate(event_type = 0):
if type_of_preestim == 'nonparam':
with open(path_mmodel+'_nonp', 'rb') as source:
model=pickle.load(source)
elif type_of_preestim == 'ordinary_hawkes':
with open(path_mdata,'rb') as source:
data=pickle.load(source)
assert symbol==data.symbol
assert date==data.date
model=sd_hawkes_model.SDHawkes(
number_of_event_types=data.number_of_event_types, number_of_states = data.number_of_states,
number_of_lob_levels=data.n_levels, volume_imbalance_upto_level = data.volume_enc.volume_imbalance_upto_level,
list_of_n_states=data.state_enc.list_of_n_states, st1_deflationary=data.state_enc.st1_deflationary,
st1_inflationary=data.state_enc.st1_inflationary, st1_stationary=data.state_enc.st1_stationary
)
model.get_input_data(data)
else:
print("type_of_preestim={}".format(type_of_preestim))
raise ValueError("type_of_preestim not recognised")
now=datetime.datetime.now()
message='\ndate of run: {}-{:02d}-{:02d} at {}:{:02d}\n'.format(now.year,now.month,now.day, now.hour, now.minute)
message+='I am calibrating on lobster\n'
message+='symbol={}, date={}, time_window={}\n'.format(symbol,date,time_window)
message+='event type: {}'.format(event_type)
name_of_model_partial=name_of_model+'_partial{}'.format(event_type)
path_mpartial=path_mmodel+'_partial{}'.format(event_type)
path_readout=path_mpartial+'_readout.txt'
fout,saveout=redirect_stdout(direction='from',message=message,path=path_readout)
model.calibrate_on_input_data(
e=event_type,
name_of_model=name_of_model_partial,
type_of_preestim=type_of_preestim,
max_imp_coef = max_imp_coef,
learning_rate = learning_rate, maxiter = maxiter, num_of_random_guesses=num_guesses,
parallel=parallel,
use_prange=use_prange,
number_of_attempts = 2, num_processes = num_processes,
batch_size = batch_size, num_run_per_minibatch = num_run_per_minibatch,
store_trans_prob=False, store_dirichlet_param=False,
dump_after_calibration=True
)
n=datetime.datetime.now()
message='\nCalibration of event_type {} terminates on {}-{:02d}-{:02d} at {}:{:02d}\n'\
.format(event_type, n.year, n.month, n.day, n.hour, n.minute)
redirect_stdout(direction='to',message=message, fout=fout, saveout=saveout)
def nonparam_preestim():
now=datetime.datetime.now()
message='\ndate of run: {}-{:02d}-{:02d} at {}:{:02d}\n'.format(now.year,now.month,now.day, now.hour, now.minute)
message+='I am pre-estimating the model using non-parametric procedure\n'
message+='symbol={}, date={}, time_window={}'.format(symbol,date,time_window)
name_of_model_nonp=name_of_model+'_nonp'
path_mnonp=path_mmodel+'_nonp'
path_readout=path_mnonp+'_readout.txt'
fout,saveout=redirect_stdout(direction='from',path=path_readout,message=message)
with open(path_mdata,'rb') as source:
data=pickle.load(source)
assert symbol==data.symbol
assert date==data.date
model=sd_hawkes_model.SDHawkes(
number_of_event_types=data.number_of_event_types, number_of_states = data.number_of_states,
number_of_lob_levels=data.n_levels, volume_imbalance_upto_level = data.volume_enc.volume_imbalance_upto_level,
list_of_n_states=data.state_enc.list_of_n_states, st1_deflationary=data.state_enc.st1_deflationary,
st1_inflationary=data.state_enc.st1_inflationary, st1_stationary=data.state_enc.st1_stationary
)
model.get_input_data(data)
model.create_nonparam_estim(type_of_input='empirical',
num_quadpnts = num_quadpnts,
quad_tmax = quad_tmax,
quad_tmin = quad_tmin,
num_gridpnts = num_gridpnts,
grid_tmax = grid_tmax,
grid_tmin = grid_tmin,
two_scales=True,
tol=1.0e-7
)
run_time = -time.time()
model.nonparam_estim.estimate_hawkes_kernel(
parallel=True,
store_L1_norm=False, use_filter=True, enforce_positive_g_hat=True,
filter_cutoff=50.0, filter_scale=30.0, num_addpnts_filter=3000)
model.nonparam_estim.fit_powerlaw(compute_L1_norm=True,ridge_param=1.0e-02, tol=1.0e-7)
model.nonparam_estim.store_base_rates()
run_time+=time.time()
model.nonparam_estim.store_runtime(run_time)
model.nonparam_estim.create_goodness_of_fit()
model.dump(name=name_of_model_nonp,path=path_models+'/'+symbol)
n=datetime.datetime.now()
message='\nNon-parametric pre-estimation terminates on {}-{:02d}-{:02d} at {}:{:02d}\n'\
.format(n.year, n.month, n.day, n.hour, n.minute)
redirect_stdout(direction='to', message=message, fout=fout, saveout=saveout)
def instantiate_and_simulate():
path_readout=path_saved_tests+'/'+this_test_model_name+'_simulation_readout.txt'
now=datetime.datetime.now()
message="I am executing {} --simulation".format(sys.argv[0])
message+="\nDate of run: {}-{:02d}-{:02d} at {:02d}:{:02d}".format(now.year, now.month, now.day, now.hour, now.minute)
fout,saveout=redirect_stdout(direction="from", message=message, path=path_readout)
model = sd_hawkes_model.SDHawkes(
number_of_event_types=n_events,
number_of_lob_levels=n_levels,
list_of_n_states=n_states,
volume_imbalance_upto_level=upto_level,
name_of_model=this_test_model_name)
tot_n_states=model.state_enc.tot_n_states
phis = model.state_enc.generate_random_transition_prob(n_events=n_events).astype(np.float)
nus = 0.1*np.random.randint(low=15,high=20,size=n_events).astype(np.float)
alphas = np.power(10,-np.random.uniform(low=1.0, high=1.2))*np.random.randint(low=0,high=4,size=(n_events, tot_n_states, n_events)).astype(np.float)
betas = np.random.uniform(1.25025,2.1,size=(n_events, tot_n_states, n_events)).astype(np.float)
gammas = np.random.uniform(low=1.25, high = 5.6,size=(tot_n_states,2*n_levels))
model.set_hawkes_parameters(nus,alphas,betas)
model.set_dirichlet_parameters(gammas)
model.set_transition_probabilities(phis)
print("\nSIMULATION\n")
global time_start
global time_end
max_number_of_events = np.random.randint(low=7900, high=8010)
times, events, states, volumes = model.simulate(
time_start, time_end, max_number_of_events=max_number_of_events,
add_initial_cond=True,
store_results=True, report_full_volumes=False)
time_end=float(times[-1])
model.create_goodness_of_fit(type_of_input='simulated', parallel=True)
model.goodness_of_fit.ks_test_on_residuals()
model.goodness_of_fit.ad_test_on_residuals()
model.dump(path=path_saved_tests)
model.dump(name=this_test_model_name+"_simulation", path=path_saved_tests)
now=datetime.datetime.now()
message='\nSimulation terminates on {}-{:02d}-{:02d} at {:02d}:{:02d}\n'\
.format(now.year, now.month, now.day, now.hour, now.minute)
redirect_stdout(direction="to", message=message, fout=fout, saveout=saveout)
def merge_from_partial(adjust_base_rates = False, leading_coef = 0.66):
now=datetime.datetime.now()
message='\ndate of run: {}-{:02d}-{:02d} at {}:{:02d}\n'.format(now.year,now.month,now.day, now.hour, now.minute)
message+='I am merging from partial models\n'
message+='symbol={}, date={}, time_window={}'.format(symbol,date,time_window)
path_readout=path_mmodel+'_merge_readout.txt'
fout,saveout=redirect_stdout(direction='from',path=path_readout,message=message)
list_of_partial_names=[name_of_model+'_partial{}'.format(e) for e in range(number_of_event_types)]
partial_models=[]
with open(path_mdata,'rb') as source:
data=pickle.load(source)
assert data.symbol == symbol
assert data.date == date
assert data.number_of_event_types==number_of_event_types
MODEL=sd_hawkes_model.SDHawkes(
number_of_event_types=data.number_of_event_types, number_of_states=data.number_of_states,
number_of_lob_levels=data.n_levels,volume_imbalance_upto_level = data.volume_enc.volume_imbalance_upto_level,
list_of_n_states=data.state_enc.list_of_n_states, st1_deflationary=data.state_enc.st1_deflationary,
st1_inflationary=data.state_enc.st1_inflationary, st1_stationary=data.state_enc.st1_stationary
)
MODEL.get_input_data(data)
for mn in list_of_partial_names:
try:
with open(path_models+'/{}/{}_{}/'.format(symbol,symbol,date)+mn,'rb') as source:
model=pickle.load(source)
except:
with open(path_models+'/{}/'.format(symbol,)+mn,'rb') as source:
model=pickle.load(source)
assert model.data.symbol == symbol
assert model.data.date == date
assert model.calibration.type_of_preestim == type_of_preestim
partial_models.append(model)
if type_of_preestim == 'nonparam':
MODEL.store_nonparam_estim_class(model.nonparam_estim)
MODEL.initialise_from_partial_calibration(partial_models, set_parameters=True, adjust_base_rates = True, dump_after_merging=True, name_of_model=name_of_model)
n=datetime.datetime.now()
message='\nMerging has been completed on {}-{:02d}-{:02d} at {}:{:02d}'.format(n.year,n.month,n.day,n.hour,n.minute)
redirect_stdout(direction='to',message=message,fout=fout, saveout=saveout)
def main():
list_of_n_states = [3, 5]
n_events = 4
n_levels = 2
sd_model = model.SDHawkes(number_of_event_types=n_events,
number_of_lob_levels=n_levels,
volume_imbalance_upto_level=2,
list_of_n_states=list_of_n_states)
tot_n_states = sd_model.state_enc.tot_n_states
# The base rates $\nu$
nus = 0.05 * np.random.randint(low=2, high=6, size=n_events)
# The impact coefficients $\alpha$
alphas = np.random.uniform(0.0002,
0.4,
size=(n_events, tot_n_states,
n_events)).astype(np.float)
# The decay coefficients $\beta$
betas = np.random.uniform(1.265,
2.805,
size=(n_events, tot_n_states,
n_events)).astype(np.float)
sd_model.set_hawkes_parameters(nus, alphas, betas)
# The transition probabilities $\phi$
phis = sd_model.state_enc.generate_random_transition_prob(
n_events=n_events).astype(np.float)
sd_model.set_transition_probabilities(phis)
sd_model.enforce_symmetry_in_transition_probabilities()
# The Dirichlet parameters $\kappa$
kappas = np.random.lognormal(size=(tot_n_states, 2 * n_levels))
sd_model.set_dirichlet_parameters(kappas)
time_start = 0.0
time_end = time_start + 1.0 * 60 * 60
max_number_of_events = 2000
print("\nSIMULATION\n")
times, events, states, volumes = sd_model.simulate(
time_start,
time_end,
max_number_of_events=max_number_of_events,
add_initial_cond=True,
store_results=True,
report_full_volumes=False)
time_end = float(times[-1])
sd_model.create_goodness_of_fit(type_of_input='simulated')
sd_model.goodness_of_fit.ks_test_on_residuals()
sd_model.goodness_of_fit.ad_test_on_residuals()
# exit()
print("\nMLE ESTIMATION\n")
"Initialise the class"
sd_model.create_mle_estim(type_of_input='simulated')
d_E = sd_model.number_of_event_types
d_S = sd_model.number_of_states
"Fictious initial guess"
list_init_guesses = []
for k in range(3):
nus = np.random.uniform(low=0.0, high=1.0, size=(d_E, ))
alphas = np.random.uniform(low=0.0, high=1.0, size=(d_E, d_S, d_E))
betas = np.random.uniform(low=1.1, high=3.0, size=(d_E, d_S, d_E))
guess = computation.parameters_to_array(nus, alphas, betas)
list_init_guesses.append(np.array(guess, copy=True))
"Set the estimation"
sd_model.mle_estim.set_estimation_of_hawkes_param(
time_start,
time_end,
list_of_init_guesses=list_init_guesses,
learning_rate=0.00005,
maxiter=10,
number_of_additional_guesses=3,
parallel=True,
pre_estim_ord_hawkes=True,
pre_estim_parallel=True,
number_of_attempts=2,
num_processes=8)
# exit()
"Launch estimation"
sd_model.mle_estim.launch_estimation_of_hawkes_param(e=0)
def read(
symbol="INTC",
date="2019-01-23",
time_window="41400-45000",
simulate=False,
):
now = datetime.datetime.now()
message = '\ndate of run: {}-{:02d}-{:02d} at {}:{:02d}\n'.format(
now.year, now.month, now.day, now.hour, now.minute)
message += 'I am reading from saved models\n'
message += 'symbol={}, date={}, time_window={}'.format(
symbol, date, time_window)
path_readout = path_impact + '/models/{}/{}_{}_{}_onesided_thesis_readout'.format(
symbol, symbol, date, time_window)
fout, saveout = redirect_stdout(direction='from',
message=message,
path=path_readout)
try:
with open(
path_models + "/{}/{}_{}/{}_sdhawkes_{}_{}".format(
symbol, symbol, date, symbol, date, time_window),
'rb') as source:
calmodel = pickle.load(source)
except FileNotFoundError:
try:
with open(
path_models + "/{}/{}_sdhawkes_{}_{}".format(
symbol, symbol, date, time_window), 'rb') as source:
calmodel = pickle.load(source)
except FileNotFoundError:
print("File not found")
raise FileNotFoundError
model=sd_hawkes_model.SDHawkes(
number_of_event_types=calmodel.number_of_event_types,
list_of_n_states=calmodel.state_enc.list_of_n_states,
number_of_lob_levels=calmodel.n_levels,
volume_imbalance_upto_level=\
calmodel.volume_enc.volume_imbalance_upto_level
)
model.get_configuration(calmodel)
model.create_uq()
model.set_base_rates(
np.array([0.14008215, 0.14451349, 6.4689, 6.0295], dtype=np.float))
# target=computation.avg_rates(model.data.number_of_event_types,
# model.data.observed_times,
# model.data.observed_events, partial=False)
# model.uncertainty_quantification.adjust_baserates(
# target,
# adj_coef=5.0e-2,
# num_iter=15,
# max_number_of_events=30000
# )
model.reduce_price_volatility(reduction_coef=0.7)
#Remarkably, compared to the same function in bacrymuzy/main.py, here we are NOT enforcing price symmetry
model.create_goodness_of_fit(type_of_input='empirical')
if simulate:
time_start = 0.0
time_end = time_start + 0.15 * 60 * 60
model.simulate(time_start,
time_end,
max_number_of_events=50000,
add_initial_cond=True,
store_results=True,
report_full_volumes=False)
model.store_price_trajectory(
type_of_input='simulated',
initial_price=model.data.mid_price.iloc[0, 1],
ticksize=model.data.ticksize)
model.store_price_trajectory(type_of_input='empirical',
initial_price=model.data.mid_price.iloc[0, 1],
ticksize=model.data.ticksize)
try:
os.mkdir(
path_impact +
'/models/{}/{}_{}_{}'.format(symbol, symbol, date, time_window))
except FileExistsError:
pass
model.set_name_of_model('{}_sdhawkes_{}_{}_onesided_thesis'.format(
symbol, date, time_window))
model.dump(path=path_impact +
'/models/{}/{}_{}_{}'.format(symbol, symbol, date, time_window))
now = datetime.datetime.now()
message = '\nEnds on {}-{:02d}-{:02d} at {}:{:02d}\n'.format(
now.year, now.month, now.day, now.hour, now.minute)
redirect_stdout(direction='to',
message=message,
fout=fout,
saveout=saveout)
def main():
global now
name_of_model_nonp = name_of_model + '_nonp'
path_mnonp = path_mmodel + '_nonp'
with open(path_mdata, 'rb') as source:
data = pickle.load(source)
assert symbol == data.symbol
assert date == data.date
model = sd_hawkes_model.SDHawkes(
number_of_event_types=data.number_of_event_types,
number_of_states=data.number_of_states,
number_of_lob_levels=data.n_levels,
volume_imbalance_upto_level=data.volume_enc.
volume_imbalance_upto_level,
list_of_n_states=data.state_enc.list_of_n_states,
st1_deflationary=data.state_enc.st1_deflationary,
st1_inflationary=data.state_enc.st1_inflationary,
st1_stationary=data.state_enc.st1_stationary)
model.get_input_data(data)
if type_of_preestim == 'nonparam':
model.create_nonparam_estim(type_of_input='empirical',
num_quadpnts=num_quadpnts,
quad_tmax=quad_tmax,
quad_tmin=quad_tmin,
num_gridpnts=num_gridpnts,
grid_tmax=grid_tmax,
grid_tmin=grid_tmin,
two_scales=True,
tol=1.0e-7)
run_time = -time.time()
model.nonparam_estim.estimate_hawkes_kernel(
store_L1_norm=False,
use_filter=True,
enforce_positive_g_hat=True,
filter_cutoff=50.0,
filter_scale=30.0,
num_addpnts_filter=3000)
model.nonparam_estim.fit_powerlaw(compute_L1_norm=True,
ridge_param=1.0e-02,
tol=1.0e-7)
model.nonparam_estim.store_base_rates()
run_time += time.time()
model.nonparam_estim.store_runtime(run_time)
model.nonparam_estim.create_goodness_of_fit()
# model.dump(name=name_of_model_nonp,path=path_models+'/'+symbol)
n = datetime.datetime.now()
message='\nNon-parametric pre-estimation terminates on {}-{:02d}-{:02d} at {}:{:02d}\n'\
.format(n.year, n.month, n.day, n.hour, n.minute)
print(message)
print("\nMLE ESTIMATION\n")
name_of_model_partial = name_of_model + '_partial{}'.format(event_type)
path_mpartial = path_mmodel + '_partial{}'.format(event_type)
now = datetime.datetime.now()
message = '\ndate of run: {}-{:02d}-{:02d} at {}:{:02d}\n'.format(
now.year, now.month, now.day, now.hour, now.minute)
message += 'I am calibrating on lobster\n'
message += 'symbol={}, date={}, time_window={}\n'.format(
symbol, date, time_window)
message += 'event type: {}'.format(event_type)
print(message)
model.calibrate_on_input_data(partial=True,
e=event_type,
name_of_model=name_of_model_partial,
type_of_preestim=type_of_preestim,
max_imp_coef=max_imp_coef,
learning_rate=learning_rate,
maxiter=maxiter,
num_of_random_guesses=num_guesses,
parallel=True,
number_of_attempts=2,
num_processes=num_processes,
skip_estim_of_state_processes=True,
dump_after_calibration=True)
n = datetime.datetime.now()
message='\nCalibration of event_type {} terminates on {}-{:02d}-{:02d} at {}:{:02d}\n'\
.format(event_type, n.year, n.month, n.day, n.hour, n.minute)
print(message)
def uncertainty_quantification(input_model_name=''):
now=datetime.datetime.now()
message='\ndate of run: {}-{:02d}-{:02d} at {}:{:02d}\n'.format(now.year,now.month,now.day, now.hour, now.minute)
message+='I am performing uncertainty quantification\n'
message+='symbol={}, date={}, time_window={}'.format(symbol,date,time_window)
path_readout=path_mmodel+'_uq_readout.txt'
fout,saveout=redirect_stdout(direction='from',path=path_readout,message=message)
if input_model_name=='':
input_model_name='{}_sdhawkes_{}_{}'.format(symbol, date, time_window)
try:
with open(path_models+'/{}/{}_{}/'.format(symbol,symbol,date)+input_model_name,'rb') as source:
input_model=pickle.load(source)
except:
with open(path_models+'/{}/'.format(symbol,)+input_model_name,'rb') as source:
input_model=pickle.load(source)
assert input_model.data.symbol == symbol
assert input_model.data.date == date
model=sd_hawkes_model.SDHawkes(
name_of_model = input_model_name+'_uq',
number_of_event_types=input_model.number_of_event_types,
number_of_states=input_model.number_of_states,
number_of_lob_levels=input_model.n_levels,
volume_imbalance_upto_level = input_model.volume_enc.volume_imbalance_upto_level,
list_of_n_states=input_model.state_enc.list_of_n_states,
st1_deflationary=input_model.state_enc.st1_deflationary,
st1_inflationary=input_model.state_enc.st1_inflationary,
st1_stationary=input_model.state_enc.st1_stationary
)
model.get_input_data(input_model.data)
try:
model.store_nonparam_estim_class(input_model.nonparam_estim)
except:
pass
model.store_mle_estim(input_model.mle_estim)
model.store_calibration(input_model.calibration)
model.store_goodness_of_fit(input_model.goodness_of_fit)
model.set_hawkes_parameters(input_model.base_rates,
input_model.impact_coefficients,
input_model.decay_coefficients)
model.set_transition_probabilities(input_model.transition_probabilities)
model.set_dirichlet_parameters(input_model.dirichlet_param)
model.create_uq()
time_start=0.0
time_end=3600.0
max_events=40000
model.uncertainty_quantification.simulate(
time_start, time_end, max_number_of_events=max_events)
model.uncertainty_quantification.create_goodness_of_fit()
model.uncertainty_quantification.calibrate_on_simulated_data(
type_of_preestim = type_of_preestim,
max_imp_coef = max_imp_coef,
learning_rate = learning_rate,
maxiter = maxiter,
num_of_random_guesses = num_guesses,
parallel=parallel, use_prange = use_prange,
number_of_attempts = number_of_attempts,
num_processes = num_processes,
batch_size = batch_size,
num_run_per_minibatch = num_run_per_minibatch,
)
model.dump(path=path_models+'/{}'.format(symbol))
n=datetime.datetime.now()
message='\nUncertainty quantification completed on {}-{:02d}-{:02d} at {}:{:02d}'.format(n.year,n.month,n.day,n.hour,n.minute)
redirect_stdout(direction='to',message=message,fout=fout, saveout=saveout)
def main():
print("I am executing test_nonparam.py")
global now
print('\ndate of run: {}-{:02d}-{:02d} at {}:{:02d}\n'.format(now.year,now.month,now.day, now.hour, now.minute))
n_states=[3,5]
n_events = 4 # number of event types, $d_e$
n_levels = 2
upto_level = 2
time_start=np.random.uniform()
time_end=time_start+0.2*60*60
model = sd_hawkes_model.SDHawkes(
number_of_event_types=n_events,
number_of_lob_levels=n_levels,
list_of_n_states=n_states,
volume_imbalance_upto_level=upto_level)
tot_n_states=model.state_enc.tot_n_states
# The transition probabilities $\phi$
phis = model.state_enc.generate_random_transition_prob(n_events=n_events).astype(np.float)
# The base rates $\nu$
nus = 0.1*np.random.randint(low=15,high=20,size=n_events)
# The impact coefficients $\alpha$
alphas = np.power(10,-np.random.uniform(low=1.0, high=1.2))*np.random.randint(low=0,high=4,size=(n_events, tot_n_states, n_events)).astype(np.float)
# The decay coefficients $\beta$
betas = np.random.uniform(1.25025,2.1,size=(n_events, tot_n_states, n_events)).astype(np.float)
# The Dirichlet parameters $\gamma$
gammas = np.random.uniform(low=1.25, high = 5.6,size=(tot_n_states,2*n_levels))
model.set_hawkes_parameters(nus,alphas,betas)
model.set_dirichlet_parameters(gammas)
model.set_transition_probabilities(phis)
print("\nSIMULATION\n")
times, events, states, volumes = model.simulate(
time_start, time_end,max_number_of_events=12000,add_initial_cond=True,
store_results=True,report_full_volumes=False)
time_end=np.array(times[-1],copy=True)
model.create_goodness_of_fit(type_of_input='simulated')
model.goodness_of_fit.ks_test_on_residuals()
model.goodness_of_fit.ad_test_on_residuals()
print("\nNON-PARAMETRIC ESTIMATION\n")
upperbound_of_support_of_kernel=1.0e+00
lowerbound_of_support_of_kernel=1.0e-01
num_quadpnts = 80
num_gridpnts= 75
run_time = -time.time()
model.create_nonparam_estim(type_of_input='simulated',
num_quadpnts = num_quadpnts,
quad_tmax = upperbound_of_support_of_kernel,
quad_tmin = lowerbound_of_support_of_kernel,
num_gridpnts = num_gridpnts,
grid_tmax = upperbound_of_support_of_kernel,
grid_tmin = lowerbound_of_support_of_kernel,
two_scales=True,
tol=1.0e-6
)
model.nonparam_estim.estimate_hawkes_kernel(store_L1_norm=False,
use_filter=True, enforce_positive_g_hat=True,
filter_cutoff=20.0, filter_scale=30.0, num_addpnts_filter=3000)
model.nonparam_estim.fit_powerlaw(compute_L1_norm=True,ridge_param=1.0e-02, tol=1.0e-7)
model.nonparam_estim.store_base_rates()
run_time+=time.time()
model.nonparam_estim.store_runtime(run_time)
model.nonparam_estim.create_goodness_of_fit()
now=datetime.datetime.now()
print("Estimation terminates on {}-{:02d}-{:02d} at {:02d}:{:02d}".format(
now.year,now.month,now.day,now.hour,now.minute
))
return model
def main():
list_of_n_states = [3, 5]
n_events = 4
n_levels = 2
sd_model = model.SDHawkes(number_of_event_types=n_events,
number_of_lob_levels=n_levels,
volume_imbalance_upto_level=2,
list_of_n_states=list_of_n_states)
tot_n_states = sd_model.state_enc.tot_n_states
# The base rates $\nu$
nus = 0.05 * np.random.randint(low=2, high=8, size=n_events)
# The impact coefficients $\alpha$
alphas = np.random.uniform(0.002,
0.2435,
size=(n_events, tot_n_states,
n_events)).astype(np.float)
# The decay coefficients $\beta$
betas = np.random.uniform(1.265,
2.805,
size=(n_events, tot_n_states,
n_events)).astype(np.float)
sd_model.set_hawkes_parameters(nus, alphas, betas)
# The transition probabilities $\phi$
phis = sd_model.state_enc.generate_random_transition_prob(
n_events=n_events).astype(np.float)
sd_model.set_transition_probabilities(phis)
# sd_model.enforce_symmetry_in_transition_probabilities()
# The Dirichlet parameters $\kappa$
kappas = np.random.lognormal(size=(tot_n_states, 2 * n_levels))
sd_model.set_dirichlet_parameters(kappas)
time_start = 0.0
time_end = time_start + 1.0 * 60 * 60
max_number_of_events = 4000
print("\nSIMULATION\n")
times, events, states, volumes = sd_model.simulate(
time_start,
time_end,
max_number_of_events=max_number_of_events,
add_initial_cond=True,
store_results=True,
report_full_volumes=False)
time_end = float(times[-1])
sd_model.create_goodness_of_fit(type_of_input='simulated', parallel=False)
sd_model.goodness_of_fit.ks_test_on_residuals()
sd_model.goodness_of_fit.ad_test_on_residuals()
print("\nMINIMISATION PROCEDURE\n")
event_type = 0
num_init_guesses = 9
list_init_guesses = []
for n in range(num_init_guesses):
list_init_guesses.append(1.0 + np.random.lognormal(size=(
1 +
2 * sd_model.number_of_event_types * sd_model.number_of_states, )))
MinimProc = minim_algo.MinimisationProcedure(
times,
events,
states,
time_start,
time_end,
sd_model.number_of_event_types,
sd_model.number_of_states,
event_type,
list_init_guesses=list_init_guesses,
learning_rate=0.0001,
maxiter=6,
tol=1.0e-7,
number_of_attempts=2,
batch_size=2000,
num_run_per_minibatch=2,
)
# MinimProc.prepare_batches_fake()
MinimProc.prepare_batches()
run_time = -time.time()
MinimProc.launch_minimisation(parallel=False, num_processes=8)
run_time += time.time()
print("Minimisation terminates. run_time = {}".format(run_time))
time.sleep(2)
print("Now exiting")
def main(model_name=''):
global time_start
global time_end
model = sd_hawkes_model.SDHawkes(number_of_event_types=n_events,
number_of_lob_levels=n_levels,
list_of_n_states=n_states,
volume_imbalance_upto_level=upto_level,
name_of_model=model_name)
tot_n_states = model.state_enc.tot_n_states
phis = model.state_enc.generate_random_transition_prob(
n_events=n_events).astype(np.float)
nus = 0.1 * np.random.randint(low=15, high=20, size=n_events)
alphas = np.power(
10, -np.random.uniform(low=1.0, high=1.2)) * np.random.randint(
low=0, high=4, size=(n_events, tot_n_states, n_events)).astype(
np.float)
betas = np.random.uniform(1.25025,
2.1,
size=(n_events, tot_n_states,
n_events)).astype(np.float)
gammas = np.random.uniform(low=1.25,
high=5.6,
size=(tot_n_states, 2 * n_levels))
model.set_hawkes_parameters(nus, alphas, betas)
model.set_dirichlet_parameters(gammas)
model.set_transition_probabilities(phis)
print("\nSIMULATION\n")
max_number_of_events = np.random.randint(low=5850, high=6000)
times, events, states, volumes = model.simulate(
time_start,
time_end,
max_number_of_events=max_number_of_events,
add_initial_cond=True,
store_results=True,
report_full_volumes=False)
time_end = float(times[-1])
model.create_goodness_of_fit(type_of_input='simulated', parallel=False)
model.goodness_of_fit.ks_test_on_residuals()
model.goodness_of_fit.ad_test_on_residuals()
if type_of_preestim == 'nonparam':
print("\nNON-PARAMETRIC ESTIMATION\n")
run_time = -time.time()
model.create_nonparam_estim(type_of_input='simulated',
num_quadpnts=num_quadpnts,
quad_tmax=quad_tmax,
quad_tmin=quad_tmin,
num_gridpnts=num_gridpnts,
grid_tmax=grid_tmax,
grid_tmin=grid_tmin,
two_scales=True,
tol=1.0e-7)
model.nonparam_estim.estimate_hawkes_kernel(
store_L1_norm=False,
use_filter=True,
enforce_positive_g_hat=True,
filter_cutoff=20.0,
filter_scale=30.0,
num_addpnts_filter=2000,
parallel=False,
parallel_prep=True)
model.nonparam_estim.fit_powerlaw(compute_L1_norm=True,
ridge_param=1.0e-01,
tol=1.0e-7)
model.nonparam_estim.store_base_rates()
run_time += time.time()
model.nonparam_estim.store_runtime(run_time)
model.nonparam_estim.create_goodness_of_fit(parallel=False)
print("\nMLE ESTIMATION\n")
"Initialise the class"
model.create_mle_estim(type_of_input='simulated', store_trans_prob=True)
"Set the estimation"
if type_of_preestim == 'nonparam':
list_init_guesses = model.nonparam_estim.produce_list_init_guesses_for_mle_estimation(
num_additional_random_guesses=2, max_imp_coef=50.0)
else:
list_init_guesses = []
model.mle_estim.set_estimation_of_hawkes_param(
time_start,
time_end,
list_of_init_guesses=list_init_guesses,
max_imp_coef=max_imp_coef,
learning_rate=learning_rate,
maxiter=maxiter,
number_of_additional_guesses=num_guesses,
parallel=parallel,
pre_estim_ord_hawkes=True,
pre_estim_parallel=parallel,
number_of_attempts=3,
num_processes=num_processes,
batch_size=batch_size,
num_run_per_minibatch=num_run_per_minibatch,
)
# exit()
"Launch estimation"
model.mle_estim.launch_estimation_of_hawkes_param(partial=True)
model.mle_estim.store_hawkes_parameters()
model.mle_estim.create_goodness_of_fit(parallel=False)
model.dump(path=path_saved_tests)