小编Hug*_*ira的帖子

我正在寻找一种快速(如巨大的性能,而不是快速修复)解决方案,用于持久化和检索数以千万计的小型(约1k)二进制对象.每个对象应具有唯一的ID以供检索(最好是GUID或SHA).其他要求是它应该可以从.NET使用,它不需要额外的软件安装.

目前,我正在使用一个带有单个表的SQLite数据库来完成这项工作,但我想摆脱处理简单SQL指令的开销,例如SELECT data FROM store WHERE id = id.

我还测试了NTFS下的直接文件系统持久性,但是一旦达到数千万个对象,性能就会快速降低.

PS顺便说一下,对象永远不需要删除,插入率非常非常低.实际上,每次对象更改时,都会存储新版本,并保留以前的版本.这实际上是支持时间旅行的要求.

只需在此线程中添加一些其他信息:

BLOB或不BLOB:数据库或文件系统中的大对象存储http://arxiv.org/abs/cs.DB/0701168

我有一个问题,一些对象根据一些内部逻辑更改其属性.为了简单起见,让我们设想一个RandomSource具有Int名为的公共字段的对象Value.该对象有自己的线程,有时它会更新Value字段.

现在,系统中的其他对象有兴趣收到Value已更新的通知.在C#中,我可以定义对象订阅的伴随委托,以及在更新属性时引发的委托委托.

我的问题如下:我如何在Scala中执行此操作？哪个是最"惯用"的解决方案？

有人可以给我一个更简单的解决方案来解决以下代码(在给定结构的情况下展开整数列表0xFC :: len :: payload :: ... :: 0x0A :: 0x0D):

object Payload {
  def unapply(z: List[Int]): Option[List[Int]] = if (z.length == z.head + 1) Some(z tail) else None
}

object EndToken {
  def unapply(z: List[Int]): Option[List[Int]] = z.reverse match {
    case 0x0D :: 0x0A :: tail => Some(tail.reverse)
    case _ => None
  }
}

object Message {
  def unapply(z: List[Int]): Option[List[Int]] = z match {
    case 0xFC :: EndToken(x) => Some(x)
    case _ => None
  }
} …

给出如下内容:

class A {
  def f(x: X) = ...
  def g(y: Y, z: Z) = ...
  ...
}

如何(自动)提取功能:

object A {
  val f' = (a: A, x: X) => a.f(x)  // do this automagically for any arbitrary f
  val g' = (a: A, y: Y, z: Z) => a.g(y, z) // and deal with arity > 1 too
  ...
}

使用此精确类型签名(首先是对象,然后是参数列表).让我非常清楚地说明问题:

"给定的方法f(x1: X1, ..., xn: Xn)中的一类的上下文中定义A,如何自动提取功能f'的是(ⅰ) 接收一个实例a类型的A …

给定前馈神经网络,如何:

1. 确保它独立于输入的顺序？例如,喂食[0.2,0.3]将输出与[0.3,0.2]相同的结果;
2. 确保它独立于输入组的顺序？例如,喂食[0.2,0.3,0.4,0.5]将产生与[0.4,0.5,0.2,0.3]相同的结果,但不会[0.5,0.4,0.3,0.2];
3. 确保输入序列上的置换将对输出序列进行置换.例如,如果[0.2,0.3]给出输出[0.8,0.7],则[0.3,0.2]给出输出[0.7,0.8].

鉴于以上情况:

1. 除了确保列车集涵盖所有可能的排列外,还有其他解决方案吗？
2. 隐藏层的奇偶校验是否受到某种程度的约束(即隐藏层中的神经元数量必须是奇数还是偶数)？
3. 在权重矩阵中寻找某种对称性是否有意义？

我已经使用Weka 3.7.9将随机森林模型保存到文件中,现在我正在尝试将其与其他(非常大的)集合(在Amazon EC2中的某些大型计算机上)进行评估.我正在使用以下命令行:

> java -server -Xmx60000m -cp weka.jar weka.classifiers.Evaluation 
weka.classifiers.trees.RandomForest -T test.arff -l random-forest.model
-i -no-cv

