python类softmax()的实例源码

vae_m2.py 文件源码 项目:variational-autoencoder 作者: musyoku 项目源码 文件源码 阅读 20 收藏 0 点赞 0 评论 0
def sample_x_y(self, x, argmax=False, test=False):
        batchsize = x.data.shape[0]
        y_distribution = self.encoder_x_y(x, test=test, softmax=True).data
        n_labels = y_distribution.shape[1]
        if self.gpu:
            y_distribution = cuda.to_cpu(y_distribution)
        sampled_y = np.zeros((batchsize, n_labels), dtype=np.float32)
        if argmax:
            args = np.argmax(y_distribution, axis=1)
            for b in xrange(batchsize):
                sampled_y[b, args[b]] = 1
        else:
            for b in xrange(batchsize):
                label_id = np.random.choice(np.arange(n_labels), p=y_distribution[b])
                sampled_y[b, label_id] = 1
        sampled_y = Variable(sampled_y)
        if self.gpu:
            sampled_y.to_gpu()
        return sampled_y
net.py 文件源码 项目:MemoryNetwork 作者: aonotas 项目源码 文件源码 阅读 35 收藏 0 点赞 0 评论 0
def encode(self, x_input, x_query, answer):
        m = self.encode_input(x_input)
        u = self.encode_query(x_query)

        # print "m.data.shape", m.data.shape
        # print "u.data.shape", u.data.shape
        mu = functions.matmul(m, u, transb=True)
        # print "mu.data.shape", mu.data.shape
        # print "mu.data",  mu.data
        p = functions.softmax(mu)
        c = self.encode_output(x_input)
        # print "p.data.shape:", p.data.shape
        # print "c.data.shape:", c.data.shape
        # print "functions.swapaxes(c ,2, 1):", functions.swapaxes(c ,2, 1).data.shape
        o = functions.matmul(functions.swapaxes(c ,1, 0), p) # (2, 50, 1)
        o = functions.swapaxes(o ,1, 0) # (2, 50) 
        # print "u.data.shape:", u.data.shape
        # print "o.data.shape:", o.data.shape
        # print "u.data.shape:", u.data
        # print "o.data.shape:", o.data
        # print (u+o).data.shape
        predict = self.W(u + o)
        # print predict.data.shape
        loss = functions.softmax_cross_entropy(predict, answer)
        return loss
use_voxelchain.py 文件源码 项目:voxcelchain 作者: hiroaki-kaneda 项目源码 文件源码 阅读 22 收藏 0 点赞 0 评论 0
def use_model(model):

    data = np.loadtxt('data/human_test_1_32_32_32.txt').reshape(1, 1, 32, 32, 32).astype(np.float32)
    y= model.fwd(data)
    A= F.softmax(y).data
    print(A.argmax(axis=1))
    print(A[0,A.argmax(axis=1)])
vgg.py 文件源码 项目:chainer-visualization 作者: hvy 项目源码 文件源码 阅读 21 收藏 0 点赞 0 评论 0
def __call__(self, x):

        """Return a softmax probability distribution over predicted classes."""

        # Convolutional layers
        hs, _ = self.feature_map_activations(x)
        h = hs[-1]

        # Fully connected layers
        h = F.dropout(F.relu(self.fc6(h)))
        h = F.dropout(F.relu(self.fc7(h)))
        h = self.fc8(h)

        return F.softmax(h)
yolov2.py 文件源码 项目:chainer-object-detection 作者: dsanno 项目源码 文件源码 阅读 26 收藏 0 点赞 0 评论 0
def predict(self, input_x):
        if isinstance(input_x, chainer.Variable):
            device = cuda.get_device(input_x.data)
        else:
            device = cuda.get_device(input_x)
        xp = self.predictor.xp
        with device:
            output = self.predictor(input_x)
            batch_size, input_channel, input_h, input_w = input_x.shape
            batch_size, _, grid_h, grid_w = output.shape
            x, y, w, h, conf, prob = F.split_axis(F.reshape(output, (batch_size, self.predictor.n_boxes, self.predictor.n_classes+5, grid_h, grid_w)), (1, 2, 3, 4, 5), axis=2)
            x = F.sigmoid(x)
            y = F.sigmoid(y)
            conf = F.sigmoid(conf)
            prob = F.transpose(prob, (0, 2, 1, 3, 4))
            prob = F.softmax(prob)
            prob = F.transpose(prob, (0, 2, 1, 3, 4))


            # convert coordinates to those on the image
            x_shift = xp.asarray(np.broadcast_to(np.arange(grid_w, dtype=np.float32), x.shape))
            y_shift = xp.asarray(np.broadcast_to(np.arange(grid_h, dtype=np.float32).reshape(grid_h, 1), y.shape))
            w_anchor = xp.asarray(np.broadcast_to(np.reshape(np.array(self.anchors, dtype=np.float32)[:, 0], (self.predictor.n_boxes, 1, 1, 1)), w.shape))
            h_anchor = xp.asarray(np.broadcast_to(np.reshape(np.array(self.anchors, dtype=np.float32)[:, 1], (self.predictor.n_boxes, 1, 1, 1)), h.shape))
            box_x = (x + x_shift) / grid_w
            box_y = (y + y_shift) / grid_h
            box_w = F.exp(w) * w_anchor / grid_w
            box_h = F.exp(h) * h_anchor / grid_h

            return box_x, box_y, box_w, box_h, conf, prob
