小编W.P*_*ill的帖子

我正在使用Stack从命令行设置,构建和运行我的Haskell项目.我想使用IntelliJ作为我的IDE,但是遇到了将Stack配置为我的构建工具的问题.

我使用Stack按照"堆栈用户指南"中的说明在命令行上创建并运行"Hello,World"Haskell程序.一切都很好.

我在IntelliJ上安装了HaskForce插件.构建,执行,部署 - >编译器 - > Haskell编译器选项卡为您提供了使用Stack构建和使用Cabal构建之间的选择.我选择使用堆栈构建并像这样配置它.

我可以使用Haskell Stack Run配置运行项目.控制台输出是正确的.

/Users/williammcneill/Library/Haskell/bin/stack exec hellohaskell-exe --
Hello, Haskell.

但是,我无法弄清楚如何通过IDE重建项目.例如,如果我更改输出文本并重新运行程序,我仍然会看到原始的"Hello,Haskell"输出.构建 - >制作项目| 制作模块| 重建项目都无所事事.

项目设置 - >工件选项卡没有列出任何内容,我没有看到在这里添加Haskell可执行文件的方法.

我的解决方法是从命令行构建我的Haskell程序,即使我正在从IDE进行编辑.

(这也看起来很奇怪,我指定给特定项目的路径stack.yaml在一般Haskell编译设置文件,但这是我能看到如何使用堆栈来构建的唯一方式.)

如何设置IntelliJ以使用Stack构建Haskell项目？

ghc 7.10.3,堆栈1.1.2,HaskForce 0.3-beta.33,IntelliJ IDEA Ultimate 2016.1.3,OS X 10.11.5

这是Haskforce 问题282.

我的TensorFlow模型用于tf.random_uniform初始化变量.我想在开始训练时指定范围,因此我为初始化值创建了一个占位符.

init = tf.placeholder(tf.float32, name="init")
v = tf.Variable(tf.random_uniform((100, 300), -init, init), dtype=tf.float32)
initialize = tf.initialize_all_variables()

我在训练开始时初始化变量就像这样.

session.run(initialize, feed_dict={init: 0.5})

这给了我以下错误:

ValueError: initial_value must have a shape specified: Tensor("Embedding/random_uniform:0", dtype=float32)

我无法找出shape要传递给的正确参数tf.placeholder.我想我应该做一个标量,init = tf.placeholder(tf.float32, shape=0, name="init")但这会产生以下错误:

ValueError: Incompatible shapes for broadcasting: (100, 300) and (0,)

如果我更换init与文字值0.5在调用tf.random_uniform它的工作原理.

如何通过提要字典传递此标量初始值？

斯坦福自然语言处理工具包的核心组件在stanford-corenlp-1.3.4.jar文件中包含Java代码,并且在单独的stanford-corenlp-1.3.4-models.jar文件中具有(非常大的)模型文件.Maven不会自动下载模型文件,但仅限<classifier>models</classifier>于向.pom 添加行.这是一个.pom片段,可以获取代码和模型.

    <dependency>
        <groupId>edu.stanford.nlp</groupId>
        <artifactId>stanford-corenlp</artifactId>
        <version>1.3.4</version>
        <classifier>models</classifier>
    </dependency>

我试图弄清楚如何从命令行做同样的事情.看起来Maven dependency:get插件任务就是这样做的方法.以下命令行似乎是正确的

mvn dependency:get \
    -DgroupId=edu.stanford.nlp \
    -DartifactId=stanford-corenlp \
    -Dversion=LATEST \
    -Dclassifier=models \
    -DrepoUrl=repo1.maven.org

但是,它只下载代码Jar文件而不是模型Jar文件.

知道为什么会这样吗？我不确定这只是斯坦福NLP包的一个问题,还是一个更普遍的classifier选择问题dependency:get.

我想使用不可变的索引多维数组.这是有道理的结构是Vector的Vector秒.

scala> val v = Vector[Vector[Int]](Vector[Int](1,2,3), Vector[Int](4,5,6), Vector[Int](7,8,9))
v: scala.collection.immutable.Vector[Vector[Int]] = Vector(Vector(1, 2, 3), Vector(4, 5, 6), Vector(7, 8, 9))

只需指定尺寸就可以创建一个空数组,这是很好的Array.ofDim.

