def test_abs(self):
size = 1000
max_val = 1000
original = torch.rand(size).mul(max_val)
# Tensor filled with values from {-1, 1}
switch = torch.rand(size).mul(2).floor().mul(2).add(-1)
types = ['torch.DoubleTensor', 'torch.FloatTensor', 'torch.LongTensor', 'torch.IntTensor']
for t in types:
data = original.type(t)
switch = switch.type(t)
res = torch.mul(data, switch)
self.assertEqual(res.abs(), data, 1e-16)
# Checking that the right abs function is called for LongTensor
bignumber = 2^31 + 1
res = torch.LongTensor((-bignumber,))
self.assertGreater(res.abs()[0], 0)
python类Tensor()的实例源码
def test_tolist(self):
list0D = []
tensor0D = torch.Tensor(list0D)
self.assertEqual(tensor0D.tolist(), list0D)
table1D = [1, 2, 3]
tensor1D = torch.Tensor(table1D)
storage = torch.Storage(table1D)
self.assertEqual(tensor1D.tolist(), table1D)
self.assertEqual(storage.tolist(), table1D)
self.assertEqual(tensor1D.tolist(), table1D)
self.assertEqual(storage.tolist(), table1D)
table2D = [[1, 2], [3, 4]]
tensor2D = torch.Tensor(table2D)
self.assertEqual(tensor2D.tolist(), table2D)
tensor3D = torch.Tensor([[[1, 2], [3, 4]], [[5, 6], [7, 8]]])
tensorNonContig = tensor3D.select(1, 1)
self.assertFalse(tensorNonContig.is_contiguous())
self.assertEqual(tensorNonContig.tolist(), [[3, 4], [7, 8]])
def set_vectors(self, stoi, vectors, dim, unk_init=torch.Tensor.zero_):
"""
Set the vectors for the Vocab instance from a collection of Tensors.
Arguments:
stoi: A dictionary of string to the index of the associated vector
in the `vectors` input argument.
vectors: An indexed iterable (or other structure supporting __getitem__) that
given an input index, returns a FloatTensor representing the vector
for the token associated with the index. For example,
vector[stoi["string"]] should return the vector for "string".
dim: The dimensionality of the vectors.
unk_init (callback): by default, initialize out-of-vocabulary word vectors
to zero vectors; can be any function that takes in a Tensor and
returns a Tensor of the same size. Default: torch.Tensor.zero_
"""
self.vectors = torch.Tensor(len(self), dim)
for i, token in enumerate(self.itos):
wv_index = stoi.get(token, None)
if wv_index is not None:
self.vectors[i] = vectors[wv_index]
else:
self.vectors[i] = unk_init(self.vectors[i])
def __getitem__(self, token):
vector = torch.Tensor(1, self.dim).zero_()
if token == "<unk>":
return self.unk_init(vector)
# These literals need to be coerced to unicode for Python 2 compatibility
# when we try to join them with read ngrams from the files.
chars = ['#BEGIN#'] + list(token) + ['#END#']
num_vectors = 0
for n in [2, 3, 4]:
end = len(chars) - n + 1
grams = [chars[i:(i + n)] for i in range(end)]
for gram in grams:
gram_key = '{}gram-{}'.format(n, ''.join(gram))
if gram_key in self.stoi:
vector += self.vectors[self.stoi[gram_key]]
num_vectors += 1
if num_vectors > 0:
vector /= num_vectors
else:
vector = self.unk_init(vector)
return vector
def testAUCMeter(self):
mtr = meter.AUCMeter()
test_size = 1000
mtr.add(torch.rand(test_size), torch.zeros(test_size))
mtr.add(torch.rand(test_size), torch.Tensor(test_size).fill_(1))
val, tpr, fpr = mtr.value()
self.assertTrue(math.fabs(val - 0.5) < 0.1, msg="AUC Meter fails")
mtr.reset()
mtr.add(torch.Tensor(test_size).fill_(0), torch.zeros(test_size))
mtr.add(torch.Tensor(test_size).fill_(0.1), torch.zeros(test_size))
mtr.add(torch.Tensor(test_size).fill_(0.2), torch.zeros(test_size))
mtr.add(torch.Tensor(test_size).fill_(0.3), torch.zeros(test_size))
mtr.add(torch.Tensor(test_size).fill_(0.4), torch.zeros(test_size))
mtr.add(torch.Tensor(test_size).fill_(1),
torch.Tensor(test_size).fill_(1))
val, tpr, fpr = mtr.value()
self.assertEqual(val, 1.0, msg="AUC Meter fails")
def __init__(self, model, action_size=1, init_value=0.0, *args, **kwargs):
super(DiagonalGaussianPolicy, self).__init__(model, *args, **kwargs)
self.init_value = init_value
self.logstd = th.zeros((1, action_size)) + self.init_value
self.logstd = P(self.logstd)
self.halflog2pie = V(T([2 * pi * exp(1)])) * 0.5
self.halflog2pi = V(T([2.0 * pi])) * 0.5
self.pi = V(T([pi]))
def discount(rewards, gamma):
tensor = False
if not isinstance(rewards, list):
tensor = True
rewards = rewards.split(1)
R = 0.0
discounted = []
for r in rewards[::-1]:
R = r + gamma * R
discounted.insert(0, R)
if tensor:
return th.cat(discounted).view(-1)
return T(discounted)
def generalized_advantage_estimations(rewards, values, terminal=None, gamma=0.99, tau=0.95):
gae = 0.0
advantages = []
values = th.cat([values, V(T([0.0077]))])
for i in reversed(range(len(rewards))):
nonterminal = 1.0 - terminal[i]
delta = rewards[i] + gamma * values[i+1] * nonterminal - values[i]
gae = delta + gamma * tau * gae * nonterminal
advantages.insert(0, gae + values[i])
return th.cat(advantages)
def get_update(self):
num_traj = loss_stats = critics_stats = entropy_stats = policy_stats = 0.0
all_rewards, all_advantages = self.advantage(self.rewards, self.critics, self.terminals)
# for actions_ep, rewards_ep, critics_ep, entropy_ep, terminals_ep in zip(self.actions, self.rewards, self.critics, self.entropies, self.terminals):
for actions_ep, rewards_ep, advantage_ep, critics_ep, entropy_ep, terminals_ep in zip(self.actions, all_rewards, all_advantages, self.critics, self.entropies, self.terminals):
if len(actions_ep) > 0:
# Compute advantages
#rewards_ep = V(T(rewards_ep))
critics_ep = th.cat(critics_ep, 0).view(-1)
#rewards_ep, advantage_ep = self.advantage(rewards_ep, critics_ep, terminals_ep)
# Compute losses
critic_loss = (rewards_ep - critics_ep).pow(2).mean()
entropy_loss = th.cat(entropy_ep).mean()
critic_loss = self.critic_weight * critic_loss
entropy_loss = - self.entropy_weight * entropy_loss
# Compute policy gradients
policy_loss = 0.0
for action, advantage in zip(actions_ep, advantage_ep):
policy_loss = policy_loss - action.log_prob.mean() * advantage.data[0]
loss = policy_loss + critic_loss + entropy_loss
loss.backward(retain_graph=True)
if self.grad_clip > 0.0:
th.nn.utils.clip_grad_norm(self.parameters(), self.grad_clip)
# Update running statistics
loss_stats += loss.data[0]
critics_stats += critic_loss.data[0]
entropy_stats += entropy_loss.data[0]
policy_stats += policy_loss.data[0]
num_traj += 1.0
# Store statistics
self.stats['Num. Updates'] += 1.0
self.stats['Num. Trajectories'] += num_traj
self.stats['Critic Loss'] += critics_stats / num_traj
self.stats['Entropy Loss'] += entropy_stats / num_traj
self.stats['Policy Loss'] += policy_stats / num_traj
self.stats['Total Loss'] += loss_stats / num_traj
self.stats['Num. Steps'] += self.steps
self._reset()
return [p.grad.clone() for p in self.parameters()]
def equal(a, b):
if isinstance(a, torch.Tensor):
return a.equal(b)
elif isinstance(a, str):
return a == b
elif isinstance(a, collections.Iterable):
res = True
for (x, y) in zip(a, b):
res = res & equal(x, y)
return res
else:
return a == b
def checkAverager(self):
acc = utils.averager()
acc.add(Variable(torch.Tensor([1, 2])))
acc.add(Variable(torch.Tensor([[5, 6]])))
assert acc.val() == 3.5
acc = utils.averager()
acc.add(torch.Tensor([1, 2]))
acc.add(torch.Tensor([[5, 6]]))
assert acc.val() == 3.5
def checkAssureRatio(self):
img = torch.Tensor([[1], [3]]).view(1, 1, 2, 1)
img = Variable(img)
img = utils.assureRatio(img)
assert torch.Size([1, 1, 2, 2]) == img.size()
def add(self, v):
if isinstance(v, Variable):
count = v.data.numel()
v = v.data.sum()
elif isinstance(v, torch.Tensor):
count = v.numel()
v = v.sum()
self.n_count += count
self.sum += v
def __init__(self, batch_size, num_tokens, embed_size, word_gru_hidden, bidirectional= True, init_range=0.1, use_lstm=False):
super(AttentionWordRNN, self).__init__()
self.batch_size = batch_size
self.num_tokens = num_tokens
self.embed_size = embed_size
self.word_gru_hidden = word_gru_hidden
self.bidirectional = bidirectional
self.use_lstm = use_lstm
self.lookup = nn.Embedding(num_tokens, embed_size)
if bidirectional == True:
if use_lstm:
print("inside using LSTM")
self.word_gru = nn.LSTM(embed_size, word_gru_hidden, bidirectional= True)
else:
self.word_gru = nn.GRU(embed_size, word_gru_hidden, bidirectional= True)
self.weight_W_word = nn.Parameter(torch.Tensor(2* word_gru_hidden, 2*word_gru_hidden))
self.bias_word = nn.Parameter(torch.Tensor(2* word_gru_hidden,1))
self.weight_proj_word = nn.Parameter(torch.Tensor(2*word_gru_hidden, 1))
else:
if use_lstm:
self.word_gru = nn.LSTM(embed_size, word_gru_hidden, bidirectional= False)
else:
self.word_gru = nn.GRU(embed_size, word_gru_hidden, bidirectional= False)
self.weight_W_word = nn.Parameter(torch.Tensor(word_gru_hidden, word_gru_hidden))
self.bias_word = nn.Parameter(torch.Tensor(word_gru_hidden,1))
self.weight_proj_word = nn.Parameter(torch.Tensor(word_gru_hidden, 1))
self.softmax_word = nn.Softmax()
self.weight_W_word.data.uniform_(-init_range, init_range)
self.weight_proj_word.data.uniform_(-init_range, init_range)
def __init__(self, batch_size, num_tokens, embed_size, word_gru_hidden, bidirectional= True, init_range=0.1, use_lstm=False):
super(AttentionWordRNN, self).__init__()
self.batch_size = batch_size
self.num_tokens = num_tokens
self.embed_size = embed_size
self.word_gru_hidden = word_gru_hidden
self.bidirectional = bidirectional
self.use_lstm = use_lstm
self.lookup = nn.Embedding(num_tokens, embed_size)
if bidirectional == True:
if use_lstm:
print("inside using LSTM")
self.word_gru = nn.LSTM(embed_size, word_gru_hidden, bidirectional= True)
else:
self.word_gru = nn.GRU(embed_size, word_gru_hidden, bidirectional= True)
self.weight_W_word = nn.Parameter(torch.Tensor(2* word_gru_hidden, 2*word_gru_hidden))
self.bias_word = nn.Parameter(torch.Tensor(2* word_gru_hidden,1))
self.weight_proj_word = nn.Parameter(torch.Tensor(2*word_gru_hidden, 1))
else:
if use_lstm:
self.word_gru = nn.LSTM(embed_size, word_gru_hidden, bidirectional= False)
else:
self.word_gru = nn.GRU(embed_size, word_gru_hidden, bidirectional= False)
self.weight_W_word = nn.Parameter(torch.Tensor(word_gru_hidden, word_gru_hidden))
self.bias_word = nn.Parameter(torch.Tensor(word_gru_hidden,1))
self.weight_proj_word = nn.Parameter(torch.Tensor(word_gru_hidden, 1))
self.softmax_word = nn.Softmax()
self.weight_W_word.data.uniform_(-init_range, init_range)
self.weight_proj_word.data.uniform_(-init_range, init_range)
def train(args):
# Setup Dataloader
data_loader = get_loader(args.dataset)
data_path = get_data_path(args.dataset)
loader = data_loader(data_path, is_transform=True, img_size=(args.img_rows, args.img_cols))
n_classes = loader.n_classes
trainloader = data.DataLoader(loader, batch_size=args.batch_size, num_workers=4, shuffle=True)
# Setup visdom for visualization
if args.visdom:
vis = visdom.Visdom()
loss_window = vis.line(X=torch.zeros((1,)).cpu(),
Y=torch.zeros((1)).cpu(),
opts=dict(xlabel='minibatches',
ylabel='Loss',
title='Training Loss',
legend=['Loss']))
# Setup Model
model = get_model(args.arch, n_classes)
model = torch.nn.DataParallel(model, device_ids=range(torch.cuda.device_count()))
model.cuda()
optimizer = torch.optim.SGD(model.parameters(), lr=args.l_rate, momentum=0.99, weight_decay=5e-4)
for epoch in range(args.n_epoch):
for i, (images, labels) in enumerate(trainloader):
images = Variable(images.cuda())
labels = Variable(labels.cuda())
optimizer.zero_grad()
outputs = model(images)
loss = cross_entropy2d(outputs, labels)
loss.backward()
optimizer.step()
if args.visdom:
vis.line(
X=torch.ones((1, 1)).cpu() * i,
Y=torch.Tensor([loss.data[0]]).unsqueeze(0).cpu(),
win=loss_window,
update='append')
if (i+1) % 20 == 0:
print("Epoch [%d/%d] Loss: %.4f" % (epoch+1, args.n_epoch, loss.data[0]))
torch.save(model, "{}_{}_{}_{}.pkl".format(args.arch, args.dataset, args.feature_scale, epoch))
def dirac_delta(ni, no, k):
n = min(ni, no)
size = (n, n) + k
repeats = (max(no // ni, 1), max(ni // no, 1)) + (1,) * len(k)
return dirac(torch.Tensor(*size)).repeat(*repeats)
def __init__(self, in_channels, out_channels, kernel_size, padding=0, dilation=1, bias=True):
super(DiracConv1d, self).__init__(in_channels, out_channels, kernel_size,
stride=1, padding=padding, dilation=dilation, bias=bias)
self.alpha = nn.Parameter(torch.Tensor([5]))
self.beta = nn.Parameter(torch.Tensor([1e-5]))
self.register_buffer('delta', dirac_delta(in_channels, out_channels, k=self.weight.size()[2:]))
assert self.delta.size() == self.weight.size()
def __init__(self, in_channels, out_channels, kernel_size, padding=0, dilation=1, bias=True):
super(DiracConv2d, self).__init__(in_channels, out_channels, kernel_size,
stride=1, padding=padding, dilation=dilation, bias=bias)
self.alpha = nn.Parameter(torch.Tensor([5]))
self.beta = nn.Parameter(torch.Tensor([1e-5]))
self.register_buffer('delta', dirac_delta(in_channels, out_channels, self.weight.size()[2:]))
assert self.delta.size() == self.weight.size()
def __init__(self, in_channels, out_channels, kernel_size, padding=0, dilation=1, bias=True):
super(DiracConv3d, self).__init__(in_channels, out_channels, kernel_size,
stride=1, padding=padding, dilation=dilation, bias=bias)
self.alpha = nn.Parameter(torch.Tensor([5]))
self.beta = nn.Parameter(torch.Tensor([1e-5]))
self.register_buffer('delta', dirac_delta(in_channels, out_channels, self.weight.size()[2:]))
assert self.delta.size() == self.weight.size()