yolov2_caltech.py 文件源码 项目:chainer-object-detection 作者: dsanno 项目源码 文件源码 阅读 22 收藏 0 点赞 0 评论 0
def predict(self, input_x):
        if isinstance(input_x, chainer.Variable):
            device = cuda.get_device(input_x.data)
        else:
            device = cuda.get_device(input_x)
        xp = self.predictor.xp
        with device:
            output = self.predictor(input_x)
            batch_size, input_channel, input_h, input_w = input_x.shape
            batch_size, _, grid_h, grid_w = output.shape
            x, y, w, h, conf, prob = F.split_axis(F.reshape(output, (batch_size, self.predictor.n_boxes, self.predictor.n_classes+5, grid_h, grid_w)), (1, 2, 3, 4, 5), axis=2)
            x = F.sigmoid(x)
            y = F.sigmoid(y)
            conf = F.sigmoid(conf)
            prob = F.transpose(prob, (0, 2, 1, 3, 4))
            prob = F.softmax(prob)
            prob = F.transpose(prob, (0, 2, 1, 3, 4))


            # convert coordinates to those on the image
            x_shift = xp.asarray(np.broadcast_to(np.arange(grid_w, dtype=np.float32), x.shape))
            y_shift = xp.asarray(np.broadcast_to(np.arange(grid_h, dtype=np.float32).reshape(grid_h, 1), y.shape))
            w_anchor = xp.asarray(np.broadcast_to(np.reshape(np.array(self.anchors, dtype=np.float32)[:, 0], (self.predictor.n_boxes, 1, 1, 1)), w.shape))
            h_anchor = xp.asarray(np.broadcast_to(np.reshape(np.array(self.anchors, dtype=np.float32)[:, 1], (self.predictor.n_boxes, 1, 1, 1)), h.shape))
            box_x = (x + x_shift) / grid_w
            box_y = (y + y_shift) / grid_h
            box_w = F.exp(w) * w_anchor / grid_w
            box_h = F.exp(h) * h_anchor / grid_h

            return box_x, box_y, box_w, box_h, conf, prob
listwise.py 文件源码 项目:shoelace 作者: rjagerman 项目源码 文件源码 阅读 27 收藏 0 点赞 0 评论 0
def listnet(x, t):
    """
    The Top-1 approximated ListNet loss as in Cao et al (2006), Learning to
    Rank: From Pairwise Approach to Listwise Approach

    :param x: The activation of the previous layer 
    :param t: The target labels
    :return: The loss
    """

    # ListNet top-1 reduces to a softmax and simple cross entropy
    st = F.softmax(t, axis=0)
    sx = F.softmax(x, axis=0)
    return -F.mean(st * F.log(sx))
boltzmann.py 文件源码 项目:chainerrl 作者: chainer 项目源码 文件源码 阅读 21 收藏 0 点赞 0 评论 0
def select_action(self, t, greedy_action_func, action_value=None):
        assert action_value is not None
        assert isinstance(action_value,
                          chainerrl.action_value.DiscreteActionValue)
        n_actions = action_value.q_values.shape[1]
        with chainer.no_backprop_mode():
            probs = chainer.cuda.to_cpu(
                F.softmax(action_value.q_values / self.T).data).ravel()
        return np.random.choice(np.arange(n_actions),  p=probs)
distribution.py 文件源码 项目:chainerrl 作者: chainer 项目源码 文件源码 阅读 25 收藏 0 点赞 0 评论 0
def all_prob(self):
        with chainer.force_backprop_mode():
            if self.min_prob > 0:
                return (F.softmax(self.beta * self.logits)
                        * (1 - self.min_prob * self.n)) + self.min_prob
            else:
                return F.softmax(self.beta * self.logits)
