def fit_network_hawkes_svi(S, K, C, B, dt, dt_max, output_path, standard_model=None): samples_and_timestamps = load_partial_results(output_path, typ="svi2") if samples_and_timestamps is not None: samples, timestamps = samples_and_timestamps else: print "Fitting the data with a network Hawkes model using SVI" # Make a new model for inference network_hypers = {'C': C, 'alpha': 1.0, 'beta': 1.0/20.0} test_model = DiscreteTimeNetworkHawkesModelGammaMixture(K=K, dt=dt, dt_max=dt_max, B=B, network_hypers=network_hypers) # Initialize with the standard model parameters if standard_model is not None: test_model.initialize_with_standard_model(standard_model) plt.ion() im = plot_network(test_model.weight_model.A, test_model.weight_model.W, vmax=0.5) plt.pause(0.001) # TODO: Add the data in minibatches minibatchsize = 500 import pdb; pdb.set_trace() test_model.add_data(S) # Stochastic variational inference N_iters = 10000 samples = [] delay = 1.0 forgetting_rate = 0.5 stepsize = (np.arange(N_iters) + delay)**(-forgetting_rate) start = time.clock() timestamps = [] for itr in xrange(N_iters): print "SVI Iter: ", itr, "\tStepsize: ", stepsize[itr] test_model.sgd_step(minibatchsize=minibatchsize, stepsize=stepsize[itr]) test_model.resample_from_mf() samples.append(test_model.copy_sample()) timestamps.append(time.clock()) if itr % 1 == 0: im.set_data(test_model.weight_model.expected_W()) plt.pause(0.001) # Save this sample with open(output_path + ".svi.itr%04d.pkl" % itr, 'w') as f: cPickle.dump((samples[-1], timestamps[-1] -start), f, protocol=-1) # Save the Gibbs samples timestamps = np.array(timestamps) with gzip.open(output_path + ".svi.pkl.gz", 'w') as f: print "Saving SVI samples to ", (output_path + ".svi.pkl.gz") cPickle.dump((samples, timestamps - start), f, protocol=-1) return samples, timestamps
########################################################### # Copy the network hypers. # Give the test model p, but not c, v, or m network_hypers = true_model.network_hypers.copy() network_hypers['v'] = None test_model = DiscreteTimeNetworkHawkesModelGammaMixture( K=K, dt=dt, dt_max=dt_max, B=B, basis_hypers=true_model.basis_hypers, bkgd_hypers=true_model.bkgd_hypers, impulse_hypers=true_model.impulse_hypers, weight_hypers=true_model.weight_hypers) test_model.add_data(S) # Initialize with the standard model parameters if init_model is not None: test_model.initialize_with_standard_model(init_model) ########################################################### # Fit the test model with Gibbs sampling ########################################################### N_samples = 500 samples = [] lps = [] for itr in progprint_xrange(N_samples): lps.append(test_model.log_probability()) samples.append(test_model.copy_sample()) test_model.resample_model()
def fit_network_hawkes_vb(S, K, C, B, dt, dt_max, output_path, standard_model=None): samples_and_timestamps = load_partial_results(output_path, typ="vb") if samples_and_timestamps is not None: samples, timestamps = samples_and_timestamps # # Check for existing Gibbs results # if os.path.exists(output_path + ".vb.pkl.gz"): # with gzip.open(output_path + ".vb.pkl.gz", 'r') as f: # print "Loading vb results from ", (output_path + ".vb.pkl.gz") # (samples, timestamps) = cPickle.load(f) # # if isinstance(timestamps, list): # timestamps = np.array(timestamps) else: print("Fitting the data with a network Hawkes model using Batch VB") # Make a new model for inference network_hypers = {'C': C, 'alpha': 1.0, 'beta': 1.0 / 20.0} test_model = DiscreteTimeNetworkHawkesModelGammaMixture( K=K, dt=dt, dt_max=dt_max, B=B, network_hypers=network_hypers) # Initialize with the standard model parameters if standard_model is not None: test_model.initialize_with_standard_model(standard_model) plt.ion() im = plot_network(test_model.weight_model.A, test_model.weight_model.W, vmax=0.5) plt.pause(0.001) # TODO: Add the data in minibatches minibatchsize = 500 test_model.add_data(S) # Stochastic variational inference N_iters = 1000 vlbs = [] samples = [] start = time.clock() timestamps = [] for itr in range(N_iters): vlbs.append(test_model.meanfield_coordinate_descent_step()) print("Batch VB Iter: ", itr, "\tVLB: ", vlbs[-1]) samples.append(test_model.copy_sample()) timestamps.append(time.clock()) if itr % 1 == 0: im.set_data(test_model.weight_model.expected_W()) plt.pause(0.001) # Save this sample with open(output_path + ".vb.itr%04d.pkl" % itr, 'w') as f: pickle.dump((samples[-1], timestamps[-1] - start), f, protocol=-1) # Save the Gibbs samples timestamps = np.array(timestamps) with gzip.open(output_path + ".vb.pkl.gz", 'w') as f: print("Saving VB samples to ", (output_path + ".vb.pkl.gz")) pickle.dump((samples, timestamps - start), f, protocol=-1) return samples, timestamps
def fit_network_hawkes_gibbs(S, K, C, B, dt, dt_max, output_path, standard_model=None): samples_and_timestamps = load_partial_results(output_path, typ="gibbs") if samples_and_timestamps is not None: samples, timestamps = samples_and_timestamps # # Check for existing Gibbs results # if os.path.exists(output_path + ".gibbs.pkl"): # with open(output_path + ".gibbs.pkl", 'r') as f: # print "Loading Gibbs results from ", (output_path + ".gibbs.pkl") # (samples, timestamps) = cPickle.load(f) else: print( "Fitting the data with a network Hawkes model using Gibbs sampling" ) # Make a new model for inference network_hypers = {'C': C, 'alpha': 1.0, 'beta': 1.0 / 20.0} test_model = DiscreteTimeNetworkHawkesModelGammaMixture( K=K, dt=dt, dt_max=dt_max, B=B, network_hypers=network_hypers) test_model.add_data(S) # Initialize with the standard model parameters if standard_model is not None: test_model.initialize_with_standard_model(standard_model) plt.ion() im = plot_network(test_model.weight_model.A, test_model.weight_model.W, vmax=0.5) plt.pause(0.001) # Gibbs sample N_samples = 1000 samples = [] lps = [] timestamps = [time.clock()] for itr in range(N_samples): lps.append(test_model.log_probability()) # lps.append(test_model.log_likelihood()) samples.append(test_model.resample_and_copy()) timestamps.append(time.clock()) if itr % 1 == 0: print("Iteration ", itr, "\t LL: ", lps[-1]) # im.set_data(test_model.weight_model.A * \ # test_model.weight_model.W) # plt.pause(0.001) # Save this sample with open(output_path + ".gibbs.itr%04d.pkl" % itr, 'w') as f: pickle.dump((samples[-1], timestamps[-1] - timestamps[0]), f, protocol=-1) # Save the Gibbs timestamps timestamps = np.array(timestamps) with open(output_path + ".gibbs.timestamps.pkl", 'w') as f: print("Saving Gibbs samples to ", (output_path + ".gibbs.timestamps.pkl")) pickle.dump(timestamps, f, protocol=-1) # Save the Gibbs samples with open(output_path + ".gibbs.pkl", 'w') as f: print("Saving Gibbs samples to ", (output_path + ".gibbs.pkl")) pickle.dump((samples, timestamps[1:] - timestamps[0]), f, protocol=-1) return samples, timestamps
def demo(seed=None): """ Fit a weakly sparse :return: """ if seed is None: seed = np.random.randint(2**32) print "Setting seed to ", seed np.random.seed(seed) ########################################################### # Load some example data. # See data/synthetic/generate.py to create more. ########################################################### data_path = os.path.join("data", "synthetic", "synthetic_K20_C4_T10000.pkl.gz") with gzip.open(data_path, 'r') as f: S, true_model = cPickle.load(f) T = S.shape[0] K = true_model.K B = true_model.B dt = true_model.dt dt_max = true_model.dt_max ########################################################### # Initialize with MAP estimation on a standard Hawkes model ########################################################### init_with_map = True if init_with_map: init_len = T print "Initializing with BFGS on first ", init_len, " time bins." init_model = DiscreteTimeStandardHawkesModel(K=K, dt=dt, dt_max=dt_max, B=B, alpha=1.0, beta=1.0) init_model.add_data(S[:init_len, :]) init_model.initialize_to_background_rate() init_model.fit_with_bfgs() else: init_model = None ########################################################### # Create a test weak spike-and-slab model ########################################################### # Copy the network hypers. # Give the test model p, but not c, v, or m network_hypers = true_model.network_hypers.copy() network_hypers['v'] = None test_model = DiscreteTimeNetworkHawkesModelGammaMixture( K=K, dt=dt, dt_max=dt_max, B=B, basis_hypers=true_model.basis_hypers, bkgd_hypers=true_model.bkgd_hypers, impulse_hypers=true_model.impulse_hypers, weight_hypers=true_model.weight_hypers, network_hypers=network_hypers) test_model.add_data(S) # Initialize with the standard model parameters if init_model is not None: test_model.initialize_with_standard_model(init_model) ########################################################### # Fit the test model with Gibbs sampling ########################################################### N_samples = 500 samples = [] lps = [] # plls = [] for itr in xrange(N_samples): lps.append(test_model.log_probability()) # plls.append(test_model.heldout_log_likelihood(S_test, F=F_test)) samples.append(test_model.copy_sample()) print "" print "Gibbs iteration ", itr print "LP: ", lps[-1] test_model.resample_model() ########################################################### # Analyze the samples ########################################################### N_samples = len(samples) A_samples = np.array([s.weight_model.A for s in samples]) W_samples = np.array([s.weight_model.W for s in samples]) g_samples = np.array([s.impulse_model.g for s in samples]) lambda0_samples = np.array([s.bias_model.lambda0 for s in samples]) lps = np.array(lps) offset = N_samples // 2 A_mean = A_samples[offset:, ...].mean(axis=0) W_mean = W_samples[offset:, ...].mean(axis=0) g_mean = g_samples[offset:, ...].mean(axis=0) lambda0_mean = lambda0_samples[offset:, ...].mean(axis=0) plt.figure() plt.plot(np.arange(N_samples), lps, 'k') plt.xlabel("Iteration") plt.ylabel("Log probability") plt.show() # Compute the link prediction accuracy curves auc_init = roc_auc_score(true_model.weight_model.A.ravel(), init_model.W.ravel()) auc_A_mean = roc_auc_score(true_model.weight_model.A.ravel(), A_mean.ravel()) auc_W_mean = roc_auc_score(true_model.weight_model.A.ravel(), W_mean.ravel()) aucs = [] for A in A_samples: aucs.append(roc_auc_score(true_model.weight_model.A.ravel(), A.ravel())) plt.figure() plt.plot(aucs, '-r') plt.plot(auc_A_mean * np.ones_like(aucs), '--r') plt.plot(auc_W_mean * np.ones_like(aucs), '--b') plt.plot(auc_init * np.ones_like(aucs), '--k') plt.xlabel("Iteration") plt.ylabel("Link prediction AUC") plt.show() plt.ioff() plt.show()
def demo(seed=None): """ Fit a weakly sparse :return: """ if seed is None: seed = np.random.randint(2 ** 32) print "Setting seed to ", seed np.random.seed(seed) ########################################################### # Load some example data. # See data/synthetic/generate.py to create more. ########################################################### data_path = os.path.join("data", "synthetic", "synthetic_K4_C1_T1000.pkl.gz") with gzip.open(data_path, "r") as f: S, true_model = cPickle.load(f) T = S.shape[0] K = true_model.K B = true_model.B dt = true_model.dt dt_max = true_model.dt_max ########################################################### # Initialize with MAP estimation on a standard Hawkes model ########################################################### if init_with_map: init_len = T print "Initializing with BFGS on first ", init_len, " time bins." init_model = DiscreteTimeStandardHawkesModel(K=K, dt=dt, dt_max=dt_max, B=B, alpha=1.0, beta=1.0) init_model.add_data(S[:init_len, :]) init_model.initialize_to_background_rate() init_model.fit_with_bfgs() else: init_model = None ########################################################### # Create a test weak spike-and-slab model ########################################################### # Copy the network hypers. # Give the test model p, but not c, v, or m network_hypers = true_model.network_hypers.copy() network_hypers["c"] = None network_hypers["v"] = None network_hypers["m"] = None test_model = DiscreteTimeNetworkHawkesModelGammaMixture( K=K, dt=dt, dt_max=dt_max, B=B, basis_hypers=true_model.basis_hypers, bkgd_hypers=true_model.bkgd_hypers, impulse_hypers=true_model.impulse_hypers, weight_hypers=true_model.weight_hypers, network_hypers=network_hypers, ) test_model.add_data(S) # F_test = test_model.basis.convolve_with_basis(S_test) # Initialize with the standard model parameters if init_model is not None: test_model.initialize_with_standard_model(init_model) # Initialize plots if do_plot: ln, im_net, im_clus = initialize_plots(true_model, test_model, S) ########################################################### # Fit the test model with stochastic variational inference ########################################################### N_iters = 500 minibatchsize = 100 delay = 1.0 forgetting_rate = 0.5 stepsize = (np.arange(N_iters) + delay) ** (-forgetting_rate) samples = [] for itr in xrange(N_iters): print "SVI Iter: ", itr, "\tStepsize: ", stepsize[itr] test_model.sgd_step(minibatchsize=minibatchsize, stepsize=stepsize[itr]) test_model.resample_from_mf() samples.append(test_model.copy_sample()) # Update plot if itr % 1 == 0 and do_plot: update_plots(itr, test_model, S, ln, im_clus, im_net) ########################################################### # Analyze the samples ########################################################### analyze_samples(true_model, init_model, samples)
def demo(seed=None): """ Fit a weakly sparse :return: """ if seed is None: seed = np.random.randint(2**32) print "Setting seed to ", seed np.random.seed(seed) ########################################################### # Load some example data. # See data/synthetic/generate.py to create more. ########################################################### data_path = os.path.join("data", "synthetic", "synthetic_K20_C4_T10000.pkl.gz") with gzip.open(data_path, 'r') as f: S, true_model = cPickle.load(f) T = S.shape[0] K = true_model.K B = true_model.B dt = true_model.dt dt_max = true_model.dt_max ########################################################### # Initialize with MAP estimation on a standard Hawkes model ########################################################### init_with_map = True if init_with_map: init_len = T print "Initializing with BFGS on first ", init_len, " time bins." init_model = DiscreteTimeStandardHawkesModel(K=K, dt=dt, dt_max=dt_max, B=B, alpha=1.0, beta=1.0) init_model.add_data(S[:init_len, :]) init_model.initialize_to_background_rate() init_model.fit_with_bfgs() else: init_model = None ########################################################### # Create a test weak spike-and-slab model ########################################################### # Copy the network hypers. # Give the test model p, but not c, v, or m network_hypers = true_model.network_hypers.copy() network_hypers['v'] = None test_model = DiscreteTimeNetworkHawkesModelGammaMixture(K=K, dt=dt, dt_max=dt_max, B=B, basis_hypers=true_model.basis_hypers, bkgd_hypers=true_model.bkgd_hypers, impulse_hypers=true_model.impulse_hypers, weight_hypers=true_model.weight_hypers, network_hypers=network_hypers) test_model.add_data(S) # Initialize with the standard model parameters if init_model is not None: test_model.initialize_with_standard_model(init_model) ########################################################### # Fit the test model with Gibbs sampling ########################################################### N_samples = 500 samples = [] lps = [] # plls = [] for itr in xrange(N_samples): lps.append(test_model.log_probability()) # plls.append(test_model.heldout_log_likelihood(S_test, F=F_test)) samples.append(test_model.copy_sample()) print "" print "Gibbs iteration ", itr print "LP: ", lps[-1] test_model.resample_model() ########################################################### # Analyze the samples ########################################################### N_samples = len(samples) A_samples = np.array([s.weight_model.A for s in samples]) W_samples = np.array([s.weight_model.W for s in samples]) g_samples = np.array([s.impulse_model.g for s in samples]) lambda0_samples = np.array([s.bias_model.lambda0 for s in samples]) lps = np.array(lps) offset = N_samples // 2 A_mean = A_samples[offset:, ...].mean(axis=0) W_mean = W_samples[offset:, ...].mean(axis=0) g_mean = g_samples[offset:, ...].mean(axis=0) lambda0_mean = lambda0_samples[offset:, ...].mean(axis=0) plt.figure() plt.plot(np.arange(N_samples), lps, 'k') plt.xlabel("Iteration") plt.ylabel("Log probability") plt.show() # Compute the link prediction accuracy curves auc_init = roc_auc_score(true_model.weight_model.A.ravel(), init_model.W.ravel()) auc_A_mean = roc_auc_score(true_model.weight_model.A.ravel(), A_mean.ravel()) auc_W_mean = roc_auc_score(true_model.weight_model.A.ravel(), W_mean.ravel()) aucs = [] for A in A_samples: aucs.append(roc_auc_score(true_model.weight_model.A.ravel(), A.ravel())) plt.figure() plt.plot(aucs, '-r') plt.plot(auc_A_mean * np.ones_like(aucs), '--r') plt.plot(auc_W_mean * np.ones_like(aucs), '--b') plt.plot(auc_init * np.ones_like(aucs), '--k') plt.xlabel("Iteration") plt.ylabel("Link prediction AUC") plt.show() plt.ioff() plt.show()
def demo(seed=None): """ Fit a weakly sparse :return: """ import warnings warnings.warn("This test runs but the parameters need to be tuned. " "Right now, the SVI algorithm seems to walk away from " "the MAP estimate and yield suboptimal results. " "I'm not convinced the variational inference with the " "gamma mixture provides the best estimates of the sparsity.") if seed is None: seed = np.random.randint(2**32) print("Setting seed to ", seed) np.random.seed(seed) ########################################################### # Load some example data. # See data/synthetic/generate.py to create more. ########################################################### data_path = os.path.join("data", "synthetic", "synthetic_K20_C4_T10000.pkl.gz") with gzip.open(data_path, 'r') as f: S, true_model = pickle.load(f) T = S.shape[0] K = true_model.K B = true_model.B dt = true_model.dt dt_max = true_model.dt_max ########################################################### # Initialize with MAP estimation on a standard Hawkes model ########################################################### if init_with_map: init_len = T print("Initializing with BFGS on first ", init_len, " time bins.") init_model = DiscreteTimeStandardHawkesModel(K=K, dt=dt, dt_max=dt_max, B=B, alpha=1.0, beta=1.0) init_model.add_data(S[:init_len, :]) init_model.initialize_to_background_rate() init_model.fit_with_bfgs() else: init_model = None ########################################################### # Create a test weak spike-and-slab model ########################################################### # Copy the network hypers. # Give the test model p, but not c, v, or m network_hypers = true_model.network_hypers.copy() network_hypers['C'] = 1 network_hypers['c'] = None network_hypers['v'] = None network_hypers['m'] = None test_network = StochasticBlockModel(K=K, **network_hypers) test_model = DiscreteTimeNetworkHawkesModelGammaMixture(K=K, dt=dt, dt_max=dt_max, B=B, basis_hypers=true_model.basis_hypers, bkgd_hypers=true_model.bkgd_hypers, impulse_hypers=true_model.impulse_hypers, weight_hypers=true_model.weight_hypers, network=test_network) test_model.add_data(S) # F_test = test_model.basis.convolve_with_basis(S_test) # Initialize with the standard model parameters if init_model is not None: test_model.initialize_with_standard_model(init_model) ########################################################### # Fit the test model with stochastic variational inference ########################################################### N_iters = 500 minibatchsize = 1000 delay = 1.0 forgetting_rate = 0.5 stepsize = (np.arange(N_iters) + delay)**(-forgetting_rate) samples = [] for itr in range(N_iters): print("SVI Iter: ", itr, "\tStepsize: ", stepsize[itr]) test_model.sgd_step(minibatchsize=minibatchsize, stepsize=stepsize[itr]) test_model.resample_from_mf() samples.append(test_model.copy_sample()) ########################################################### # Analyze the samples ########################################################### analyze_samples(true_model, init_model, samples)
def demo(seed=None): """ Fit a weakly sparse :return: """ if seed is None: seed = np.random.randint(2**32) print "Setting seed to ", seed np.random.seed(seed) ########################################################### # Load some example data. # See data/synthetic/generate.py to create more. ########################################################### data_path = os.path.join("data", "synthetic", "synthetic_K4_C1_T1000.pkl.gz") with gzip.open(data_path, 'r') as f: S, true_model = cPickle.load(f) T = S.shape[0] K = true_model.K B = true_model.B dt = true_model.dt dt_max = true_model.dt_max ########################################################### # Initialize with MAP estimation on a standard Hawkes model ########################################################### if init_with_map: init_len = T print "Initializing with BFGS on first ", init_len, " time bins." init_model = DiscreteTimeStandardHawkesModel(K=K, dt=dt, dt_max=dt_max, B=B, alpha=1.0, beta=1.0) init_model.add_data(S[:init_len, :]) init_model.initialize_to_background_rate() init_model.fit_with_bfgs() else: init_model = None ########################################################### # Create a test weak spike-and-slab model ########################################################### # Copy the network hypers. # Give the test model p, but not c, v, or m network_hypers = true_model.network_hypers.copy() test_model = DiscreteTimeNetworkHawkesModelGammaMixture(K=K, dt=dt, dt_max=dt_max, B=B, basis_hypers=true_model.basis_hypers, bkgd_hypers=true_model.bkgd_hypers, impulse_hypers=true_model.impulse_hypers, weight_hypers=true_model.weight_hypers, network_hypers=network_hypers) test_model.add_data(S) # F_test = test_model.basis.convolve_with_basis(S_test) # Initialize with the standard model parameters if init_model is not None: test_model.initialize_with_standard_model(init_model) ########################################################### # Fit the test model with variational Bayesian inference ########################################################### # VB coordinate descent N_iters = 100 vlbs = [] samples = [] for itr in xrange(N_iters): vlbs.append(test_model.meanfield_coordinate_descent_step()) print "VB Iter: ", itr, "\tVLB: ", vlbs[-1] if itr > 0: if (vlbs[-2] - vlbs[-1]) > 1e-1: print "WARNING: VLB is not increasing!" # Resample from variational distribution and plot test_model.resample_from_mf() samples.append(test_model.copy_sample()) ########################################################### # Analyze the samples ########################################################### N_samples = len(samples) # Compute sample statistics for second half of samples A_samples = np.array([s.weight_model.A for s in samples]) W_samples = np.array([s.weight_model.W for s in samples]) g_samples = np.array([s.impulse_model.g for s in samples]) lambda0_samples = np.array([s.bias_model.lambda0 for s in samples]) vlbs = np.array(vlbs) offset = N_samples // 2 A_mean = A_samples[offset:, ...].mean(axis=0) W_mean = W_samples[offset:, ...].mean(axis=0) g_mean = g_samples[offset:, ...].mean(axis=0) lambda0_mean = lambda0_samples[offset:, ...].mean(axis=0) # Plot the VLBs plt.figure() plt.plot(np.arange(N_samples), vlbs, 'k') plt.xlabel("Iteration") plt.ylabel("VLB") plt.show() # Compute the link prediction accuracy curves auc_init = roc_auc_score(true_model.weight_model.A.ravel(), init_model.W.ravel()) auc_A_mean = roc_auc_score(true_model.weight_model.A.ravel(), A_mean.ravel()) auc_W_mean = roc_auc_score(true_model.weight_model.A.ravel(), W_mean.ravel()) aucs = [] for A in A_samples: aucs.append(roc_auc_score(true_model.weight_model.A.ravel(), A.ravel())) plt.figure() plt.plot(aucs, '-r') plt.plot(auc_A_mean * np.ones_like(aucs), '--r') plt.plot(auc_W_mean * np.ones_like(aucs), '--b') plt.plot(auc_init * np.ones_like(aucs), '--k') plt.xlabel("Iteration") plt.ylabel("Link prediction AUC") plt.show() plt.ioff() plt.show()
def demo(seed=None): """ Fit a weakly sparse :return: """ if seed is None: seed = np.random.randint(2**32) print "Setting seed to ", seed np.random.seed(seed) ########################################################### # Load some example data. # See data/synthetic/generate.py to create more. ########################################################### data_path = os.path.join("data", "synthetic", "synthetic_K20_C4_T10000.pkl.gz") with gzip.open(data_path, 'r') as f: S, true_model = cPickle.load(f) T = S.shape[0] K = true_model.K B = true_model.B dt = true_model.dt dt_max = true_model.dt_max ########################################################### # Initialize with MAP estimation on a standard Hawkes model ########################################################### init_with_map = True if init_with_map: init_len = T print "Initializing with BFGS on first ", init_len, " time bins." init_model = DiscreteTimeStandardHawkesModel(K=K, dt=dt, dt_max=dt_max, B=B, alpha=1.0, beta=1.0) init_model.add_data(S[:init_len, :]) init_model.initialize_to_background_rate() init_model.fit_with_bfgs() else: init_model = None ########################################################### # Create a test weak spike-and-slab model ########################################################### # Copy the network hypers. # Give the test model p, but not c, v, or m network_hypers = true_model.network_hypers.copy() network_hypers['c'] = None network_hypers['v'] = None network_hypers['m'] = None test_model = DiscreteTimeNetworkHawkesModelGammaMixture( K=K, dt=dt, dt_max=dt_max, B=B, basis_hypers=true_model.basis_hypers, bkgd_hypers=true_model.bkgd_hypers, impulse_hypers=true_model.impulse_hypers, weight_hypers=true_model.weight_hypers, network_hypers=network_hypers) test_model.add_data(S) # F_test = test_model.basis.convolve_with_basis(S_test) # Initialize with the standard model parameters if init_model is not None: test_model.initialize_with_standard_model(init_model) # Initialize plots ln, im_net, im_clus = initialize_plots(true_model, test_model, S) ########################################################### # Fit the test model with stochastic variational inference ########################################################### N_iters = 500 minibatchsize = 500 delay = 1.0 forgetting_rate = 0.5 stepsize = (np.arange(N_iters) + delay)**(-forgetting_rate) samples = [] for itr in xrange(N_iters): print "SVI Iter: ", itr, "\tStepsize: ", stepsize[itr] test_model.sgd_step(minibatchsize=minibatchsize, stepsize=stepsize[itr]) test_model.resample_from_mf() samples.append(test_model.copy_sample()) # Update plot if itr % 1 == 0: update_plots(itr, test_model, S, ln, im_clus, im_net) ########################################################### # Analyze the samples ########################################################### analyze_samples(true_model, init_model, samples)
def demo(seed=None): """ Fit a weakly sparse :return: """ import warnings warnings.warn("This test runs but the parameters need to be tuned. " "Right now, the SVI algorithm seems to walk away from " "the MAP estimate and yield suboptimal results. " "I'm not convinced the variational inference with the " "gamma mixture provides the best estimates of the sparsity.") if seed is None: seed = np.random.randint(2**32) print("Setting seed to ", seed) np.random.seed(seed) ########################################################### # Load some example data. # See data/synthetic/generate.py to create more. ########################################################### data_path = os.path.join("data", "synthetic", "synthetic_K20_C4_T10000.pkl.gz") with gzip.open(data_path, 'r') as f: S, true_model = pickle.load(f) T = S.shape[0] K = true_model.K B = true_model.B dt = true_model.dt dt_max = true_model.dt_max ########################################################### # Initialize with MAP estimation on a standard Hawkes model ########################################################### if init_with_map: init_len = T print("Initializing with BFGS on first ", init_len, " time bins.") init_model = DiscreteTimeStandardHawkesModel(K=K, dt=dt, dt_max=dt_max, B=B, alpha=1.0, beta=1.0) init_model.add_data(S[:init_len, :]) init_model.initialize_to_background_rate() init_model.fit_with_bfgs() else: init_model = None ########################################################### # Create a test weak spike-and-slab model ########################################################### # Copy the network hypers. # Give the test model p, but not c, v, or m # network_hypers = true_model.network_hypers.copy() # network_hypers['c'] = None # network_hypers['v'] = None # network_hypers['m'] = None # test_network = StochasticBlockModel(K=K, **network_hypers) test_network = StochasticBlockModel(K=K, C=1) test_model = DiscreteTimeNetworkHawkesModelGammaMixture( K=K, dt=dt, dt_max=dt_max, B=B, basis_hypers=true_model.basis_hypers, bkgd_hypers=true_model.bkgd_hypers, impulse_hypers=true_model.impulse_hypers, weight_hypers=true_model.weight_hypers, network=test_network) test_model.add_data(S) # Initialize with the standard model parameters if init_model is not None: test_model.initialize_with_standard_model(init_model) ########################################################### # Fit the test model with variational Bayesian inference ########################################################### # VB coordinate descent N_iters = 100 vlbs = [] samples = [] for itr in range(N_iters): vlbs.append(test_model.meanfield_coordinate_descent_step()) print("VB Iter: ", itr, "\tVLB: ", vlbs[-1]) if itr > 0: if (vlbs[-2] - vlbs[-1]) > 1e-1: print("WARNING: VLB is not increasing!") # Resample from variational distribution and plot test_model.resample_from_mf() samples.append(test_model.copy_sample()) ########################################################### # Analyze the samples ########################################################### N_samples = len(samples) # Compute sample statistics for second half of samples A_samples = np.array([s.weight_model.A for s in samples]) W_samples = np.array([s.weight_model.W for s in samples]) g_samples = np.array([s.impulse_model.g for s in samples]) lambda0_samples = np.array([s.bias_model.lambda0 for s in samples]) vlbs = np.array(vlbs) offset = N_samples // 2 A_mean = A_samples[offset:, ...].mean(axis=0) W_mean = W_samples[offset:, ...].mean(axis=0) g_mean = g_samples[offset:, ...].mean(axis=0) lambda0_mean = lambda0_samples[offset:, ...].mean(axis=0) # Plot the VLBs plt.figure() plt.plot(np.arange(N_samples), vlbs, 'k') plt.xlabel("Iteration") plt.ylabel("VLB") plt.show() # Compute the link prediction accuracy curves auc_init = roc_auc_score(true_model.weight_model.A.ravel(), init_model.W.ravel()) auc_A_mean = roc_auc_score(true_model.weight_model.A.ravel(), A_mean.ravel()) auc_W_mean = roc_auc_score(true_model.weight_model.A.ravel(), W_mean.ravel()) aucs = [] for A in A_samples: aucs.append(roc_auc_score(true_model.weight_model.A.ravel(), A.ravel())) plt.figure() plt.plot(aucs, '-r') plt.plot(auc_A_mean * np.ones_like(aucs), '--r') plt.plot(auc_W_mean * np.ones_like(aucs), '--b') plt.plot(auc_init * np.ones_like(aucs), '--k') plt.xlabel("Iteration") plt.ylabel("Link prediction AUC") plt.show() plt.ioff() plt.show()
init_model = None ########################################################### # Create a test weak spike-and-slab model ########################################################### # Copy the network hypers. # Give the test model p, but not c, v, or m network_hypers = true_model.network_hypers.copy() network_hypers['v'] = None test_model = DiscreteTimeNetworkHawkesModelGammaMixture(K=K, dt=dt, dt_max=dt_max, B=B, basis_hypers=true_model.basis_hypers, bkgd_hypers=true_model.bkgd_hypers, impulse_hypers=true_model.impulse_hypers, weight_hypers=true_model.weight_hypers) test_model.add_data(S) # Initialize with the standard model parameters if init_model is not None: test_model.initialize_with_standard_model(init_model) ########################################################### # Fit the test model with Gibbs sampling ########################################################### N_samples = 500 samples = [] lps = [] for itr in progprint_xrange(N_samples): lps.append(test_model.log_probability()) samples.append(test_model.copy_sample())
def fit_network_hawkes_svi(S, K, C, dt, dt_max, output_path, standard_model=None, N_iters=500): # Check for existing Gibbs results # if os.path.exists(output_path + ".svi.pkl.gz"): # with gzip.open(output_path + ".svi.pkl.gz", 'r') as f: # print "Loading SVI results from ", (output_path + ".svi.pkl.gz") # (samples, timestamps) = cPickle.load(f) if os.path.exists(output_path + ".svi.itr%04d.pkl" % (N_iters-1)): with open(output_path + ".svi.itr%04d.pkl" % (N_iters-1), 'r') as f: print "Loading SVI results from ", (output_path + ".svi.itr%04d.pkl" % (N_iters-1)) sample = cPickle.load(f) samples = [sample] timestamps = None # (samples, timestamps) = cPickle.load(f) else: print "Fitting the data with a network Hawkes model using SVI" # Make a new model for inference test_basis = IdentityBasis(dt, dt_max, allow_instantaneous=True) network_hypers = {'C': C, 'alpha': 1.0, 'beta': 1.0/10.0, 'tau1': 1.0, 'tau0': 10.0, 'allow_self_connections': False} test_model = DiscreteTimeNetworkHawkesModelGammaMixture(K=K, dt=dt, dt_max=dt_max, basis=test_basis, network_hypers=network_hypers) # Initialize with the standard model parameters if standard_model is not None: test_model.initialize_with_standard_model(standard_model) plt.ion() im = plot_network(test_model.weight_model.A, test_model.weight_model.W, vmax=0.5) plt.pause(0.001) # Plot the block affiliations plt.figure(2) KC = np.zeros((K,C)) KC[np.arange(K), test_model.network.c] = 1.0 im_clus = plt.imshow(KC, interpolation="none", cmap="Greys", aspect=float(C)/K) # TODO: Add the data in minibatches minibatchsize = 1000 test_model.add_data(S) # Stochastic variational inference samples = [] delay = 1.0 forgetting_rate = 0.5 stepsize = (np.arange(N_iters) + delay)**(-forgetting_rate) timestamps = [] for itr in xrange(N_iters): print "SVI Iter: ", itr, "\tStepsize: ", stepsize[itr] test_model.sgd_step(minibatchsize=minibatchsize, stepsize=stepsize[itr]) test_model.resample_from_mf() samples.append(test_model.copy_sample()) timestamps.append(time.clock()) if itr % 1 == 0: plt.figure(1) im.set_data(test_model.weight_model.expected_W()) plt.pause(0.001) plt.figure(2) im_clus.set_data(test_model.network.mf_m) plt.title("Iteration %d" % itr) plt.pause(0.001) # Save this sample with open(output_path + ".svi.itr%04d.pkl" % itr, 'w') as f: cPickle.dump(samples[-1], f, protocol=-1) # Save the Gibbs samples # with gzip.open(output_path + ".svi.pkl.gz", 'w') as f: # print "Saving SVI samples to ", (output_path + ".svi.pkl.gz") # cPickle.dump((samples, timestamps), f, protocol=-1) return samples, timestamps
def fit_network_hawkes_vb(S, K, C, B, dt, dt_max, output_path, standard_model=None): samples_and_timestamps = load_partial_results(output_path, typ="vb") if samples_and_timestamps is not None: samples, timestamps = samples_and_timestamps # # Check for existing Gibbs results # if os.path.exists(output_path + ".vb.pkl.gz"): # with gzip.open(output_path + ".vb.pkl.gz", 'r') as f: # print "Loading vb results from ", (output_path + ".vb.pkl.gz") # (samples, timestamps) = cPickle.load(f) # # if isinstance(timestamps, list): # timestamps = np.array(timestamps) else: print "Fitting the data with a network Hawkes model using Batch VB" # Make a new model for inference network_hypers = {'C': C, 'alpha': 1.0, 'beta': 1.0/20.0} test_model = DiscreteTimeNetworkHawkesModelGammaMixture(K=K, dt=dt, dt_max=dt_max, B=B, network_hypers=network_hypers) # Initialize with the standard model parameters if standard_model is not None: test_model.initialize_with_standard_model(standard_model) plt.ion() im = plot_network(test_model.weight_model.A, test_model.weight_model.W, vmax=0.5) plt.pause(0.001) # TODO: Add the data in minibatches minibatchsize = 500 test_model.add_data(S) # Stochastic variational inference N_iters = 1000 vlbs = [] samples = [] start = time.clock() timestamps = [] for itr in xrange(N_iters): vlbs.append(test_model.meanfield_coordinate_descent_step()) print "Batch VB Iter: ", itr, "\tVLB: ", vlbs[-1] samples.append(test_model.copy_sample()) timestamps.append(time.clock()) if itr % 1 == 0: im.set_data(test_model.weight_model.expected_W()) plt.pause(0.001) # Save this sample with open(output_path + ".vb.itr%04d.pkl" % itr, 'w') as f: cPickle.dump((samples[-1], timestamps[-1] - start), f, protocol=-1) # Save the Gibbs samples timestamps = np.array(timestamps) with gzip.open(output_path + ".vb.pkl.gz", 'w') as f: print "Saving VB samples to ", (output_path + ".vb.pkl.gz") cPickle.dump((samples, timestamps - start), f, protocol=-1) return samples, timestamps
def fit_network_hawkes_gibbs(S, K, C, B, dt, dt_max, output_path, standard_model=None): samples_and_timestamps = load_partial_results(output_path, typ="gibbs") if samples_and_timestamps is not None: samples, timestamps = samples_and_timestamps # # Check for existing Gibbs results # if os.path.exists(output_path + ".gibbs.pkl"): # with open(output_path + ".gibbs.pkl", 'r') as f: # print "Loading Gibbs results from ", (output_path + ".gibbs.pkl") # (samples, timestamps) = cPickle.load(f) else: print "Fitting the data with a network Hawkes model using Gibbs sampling" # Make a new model for inference network_hypers = {'C': C, 'alpha': 1.0, 'beta': 1.0/20.0} test_model = DiscreteTimeNetworkHawkesModelGammaMixture(K=K, dt=dt, dt_max=dt_max, B=B, network_hypers=network_hypers) test_model.add_data(S) # Initialize with the standard model parameters if standard_model is not None: test_model.initialize_with_standard_model(standard_model) plt.ion() im = plot_network(test_model.weight_model.A, test_model.weight_model.W, vmax=0.5) plt.pause(0.001) # Gibbs sample N_samples = 1000 samples = [] lps = [] timestamps = [time.clock()] for itr in xrange(N_samples): lps.append(test_model.log_probability()) # lps.append(test_model.log_likelihood()) samples.append(test_model.resample_and_copy()) timestamps.append(time.clock()) if itr % 1 == 0: print "Iteration ", itr, "\t LL: ", lps[-1] # im.set_data(test_model.weight_model.A * \ # test_model.weight_model.W) # plt.pause(0.001) # Save this sample with open(output_path + ".gibbs.itr%04d.pkl" % itr, 'w') as f: cPickle.dump((samples[-1], timestamps[-1]-timestamps[0]), f, protocol=-1) # Save the Gibbs timestamps timestamps = np.array(timestamps) with open(output_path + ".gibbs.timestamps.pkl", 'w') as f: print "Saving Gibbs samples to ", (output_path + ".gibbs.timestamps.pkl") cPickle.dump(timestamps, f, protocol=-1) # Save the Gibbs samples with open(output_path + ".gibbs.pkl", 'w') as f: print "Saving Gibbs samples to ", (output_path + ".gibbs.pkl") cPickle.dump((samples, timestamps[1:] - timestamps[0]), f, protocol=-1) return samples, timestamps
def demo(seed=None): """ Fit a weakly sparse :return: """ if seed is None: seed = np.random.randint(2**32) print "Setting seed to ", seed np.random.seed(seed) ########################################################### # Load some example data. # See data/synthetic/generate.py to create more. ########################################################### data_path = os.path.join("data", "synthetic", "synthetic_K20_C4_T10000.pkl.gz") with gzip.open(data_path, 'r') as f: S, true_model = cPickle.load(f) T = S.shape[0] K = true_model.K B = true_model.B dt = true_model.dt dt_max = true_model.dt_max ########################################################### # Initialize with MAP estimation on a standard Hawkes model ########################################################### init_with_map = True if init_with_map: init_len = T print "Initializing with BFGS on first ", init_len, " time bins." init_model = DiscreteTimeStandardHawkesModel(K=K, dt=dt, dt_max=dt_max, B=B, alpha=1.0, beta=1.0) init_model.add_data(S[:init_len, :]) init_model.initialize_to_background_rate() init_model.fit_with_bfgs() else: init_model = None ########################################################### # Create a test weak spike-and-slab model ########################################################### # Copy the network hypers. # Give the test model p, but not c, v, or m network_hypers = true_model.network_hypers.copy() network_hypers['c'] = None network_hypers['v'] = None network_hypers['m'] = None test_model = DiscreteTimeNetworkHawkesModelGammaMixture( K=K, dt=dt, dt_max=dt_max, B=B, basis_hypers=true_model.basis_hypers, bkgd_hypers=true_model.bkgd_hypers, impulse_hypers=true_model.impulse_hypers, weight_hypers=true_model.weight_hypers, network_hypers=network_hypers) test_model.add_data(S) # F_test = test_model.basis.convolve_with_basis(S_test) # Initialize with the standard model parameters if init_model is not None: test_model.initialize_with_standard_model(init_model) # Initialize plots ln, im_net, im_clus = initialize_plots(true_model, test_model, S) ########################################################### # Fit the test model with Gibbs sampling ########################################################### N_samples = 500 samples = [] lps = [] # plls = [] for itr in xrange(N_samples): lps.append(test_model.log_probability()) # plls.append(test_model.heldout_log_likelihood(S_test, F=F_test)) samples.append(test_model.copy_sample()) print "" print "Gibbs iteration ", itr print "LP: ", lps[-1] test_model.resample_model() # Update plot if itr % 1 == 0: update_plots(itr, test_model, S, ln, im_clus, im_net) ########################################################### # Analyze the samples ########################################################### analyze_samples(true_model, init_model, samples, lps)