小编Der*_*erk的帖子

我转换了以下功能

def quaternion_multiply(quaternion0, quaternion1):
    """Return multiplication of two quaternions.

    >>> q = quaternion_multiply([1, -2, 3, 4], [-5, 6, 7, 8])
    >>> numpy.allclose(q, [-44, -14, 48, 28])
    True

    """
    x0, y0, z0, w0 = quaternion0
    x1, y1, z1, w1 = quaternion1
    return numpy.array((
         x1*w0 + y1*z0 - z1*y0 + w1*x0,
        -x1*z0 + y1*w0 + z1*x0 + w1*y0,
         x1*y0 - y1*x0 + z1*w0 + w1*z0,
        -x1*x0 - y1*y0 - z1*z0 + w1*w0), dtype=numpy.float64)

批量版本

def quat_multiply(self, quaternion0, quaternion1):
    x0, y0, z0, w0 …

我启动了一个 docker 容器来运行 Kafka 服务器

docker run -p 2181:2181 -p 9092:9092 --env ADVERTISED_HOST=192.168.99.100 --env ADVERTISED_PORT=9092 spotify/kafka

我找到了 Docker 容器的 IP 地址。这是 172.17.0.2，我可以 ping 这个地址。

现在我想要一个发送消息的生产者：

from kafka import KafkaProducer

producer = KafkaProducer(bootstrap_servers='172.17.0.2:9092')

for i in range(100):
    producer.send('foobar', b'hola')

producer.close()

然而，这给出了：kafka.errors.KafkaTimeoutError: KafkaTimeoutError: Failed to update metadata after 60.0 secs.

如何解决这个问题？

我的神经网络的输出充当协方差矩阵的入口。但是，输出和条目之间的一对一对应关系不会导致正定协方差矩阵。

因此，我阅读了https://www.quora.com/When-carrying-out-the-EM-algorithm-how-do-I-ensure-that-the-covariance-matrix-is-positive-definite-at-始终避免回合问题和https://en.wikipedia.org/wiki/Cholesky_decomposition，更具体地说，“当A具有真实条目时，L也具有真实条目，并且因式分解可以写成A = LL^T”。

现在，我的输出对应于L矩阵的项，然后我将其乘以转置来生成协方差矩阵。

但是，有时我仍然会遇到非正定矩阵的错误。这怎么可能？

我发现了一个会产生错误的矩阵，请参见

print L.shape
print Sigma.shape

S = Sigma[1,18,:,:] # The matrix that gives the error
L_ = L[1,18,:,:]
print L_
S = np.dot(L_,np.transpose(L_))
print S
chol = np.linalg.cholesky(S)

给出作为输出：

(3, 20, 2, 2)
(3, 20, 2, 2)
[[ -1.69684255e+00   0.00000000e+00]
 [ -1.50235415e+00   1.73807144e-04]]
[[ 2.87927461  2.54925847]
 [ 2.54925847  2.25706792]]
.....
LinAlgError: Matrix is not positive definite

但是，此代码可复制值，但效果很好（但可能不会完全相同的值，因为并非所有小数点都被打印出来）

B = np.array([[-1.69684255e+00, 0.00000000e+00], [-1.50235415e+00, 1.73807144e-04]])
A = np.dot(B,B.T)
chol_A = …

我有以下设置，其中每个输入包含两个轨迹。我希望左图与右图具有相同的权重

我尝试遵循此处描述的共享变量的方法https://www.tensorflow.org/versions/r1.0/how_tos/variable_scope/，但是它不起作用。将创建两个不同的图。我究竟做错了什么？

def build_t_model(trajectories):
    """
    Function to build a subgraph
    """
    with tf.name_scope('h1_t'):
        weights = tf.Variable(tf.truncated_normal([150, h1_t_units], stddev=1.0/math.sqrt(float(150))), name='weights')
        biases = tf.Variable(tf.zeros([h1_t_units]), name='biases')
        h1_t = tf.nn.relu(tf.matmul(trajectories, weights) + biases)

    with tf.name_scope('h2_t'):
        weights = tf.Variable(tf.truncated_normal([h1_t_units, h2_t_units], stddev=1.0/math.sqrt(float(h1_t_units))), name='weights')
        biases = tf.Variable(tf.zeros([h2_t_units]), name='biases')
        h2_t = tf.nn.relu(tf.matmul(h1_t, weights) + biases)

    with tf.name_scope('h3_t'):
        weights = tf.Variable(tf.truncated_normal([h2_t_units, M], stddev=1.0/math.sqrt(float(h2_t_units))), name='weights')
        biases = tf.Variable(tf.zeros([M]), name='biases')
        h3_t = tf.nn.relu(tf.matmul(h2_t, weights) + biases)

    return h3_t


# We build two trajectory networks. The weights should be shared …

查看屏幕截图。没有批量标准化的是蓝线。上图中的精度，下图中的损耗。因此，在没有BN的情况下，损耗会缓慢降低，而精度则会缓慢提高，这是预期的行为。

但是，然后我尝试批量标准化。训练损失很快收敛到接近零的值。比没有情况下要好得多，但是在训练和测试集上的测试准确性都会给出较差的结果。

我基于此实现：http : //ruishu.io/2016/12/27/batchnorm/ 因此，将批处理规范添加到这样的层：

h1_p_bn = tf.contrib.layers.batch_norm(h1_p, center=True, scale=True, is_training=self.is_training,scope='bn1')

使用model.is_training一个占位符，该占位符在测试准确性（上部图）时设置为零。

