小编yal*_*lis的帖子

我已经习惯了python/java中的OO.现在做Clojure.我遇到了defrecord,但似乎我必须为我希望记录实现的每个函数或函数集定义一个协议.创建新协议会产生摩擦.我不仅要说出我想要的功能,还要说出协议.我正在寻找的是一种"很好地"将函数与记录相关联的方法,以便函数可以通过this参数访问记录的参数,而无需定义新协议或向现有协议添加函数.

减少和减少可以让您在序列中累积状态.序列中的每个元素将修改累积状态,直到达到序列结束.

在无限列表中调用reduce或reduce的含义是什么？

(def c (cycle [0]))
(reduce + c)

这将很快抛出OutOfMemoryError.顺便说一句,(reduce + (cycle [0]))不会抛出OutOfMemoryError(至少不是我等待的时间).它永远不会回来.不知道为什么.

有没有办法以一种有意义的方式调用无限列表中的减少或减少？我在上面的例子中看到的问题是,最终列表的评估部分变得足够大以溢出堆.也许无限列表不是正确的范例.减少生成器,IO流或事件流会更有意义.在评估并用于修改状态后,不应保留该值.

假设你有一些像这样的代码

import tensorflow as tf
...
f = h*y + z*t  #Just some expression involving other tensors.
e = ... # some expression that does not involve f. 
result = tf.select(b, e, f)

sess.run(result)

b是与e和f相同形状的布尔张量.如果b的所有元素都评估为真,那么我们不需要f,结果将只是(或等于)e.

问题:当会话以结果运行,并且e的元素都是真的时,是否会被评估？

我想重复将某些函数应用于某个状态,直到条件成立为止.

函数f采用状态,修改它并返回它.再次将f应用于返回状态,依此类推.

我认为这会奏效.

(first (filter pred (iterate f x)))

但它有点难看.加上内存消耗并不理想,因为迭代器将被强制评估并保持中间状态,直到返回pred保持为true的状态为止,此时中间状态应该被垃圾收集.

我知道你可以编写一个简单的递归函数:

(loop [f x p] (if (p x) x (recur f (f x) p))

但我正在寻找一个核心库函数(或某些函数组合),它们以相同的内存效率执行相同的操作.

该模型将 LSTM 作为其第一层。

在调用 model.predict 时说你传入了几个样本：

>sam = np.array([ [[.5, .6, .3]], [[.6, .6, .3]], [[.5, .6, .3]] ])
>model.predict(sam)
array([[ 0.23589483],
       [ 0.2327884 ],
       [ 0.23589483]])

上面我们看到了映射：[[.5, .6, .3]] -> 0.23589483 等等（1 个元素的序列，它是一个长度为 3 的向量，映射到一个实数）

该模型的 input_length 为 1，input_dim 为 3。请注意，第一个和最后一个相同并且具有相同的输出 (0.23589483)。所以我的假设是，在 Keras 处理一个样本（在这种情况下是 1 个 3-D 向量的序列）之后，它会重置模型的内存。即每个序列基本上是独立的。这种观点是否有任何不正确或误导之处？

再举一个 input_length 3 和 input_dim 1 的例子。这一次，在一个序列中切换值并看到不同的结果（比较第二个列表和最后一个）。因此，随着 Keras 处理一个序列，内存正在发生变化，但是当完成处理时，内存会重置（第一个和第二个序列具有相同的结果）。

sam = np.array([ [[.1],[.1],[.9]], [[.1],[.9],[.1]], [[.1],[.1],[.9]]   ])
model.predict(sam)
array([[ 0.69906837],
   [ 0.1454899 ],
   [ 0.69906837]])

上面我们看到映射 [[.1],[.1],[.9]] -> 0.69906837 等等（3 个元素到实数的序列）

我想成对地将函数列表应用于值列表.

这是一个例子来说明.

user=> (defn a [f x] (f x))
#'user/a
user=> (map a [inc dec] '(98 8))
(99 7)

注意我必须定义一个函数a,它接受一个函数并将它应用于一个值.基本上抽象功能应用程序.

有更自然的方法吗？我真的只想使用map来定义辅助函数.

我一直在和Clojure一起玩,我设法打破了筹码.在这段代码中,我只使用recur进行递归.我正在进行大量的连接(请注意下面的跟踪调用concat).我试图在所有连接列表上执行操作,因为这些是懒惰的,我希望它们在我进行时进行评估.我仍然得到堆栈溢出.这是跟踪.我认为这可能是一个普遍的问题,而且有更多经验黑客攻击的人可以指出我正确的方向.

这是造成问题的代码段.

(defn move-split [[xs ys]] (doall (concat (list (concat xs (list (first ys))))  (list (next ys)))))

由于stackoverflow,我把doall放在那里,但仍然没有解决问题.

(defn move-split [[xs ys]] (doall (concat (list (doall (concat xs (list (first ys))))  ) (doall (list (next ys)))   )))

注意额外的doalls？在这里,我称之为concat,我通过doall过滤结果.Stackoverflow消失了.

doall似乎不是递归的.这是嵌套列表,也是concat的结果,不会被评估.你怎么看？

Exception in thread "main" java.lang.reflect.InvocationTargetException
    at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
    at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:39)
    at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:25)
    at java.lang.reflect.Method.invoke(Method.java:597)
    at jline.ConsoleRunner.main(Unknown Source)
