小编Nim*_*and的帖子

我是Python的新手,我正在学习TensorFlow.在使用notMNIST数据集的教程中,他们给出了将标签矩阵转换为n个编码数组的示例代码.

目标是采用由标签整数0 ... 9组成的数组,并返回一个矩阵,其中每个整数已转换为一个n编码数组,如下所示:

0 -> [1, 0, 0, 0, 0, 0, 0, 0, 0, 0]
1 -> [0, 1, 0, 0, 0, 0, 0, 0, 0, 0]
2 -> [0, 0, 1, 0, 0, 0, 0, 0, 0, 0]
...

他们提供的代码是:

# Map 0 to [1.0, 0.0, 0.0 ...], 1 to [0.0, 1.0, 0.0 ...]
labels = (np.arange(num_labels) == labels[:,None]).astype(np.float32)

但是,我不明白这段代码是如何做到的.看起来它只是生成0到9范围内的整数数组,然后将其与标签矩阵进行比较,并将结果转换为浮点数.==运算符如何产生一个n编码矩阵？

我正在TensorFlow/Python中为notMNIST数据集编写一个神经网络分类器.我已经在隐藏层上实现了l2正则化和丢失.只要只有一个隐藏层,它就可以正常工作,但是当我添加更多层(以提高准确性)时,损失函数在每一步都会迅速增加,在步骤5中变为NaN.我尝试暂时禁用Dropout和L2正则化,但是只要有2层以上,我就会得到相同的行为.我甚至从头开始重写我的代码(做一些重构以使其更灵活),但结果相同.层的数量和大小由hidden_layer_spec.我错过了什么？

#works for np.array([1024]) with about 96.1% accuracy
hidden_layer_spec = np.array([1024, 300])
num_hidden_layers = hidden_layer_spec.shape[0]
batch_size = 256
beta = 0.0005

epochs = 100
stepsPerEpoch = float(train_dataset.shape[0]) / batch_size
num_steps = int(math.ceil(float(epochs) * stepsPerEpoch))

l2Graph = tf.Graph()
with l2Graph.as_default():
  #with tf.device('/cpu:0'):
      # Input data. For the training data, we use a placeholder that will be fed
      # at run time with a training minibatch.
      tf_train_dataset = tf.placeholder(tf.float32,
                                        shape=(batch_size, image_size * image_size))
      tf_train_labels = tf.placeholder(tf.float32, shape=(batch_size, num_labels)) …

我已经在我正在编写的库中出现过多次这种情况,而且我对目前为止我提出的解决方案并不是特别满意.

假设我有一个昂贵的函数f,它接受一个T类型的项并返回一个类型为Option [U]的值.现在,假设我有一个类型为T的集合,我希望在跨越T的元素执行时检索f返回的第一个非None值,而不是为T的所有元素评估f(如果已找到该值).

我想出的唯一方法是将F包装到Extractor对象中,并将其与scala的collectFirst方法一起使用.

例如:

object FMatch { def unapply(t : T) = f(t) }

collection.collectFirst{ case FMatch(result) => result }

这似乎有点不优雅,我不确定f是否只对每个结果进行一次或两次评估(我还没有测试过这一点).似乎使用一个版本的collectFirst来获取类型为T => Option [U]而不是PartialFunction1 [T]的参数会很有用.

有没有更优雅的方式来做到这一点,我错过了？

在我的库中,我有三个类型类:

trait Monoid[T] {
  val zero : T
  def sum(x : T, y : T) : T
}

trait AbelianGroup[T] extends Monoid[T] {
  def inverse(x : T) : T
  def difference(x : T, y : T) : T
}

//represents types that are represents lists with a fixed number of elements, such as
//the tuple type (Int, Int)
trait Vector[T, U] {
  ...
}

在以下条件下,这些类型类可以相互转换:

• 如果type T是一个scala.math.Numeric类型,它也是一个类型AbelianGroup.
• 如果type T是a AbelianGroup,那么它也是一个Monoid(当前AbelianGroup …

我有一个枚举类型ResourceType,我试图使用光滑的API将其作为Int存储在数据库中.我已经为ResourceType定义了一个自定义类型映射器,但是在我的表定义中我的*定义中出现了编译器错误,说"找不到匹配的形状.Slick不知道如何映射给定的类型.".是否有可能使这项工作？

import scala.slick.driver.H2Driver.simple._

case class Resource(val id : Option[Int], val creationDate : Date, val title : String, val resourceType : ResourceType, val description : String) {
}

case class ResourceType private(val databaseCode : Int, val label : String) {
}

object ResourceType {
  val lessonPlan = new ResourceType(1, "Lesson Plan")
  val activity = new ResourceType(2, "Activity")

  val all = scala.collection.immutable.Seq(lessonPlan, activity)

  private val _databaseCodeMap = all.map(t => t.databaseCode -> t).toMap

  def apply(databaseCode : Int) = _databaseCodeMap(databaseCode)
}

class ResourceTable(tag : …

我需要使用内部类或抽象类型作为外部类型的类型参数,例如在下面的大量简化示例中:

trait A[T <: Ordered[T]] {
}

class B extends A[C] { //<-- Compiler error, type C not found.
  class C extends Ordered[C] {
  }
}

我的库中出现了一个相当棘手的设计问题,我没有看到任何令人满意的方法来避免这种结构.我已尝试过许多不同的想法从类型参数引用内部类,但无济于事.

我的问题是:

1. 有没有办法从外部类的类型参数引用内部类？

2. 如果没有,是否存在排除这种情况的逻辑不一致,或者只是限制了编译器和语言规范？