scala> a = Array.ofDim[Int](3,3)
a: Array[Array[Int]] = Array(Array(0, 0, 0), Array(0, 0, 0), Array(0, 0, 0))

但是,没有Vector.ofDim,功能,我找不到相应的.

是否有相当于Array.ofDim不可变对象？如果没有,为什么不呢？

我正在编写一个Scala解析器组合语法,它读取换行符分隔的单词列表,其中列表由一个或多个空行分隔.给出以下字符串:

cat
mouse
horse

apple
orange
pear

我想让它回来List(List(cat, mouse, horse), List(apple, orange, pear)).

我写了这个基本语法,将单词列表视为换行符分隔的单词.请注意,我必须覆盖默认定义whitespace.

import util.parsing.combinator.RegexParsers

object WordList extends RegexParsers {

    private val eol = sys.props("line.separator")

    override val whiteSpace = """[ \t]+""".r

    val list: Parser[List[String]] = repsep( """\w+""".r, eol)

    val lists: Parser[List[List[String]]] = repsep(list, eol)

    def main(args: Array[String]) {
        val s =
          """cat
            |mouse
            |horse
            |
            |apple
            |orange
            |pear""".stripMargin

        println(parseAll(lists, s))
    }
}

这会错误地将空行视为空单词列表,即返回

[8.1] parsed: List(List(cat, mouse, horse), List(), List(apple, orange, pear))

(注意中间的空列表.)

我可以在每个列表的末尾添加一个可选的行尾.

val …

我想要一个无限的非严格系列x ₁,x ₂,x ₃ ...我可以一次使用一个元素,而不是记住结果以保持我的内存使用不变.为了特殊性,我们假设它是一系列整数(例如自然数,奇数,素数),尽管这个问题可能适用于更一般的数据类型.

使用无限列表的最简单方法是使用Scala的Stream对象.一个常见的习惯用法是编写一个返回a的函数Stream,使用#::运算符为该系列添加一个术语,然后递归调用自身.例如,给定起始值和后继函数,以下内容生成无限的整数流.

  def infiniteList(n: Int, f: Int => Int): Stream[Int] = {
      n #:: infiniteList(f(n), f)
  }
  infiniteList(2, _*2+3).take(10) print
  // returns 2, 7, 17, 37, 77, 157, 317, 637, 1277, 2557, empty

(我意识到上面的内容相当于库调用Stream.iterate(2)(_*2+3).我在这里写了这个无限Stream成语的例子.)

但是,流会记住它们的结果,使它们的内存要求不是恒定的,并且可能非常大.该文件指出,如果你不坚持到的头部记忆化避免Stream,但在实践中,这可能会非常棘手.我可以实现无限列表代码,其中我不认为我持有任何流头,但如果它仍然有无限的内存要求,我必须弄清楚问题是我是否以某种方式处理我的流这会导致记忆,或者是否是其他东西.这可能是一个困难的调试任务,并且有代码味道,因为我试图欺骗一个明确的memoized数据结构来返回一个非memoized结果.

我想要的是具有Stream期望语义而没有记忆的东西.Scala中似乎不存在这样的对象.我一直在尝试使用迭代器来实现无限数字系列,但是当你开始想要对它们进行理解操作时,迭代器的可变性使得这很棘手.我也试着从头开始写我自己的代码,但目前还不清楚我应该在哪里开始(我继承Traversable？),或如何避免在重新实现的功能map,fold等等.

有人有一个很好的示例Scala代码的非严格,不可变,非记忆无限列表的实现？

更一般地说,我理解可遍历,可迭代,序列,流和视图的语义,但事实上,我发现这个问题非常令人烦恼,这让我觉得我误解了一些东西.在我看来,非严格性和非记忆性是完全正交的属性,但Scala似乎做出了一个设计决定,将它们统一起来Stream并且没有简单的方法将它们分开.这是对Scala的疏忽吗,还是我忽略的非严格和非记忆之间有一些深层的联系？

我意识到这个问题相当抽象.这是一些将其与特定问题联系起来的附加上下文.

我正在实施一个素数发生器的过程中遇到这个问题,如Meissa O'Niell的论文" Eratosthenes的真正的筛子 "所描述的那样,很难给出一个简单的例子,说明一个Iterator …

NLTK的默认标记器nltk.word_tokenizer链接两个标记器,一个句子标记器,然后是一个对句子进行操作的单词标记器.它的开箱即用相当不错.

