python类Tensor()的实例源码

test_torch.py 文件源码 项目:pytorch-dist 作者: apaszke 项目源码 文件源码 阅读 30 收藏 0 点赞 0 评论 0
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)
test_torch.py 文件源码 项目:pytorch-dist 作者: apaszke 项目源码 文件源码 阅读 27 收藏 0 点赞 0 评论 0
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]])
vocab.py 文件源码 项目:text 作者: pytorch 项目源码 文件源码 阅读 43 收藏 0 点赞 0 评论 0
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])
vocab.py 文件源码 项目:text 作者: pytorch 项目源码 文件源码 阅读 34 收藏 0 点赞 0 评论 0
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
test_meters.py 文件源码 项目:tnt 作者: pytorch 项目源码 文件源码 阅读 37 收藏 0 点赞 0 评论 0
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")
policies.py 文件源码 项目:drl.pth 作者: seba-1511 项目源码 文件源码 阅读 32 收藏 0 点赞 0 评论 0
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]))
algos_utils.py 文件源码 项目:drl.pth 作者: seba-1511 项目源码 文件源码 阅读 31 收藏 0 点赞 0 评论 0
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)
algos_utils.py 文件源码 项目:drl.pth 作者: seba-1511 项目源码 文件源码 阅读 28 收藏 0 点赞 0 评论 0
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)
reinforce.py 文件源码 项目:drl.pth 作者: seba-1511 项目源码 文件源码 阅读 27 收藏 0 点赞 0 评论 0
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()]
test_utils.py 文件源码 项目:crnn 作者: wulivicte 项目源码 文件源码 阅读 26 收藏 0 点赞 0 评论 0
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
test_utils.py 文件源码 项目:crnn 作者: wulivicte 项目源码 文件源码 阅读 28 收藏 0 点赞 0 评论 0
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
test_utils.py 文件源码 项目:crnn 作者: wulivicte 项目源码 文件源码 阅读 41 收藏 0 点赞 0 评论 0
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()
utils.py 文件源码 项目:crnn 作者: wulivicte 项目源码 文件源码 阅读 24 收藏 0 点赞 0 评论 0
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
nn1_stress_test.py 文件源码 项目:YellowFin_Pytorch 作者: JianGoForIt 项目源码 文件源码 阅读 40 收藏 0 点赞 0 评论 0
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)
nn1.py 文件源码 项目:YellowFin_Pytorch 作者: JianGoForIt 项目源码 文件源码 阅读 34 收藏 0 点赞 0 评论 0
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)
train.py 文件源码 项目:pytorch-semseg 作者: meetshah1995 项目源码 文件源码 阅读 39 收藏 0 点赞 0 评论 0
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))
diracconv.py 文件源码 项目:diracnets 作者: szagoruyko 项目源码 文件源码 阅读 48 收藏 0 点赞 0 评论 0
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)
diracconv.py 文件源码 项目:diracnets 作者: szagoruyko 项目源码 文件源码 阅读 29 收藏 0 点赞 0 评论 0
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()
diracconv.py 文件源码 项目:diracnets 作者: szagoruyko 项目源码 文件源码 阅读 37 收藏 0 点赞 0 评论 0
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()
diracconv.py 文件源码 项目:diracnets 作者: szagoruyko 项目源码 文件源码 阅读 53 收藏 0 点赞 0 评论 0
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()


问题


面经


文章

微信
公众号

扫码关注公众号