def _main(self, ratings, sigma, args):
self.n_thread = args.n_threads
# split data to training & testing
train_pct = 0.9
rand_state.shuffle(ratings)
train_size = int(train_pct * ratings.shape[0])
train = ratings[:train_size]
validation = ratings[train_size:]
self.data = train
nuts_kernel = NUTS(self._conditioned_model, jit_compile=args.jit,)
posterior = MCMC(nuts_kernel,
num_samples=args.num_samples,
warmup_steps=args.warmup_steps,
num_chains=args.num_chains,
disable_progbar=False).run(self._model, sigma, train)
sites = ['mu_item', 'mu_user'] + ['u_temp_feature' + str(user_id) for user_id in xrange(self.n_user)] + ['i_temp_feature' + str(item_id) for item_id in xrange(self.n_item)]
marginal = posterior.marginal(sites=sites)
marginal = torch.cat(list(marginal.support(flatten=True).values()), dim=-1).cpu().numpy()
avg_mu_item = np.average(marginal[:, :self.n_feature], axis=0)
avg_mu_user = np.average(marginal[:, self.n_feature:2*self.n_feature], axis=0)
avg_u_temp_feature = np.average(marginal[:, 2*self.n_feature:2*self.n_feature + self.n_user*self.n_feature].reshape(-1,self.n_user,self.n_feature), axis=0)
avg_i_temp_feature = np.average(marginal[:, 2*self.n_feature + self.n_user*self.n_feature:].reshape(-1,self.n_item, self.n_feature), axis=0)
train_preds = self._predict(train[:, :2], True, avg_u_temp_feature, avg_i_temp_feature)
train_rmse = RMSE(train_preds, train[:, 2])
val_preds = self._predict(validation[:, :2], True, avg_u_temp_feature, avg_i_temp_feature)
val_rmse = RMSE(val_preds, validation[:, 2])
print("After %d iteration, train RMSE: %.6f, validation RMSE: %.6f" % (self.iter_, train_rmse, val_rmse))
def compute_posteriors(self,
x_obs: torch.Tensor,
mcmc_kwargs: dict = None):
"""
:param x_obs:
:param mcmc_kwargs: By default:
{num_samples=1000, warmup_steps=1000, num_chains=4)
:return:
"""
if mcmc_kwargs is None:
mcmc_kwargs = {
"num_samples": 1000,
"warmup_steps": 1000,
"num_chains": 4
}
kernel = NUTS(
self.pyro_mdl,
adapt_step_size=True,
max_plate_nesting=1,
jit_compile=True,
target_accept_prob=0.6,
)
mcmc_run = MCMC(kernel, **mcmc_kwargs).run(data=x_obs)
marginals = mcmc_run.marginal(sites=["z"])
marginals_supp = marginals.support()
z_x = marginals_supp["z"]
return z_x, marginals
def nuts_fit(model, data, num_samples=None, warmup_steps=None, var_names=None):
""" Use No U-turn Sampler for inferring latent variables """
num_samples = int(0.8 * len(data)) if num_samples is None else num_samples
warmup_steps = len(
data) - num_samples if warmup_steps is None else warmup_steps
nuts_kernel = NUTS(model, adapt_step_size=True)
trace = MCMC(nuts_kernel,
num_samples=num_samples,
warmup_steps=warmup_steps).run(data)
if var_names is None:
posteriors = None
else:
posteriors = trace.marginal(var_names).empirical
return trace, posteriors
class BenchmarkPyroModel(PyroModel):
def __init__(self,
base,
subspace,
prior_log_sigma,
likelihood_given_outputs,
batch_size=100,
kernel=NUTS,
num_samples=30,
kernel_kwargs={},
*args,
**kwargs):
super(BenchmarkPyroModel, self).__init__(base,
subspace,
prior_log_sigma,
likelihood_given_outputs,
batch_size=batch_size,
*args,
**kwargs)
self.kernel = kernel(self.model, **kernel_kwargs)
self.num_samples = num_samples
#self.loader = loader
self.all_samples = None
self.mcmc_run = None
def fit(self, inputs, targets, *args, **kwargs):
self.mcmc_run = MCMC(self.kernel,
num_samples=self.num_samples,
warmup_steps=100).run(inputs, targets)
self.all_samples = torch.cat(list(
self.mcmc_run.marginal(sites="t").support(flatten=True).values()),
dim=-1)
def sample(self, ind=None, scale=1.0):
if ind is None:
ind = np.random.randint(self.num_samples)
self.eval()
self.t.set_(self.all_samples[int(ind), :])
def model(utt, phi):
a = pyro.sample("a", dist.Uniform(.1, 20.))
b = pyro.sample("b", dist.Uniform(.1, 20.))
mu = pyro.sample("mu", dist.Beta(a,b))
nu = pyro.sample("nu", dist.LogNormal(2,0.5))
a2 = mu * (nu + 1)
b2 = (1-mu) * (nu + 1)
with pyro.plate("data"):
pyro.sample("obs", RSASpeaker(mu, phi), obs=utt)
utt = torch.ones(200)
utt[50:200] = 0
phi = torch.rand(50) * .3
phi2 = torch.rand(150) * 0.6 + .4
phi = torch.cat([phi, phi2])
nuts_kernel = NUTS(model, jit_compile=True, adapt_step_size=True)
hmc_posterior = MCMC(nuts_kernel, num_samples=100, warmup_steps=200) \
.run(utt, phi)
print(EmpiricalMarginal(hmc_posterior, "mu")._get_samples_and_weights()[0])
print(hmc_posterior.marginal('mu').empirical['mu'].mean)
inpts = inpts.reshape([num_batches, batch_size, *inpts.shape[1:]])
trgts = trgts.reshape([num_batches, batch_size])
print("Inputs:", inpts.shape)
print("Targets:", trgts.shape)
printf, logfile = utils.get_logging_print(os.path.join(args.dir, args.log_fname + '-%s.txt'))
print('Saving logs to: %s' % logfile)
nuts_kernel = NUTS(pyro_model.model, step_size=10.)
num_samples = 30
# x_, y_ = loaders["train"].dataset.tensors
mcmc_run = MCMC(nuts_kernel, num_samples=num_samples, warmup_steps=10).run(inpts, trgts)
#mcmc_run = MCMC(nuts_kernel, num_samples=num_samples, warmup_steps=100).run(islice(loaders["train"], 1000))
samples = torch.cat(list(mcmc_run.marginal(sites="t").support(flatten=True).values()), dim=-1)
print(samples)
utils.save_checkpoint(
args.dir,
0,
name='nuts',
state_dict=pyro_model.state_dict()
)
predictions = np.zeros((len(loaders['test'].dataset), num_classes))
targets = np.zeros(len(loaders['test'].dataset))
printf, logfile = utils.get_logging_print(os.path.join(args.dir, args.log_fname + '-%s.txt'))
print('Saving logs to: %s' % logfile)
def _main(self,
ratings,
validation,
jit=False,
num_samples=30,
warmup_steps=5,
num_chains=1):
ratingstmp = np.zeros((self.n_user, self.n_item), dtype='float64')
for rat in ratings:
ratingstmp[rat[0], rat[1]] = rat[2]
nuts_kernel = NUTS(
self._conditioned_model,
jit_compile=jit,
)
posterior = MCMC(nuts_kernel,
num_samples=num_samples,
warmup_steps=warmup_steps,
num_chains=num_chains,
disable_progbar=False).run(self._model, ratingstmp)
sites = ['mu_item', 'mu_user'] + [
'u_temp_feature' + str(user_id) for user_id in xrange(self.n_user)
] + [
'i_temp_feature' + str(item_id) for item_id in xrange(self.n_item)
]
marginal = posterior.marginal(sites=sites)
marginal = torch.cat(list(marginal.support(flatten=True).values()),
dim=-1)
numOfres = (2 + int(self.n_user) + int(self.n_item)) * int(
self.n_feature)
print("shape : " + str(marginal.shape))
print("numOfres : " + str(numOfres))
marginal = marginal[num_samples - 1]
ifmatrix = torch.zeros(
(int(self.n_item), int(self.n_feature))).detach().numpy()
ufmatrix = torch.zeros(
(int(self.n_user), int(self.n_feature))).detach().numpy()
marginal = torch.reshape(
marginal,
(2 + int(self.n_user) + int(self.n_item), int(self.n_feature)))
for i in range(int(self.n_user)):
ufmatrix[i, :] = marginal[2 + i]
for i in range(int(self.n_item)):
ifmatrix[i, :] = marginal[2 + int(self.n_user) + i]
Y = np.matmul(ufmatrix, ifmatrix.transpose())
for x in range(self.n_user):
for y in range(self.n_item):
if Y[x, y] > self.max_rating:
Y[x, y] = self.max_rating
elif Y[x, y] < self.min_rating:
Y[x, y] = self.min_rating
output_file.write("item feature : \n")
output_file.write(str(ifmatrix) + "\n")
output_file.write("user feature : \n")
output_file.write(str(ufmatrix) + "\n")
output_file.write("Y : \n")
output_file.write(str(Y) + "\n")
numOfrat = 0
summ = 0.0
for rat in validation:
numOfrat += 1
summ += np.power(Y[rat[0], rat[1]] - rat[2], 2)
rmse = np.power(summ / numOfrat, 0.5)
output_file.write("RMSE: " + str(rmse))
print("RMSE: " + str(rmse))
