小编Shu*_*his的帖子

我在这里浏览tensorflow API文档.在tensorflow文档中,他们使用了一个名为的关键字logits.它是什么？在API文档的很多方法中,它都是这样编写的

tf.nn.softmax(logits, name=None)

如果写的是什么是那些logits只Tensors,为什么保持一个不同的名称,如logits？

另一件事是我有两种方法无法区分.他们是

tf.nn.softmax(logits, name=None)
tf.nn.softmax_cross_entropy_with_logits(logits, labels, name=None)

它们之间有什么区别？这些文档对我来说并不清楚.我知道是什么tf.nn.softmax呢.但不是另一个.一个例子将非常有用.

我在tf.nn.conv2d 这里看一下tensorflow的文档.但我无法理解它的作用或它想要实现的目标.它在文档上说,

#1:将滤镜展平为具有形状的二维矩阵

[filter_height * filter_width * in_channels, output_channels].

那现在做什么？是元素乘法还是纯矩阵乘法？我也无法理解文档中提到的其他两点.我在下面写了:

#2:从输入张量中提取图像块以形成虚拟的形状张量

[batch, out_height, out_width, filter_height * filter_width * in_channels].

#3:对于每个补丁,右对乘滤波器矩阵和图像补丁矢量.

如果有人能给出一个例子,一段代码(非常有用)可能并解释那里发生了什么以及为什么操作是这样的,这将是非常有用的.

我尝试过编写一小部分并打印出操作的形状.不过,我无法理解.

我试过这样的事情:

op = tf.shape(tf.nn.conv2d(tf.random_normal([1,10,10,10]), 
              tf.random_normal([2,10,10,10]), 
              strides=[1, 2, 2, 1], padding='SAME'))

with tf.Session() as sess:
    result = sess.run(op)
    print(result)

我理解卷积神经网络的点点滴滴.我在这里研究过它们.但是,张量流的实现并不是我的预期.所以它提出了这个问题.

编辑:所以,我实现了一个更简单的代码.但我无法弄清楚发生了什么.我的意思是结果是这样的.如果有人能告诉我什么过程产生这个输出,那将是非常有帮助的.

input = tf.Variable(tf.random_normal([1,2,2,1]))
filter = tf.Variable(tf.random_normal([1,1,1,1]))

op = tf.nn.conv2d(input, filter, strides=[1, 1, 1, 1], padding='SAME')
init = tf.initialize_all_variables()
with tf.Session() as sess:
    sess.run(init)

    print("input")
    print(input.eval())
    print("filter")
    print(filter.eval())
    print("result")
    result = sess.run(op) …

我无法理解为什么dropout在tensorflow中这样工作.CS231n的博客说,"dropout is implemented by only keeping a neuron active with some probability p (a hyperparameter), or setting it to zero otherwise."你也可以从图片中看到这个(取自同一网站)

来自tensorflow网站, With probability keep_prob, outputs the input element scaled up by 1 / keep_prob, otherwise outputs 0.

现在,为什么输入元素按比例放大1/keep_prob？为什么不保持输入元素的概率而不是用它来缩放1/keep_prob？

我正在研究CS231n卷积神经网络用于视觉识别的卷积神经网络.在卷积神经网络,神经元被设置在3个维度(height,width,depth).我遇到depth了CNN的问题.我无法想象它是什么.

在链接中他们说The CONV layer's parameters consist of a set of learnable filters. Every filter is small spatially (along width and height), but extends through the full depth of the input volume.

例如,对这张照片感兴趣.对不起,如果图像太糟糕了.

我可以理解我们从图像中取出一小块区域,然后将其与"过滤器"进行比较.那么滤镜会收集小图片吗？他们还说,We will connect each neuron to only a local region of the input volume. The spatial extent of this connectivity is a hyperparameter called the receptive field of the neuron.那么感受野与过滤器具有相同的尺寸吗？这里的深度又是什么？我们用CNN的深度表示什么？

