标签: data-processing

让我们假设我们有一个可能大约给出的数据集

import numpy as np
x = np.linspace(0,2*np.pi,100)
y = np.sin(x) + np.random.random(100) * 0.2

因此,我们有20%的数据集变化.我的第一个想法是使用scipy的单变量函数函数,但问题是这不会很好地考虑小噪声.如果你考虑频率,背景远小于信号,所以只有截止的样条可能是一个想法,但这将涉及来回傅里叶变换,这可能导致不良行为.另一种方式是移动平均线,但这也需要正确选择延迟.

任何提示/书籍或链接如何解决这个问题？

在研究了大规模数据存储解决方案之后,我几乎落在了卡桑德拉.但它普遍认为Hbase是大规模数据处理和分析的更好解决方案.

虽然两者都是相同的键/值存储,并且两者都是/可以运行(最近的Cassandra)Hadoop层,但是当大数据需要处理/分析时,Hadoop是更好的候选者.

我也在http://ria101.wordpress.com/2010/02/24/hbase-vs-cassandra-why-we-moved/找到了关于这两方面的详细信息.

但我仍然在寻找Hbase的具体优势.

虽然我更加信服Cassandra,因为它简单易用,无需添加节点和无缝复制,也没有故障点功能.它还保留了二级索引功能,因此它是一个很好的优点.

我有一些非常大的分隔数据文件,我想只处理R中的某些列而不花时间和内存来创建data.frame整个文件.

我所知道的唯一选择是read.table,当我只想要几列或者scan看起来我想要的水平太低时非常浪费.

有没有更好的选择,无论是使用纯R还是调用其他shell脚本来进行列提取,然后在其输出上使用scan或read.table？(这导致了如何调用shell脚本并在R中捕获其输出的问题).

当前选择: lua-jit.令人印象深刻的基准测试,我已经习惯了语法.编写高性能ABI需要仔细考虑如何构建我的C++.

其他感兴趣的问题

1. Gambit-C和Guile是可嵌入的语言
2. Lua性能提示(可选择使用已禁用的收集器运行,并在处理运行结束时调用收集器始终是一个选项).

背景

我正在研究一个实时高容量(复杂)事件处理系统.我有一个DSL,代表源的事件结构的模式,存储格式,某些特定于域的构造,触发内部事件(构造和驱动通用处理),以及编码始终发生的某些处理步骤.

DSL看起来非常类似于SQL,事实上我使用berkeley db(通过sqlite3接口)来长期存储事件.这里的重要部分是事件处理是基于集合完成的,就像SQL一样.然而,我得出结论,我不应该在DSL中添加通用处理逻辑,而是嵌入lua或lisp来处理这个问题.

处理核心是arround boost :: asio,它是多线程的,rpc是通过协议缓冲区完成的,事件是使用协议缓冲区IO库编码的 - 事件不是使用协议缓冲区对象构建的,它们只使用相同的编码/解码库.我将创建一个包含行的数据集对象,与数据库引擎在内存集中的存储方式非常相似.首先处理DSL中的处理步骤,然后将其呈现给通用处理逻辑.

无论我使用哪种可嵌入的脚本环境,我的处理核心中的每个线程都可能需要它自己的嵌入式语言环境(这就是lua至少在你做多线程工作时需要它的方式).

问题

目前的选择是在lisp ECL和lua之间.请记住,性能和吞吐量是一个强烈要求,这意味着非常需要最小化内存分配:

1. 如果你在我的位置,你会选择哪种语言？

2. 有没有我应该考虑的替代方案(不建议没有可嵌入实现的语言).Javascript v8也许吧？

3. lisp更适合这个领域吗？我不认为lua和lisp在它们提供的方面有所不同.叫我出去:D

4. 我应该考虑其他任何属性(如下所示)吗？

5. 我断言任何形式的嵌入式数据库IO(请参阅下面的示例DSL以获取上下文)使脚本语言调用在数量级上相形见绌,并且选择这两者不会给总体吞吐量增加太多开销.我是在正确的轨道上吗？:d

期望的属性

1. 我想将我的数据集映射到lisp列表或lua表,我想最小化冗余数据副本.例如,如果两个表具有相同的形状,则从一个数据集向另一个数据集添加行应尝试使用引用语义.

2. 我可以保证在我进行lua/lisp调用时,作为输入传递的数据集不会改变.我希望lua和lisp在可能的情况下强制不改变数据集.

3. 在嵌入式调用结束后,应该销毁数据集,创建的任何引用都需要用副本替换(我猜).

DSL示例

我附上了一个DSL供您观看,这样您就可以了解我想要实现的目标.注意:DSL不显示通用处理.