我也这样做：

# Requirement from tf.contrib.layers.batch_norm
update_ops = tf.get_collection(tf.GraphKeys.UPDATE_OPS)
with tf.control_dependencies(update_ops):
    # Ensures that we execute the update_ops before performing the train_step
    optimizer = tf.train.AdamOptimizer(learning_rate)
    self.train_op = optimizer.minimize(self.loss, global_step=global_step)

有什么想法或建议吗？

如https://arxiv.org/pdf/1703.07737.pdf中所建议的那样，我尝试重构我的Keras代码以对三胞胎使用“批处理硬”采样。

“核心思想是通过对P个类别（人的身份）进行随机抽样，然后对每个类别（人）的K个图像进行随机抽样，从而形成一批PK图像。现在，对于批次中的每个样本a，我们在形成三元组以计算损失时，可以在批次中选择最硬的正样本和最硬的负样本，我们将其称为“硬批次”

因此，目前我有一个Python生成器（与Keras中的model.fit_generator配合使用），可以在CPU上生成批处理。然后，可以在GPU上完成通过模型的实际前向和后向传递。

但是，如何使这种方法适合“硬分批”方法？生成器对64个图像进行采样，为此应形成64个三元组。首先，需要向前通过以获取当前模型的64个嵌入。

    embedding_model = Model(inputs = input_image, outputs = embedding)

但是随后必须从64个嵌入中选择最难的正数和最难的负数以形成三元组。然后可以计算出损失

    anchor = Input(input_shape, name='anchor')
    positive = Input(input_shape, name='positive')
    negative = Input(input_shape, name='negative')

    f_anchor = embedding_model(anchor)
    f_pos = embedding_model(pos)
    f_neg = embedding_model(neg)

    triplet_model = Model(inputs = [anchor, positive, negative], outputs=[f_anchor, f_pos, f_neg])

并且可以通过定义三元组损失函数来训练此Triplet_model。但是，Keras是否可以使用fit_generator和'Batch Hard'方法？还是如何从批处理中的其他样本获取对嵌入的访问？

编辑：使用keras.layers.Lambda，我可以定义一个自己的层，以输入（batch_size，height，width，3）和输出（batch_size，3，height，width，3）创建三元组，但是我还需要访问id的某个位置。这在图层内可能吗？

在生产环境中，我有来自N个生产者的数据必须经过网络。我在并行化tf.data.Dataset.from_generator时发现了此注释，它实际上描述了我想要的内容。

def generator(n):
  # returns n-th generator function

def dataset(n):
  return tf.data.Dataset.from_generator(generator(n))

ds = tf.data.Dataset.range(N).apply(tf.contrib.data.parallel_interleave(dataset, cycle_lenght=N))

# where N is the number of generators you use

但是generator（n）函数应该是什么样子。因为当我用

 def generator(n):
        """Returns the n-th generator function (for consumer n)
        """
        consumer = self.consumers[n]

        def gen():
            for item in consumer:
                yield item

        return gen

与self.consumers一个Python列表，然后我会得到错误：

TypeError：列表索引必须是整数或切片，而不是Tensor

我尝试建立fblualib。但是，在运行build.sh时，出现以下错误：

-- Found Folly: /usr/local/include  
-- Found Torch7 in /home/dmus/torch/install
-- Found Folly: /usr/local/include  
-- Configuring done
-- Generating done
-- Build files have been written to: /home/dmus/fblualib/fblualib/build
[ 25%] Building CXX object CMakeFiles/fblualib.dir/LuaUtils.cpp.o
c++: error: unrecognized command line option ‘-std=gnu++14’
make[2]: *** [CMakeFiles/fblualib.dir/LuaUtils.cpp.o] Error 1
make[1]: *** [CMakeFiles/fblualib.dir/all] Error 2
make: *** [all] Error 2

g ++ --version输出g ++（Ubuntu 4.8.4-2ubuntu1〜14.04.1）4.8.4。我看到了相关的问题，但是我看不到如何解决此问题。

我的输入管道中出现以下错误:

tensorflow.python.framework.errors_impl.InvalidArgumentError:无法在组件0中批量生成具有不同形状的张量.第一个元素具有形状[2,48,48,3],元素1具有形状[27,48,48,3].

用这个代码

dataset = tf.data.Dataset.from_generator(generator,
                                         (tf.float32, tf.int64, tf.int64, tf.float32, tf.int64, tf.float32))

dataset = dataset.batch(max_buffer_size)

这是完全合乎逻辑的,因为批处理方法尝试创建(batch_size,？,48,48,3)Tensor.但是我希望它为这种情况创建一个[29,48,48,3] Tensor.所以连接而不是堆栈.这可能与tf.data有关吗？

我可以在生成器函数中用Python进行连接,但我想知道这是否也可以使用tf.data管道

我有一个我制作的模型Keras（用作Tensorflow后端）。现在我想使用Keras里面的Tensorflowrelease。

但是，替换这条线

from keras.engine.topology import get_source_inputs

用这条线

from tensorflow.keras.engine.topology import get_source_inputs

不起作用。它说

ImportError: No module named 'tensorflow.keras.engine'

我在哪里可以找到该get_source_inputs函数Tensorflow？

我正在尝试在配备NVIDIA Geforce 9600 GT的计算机上安装CUDA 7.0.我认为这是一个受支持的GPU,但是我收到了消息:

此图形驱动程序找不到兼容的图形硬件.您可以继续安装,但无法运行CUDA应用程序.

我的显卡是不受支持还是我还能做什么？