model_common.py 文件源码 项目:LSTMVAE 作者: ashwatthaman 项目源码 文件源码 阅读 25 收藏 0 点赞 0 评论 0
def predict(self,batch,randFlag):
        t = [[bi] for bi in [1] * batch]
        t = self.makeEmbedBatch(t)

        ys_d = self.dec(t, train=False)
        ys_w = [self.h2w(y) for y in ys_d]
        name_arr_arr = []
        if randFlag:
            t = [predictRandom(F.softmax(y_each)) for y_each in ys_w]
        else:
            t = [y_each.data[-1].argmax(0) for y_each in ys_w]
        name_arr_arr.append(t)
        t = [self.embed(xp.array([t_each], dtype=xp.int32)) for t_each in t]
        count_len = 0
        while count_len < 50:
            ys_d = self.dec(t, train=False)
            ys_w = [self.h2w(y) for y in ys_d]
            if randFlag:
                t = [predictRandom(F.softmax(y_each)) for y_each in ys_w]
            else:
                t = [y_each.data[-1].argmax(0) for y_each in ys_w]
            name_arr_arr.append(t)
            t = [self.embed(xp.array([t_each], dtype=xp.int32)) for t_each in t]
            count_len += 1
        tenti = xp.array(name_arr_arr).T
        for name in tenti:
            name = [self.vocab.itos(nint) for nint in name]
            if "</s>" in name:
                print("     Gen:{}".format("".join(name[:name.index("</s>")])))
calc_vector.py 文件源码 项目:LSTMVAE 作者: ashwatthaman 项目源码 文件源码 阅读 20 收藏 0 点赞 0 评论 0
def weighted_cross_entropy(p,t,weight_arr,sec_arr,weigh_flag=True):
    print("p:{}".format(p.data.shape))
    b = np.zeros(p.shape,dtype=np.float32)
    b[np.arange(p.shape[0]), t] = 1
    soft_arr = F.softmax(p)
    log_arr = -F.log(soft_arr)
    xent = b*log_arr

    #
    # print("sec_arr:{}".format(sec_arr))
    # print("xent_shape:{}".format(xent.data.shape))
    xent = F.split_axis(xent,sec_arr,axis=0)
    print([xent_e.data.shape[0] for xent_e in xent])
    x_sum = [F.reshape(F.sum(xent_e)/xent_e.data.shape[0],(1,1)) for xent_e in xent]
    # print("x_sum:{}".format([x_e.data for x_e in x_sum]))
    xent = F.concat(x_sum,axis=0)
    #
    # print("xent1:{}".format(xent.data))
    xent = F.max(xent,axis=1)/p.shape[0]
    # print("xent2:{}".format(xent.data))
    if not weigh_flag:
        return F.sum(xent)
    # print("wei_arr:{}".format(weight_arr))
    # print("wei_arr:{}".format(weight_arr.data.shape))

    print("xent3:{}".format(xent.data.shape))
    wxent= F.matmul(weight_arr,xent,transa=True)
    wxent = F.sum(F.sum(wxent,axis=0),axis=0)
    print("wxent:{}".format(wxent.data))
    return wxent
policy_output.py 文件源码 项目:async-rl 作者: muupan 项目源码 文件源码 阅读 24 收藏 0 点赞 0 评论 0
def probs(self):
        return F.softmax(self.logits)
qrnn.py 文件源码 项目:depccg 作者: masashi-y 项目源码 文件源码 阅读 27 收藏 0 点赞 0 评论 0
def attention_sum(encoding, query):
    alpha = F.softmax(F.batch_matmul(encoding, query, transb=True))
    alpha, encoding = F.broadcast(alpha[:, :, :, None],
                                  encoding[:, :, None, :])
    return F.sum(alpha * encoding, axis=1)
attenders.py 文件源码 项目:lencon 作者: kiyukuta 项目源码 文件源码 阅读 21 收藏 0 点赞 0 评论 0
def _attend(self, p):
        weight = F.batch_matmul(self.source_hiddens, p)
        weight = F.where(self.mask, weight, self.minf)
        attention = F.softmax(weight)
        return attention
attenders.py 文件源码 项目:lencon 作者: kiyukuta 项目源码 文件源码 阅读 23 收藏 0 点赞 0 评论 0
def _attend(self, p):
        p = self.xh(p)
        p = F.expand_dims(p, 1)
        p = F.broadcast_to(p, self.shape2)

        h = F.tanh(self.h + p)
        shape3 = (self.batchsize * self.src_len, self.dim_hid)
        h_reshaped = F.reshape(h, shape3)
        weight_reshaped = self.hw(h_reshaped)
        weight = F.reshape(weight_reshaped, (self.batchsize, self.src_len, 1))
        weight = F.where(self.mask, weight, self.minf)
        attention = F.softmax(weight)
        return attention
nn.py 文件源码 项目:chainer-speech-recognition 作者: musyoku 项目源码 文件源码 阅读 29 收藏 0 点赞 0 评论 0
def __call__(self, x):
        return functions.softmax(x, self.axis)