所以,我的问题主要是,如果我拍摄的图像具有维度[32*32*3](假设我有50000个这样的图像,制作数据集[50000*32*32*3] …

我正在从swift 2转换为swift 3.我注意到我无法在swift 3中将布尔值转换为整数值:\.

let p1 = ("a" == "a") //true

print(true)           //"true\n"
print(p1)             //"true\n"

Int(true)             //1

Int(p1)               //error

例如,这些语法在swift 2中运行良好.但在swift 3中,会print(p1)产生错误.

错误是 error: cannot invoke initializer for type 'Int' with an argument list of type '((Bool))'

我明白为什么错误发生了.任何人都可以解释这种安全性的原因以及如何在swift 3中将Bool转换为Int？

最近我开始玩神经网络.我试图AND用Tensorflow 实现一个门.我无法理解何时使用不同的成本和激活功能.这是一个基本的神经网络,只有输入和输出层,没有隐藏层.

首先,我尝试以这种方式实现它.正如您所看到的,这是一个糟糕的实现,但我认为它完成了工作,至少在某种程度上.所以,我只尝试了真正的输出,没有一个真正的输出.对于激活函数,我使用了sigmoid函数,对于成本函数,我使用了平方误差成本函数(我认为它称之为,如果我错了,请纠正我).

我尝试使用ReLU和Softmax作为激活功能(具有相同的成本函数),但它不起作用.我弄清楚他们为什么不工作.我也尝试过使用交叉熵成本函数的sigmoid函数,它也不起作用.

import tensorflow as tf
import numpy

train_X = numpy.asarray([[0,0],[0,1],[1,0],[1,1]])
train_Y = numpy.asarray([[0],[0],[0],[1]])

x = tf.placeholder("float",[None, 2])
y = tf.placeholder("float",[None, 1])

W = tf.Variable(tf.zeros([2, 1]))
b = tf.Variable(tf.zeros([1, 1]))

activation = tf.nn.sigmoid(tf.matmul(x, W)+b)
cost = tf.reduce_sum(tf.square(activation - y))/4
optimizer = tf.train.GradientDescentOptimizer(.1).minimize(cost)

init = tf.initialize_all_variables()

with tf.Session() as sess:
    sess.run(init)
    for i in range(5000):
        train_data = sess.run(optimizer, feed_dict={x: train_X, y: train_Y})

    result = sess.run(activation, feed_dict={x:train_X})
    print(result)

5000次迭代后:

[[ 0.0031316 ]
[ 0.12012422]
[ 0.12012422]
[ 0.85576665]] …

我在Pytorch中使用Sequence to Sequence模型.序列到序列模型包括编码器和解码器.

编码器转换a (batch_size X input_features X num_of_one_hot_encoded_classes) -> (batch_size X input_features X hidden_size)

解码器将采用此输入序列并将其转换为 (batch_size X output_features X num_of_one_hot_encoded_classes)

一个例子是 -

所以在上面的例子中,我需要将22个输入功能转换为10个输出功能.在Keras中,可以使用RepeatVector(10)完成.

一个例子 -

model.add(LSTM(256, input_shape=(22, 98)))
model.add(RepeatVector(10))
model.add(Dropout(0.3))
model.add(LSTM(256, return_sequences=True))

虽然,我不确定它是否是将输入序列转换为输出序列的正确方法.

所以,我的问题是 -

• 将输入序列转换为输出序列的标准方法是什么.例如.转换自(batch_size,22,98) - >(batch_size,10,98)？或者我应该如何准备解码器？

编码器代码片段(用Pytorch编写) -

class EncoderRNN(nn.Module):
    def __init__(self, input_size, hidden_size):
        super(EncoderRNN, self).__init__()
        self.hidden_size = hidden_size
        self.lstm = nn.LSTM(input_size=input_size, hidden_size=hidden_size,
          num_layers=1, batch_first=True)

    def forward(self, input):
        output, hidden = self.lstm(input)
        return output, hidden

几天前我遇到了一个谜题.它可以轻松地手动解决.但我试图建立一个解决它的算法.但我不知道该怎么办.

在这里你可以看到我必须连接所有的彩色圆点.例如,我需要将黄点连接到另一个黄点,绿色连接到其他绿色,蓝色连接到蓝色等等.

这是一个如何解决它的例子.如果描述不清楚.

所以你可以看到我将黄点与另一个黄点相连.蓝色与另一个蓝色.但这会导致问题.你可以看到我已经阻挡了浅绿色的路径.我希望你明白这个主意.

所以我想解决它.蛮力方法可行,但需要很长时间,我对此不感兴趣.我尝试了实现广度优先搜索,深度优先搜索和Dijkstra算法.但我认为在这种情况下他们不会好.如果我错了,请纠正我.A*搜索可能有效,但启发式是什么？

谁能给我一些关于如何解决问题的直觉？

我认为这个问题可能有点令人困惑.所以,我会先尝试解释一下.

假设给出了两个数的XOR和SUM.(请注意,有多对可能满足此要求.)

例如,如果XOR是5其和9有4满足SUM和XOR对.它们是(2,?7),(3,?6),(6,?3),(7,?2).所以2+7=9和2^7=5.

我只想找到满足SUM和XOR的对的数量.所以在我提到的例子中,答案4就足够了.我不需要知道哪些对满足它们.

我从这里解决了这个问题.

我在这里查了一个答案.它提供的O(n)解决方案还不够.

有一个编辑提供了解决这个问题的方法.它可以在这里找到.(寻找627A的解决方案)

问题是我无法理解解决方案.根据我的总结,他们使用了这样的公式,
(如果有两个数字a和b)那么, a+b = (a XOR b) + (a AND b)*2

我怎么到达那个？其余的步骤对我来说不清楚.

如果有人能提出如何解决这个问题或解释他们的解决方案,请帮助.

我试图顺序执行相同的Asynctask.例如,让我们有一个的AsyncTask 一个.现在假设A检查某个服务器是否忙碌.如果它很忙,它会再次检查....依此类推.假设它检查了5次,然后让用户知道该服务不可用.
因此显然可以使用相同的Asynctask.
尝试使用循环实现它可能会产生意想不到的结果,因为根据此 链接,
Asynctask是一个即发即弃的实例,而AsyncTask实例只能使用一次..
所以循环5次意味着Asynctask将被调用5次.但是如果服务器在第二次尝试时是免费的,我不需要额外的检查.Android应用程序也可能挂起(我的确).如果我在这个话题上错了,请纠正我.

另外,回答是," calling task like new MyAsyncTask().execute("");"
所以,如果我不喜欢这样-例如,

new someAsyncTask() {
            @Override
            protected void onPostExecute(String msg) {
                new someAsyncTask() {
                    @Override
                    protected void onPostExecute(String msg) {
                      ....and so on 5 times.
                   }
               }.execute(this);
            }
        }.execute(this);

它应该按顺序调用5次,不会出现任何问题.
它是唯一的方法吗？还是存在任何其他解决方案？