小编Man*_*idt的帖子

我最近看到了谈判死亡简单的依赖注入和依赖注入没有体操关于DI与Monads并且留下了深刻的印象.我试图将它应用于一个简单的问题,但是一旦它变得非常重要就失败了.我真的很想看到依赖注入的运行版本

• 一个依赖于多个必须注入的值的类
• 依赖于依赖于要注入的东西的类的类

如下例所示

trait FlyBehaviour { def fly() }
trait QuackBehaviour { def quack() }
trait Animal { def makeSound() }

// needs two behaviours injected
class Duck(val flyBehaviour: FlyBehaviour, val quackBehaviour: QuackBehaviour) extends Animal 
{
   def quack() = quackBehaviour.quack()
   def fly() = flyBehaviour.fly()
   def makeSound() = quack()
}

// needs an Animal injected (e.g. a Duck)
class Zoo(val animal: Animal)

// Spring for example would be able to provide a Zoo instance
// assuming …

从Scala开始,阅读Either我自然地将新概念与我所知道的事物进行比较(在本例中来自Java).与检查异常的概念有什么不同Either吗？

在这两种情况下

• 失败的可能性在方法中明确注释(throws或返回Either)
• 程序员可以直接处理错误情况或将其向上移动(再次返回Either)
• 有一种方法可以通知呼叫者错误的原因

我想在Either编写代码时会使用for-comprehensions,因为没有类似于checked异常的错误.

我想知道我是否是唯一一个遇到问题的初学者.

谢谢

我正在考虑将我的代码库移动到tf.estimator.Estimator,但我找不到如何将它与tensorboard摘要结合使用的示例.

MWE:

import numpy as np
import tensorflow as tf

tf.logging.set_verbosity(tf.logging.INFO)

# Declare list of features, we only have one real-valued feature
def model(features, labels, mode):
    # Build a linear model and predict values
    W = tf.get_variable("W", [1], dtype=tf.float64)
    b = tf.get_variable("b", [1], dtype=tf.float64)
    y = W*features['x'] + b
    loss = tf.reduce_sum(tf.square(y - labels))

    # Summaries to display for TRAINING and TESTING
    tf.summary.scalar("loss", loss)    
    tf.summary.image("X", tf.reshape(tf.random_normal([10, 10]), [-1, 10, 10, 1])) # dummy, my inputs are images

    # …

为什么get定义方法Option而不是Some？

一个可以应用模式匹配和使用foreach,map,flatMap,getOrElse这无论如何是不优先运行时异常的危险,如果None.get被调用.

是否真的存在这种get方法非常有说服力以至于证明这一点的理由？使用该get方法让我想起Java,其中"我不需要检查null,因为我知道var已设置",然后查看a NullPointerException.

我有一个List [Option [Int]]并希望使用applicative functors来总结它.从[1]我明白它应该是类似下面的东西

import scalaz._
import Scalaz._

List(1,2,3).map(some(_)).foldLeft(some(0))({
    case (acc,value) => (acc <|*|> value){_+_}
})

但是我根本无法弄清楚写这个的正确方法.如果有人可以帮助我,我会很高兴.

非常感谢你

[1] 如何在Scala中组合选项值？

编辑

感谢所有的好答案.

如果列表中有任何None,我希望它返回None.我试图用Option/Either替换Null/Exception,看看我是否可以生成一些可用的代码.

一些函数将填充我的列表,我想尽可能简单地处理它,而不检查其中一个元素是否为None.它应该像Exceptions类似,我不需要在我的函数中检查它,但让调用者处理它.

我设置了一个以文件名队列开头的管道,如下面的伪代码:

filename_queue = tf.train.string_input_producer(["file0.pd", "file1.pd"])

指向TFRecords包含多个序列化tf.train.Example图像.跟随张量流指导一个函数,它读取一个例子:

def read_my_file_format(filename_queue):
  reader = tf.SomeReader()
  key, record_string = reader.read(filename_queue)
  example, label = tf.some_decoder(record_string)
  processed_example = some_processing(example)
  return processed_example, label

用于批处理队列:

def input_pipeline(filenames, batch_size):
  filename_queue = tf.train.string_input_producer(filenames)
  example, label = read_my_file_format(filename_queue)

  example_batch, label_batch = tf.train.shuffle_batch(
      [example, label], batch_size=batch_size, capacity=100,
      min_after_dequeue=10)
  return example_batch, label_batch

我正在寻找一种方法将数据随机分成训练和测试集.我不想将训练和测试集保存到不同的文件中,但是图像被随机分配给训练或测试集,而与他们从中读取的文件无关.理想情况下,我想将输入管道拆分为训练和测试队列.

当我必须拆分一个庞大的数据集时,这就是我通常在numpy中所做的事情

import numpy as np
from numpy.random import choice
from numpy.random import RandomState

queue = range(10)
weights = (.8,.2) # create 2 partitions with this weights

def …

我想定义一个List实现公共类型类的元素.例如

  trait Show[A] {
    def show(a: A): String
  }
  implicit val intCanShow: Show[Int] = new Show[Int] {
      def show(int: Int): String = s"int $int"
  }
  implicit val stringCanShow: Show[String] = new Show[String] {
    def show(str: String): String = str
  }

问题是,如何定义一个list = List(1, "abc")这样的值,以确保Show这些值的实例在范围内？然后我想将这个列表映射到show上list map {_.show}.

我对C++库Eigen印象深刻,它使用表达式模板在矩阵/向量计算中获得巨大的加速.

我想在scala中克隆这个库.据我所知,scalas类型系统不够强大,不能做这样的事情,但应该可以轻量级模块化升级LMS.似乎有几个项目(Delight,virtualization-lms等).在可靠性和性能方面,哪种项目可以用于此类项目？

谢谢

编辑:我刚刚在scala 2.10中遇到过宏.也许这就是我想在这里使用的.

@ OM-NOM-NOM

重要的部分在http://eigen.tuxfamily.org/dox/TopicInsideEigenExample.html中解释

该示例解释了向量加法

u = v + w

在(本机)C++中具有良好的性能,因为为添加创建了一个临时变量,并将此变量分配给u

for(int i = 0; i < size; i++) tmp[i] = v[i] + w[i];
for(int i = 0; i < size; i++) u[i] = tmp[i];

Eigen使用模板元编程(在上面的链接中逐步解释)在编译时将其减少到

for(int i = 0; i < size; i++) u[i] = v[i] + w[i];

这显然更快,不需要额外的变量.

是否有一个原因(性能,内存,类型系统)为什么元组不是HList而函数不是从HList到某个值的映射形式？

大多数教程都关注整个训练数据集适合内存的情况.但是,我有一个迭代器,它充当(特征,标签)-tuples的无限流(在运行中便宜地创建它们).

在实现input_fnfor tensorflows 估算器时,我可以从迭代器返回一个实例

def input_fn():
   (feature_batch, label_batch) = next(it)
   return tf.constant(feature_batch), tf.constant(label_batch)

或者input_fn必须在每次通话时返回相同的(功能,标签) - 元组？

此外,在训练期间多次调用此函数,因为我希望它类似于以下伪代码:

for i in range(max_iter):
   learn_op(input_fn())