Caused by: java.lang.StackOverflowError (bubble_sort2.clj:0)
    at clojure.lang.Compiler.eval(Compiler.java:5440)
    at clojure.lang.Compiler.load(Compiler.java:5857)
    at clojure.lang.Compiler.loadFile(Compiler.java:5820)
    at clojure.main$load_script.invoke(main.clj:221)
    at clojure.main$script_opt.invoke(main.clj:273)
    at clojure.main$main.doInvoke(main.clj:354)
    at clojure.lang.RestFn.invoke(RestFn.java:409)
    at clojure.lang.Var.invoke(Var.java:365)
    at clojure.lang.AFn.applyToHelper(AFn.java:163)
    at clojure.lang.Var.applyTo(Var.java:482) …

例如,尝试理解这些结果:

>>> x
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
>>> (x == np.array([[1],[2]])).astype(np.float32)
array([[ 0.,  1.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.],
       [ 0.,  0.,  1.,  0.,  0.,  0.,  0.,  0.,  0.,  0.]], dtype=float32)
>>> (x == np.array([1,2]))
   False
>>> (x == np.array([[1]])).astype(np.float32)
array([[ 0.,  1.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.]], dtype=float32)
>>> (x == np.array([1])).astype(np.float32)
array([ 0.,  1.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.], dtype=float32)

>>> (x == …

举个例子:

from("seda:data").log("data added to queue")
                  .setHeader("CamelHttpMethod", constant("POST"))
                  .setHeader(Exchange.CONTENT_TYPE, constant("application/json"))
                  .process(new Processor() {
                      public void process(Exchange exchange) throws Exception {
                              exchange.setProperty(Exchange.CHARSET_NAME, "UTF-8");
                      }
                   })
                  .recipientList(header(RECIPIENT_LIST))
                  .ignoreInvalidEndpoints().parallelProcessing();

假设RECIPENT_LIST头只包含一个http端点.对于给定的http端点,应按顺序处理消息,但可以并行处理不同端点的两条消息.

基本上,我想知道是否有任何措施可以改善性能.例如,使用concurrentConsumers会有帮助吗？

所有的期货最终可能会成功（有些可能会失败），但我们希望第一个成功。并希望将这一结果表示为未来。如果列表中的所有期货都失败，则此期货将失败。

Clojure 1.2.0
user=> (def x (repeat 10 1))
#'user/x
user=> (counted? x)
false
user=> (def x (list 1 2 3))
#'user/x
user=> (counted? x)
true
user=> 

我有一个看起来像这样的单元格:

from IPython.display import Image
i = Image(filename='test.png')
i
print("test")

输出只是:

test

我没有在输出中看到图像.我检查了文件是否存在(无论如何,如果它不存在,你会收到错误).

有线索吗？

如果我做了,

var i = '{"xyz":"??"}'

 $.ajax({ url: '/someendpoint',type: 'post', dataType: 'json', success: null,error: null,data: i });

根据萤火虫的帖子是:

{"xyz":"jQuery164042601801476224854_1371690944590"}

如果只有一个问号,帖子就是

{"xyz":"?"}

正如所料.

这可能与邮政体内的逃避有关,但需要细节.

看起来像一个jquery bug:http://bugs.jquery.com/ticket/8417