>>> nltk.word_tokenize("(Dr. Edwards is my friend.)")
['(', 'Dr.', 'Edwards', 'is', 'my', 'friend', '.', ')']

我想使用相同的算法,除了让它将偏移元组返回到原始字符串而不是字符串标记.

通过偏移我的意思是2-ples可以作为原始字符串的索引.比如我在这里

>>> s = "(Dr. Edwards is my friend.)"
>>> s.token_spans()
[(0,1), (1,4), (5,12), (13,15), (16,18), (19,25), (25,26), (26,27)]

因为s [0:1]是"(",s [1:4]是"博士"等等.

有没有一个NLTK调用可以做到这一点,还是我必须编写自己的偏移算术？

我正在编写返回promises的代码的Javascript Mocha单元测试.我正在使用Chai作为承诺的图书馆.我希望以下最小单元测试失败.

var chai = require("chai");
var chaiAsPromised = require("chai-as-promised");
chai.use(chaiAsPromised);
chai.should();

var Promise = require("bluebird");

describe('2+2', function () {
    var four = Promise.resolve(2 + 2);
    it('should equal 5', function () {
        four.should.eventually.equal(5);
    })
});

当我运行此测试时,我看到打印到控制台的断言错误,但测试仍然算作传递.

> mocha test/spec.js 


  2+2
    ? should equal 5 
Unhandled rejection AssertionError: expected 4 to equal 5


  1 passing (10ms)

如何编写此测试以使失败的断言导致测试计为失败？

我有一个整数类标签的字节张量,例如来自MNIST数据集.

 1
 7
 5
[torch.ByteTensor of size 3]

如何使用它来创建1-hot向量的张量？

 1  0  0  0  0  0  0  0  0  0
 0  0  0  0  0  0  1  0  0  0
 0  0  0  0  1  0  0  0  0  0
[torch.DoubleTensor of size 3x10]

我知道我可以通过一个循环来做到这一点,但我想知道是否有任何聪明的Torch索引会在一行中为我提供.

我有一个关于以函数式编写递归算法的问题.我将在这里使用Scala作为我的示例,但问题适用于任何函数式语言.

我正在对n - tree树进行深度优先枚举,其中每个节点都有一个标签和可变数量的子节点.这是一个简单的实现,它打印叶节点的标签.

case class Node[T](label:T, ns:Node[T]*)
def dfs[T](r:Node[T]):Seq[T] = {
    if (r.ns.isEmpty) Seq(r.label) else for (n<-r.ns;c<-dfs(n)) yield c
}
val r = Node('a, Node('b, Node('d), Node('e, Node('f))), Node('c))
dfs(r) // returns Seq[Symbol] = ArrayBuffer('d, 'f, 'c)

现在说有时我希望能够通过抛出异常来放弃解析超大树.这可能是一种功能语言吗？具体是这可能不使用可变状态吗？这似乎取决于你所说的"超大".这是算法的纯函数版本,当它尝试处理深度为3或更大的树时会抛出异常.

def dfs[T](r:Node[T], d:Int = 0):Seq[T] = {
    require(d < 3)
    if (r.ns.isEmpty) Seq(r.label) else for (n<-r.ns;c<-dfs(n, d+1)) yield c
}

但是,如果树太大而因为太宽而不是太深,该怎么办呢？具体来说,如果我想在递归时调用函数的第n次抛出异常,dfs()而不管递归的深度如何？我能看到如何做到这一点的唯一方法是拥有一个可变计数器,该计数器随每次调用递增.没有可变变量,我无法看到如何做到这一点.

我是函数式编程的新手,并且一直在假设你可以用可变状态做任何事都可以完成,但是我没有在这里看到答案.我唯一能想到的就是编写一个版本,dfs()以深度优先顺序返回树中所有节点的视图.

dfs[T](r:Node[T]):TraversableView[T, Traversable[_]] = ...

然后我可以通过说dfs(r).take(n),强加我的限制,但我不知道如何写这个功能.在Python中,我只是在yield访问节点时通过节点创建一个生成器,但我没有看到如何在Scala中实现相同的效果.(Scala相当于Python风格的yield语句似乎是作为参数传入的访问者函数,但我无法弄清楚如何编写其中一个将生成序列视图.)

编辑 …