generate.py 文件源码 项目:chainer-qrnn 作者: musyoku 项目源码 文件源码 阅读 32 收藏 0 点赞 0 评论 0
def main():
    model = load_model(args.model_dir)
    assert model is not None

    vocab, vocab_inv = load_vocab(args.model_dir)
    assert vocab is not None
    assert vocab_inv is not None

    vocab_size = model.vocab_size

    with chainer.using_config("train", False):
        for n in range(args.num_generate):
            word_ids = np.arange(0, vocab_size, dtype=np.int32)
            token = ID_BOS
            x = np.asarray([[token]]).astype(np.int32)
            model.reset_state()
            while token != ID_EOS and x.shape[1] < args.max_sentence_length:
                u = model.forward_one_step(x)
                p = F.softmax(u).data[-1]
                token = np.random.choice(word_ids, size=1, p=p)
                x = np.append(x, np.asarray([token]).astype(np.int32), axis=1)

            sentence = []
            for token in x[0]:
                word = vocab_inv[token]
                sentence.append(word)
            print(" ".join(sentence))
test_softmax.py 文件源码 项目:chainer-deconv 作者: germanRos 项目源码 文件源码 阅读 21 收藏 0 点赞 0 评论 0
def check_forward(self, x_data, use_cudnn=True):
        x = chainer.Variable(x_data)
        y = functions.softmax(x, use_cudnn)
        self.assertEqual(y.data.dtype, self.dtype)

        y_expect = numpy.exp(self.x)
        y_roll = numpy.rollaxis(y_expect, 1, y_expect.ndim)
        for i in numpy.ndindex(y_roll.shape[:-1]):
            y_roll[i] /= y_roll[i].sum()

        gradient_check.assert_allclose(
            y_expect, y.data, **self.check_forward_options)
test_softmax.py 文件源码 项目:chainer-deconv 作者: germanRos 项目源码 文件源码 阅读 20 收藏 0 点赞 0 评论 0
def forward(self):
        x = chainer.Variable(self.x)
        return functions.softmax(x, use_cudnn=self.use_cudnn)
TinynetUnpooling.py 文件源码 项目:chainer-deconv 作者: germanRos 项目源码 文件源码 阅读 21 收藏 0 点赞 0 评论 0
def __call__(self, input_blob, test_mode=False):
        # explicit and very flexible DAG!
        #################################
        data = input_blob[0]
        labels = input_blob[1]

        if(len(input_blob) >= 3):
            weights_classes = input_blob[2]
        else:
            weights_classes = chainer.Variable(cuda.cupy.ones((self.classes, 1), dtype='float32'))

        # ---- CONTRACTION BLOCKS ---- #
        blob_b0  = self.bnorm0(data)
        (blob_b1, indices_b1, size_b1)  = F.max_pooling_2dIndices(self.bnorm1(F.relu(self.conv1(blob_b0)), test=test_mode), (2, 2), stride=(2,2), pad=(0, 0))
        (blob_b2, indices_b2, size_b2)  = F.max_pooling_2dIndices(self.bnorm2(F.relu(self.conv2(blob_b1)), test=test_mode), (2, 2), stride=(2,2), pad=(0, 0))
        (blob_b3, indices_b3, size_b3)  = F.max_pooling_2dIndices(self.bnorm3(F.relu(self.conv3(blob_b2)), test=test_mode), (2, 2), stride=(2,2), pad=(0, 0))
        (blob_b4, indices_b4, size_b4)  = F.max_pooling_2dIndices(self.bnorm4(F.relu(self.conv4(blob_b3)), test=test_mode), (2, 2), stride=(2,2), pad=(0, 0))

        # ---- EXPANSION BLOCKS ---- #
        blob_b5  = self.bnorm5(F.relu(self.conv5(F.unpooling_2d(blob_b4, indices_b4, size_b4))), test=test_mode)
        blob_b6  = self.bnorm6(F.relu(self.conv6(F.unpooling_2d(blob_b5, indices_b3, size_b3))), test=test_mode)
        blob_b7  = self.bnorm7(F.relu(self.conv7(F.unpooling_2d(blob_b6, indices_b2, size_b2))), test=test_mode)
        blob_b8  = self.bnorm8(F.relu(self.conv8(F.unpooling_2d(blob_b7, indices_b1, size_b1))), test=test_mode)

        #ipdb.set_trace()

        # ---- SOFTMAX CLASSIFIER ---- #
        self.blob_class = self.classi(blob_b8)
        self.probs = F.softmax(self.blob_class)

        # ---- CROSS-ENTROPY LOSS ---- #
        #ipdb.set_trace()
            self.loss = F.weighted_cross_entropy(self.probs, labels, weights_classes, normalize=True)
        self.output_point = self.probs

        return self.loss


问题


面经


文章

微信
公众号

扫码关注公众号