小编jst*_*er7的帖子

我有一个相当复杂的Tensorflow图,我想为优化目的进行可视化.是否有一个我可以调用的函数,只需保存图形以便在Tensorboard中查看而无需注释变量？

我试过这个:

merged = tf.merge_all_summaries()
writer = tf.train.SummaryWriter("/Users/Name/Desktop/tf_logs", session.graph_def)

但没有产生任何产出.这是使用0.6轮.

这似乎是相关的: 在seq2seq模型的张量板中没有显示图形可视化

我想使用[int,-1]表示法重新形成张量(例如,展平图像).但我不提前知道第一个维度.一个用例是大批量训练,然后在较小批次上进行评估.

为什么会出现以下错误:got list containing Tensors of type '_Message'？

import tensorflow as tf
import numpy as np

x = tf.placeholder(tf.float32, shape=[None, 28, 28])
batch_size = tf.placeholder(tf.int32)

def reshape(_batch_size):
    return tf.reshape(x, [_batch_size, -1])

reshaped = reshape(batch_size)


with tf.Session() as sess:
    sess.run([reshaped], feed_dict={x: np.random.rand(100, 28, 28), batch_size: 100})

    # Evaluate
    sess.run([reshaped], feed_dict={x: np.random.rand(8, 28, 28), batch_size: 8})

注意:当我在函数外部重塑它似乎工作,但我有很多次使用的非常大的模型,所以我需要将它们保存在一个函数中并使用参数传递dim.

在以下情况下如何处理设备范围，其中外部设备范围被内部设备范围覆盖：

with tf.device("/cpu:0"):
    a = function1()

    with tf.device("/gpu:0"):
        b = function2()

    with tf.device("/gpu:1"):
        c = function3()

    d = a+b+c

我的直觉如下：

1) "a" 首先在 "cpu:0" 上计算

2) "b" 和 "c" 分别在 "gpu:0" 和 "gpu:1" 上并行计算。

3) "d" 等待 "b" 和 "c"，因为它取决于它们，当它们的值可用时，"d" 在 "cpu:0" 上计算

我的直觉正确吗？

在下面的代码中,l2令人惊讶地返回与l1相同的值,但由于在l2之前在列表中请求了优化器,我预计损失将是训练后的新损失.我可以不从图表中同时请求多个值并期望输出一致吗？

import tensorflow as tf
import numpy as np

x = tf.placeholder(tf.float32, shape=[None, 10])
y = tf.placeholder(tf.float32, shape=[None, 2])

weight = tf.Variable(tf.random_uniform((10, 2), dtype=tf.float32))

loss = tf.nn.sigmoid_cross_entropy_with_logits(tf.matmul(x, weight), y)

optimizer = tf.train.AdamOptimizer(0.1).minimize(loss)

with tf.Session() as sess:
    tf.initialize_all_variables().run()

    X = np.random.rand(1, 10)
    Y = np.array([[0, 1]])

    # Evaluate loss before running training step
    l1 = sess.run([loss], feed_dict={x: X, y: Y})[0][0][0]
    print(l1) # 3.32393

    # Running the training step
    _, l2 = sess.run([optimizer, loss], feed_dict={x: X, y: Y})
    print(l2[0][0]) # 3.32393 -- …

我用以下代码保存了许多numpy对象:

f = gzip.GzipFile('/some/path/file.npy.gz', "w")
np.save(file=f, arr=np.rint(trimmed).astype('int16'))
f.close()

现在我有一堆npy.gz文件,但我无法弄清楚如何以编程方式将它们返回到python中.np.fromtext或者np.fromstring似乎不起作用,并且无论如何都不会保留形状信息.

我试过了:

gzipfile = gzip.GzipFile('/some/path/file.npy.gz', 'rb')
text = gzipfile.read() 

而且text看起来是这样的:

b'\x93NUMPY\x01\x00F\x00{\'descr\': \'<i2\', \'fortran_order\': False, \'shape\': (132, 248, 291), } \n0\xf80\xf80...'

但是我接下来要做什么才能将该字符串重新变成一个numpy对象？

