def test3():
"""
The binomial distribution
:return:
"""
from torch.distributions.binomial import Binomial
# 100-count of trials: 0, 0.2, 0.8 and 1 are event probabilities
dist = Binomial(100, torch.tensor([0, 0.2, 0.8, 1]))
dist.sample() # tensor([ 0., 19., 72., 100.])
def main(args):
np.random.seed(args.seed)
torch.manual_seed(args.seed)
n, d = args.n, args.d
p = np.sqrt(d) / d
probs = torch.ones(d) * p
sampler = Binomial(1, probs)
data = sampler.sample(sample_shape=(torch.Size([n])))
# add some correlation
offset = int(np.sqrt(d))
for i in range(offset):
data[:, i + offset] = data[:, i]
weight = torch.randn((d))
noise = torch.randn((n)) / 2
labels = data @ weight + noise
print('data shape', data.shape)
path = os.path.join(args.save_prefix, 'sparse_' + str(n) + '_' + str(d))
os.makedirs(path)
data_path = os.path.join(path, 'data.npy')
p_path = os.path.join(path, 'p.npy')
labels_path = os.path.join(path, 'labels.npy')
np.save(data_path, data.numpy())
np.save(p_path, p)
np.save(labels_path, labels.numpy())
def __getitem__(self, idx):
# idx only acts as a counter while generating batches.
num_item = torch.randint(self.min_item,
self.max_item, (1, ),
dtype=torch.long).item()
prob = 0.5 * \
torch.ones([self.seq_len, self.seq_width], dtype=torch.float64)
seq = Binomial(1, prob)
# fill in input two bit wider than target to account for delimiter
# flags.
input_items = torch.zeros([(self.seq_len + 1) * (num_item + 1) + 1,
self.seq_width + 2])
for i in range(num_item):
input_items[(self.seq_len + 1) * i, self.seq_width] = 1.0
input_items[(self.seq_len + 1) * i + 1:(self.seq_len + 1) *
(i + 1), :self.seq_width] = seq.sample()
# generate query item randomly
# in case of only one item, torch.randint throws error as num_item-1=0
query_item = 0
if num_item != 1:
query_item = torch.randint(0,
num_item - 1, (1, ),
dtype=torch.long).item()
query_seq = input_items[(self.seq_len + 1) * query_item +
1:(self.seq_len + 1) *
(query_item + 1), :self.seq_width]
input_items[(self.seq_len + 1) * num_item,
self.seq_width + 1] = 1.0 # query delimiter
input_items[(self.seq_len + 1) * num_item + 1:(self.seq_len + 1) *
(num_item + 1), :self.seq_width] = query_seq
input_items[(self.seq_len + 1) * (num_item + 1),
self.seq_width + 1] = 1.0 # query delimiter
# generate target sequences(item next to query in the input list)
target_item = torch.zeros([self.seq_len, self.seq_width])
# in case of last item, target sequence is zero
if query_item != num_item - 1:
target_item[:self.seq_len, :self.seq_width] = input_items[
(self.seq_len + 1) * (query_item + 1) + 1:(self.seq_len + 1) *
(query_item + 2), :self.seq_width]
return {'input': input_items, 'target': target_item}
def get_sample_wlen(self, num_item, seq_len, bs=1):
prob = 0.5 * \
torch.ones([seq_len, bs, self.seq_width], dtype=torch.float64)
seq = Binomial(1, prob)
# fill in input two bit wider than target to account for delimiter
# flags.
input_items = torch.zeros([(seq_len + 1) * (num_item + 1) + 1, bs,
self.seq_width + 2])
for i in range(num_item):
input_items[(seq_len + 1) * i, :, self.seq_width] = 1.0
input_items[(seq_len + 1) * i + 1:(seq_len + 1) *
(i + 1), :, :self.seq_width] = seq.sample()
# generate query item randomly
# in case of only one item, torch.randint throws error as num_item-1=0
query_item = 0
if num_item != 1:
query_item = torch.randint(0,
num_item - 1, (1, ),
dtype=torch.long).item()
query_seq = input_items[(seq_len + 1) * query_item + 1:(seq_len + 1) *
(query_item + 1), :, :self.seq_width]
input_items[(seq_len + 1) * num_item, :,
self.seq_width + 1] = 1.0 # query delimiter
input_items[(seq_len + 1) * num_item + 1:(seq_len + 1) *
(num_item + 1), :, :self.seq_width] = query_seq
input_items[(seq_len + 1) * (num_item + 1), :,
self.seq_width + 1] = 1.0 # query delimiter
# generate target sequences(item next to query in the input list)
target_item = torch.zeros([seq_len, bs, self.seq_width])
# in case of last item, target sequence is zero
for b in range(bs):
choose_max = False
qitem = input_items[(seq_len + 1) * query_item + 1:(seq_len + 1) *
(query_item + 1), b, :self.seq_width]
if qitem.contiguous().view(-1)[-1].item() == 1:
choose_max = True
# print("max")
else:
pass
# print("min")
if choose_max:
cd = 0
else:
cd = 10000000000000000
titem = qitem
for ii in range(num_item):
if ii != query_item:
cur_item = input_items[(seq_len + 1) * ii +
1:(seq_len + 1) * (ii + 1),
b, :self.seq_width]
curd = torch.norm(qitem.contiguous().view(-1) -
cur_item.contiguous().view(-1))
if choose_max:
if curd > cd:
titem = ii
cd = curd
else:
if curd < cd:
titem = ii
cd = curd
# print(num_item)
# print(titem)
# print(cd)
target_item[:seq_len, b, :self.seq_width] = input_items[
(seq_len + 1) * titem + 1:(seq_len + 1) * (titem + 1),
b, :self.seq_width]
return {'input': input_items, 'target': target_item}
def _sampleWidthByAlphas(self):
# define Binomial distribution on n-1 layer filters (because we have to choose at least one filter)
dist = Binomial(self.outputChannels() - 1, logits=self._alphas)
# draw from distribution
width = 1 + dist.sample().type(int32).item()
return width
def calcNewWidthFunc(width: int,
alphaWidth: AlphaPerWidthBlock.AlphaWidth):
# define Binomial distribution on n-1 layer filters (because we have to choose at least one filter)
dist = Binomial(width - 1, logits=alphaWidth.tensor())
# draw from distribution
return 1 + dist.sample().type(int32).item()
os.makedirs(model_path)
from tensorboardX import SummaryWriter
writer = SummaryWriter(os.path.join('runs', model_name))
n_iter = 0
num_samples = 50
sample = torch.randn(64, opts.nz).double().to(device)
for epoch in range(opts.epochs):
print('=> Epoch {}'.format(epoch))
model.train()
running_loss = []
for data in tqdm(train_loader):
image = data[0]
m = Binomial(1, image.view(-1, 784))
# inputs = m.sample(torch.Size([num_samples])).double().to(device)
inputs = m.sample().expand(num_samples, image.shape[0],
784).double().to(device)
optimizer.zero_grad()
loss, bce, kld = model.train_loss(inputs)
loss.backward()
optimizer.step()
running_loss.append(loss.item())
writer.add_scalar('bce', bce, n_iter)
writer.add_scalar('kld', kld, n_iter)
writer.add_scalar('loss', loss, n_iter)
n_iter += 1
writer.add_scalar('loss_epoch', np.mean(running_loss), epoch)
model.eval()
running_loss = []