// Derived Events : NewSession EndSession
NAMESPACE WebEvents
{
  SYMBOLTABLE DomainName(TEXT) AS INT4;
  SYMBOLTABLE STPageHitId(GUID) AS INT8;
  SYMBOLTABLE UrlPair(TEXT hostname ,TEXT scriptname) AS INT4;
  SYMBOLTABLE UserAgent(TEXT UserAgent) AS INT4;  

  EVENT 3:PageInput
  {
    //------------------------------------------------------------//
    REQUIRED 1:PagehitId              GUID
    REQUIRED 2:Attribute              TEXT;
    REQUIRED 3:Value                  TEXT; 

    FABRRICATED 4:PagehitIdSymbol     INT8;
    //------------------------------------------------------------// …

正如您期望的DSL用于数据分析,R很好地处理丢失/不完整的数据,例如:

许多R函数都有一个na.rm标志,当设置为TRUE时,删除NA:

>>> v = mean( c(5, NA, 6, 12, NA, 87, 9, NA, 43, 67), na.rm=T)
>>> v
      (5, 6, 12, 87, 9, 43, 67)

但是如果你想在函数调用之前处理NA ,你需要做这样的事情:

从矢量中删除每个'NA':

vx = vx[!is.na(a)]

从矢量中删除每个'NA'并将其替换为'0':

ifelse(is.na(vx), 0, vx)

从数据框中删除包含"NA"的整个行:

dfx = dfx[complete.cases(dfx),]

所有这些功能都会永久删除 "NA"或其中带有"NA"的行.

有时候这并不是你想要的 - 在工作流程的下一步可能需要为数据帧的"NA"删除副本,但在后续步骤中,你经常需要这些行(例如,计算一个由于先前调用"完整案例"而导致缺少行的列的列式统计信息,但该列中没有"NA"值.

尽可能清楚我正在寻找的东西:python/numpy有一个类,蒙面数组,有一个掩码方法,它允许你在函数调用期间隐藏 -但不删除 - NA.R中是否有类似的功能？

是否有内置的方法通过IQR对列进行过滤(即Q1-1.5IQR和Q3 + 1.5IQR之间的值)？另外,建议大熊猫中任何其他可能的广义过滤都将受到重视.

给定一组单词,我们需要找到anagram单词并使用最佳算法单独显示每个类别.

输入:

man car kile arc none like

输出:

man
car arc
kile like
none

我现在开发的最佳解决方案是基于散列表,但我正在考虑将anagram字转换为整数值的等式.

示例:man =>'m'+'a'+'n'但这不会给出唯一值.

有什么建议吗？

请参阅C#中的以下代码:

string line = Console.ReadLine();
string []words=line.Split(' ');
int[] numbers = GetUniqueInts(words);
for (int i = 0; i < words.Length; i++)
{
    if (table.ContainsKey(numbers[i]))
    {
        table[numbers[i]] = table[numbers[i]].Append(words[i]);
    }
    else
    {
        table.Add(numbers[i],new StringBuilder(words[i]));
    }

}

问题是如何开发GetUniqueInts(string [])方法.

大多数数据处理可以被设想为组件的流水线,一个组件的输出馈入另一个组件的输入.典型的处理管道是:

reader | handler | writer

作为开始讨论的一个衬托,让我们考虑一个面向对象的实现这个管道,其中每个段都是一个对象.该handler对象包含对reader和writer对象的引用,并具有如下所示的run方法:

define handler.run:
  while (reader.has_next) {
    data = reader.next
    output = ...some function of data...
    writer.put(output)
  }

示意性依赖关系是:

reader <- handler -> writer

现在假设我想在读者和处理程序之间插入一个新的管道段:

reader | tweaker | handler | writer

同样,在这个OO实现中,tweaker将是reader对象的包装器,并且tweaker方法可能看起来像(在一些伪命令性代码中):

define tweaker.has_next:
  return reader.has_next

define tweaker.next:
  value = reader.next
  result = ...some function of value...
  return result

我发现这不是一个非常可组合的抽象.一些问题是:

1. tweaker只能在左侧使用handler,即我不能使用上面的实现tweaker来形成这个管道:

   读者| 处理程序| tweaker | …

在实践中(非理论),小批量与实时流之间有什么区别？从理论上讲,我理解迷你批量是在给定的时间范围内批量生成的,而实时流式更像是在数据到达时做某事但是我最大的问题是为什么不使用epsilon时间框架(比如说一毫秒)或我想了解为什么一个人比其他人更有效的解决方案？

我最近遇到了一个例子,其中迷你批处理(Apache Spark)用于欺诈检测,实时流(Apache Flink)用于欺诈预防.有人还评论说小批量不是防止欺诈的有效解决方案(因为目标是防止交易发生)现在我想知道为什么这对迷你批次(Spark)不会那么有效？为什么以1毫秒的延迟运行迷你批处理无效？批处理是一种在任何地方使用的技术,包括操作系统和内核TCP/IP堆栈,其中磁盘或网络的数据确实被缓冲,那么说一个比其他更有效的令人信服的因素是什么？

我需要格式化一个大的JSON文件以提高可读性，但是我发现的每个资源（主要是在线资源）都无法处理1-2 MB以上的数据。我需要格式化大约30 MB。有没有办法做到这一点，或者有什么办法编写一些东西来做到这一点？