我正在学习OpenCV,目前我正在尝试理解存储在a中的基础数据,KeyPoint以便我可以更好地利用我正在处理的应用程序的数据.

到目前为止,我一直在浏览这两页:

http://docs.opencv.org/modules/features2d/doc/common_interfaces_of_feature_detectors.html?highlight=featuredetector#FeatureDetector

http://docs.opencv.org/doc/tutorials/features2d/feature_detection/feature_detection.html

然而,当我按照教程使用时drawKeypoints(),这些点的大小和形状都相同,并且使用看似随意的颜色绘制.

我想我可以遍历每个关键点的属性:绘制一个圆圈,绘制一个箭头(为角度),根据响应给它一个颜色,等等.但我认为必须有一个更好的方法.

是否有内置方法或类似的其他方法drawKeypoints()将帮助我更有效地可视化KeyPoints图像？

给定状态向量,我们可以通过连续生成每个输出以贪婪的方式递归地解码序列,其中每个预测以先前的输出为条件.我最近读了一篇论文,描述了在解码过程中使用光束搜索,光束大小为1(k = 1).如果我们只是在每一步保留最佳输出,这不是贪婪解码的同一个东西,并没有提供光束搜索通常提供的任何好处吗？

我遵循这两篇文章的建议,因为我也在尝试创建一个通用的scrapy蜘蛛:

如何在scrapy spider中传递用户定义的参数

创建一个通用的scrapy蜘蛛

但我得到一个错误,我应该作为参数传递的变量没有定义.我在init方法中遗漏了什么吗？

码:

from scrapy.spider import BaseSpider
from scrapy.selector import HtmlXPathSelector

from data.items import DataItem

class companySpider(BaseSpider):
    name = "woz"

    def __init__(self, domains=""):
        '''
        domains is a string
        '''
        self.domains = domains

    deny_domains = [""]
    start_urls = [domains]

    def parse(self, response):
        hxs = HtmlXPathSelector(response)
        sites = hxs.select('/html')
        items = []
        for site in sites:
            item = DataItem()
            item['text'] = site.select('text()').extract()
            items.append(item)
        return items

这是我的命令行:

scrapy crawl woz -a domains="http://www.dmoz.org/Computers/Programming/Languages/Python/Books/"

这是错误:

NameError: name 'domains' is not …

我有一个复杂的网络设计版本:

import tensorflow as tf

a = tf.ones([1000])
b = tf.ones([1000])

for i in range(int(1e6)):
    a = a * b

我的直觉是,这应该需要很少的记忆.只是初始数组分配的空间和一串利用节点的命令,并在每一步都覆盖存储在张量'a'中的内存.但是内存使用量增长很快.

这里发生了什么,当我计算张量并多次覆盖它时,如何减少内存使用？

编辑:

感谢Yaroslav的建议,解决方案结果是使用了一个while_loop来最小化图上的节点数量.这种方法效果很好,速度更快,需要更少的内存,并且全部包含在图形中.

import tensorflow as tf

a = tf.ones([1000])
b = tf.ones([1000])

cond = lambda _i, _1, _2: tf.less(_i, int(1e6))
body = lambda _i, _a, _b: [tf.add(_i, 1), _a * _b, _b]

i = tf.constant(0)
output = tf.while_loop(cond, body, [i, a, b])

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

在Tensorflow CIFAR教程中,它讨论了使用多个GPU并提供此警告:

"天真地使用模型参数的异步更新会导致次优的训练性能,因为单个模型副本可能会在模型参数的陈旧副本上进行训练.相反,使用完全同步更新将与最慢的模型副本一样慢."

这是什么意思？有人可以提供一个非常简单的例子来说明这个警告吗？

我正在考虑购买一个带有双用途机器的想象力.我想将它用作家用电脑,但也使用OSX Server托管一两个人的网站.

通过将我的计算机用作服务器,有没有办法通过我的网站进行恶意攻击可以让某人访问本地存储在我的硬盘上的文件？简单地使用专用机器或服务更安全吗？

注意:我希望有关网站安全性的问题是合适的,对不起,这不是明确的编码问题.