def demo(K=3, T=1000, dt_max=20, p=0.25):
"""
:param K: Number of nodes
:param T: Number of time bins to simulate
:param dt_max: Number of future time bins an event can influence
:param p: Sparsity of network
:return:
"""
###########################################################
# Generate synthetic data
###########################################################
network_hypers = {"p": p, "allow_self_connections": False}
true_model = DiscreteTimeNetworkHawkesModelSpikeAndSlab(
K=K, dt_max=dt_max,
network_hypers=network_hypers)
assert true_model.check_stability()
# Sample from the true model
S,R = true_model.generate(T=T, keep=True, print_interval=50)
plt.ion()
true_figure, _ = true_model.plot(color="#377eb8", T_slice=(0,100))
###########################################################
# Create a test spike and slab model
###########################################################
test_model = DiscreteTimeNetworkHawkesModelSpikeAndSlab(
K=K, dt_max=dt_max,
network_hypers=network_hypers)
test_model.add_data(S)
# Initialize plots
test_figure, test_handles = test_model.plot(color="#e41a1c", T_slice=(0,100))
###########################################################
# Fit the test model with Gibbs sampling
###########################################################
N_samples = 100
samples = []
lps = []
for itr in range(N_samples):
print("Gibbs iteration ", itr)
test_model.resample_model()
lps.append(test_model.log_probability())
samples.append(test_model.copy_sample())
# Update plots
test_model.plot(handles=test_handles)
###########################################################
# Analyze the samples
###########################################################
analyze_samples(true_model, samples, lps)
def demo(K=3, T=1000, dt_max=20, p=0.25):
"""
:param K: Number of nodes
:param T: Number of time bins to simulate
:param dt_max: Number of future time bins an event can influence
:param p: Sparsity of network
:return:
"""
###########################################################
# Generate synthetic data
###########################################################
network_hypers = {"p": p, "allow_self_connections": False}
true_model = DiscreteTimeNetworkHawkesModelSpikeAndSlab(
K=K, dt_max=dt_max,
network_hypers=network_hypers)
assert true_model.check_stability()
# Sample from the true model
S,R = true_model.generate(T=T, keep=True, print_interval=50)
plt.ion()
true_figure, _ = true_model.plot(color="#377eb8", T_slice=(0,100))
###########################################################
# Create a test spike and slab model
###########################################################
test_model = DiscreteTimeNetworkHawkesModelSpikeAndSlab(
K=K, dt_max=dt_max,
network_hypers=network_hypers)
test_model.add_data(S)
# Initialize plots
test_figure, test_handles = test_model.plot(color="#e41a1c", T_slice=(0,100))
###########################################################
# Fit the test model with Gibbs sampling
###########################################################
N_samples = 100
samples = []
lps = []
for itr in xrange(N_samples):
print "Gibbs iteration ", itr
test_model.resample_model()
lps.append(test_model.log_probability())
samples.append(test_model.copy_sample())
# Update plots
test_model.plot(handles=test_handles)
###########################################################
# Analyze the samples
###########################################################
analyze_samples(true_model, samples, lps)
def demo(K=3, T=1000, dt_max=20, p=0.25):
"""
:param K: Number of nodes
:param T: Number of time bins to simulate
:param dt_max: Number of future time bins an event can influence
:param p: Sparsity of network
:return:
"""
###########################################################
# Generate synthetic data
###########################################################
network = ErdosRenyiFixedSparsity(K, p, v=1., allow_self_connections=False)
bkgd_hypers = {"alpha": 1.0, "beta": 20.0}
true_model = DiscreteTimeNetworkHawkesModelSpikeAndSlab(
K=K, dt_max=dt_max, bkgd_hypers=bkgd_hypers, network=network)
A_true = np.zeros((K, K))
A_true[0, 1] = A_true[0, 2] = 1
W_true = np.zeros((K, K))
W_true[0, 1] = W_true[0, 2] = 1.0
true_model.weight_model.A = A_true
true_model.weight_model.W = W_true
true_model.bias_model.lambda0[0] = 0.2
assert true_model.check_stability()
# Sample from the true model
S, R = true_model.generate(T=T, keep=True, print_interval=50)
plt.ion()
true_figure, _ = true_model.plot(color="#377eb8", T_slice=(0, 100))
# Save the true figure
true_figure.savefig("gifs/true.gif")
###########################################################
# Create a test spike and slab model
###########################################################
test_model = DiscreteTimeNetworkHawkesModelSpikeAndSlab(K=K,
dt_max=dt_max,
network=network)
test_model.add_data(S)
# Initialize plots
test_figure, test_handles = test_model.plot(color="#e41a1c",
T_slice=(0, 100))
test_figure.savefig("gifs/test0.gif")
###########################################################
# Fit the test model with Gibbs sampling
###########################################################
N_samples = 100
samples = []
lps = []
for itr in xrange(N_samples):
print "Gibbs iteration ", itr
test_model.resample_model()
lps.append(test_model.log_probability())
samples.append(test_model.copy_sample())
# Update plots
test_model.plot(handles=test_handles)
test_figure.savefig("gifs/test%d.gif" % (itr + 1))
def generate_synthetic_data(seed=None):
"""
Create a discrete time Hawkes model and generate from it.
:return:
"""
if seed is None:
seed = np.random.randint(2**32)
print("Setting seed to ", seed)
np.random.seed(seed)
# Create a true model
# Larger v (weight scale) implies smaller weights
T_test = 1000
# Debugging network:
# C = 1
# K = 4
# T = 1000
# dt = 1.0
# B = 3
# p = 0.5
# kappa = 3.0
# v = kappa * 5.0
# c = np.zeros(K, dtype=np.int)
# Small network:
# Seed: 1957629166
# C = 4
# K = 20
# T = 10000
# dt = 1.0
# B = 3
# kappa = 3.0
# p = 0.9 * np.eye(C) + 0.05 * (1-np.eye(C))
# v = kappa * (5.0 * np.eye(C) + 25.0 * (1-np.eye(C)))
# c = np.arange(C).repeat((K // C))
# Medium network:
# Seed: 2723361959
# C = 5
# K = 50
# T = 100000
# dt = 1.0
# B = 3
# kappa = 3.0
# p = 0.75 * np.eye(C) + 0.05 * (1-np.eye(C))
# v = kappa * (9 * np.eye(C) + 25.0 * (1-np.eye(C)))
# c = np.arange(C).repeat((K // C))
# Medium netowrk 2:
# Seed = 3848328624
# C = 5
# K = 50
# T = 100000
# dt = 1.0
# B = 3
# kappa = 2.0
# c = np.arange(C).repeat((K // C))
# p = 0.4 * np.eye(C) + 0.01 * (1-np.eye(C))
# v = kappa * (5 * np.eye(C) + 5.0 * (1-np.eye(C)))
# Medium netowrk, one cluster
# Seed: 3848328624
C = 1
K = 50
T = 100000
dt = 1.0
B = 3
p = 0.08
kappa = 3.0
v = kappa * 5.0
c = np.zeros(K, dtype=np.int)
# Large network:
# Seed = 2467634490
# C = 5
# K = 100
# T = 100000
# dt = 1.0
# B = 3
# kappa = 3.0
# p = 0.4 * np.eye(C) + 0.025 * (1-np.eye(C))
# v = kappa * (10 * np.eye(C) + 25.0 * (1-np.eye(C)))
# c = np.arange(C).repeat((K // C))
# Large network 2:
# Seed =
# C = 10
# K = 100
# T = 100000
# dt = 1.0
# B = 3
# kappa = 3.0
# p = 0.75 * np.eye(C) + 0.05 * (1-np.eye(C))
# v = kappa * (9 * np.eye(C) + 25.0 * (1-np.eye(C)))
# c = np.arange(C).repeat((K // C))
# Extra large network:
# Seed: 2327447870
# C = 20
# K = 1000
# T = 100000
# dt = 1.0
# B = 3
# kappa = 3.0
# p = 0.25 * np.eye(C) + 0.0025 * (1-np.eye(C))
# v = kappa * (15 * np.eye(C) + 30.0 * (1-np.eye(C)))
# c = np.arange(C).repeat((K // C))
# Create the model with these parameters
network_hypers = {'C': C, 'kappa': kappa, 'c': c, 'p': p, 'v': v}
# Create a simple network
from pyhawkes.internals.network import ErdosRenyiFixedSparsity
network = ErdosRenyiFixedSparsity(K, p, kappa, v=v)
true_model = DiscreteTimeNetworkHawkesModelSpikeAndSlab(K=K,
dt=dt,
B=B,
network=network)
assert true_model.check_stability()
# Plot the true network
plt.ion()
plot_network(true_model.weight_model.A, true_model.weight_model.W)
plt.pause(0.001)
# Sample from the true model
S, R = true_model.generate(T=T, keep=False, print_interval=50)
# Pickle and save the data
out_dir = os.path.join('data', "synthetic")
out_name = 'synthetic_K%d_C%d_T%d.pkl.gz' % (K, C, T)
out_path = os.path.join(out_dir, out_name)
with gzip.open(out_path, 'w') as f:
print("Saving output to ", out_path)
pickle.dump((S, true_model), f, protocol=-1)
# Sample test data
S_test, _ = true_model.generate(T=T_test, keep=False)
# Pickle and save the data
out_dir = os.path.join('data', "synthetic")
out_name = 'synthetic_test_K%d_C%d_T%d.pkl.gz' % (K, C, T_test)
out_path = os.path.join(out_dir, out_name)
with gzip.open(out_path, 'w') as f:
print("Saving output to ", out_path)
pickle.dump((S_test, true_model), f, protocol=-1)
def demo(K=3, T=1000, dt_max=20, p=0.25):
"""
:param K: Number of nodes
:param T: Number of time bins to simulate
:param dt_max: Number of future time bins an event can influence
:param p: Sparsity of network
:return:
"""
###########################################################
# Generate synthetic data
###########################################################
network = ErdosRenyiFixedSparsity(K, p, v=1., allow_self_connections=False)
bkgd_hypers = {"alpha": 1.0, "beta": 20.0}
true_model = DiscreteTimeNetworkHawkesModelSpikeAndSlab(
K=K, dt_max=dt_max, bkgd_hypers=bkgd_hypers, network=network)
A_true = np.zeros((K,K))
A_true[0,1] = A_true[0,2] = 1
W_true = np.zeros((K,K))
W_true[0,1] = W_true[0,2] = 1.0
true_model.weight_model.A = A_true
true_model.weight_model.W = W_true
true_model.bias_model.lambda0[0] = 0.2
assert true_model.check_stability()
# Sample from the true model
S,R = true_model.generate(T=T, keep=True, print_interval=50)
plt.ion()
true_figure, _ = true_model.plot(color="#377eb8", T_slice=(0,100))
# Save the true figure
true_figure.savefig("gifs/true.gif")
###########################################################
# Create a test spike and slab model
###########################################################
test_model = DiscreteTimeNetworkHawkesModelSpikeAndSlab(
K=K, dt_max=dt_max, network=network)
test_model.add_data(S)
# Initialize plots
test_figure, test_handles = test_model.plot(color="#e41a1c", T_slice=(0,100))
test_figure.savefig("gifs/test0.gif")
###########################################################
# Fit the test model with Gibbs sampling
###########################################################
N_samples = 100
samples = []
lps = []
for itr in xrange(N_samples):
print "Gibbs iteration ", itr
test_model.resample_model()
lps.append(test_model.log_probability())
samples.append(test_model.copy_sample())
# Update plots
test_model.plot(handles=test_handles)
test_figure.savefig("gifs/test%d.gif" % (itr+1))
def generate_synthetic_data(seed=None):
"""
Create a discrete time Hawkes model and generate from it.
:return:
"""
if seed is None:
seed = np.random.randint(2**32)
print "Setting seed to ", seed
np.random.seed(seed)
# Create a true model
# Larger v (weight scale) implies smaller weights
T_test=1000
# Debugging network:
# C = 1
# K = 4
# T = 1000
# dt = 1.0
# B = 3
# p = 0.5
# kappa = 3.0
# v = kappa * 5.0
# c = np.zeros(K, dtype=np.int)
# Small network:
# Seed: 1957629166
# C = 4
# K = 20
# T = 10000
# dt = 1.0
# B = 3
# kappa = 3.0
# p = 0.9 * np.eye(C) + 0.05 * (1-np.eye(C))
# v = kappa * (5.0 * np.eye(C) + 25.0 * (1-np.eye(C)))
# c = np.arange(C).repeat((K // C))
# Medium network:
# Seed: 2723361959
# C = 5
# K = 50
# T = 100000
# dt = 1.0
# B = 3
# kappa = 3.0
# p = 0.75 * np.eye(C) + 0.05 * (1-np.eye(C))
# v = kappa * (9 * np.eye(C) + 25.0 * (1-np.eye(C)))
# c = np.arange(C).repeat((K // C))
# Medium netowrk 2:
# Seed = 3848328624
# C = 5
# K = 50
# T = 100000
# dt = 1.0
# B = 3
# kappa = 2.0
# c = np.arange(C).repeat((K // C))
# p = 0.4 * np.eye(C) + 0.01 * (1-np.eye(C))
# v = kappa * (5 * np.eye(C) + 5.0 * (1-np.eye(C)))
# Medium netowrk, one cluster
# Seed: 3848328624
C = 1
K = 50
T = 100000
dt = 1.0
B = 3
p = 0.08
kappa = 3.0
v = kappa * 5.0
c = np.zeros(K, dtype=np.int)
# Large network:
# Seed = 2467634490
# C = 5
# K = 100
# T = 100000
# dt = 1.0
# B = 3
# kappa = 3.0
# p = 0.4 * np.eye(C) + 0.025 * (1-np.eye(C))
# v = kappa * (10 * np.eye(C) + 25.0 * (1-np.eye(C)))
# c = np.arange(C).repeat((K // C))
# Large network 2:
# Seed =
# C = 10
# K = 100
# T = 100000
# dt = 1.0
# B = 3
# kappa = 3.0
# p = 0.75 * np.eye(C) + 0.05 * (1-np.eye(C))
# v = kappa * (9 * np.eye(C) + 25.0 * (1-np.eye(C)))
# c = np.arange(C).repeat((K // C))
# Extra large network:
# Seed: 2327447870
# C = 20
# K = 1000
# T = 100000
# dt = 1.0
# B = 3
# kappa = 3.0
# p = 0.25 * np.eye(C) + 0.0025 * (1-np.eye(C))
# v = kappa * (15 * np.eye(C) + 30.0 * (1-np.eye(C)))
# c = np.arange(C).repeat((K // C))
# Create the model with these parameters
network_hypers = {'C': C, 'kappa': kappa, 'c': c, 'p': p, 'v': v}
# Create a simple network
from pyhawkes.internals.network import ErdosRenyiFixedSparsity
network = ErdosRenyiFixedSparsity(K, p, kappa, v=v)
true_model = DiscreteTimeNetworkHawkesModelSpikeAndSlab(K=K, dt=dt, B=B,
network=network)
assert true_model.check_stability()
# Plot the true network
plt.ion()
plot_network(true_model.weight_model.A,
true_model.weight_model.W)
plt.pause(0.001)
# Sample from the true model
S,R = true_model.generate(T=T, keep=False, print_interval=50)
# Pickle and save the data
out_dir = os.path.join('data', "synthetic")
out_name = 'synthetic_K%d_C%d_T%d.pkl.gz' % (K,C,T)
out_path = os.path.join(out_dir, out_name)
with gzip.open(out_path, 'w') as f:
print "Saving output to ", out_path
cPickle.dump((S, true_model), f, protocol=-1)
# Sample test data
S_test,_ = true_model.generate(T=T_test, keep=False)
# Pickle and save the data
out_dir = os.path.join('data', "synthetic")
out_name = 'synthetic_test_K%d_C%d_T%d.pkl.gz' % (K,C,T_test)
out_path = os.path.join(out_dir, out_name)
with gzip.open(out_path, 'w') as f:
print "Saving output to ", out_path
cPickle.dump((S_test, true_model), f, protocol=-1)