但是,我唯一的输出是这样的:

=== Error on test data ===

Correctly Classified Instances     3252532               80.0686 %
Incorrectly Classified Instances    809651               19.9314 %
Kappa statistic                          0.2884
Mean absolute error                      0.2539
Root mean squared error                  0.3608
Coverage of cases (0.95 level)          98.7413 %
Total Number of Instances          4062183

而我正在寻找这样的东西:

=== Detailed Accuracy By Class ===

                 TP Rate  FP Rate  Precision  Recall   F-Measure  MCC      ROC Area  PRC Area  Class …

让我们尝试定义一个返回两个值 x 和 y 中的最大值的函数。这些公式有效的充分条件是，对于有符号整数，\xe2\x80\x932^30 <= x, y <= 2^30 \xe2\x80\x93 1，对于无符号整数，0 <= x, y <= 2^31 \xe2\x80\x93 1（即，只需要处理有效减少一位的缩小整数范围）。最通用（且最简单）的实现是：

int max(int x, int y) {\n    return (x > y) ? x : y\n}\n

在 Pentium Pro 之前，这将是 x86 中生成的程序集：

max:  # GCC -O3 -march=pentium -m32\n  mov eax, DWORD PTR [esp+8]\n  cmp eax, DWORD PTR [esp+4]\n  jge .L4\n  mov eax, DWORD PTR [esp+4]\n.L4:\n  ret\n

但从 Pentium Pro 开始，CMOVcc r32,r/m引入了一条新指令，它根据某些指定的状态标志执行条件移动： …

这不会输入:

sealed trait BinOp[-InA, -InB, +Out]
case object Add extends BinOp[Int, Int, Int]

sealed trait Expression[+A]
final case class IntegerAtom(value: Int) extends Expression[Int]
final case class BinaryExp[-A, -B, +C](op: BinOp[A, B, C], lhs: Expression[A], rhs: Expression[B]) extends Expression[C]

def optimizeStep[A](x: Expression[A]): Expression[A] = x match {
  case BinaryExp(Add, IntegerAtom(a), IntegerAtom(b)) => IntegerAtom(a + b)
}

最直接的事情是在模式匹配中使用case对象:

[error] (...) pattern type is incompatible with expected type;
[error]  found   : minimumexample.Add.type
[error]  required: minimumexample.BinOp[Any,Any,A]

这似乎可以通过引入眼睛出血来解决:

val AddOp = Add

然后:

case BinaryExp(AddOp, …

为什么以下退出ERROR: Out of global stack后返回预期的答案？

?- L #>= 0, L #=< 3, length(X, L).

L = 0,
X = [] ;
L = 1,
X = [_G1784] ;
L = 2,
X = [_G1784, _G1787] ;
L = 3,
X = [_G1784, _G1787, _G1790] ;
ERROR: Out of global stack

更新:WRT @琼的回答,我试图理解为什么它不会终止,也不一定找到一个解决方案将终止.我的意思是,如果问题是没有约束力,那么在贴标签之前它不应该同样产生任何答案,对吧？所以我的问题与产生答案(而不是终止)的机制有关,而不是修复代码.

我正在尝试优化以下简单算法，针对 x86-64 和 arm64 中的 SIMD 指令。给定一个T位向量，以及两个Aidx与Bidx大小相同的向量T，包含 中值的索引T，函数将T'使用以下算法生成新的：

A = T[Aidx]
B = T[Bidx]
T' = A NAND B

这是一个 C++ 实现：

#include <cstddef>

#define align 128
#define vsize 1024

struct alignas(align) vec_friendly_idx {
    const static std::size_t size = vsize;
    unsigned short v[size];
};

struct alignas(align) vec_friendly_bool {
    const static std::size_t size = vsize;
    unsigned char v[size];
};

void vecadd3(vec_friendly_bool& __restrict t, const vec_friendly_idx& aidx, const vec_friendly_idx& bidx, …