标签: chunking

我正在使用.Net 4.0和SQL Server 2008 R2.

我正在运行一个大的SQL选择查询,它会返回数百万个结果,并且需要很长时间才能完全运行.

有谁知道如何只读取查询返回的一些结果而不必等待整个查询完成？

换句话说,我想在查询仍然运行并获得下一个结果时读取第一个10,000个记录块.

我正在尝试使用正则表达式(并且没有NLTK)构建一个chunker(或浅层解析器),但是无法提出一个正常的表达式来完成我想要它做的事情.这是我的直接目标:在自然语言文本中查找所有名词短语.

我的第一步是用我自己酿造的词性标记器标记所有句子,然后将标记/标记对列表加入到单个字符串中,如下所示:

'he PRN and CC bill NP could MOD hear VB them PRN on IN the DT large JJ balcony NN near IN the DT house NN'

我的下一步是使用正则表达式在字符串中搜索名词短语的实例.现在,名词短语的一般语言公式是:可选的确定词(DT),零个或多个形容词(JJ),以及名词(NN),专有名词(NP)或代词(PRN).给定这个通用公式,我尝试了这个正则表达式(请记住,标记的字符串在单词和标签之间交替):

'(\w+ DT)? (\w+ JJ)* (\w+ (NN|NP|PRN))'

这是我的代码:

text = 'he PRN and CC bill NP could MOD hear VB them PRN on IN the DT large JJ balcony NN near IN the DT house NN'

regex = re.compile(r'(\w+ DT)? (\w+ JJ)* (\w+ (NN|NP|PRN))')
m = regex.findall(text)

if m:
     print m

这是我的输出: …

我正在尝试构造一个Conduit接收为输入ByteStrings(每个块大小约1kb)并生成ByteString512kb块的输出连接.

这看起来应该很简单,但是我遇到了很多麻烦,我尝试过的大多数策略只能成功地将块分成更小的块,我没有成功连接更大的块.

我开始尝试isolate,然后takeExactlyE最终conduitVector,但无济于事.最终我决定这个:

import qualified Data.Conduit               as C
import qualified Data.Conduit.Combinators   as C
import qualified Data.ByteString            as B
import qualified Data.ByteString.Lazy       as BL

chunksOfAtLeast :: Monad m => Int -> C.Conduit B.ByteString m BL.ByteString
chunksOfAtLeast chunkSize = loop BL.empty chunkSize
  where 
    loop buffer n = do
      mchunk <- C.await
      case mchunk of 
        Nothing -> 
          -- Yield last remaining bytes
          when (n < chunkSize) (C.yield buffer)
        Just chunk -> …

我试图弄清楚如何按照NLTK书的第7章使用NLTK的级联组块.不幸的是,我在执行非平凡的分块测量时遇到了一些问题.

让我们从这句话开始:

"adventure movies between 2000 and 2015 featuring performances by daniel craig"

当我使用以下语法时,我能够找到所有相关的NP:

grammar = "NP: {<DT>?<JJ>*<NN.*>+}"

但是,我不确定如何使用NLTK构建嵌套结构.本书给出了以下格式,但显然有一些缺失(例如,如何实际指定多个规则？):

grammar = r"""
  NP: {<DT|JJ|NN.*>+}          # Chunk sequences of DT, JJ, NN
  PP: {<IN><NP>}               # Chunk prepositions followed by NP
  VP: {<VB.*><NP|PP|CLAUSE>+$} # Chunk verbs and their arguments
  CLAUSE: {<NP><VP>}           # Chunk NP, VP
  """

在我的情况下,我想做类似以下的事情:

grammar = r"""
          MEDIA: {<DT>?<JJ>*<NN.*>+}
          RELATION: {<V.*>}{<DT>?<JJ>*<NN.*>+}
          ENTITY: {<NN.*>}
          """

假设我想为我的任务使用级联的chunker,我需要使用什么语法？另外,在使用chunker时,我是否可以指定特定的单词(例如"定向"或"行动")？

在我们的应用程序中,我们有一些数据结构,其中包含一个分块的字节列表(当前公开为a List<byte[]>).我们将字节大块化,因为如果我们允许将字节数组放在大对象堆上,那么随着时间的推移,我们会遇到内存碎片.

我们也开始使用Protobuf-net来序列化这些结构,使用我们自己生成的序列化DLL.

但是我们注意到Protobuf-net在序列化时会创建非常大的内存缓冲区.浏览源代码看起来似乎它可能无法刷新其内部缓冲区,直到整个List<byte[]>结构被写入,因为它需要在缓冲区前面写入总长度.

不幸的是,这首先解决了我们的工作,首先将字节分块,最终由于内存碎片而给我们OutOfMemoryExceptions(异常发生在Protobuf-net尝试将缓冲区扩展到84k以上时,这显然是在LOH,我们的整体进程内存使用率相当低.

如果我对Protobuf-net如何工作的分析是正确的,那么有没有解决这个问题的方法呢？

更新

根据Marc的回答,这是我尝试过的:

[ProtoContract]
[ProtoInclude(1, typeof(A), DataFormat = DataFormat.Group)]
public class ABase
{
}

[ProtoContract]
public class A : ABase
{
    [ProtoMember(1, DataFormat = DataFormat.Group)]
    public B B
    {
        get;
        set;
    }
}

[ProtoContract]
public class B
{
    [ProtoMember(1, DataFormat = DataFormat.Group)]
    public List<byte[]> Data
    {
        get;
        set;
    }
}

然后序列化它:

var a = new A();
var b = new B();
a.B = b;
b.Data = new List<byte[]>
{
    Enumerable.Range(0, 1999).Select(v => …

在我们的客户端上,可以上传大文件.我们希望使用分块来减少请求的大小.我们正在使用Plupload,所以很容易以块的形式发送文件.但是,我不知道如何处理这些块.我们在服务器上使用Spring MVC和我目前有我的控制器方法如下:uploadMedia(@RequestBody MultipartFile file)这里MultipartFile是org.springframework.web.multipart.MultipartFile.这样可以在不进行分块时正常工作.当我打开客户端的分块时,它仍然可以很好地进入这个方法,但是我没有看到传递的文件中的任何内容,它标识了chunk所属的文件.希望我只是遗漏了一些东西.

看起来这是一个常见的工作流程,但我似乎无法找到在服务器端如何完成这一任务的任何好例子.只有Spring的解决方案会很棒,但是如果需要另一个库,那也没关系.我看了一下Apache Commons FileUpload,但我在那里找不到任何有关分块的信息.对此的任何帮助都会很棒.谢谢.

我想问一个关于压缩性能的问题,这与hdf5文件的块大小有关.

我手边有2个hdf5文件,它们具有以下属性.它们都只包含一个数据集,称为"数据".

文件A的"数据":

1. 类型:HDF5标量数据集
2. 尺寸数量:2
3. 尺寸大小:5094125 x 6
4. 最大.尺寸大小:无限x无限制
5. 数据类型:64位浮点
6. 分块:10000 x 6
7. 压缩:GZIP等级= 7

文件B的"数据":

1. 类型:HDF5标量数据集
2. 尺寸数量:2
3. 尺寸大小:6720 x 1000
4. 最大.尺寸大小:无限x无限制
5. 数据类型:64位浮点
6. Chunking:6000 x 1
7. 压缩:GZIP等级= 7

文件A的大小:HDF5 ---- 19 MB CSV ----- 165 MB

文件B的大小:HDF5 ---- 60 MB CSV ----- 165 MB

与csv文件相比,它们都显示了对存储数据的强大压缩.但是,文件A的压缩率约为原始csv的10%,而文件B的压缩率仅为原始csv的约30%.

我尝试了不同的块大小使文件B尽可能小,但似乎30%是最佳压缩率.我想问一下,为什么文件A可以实现更大的压缩,而文件B则不能.

如果文件B也可以实现,那么块大小应该是多少？

是否有任何规则来确定HDF5的最佳块大小以用于压缩目的？

谢谢!

档案下:"意外效率部门"

前9000万个数字约占761MB,输出为:

 seq 90000000

根据man parallel它,它可以gzip通过切断输入并使用不同的CPU来压缩块来加速归档大文件.因此即使gzip是单线程,这种技术也使它成为多线程:

seq 90000000  | parallel --pipe --recend '' -k gzip -9 >bigfile.gz

在Intel Core i3-2330M(4)@ 2.2GHz上花了46秒.

管道到老了gzip:

seq 90000000  | gzip -9 > bigfile2.gz

在相同的CPU上花了80秒.现在出人意料:

ls -log bigfile*.gz

输出:

-rw-rw-r-- 1 200016306 Jul  3 17:27 bigfile.gz
-rw-rw-r-- 1 200381681 Jul  3 17:30 bigfile2.gz

300K更大？这看起来不对.首先,我检查zdiff文件是否具有相同的内容 - 是的,相同.我认为任何压缩器在连续数据流方面都会比分块数据流做得更好.为什么不bigfile2.gz小于bigfile.gz？

我正在尝试为我正在处理的应用程序构建自己的客户端RTMP库.到目前为止,一切都已成功,因为我能够连接到RTMP服务器协商握手,然后发送所有必要的数据包(FCPublish Publish ETC)然后从服务器获取NetStream.Publish.Start的onStatus消息,这意味着我成功地让服务器允许我开始发布我的实时视频广播.Wireshark还确认信息(/数据打包)是正确的,因为它也正确显示.

现在我遇到麻烦的地方是RTMP Chunking,第17页和第18页的Adobe RTMP规范显示了一个消息如何分块的示例.从这个例子中我可以看出它是根据块大小(128字节)分解的.对我来说,块大小在初始连接和交换中协商,总是4096字节.因此,当我交换大于4096字节的视频数据时,我需要将消息分块,然后发送RTMP packetHeader并结合前4096字节的数据,然后发送一个小的RTMP头,即0xc4(0xc0 | packetHeaderType(0x04))结合4096字节的视频数据,直到发送了标头指定的完整数据包.然后进入一个新框架并重复相同的过程.

通过检查用不同语言编写的其他RTMP客户端示例,这似乎就是他们正在做的事情.不幸的是,我尝试传输的摄取服务器没有接收广播视频数据,他们不关闭我的连接,他们只是从不显示视频或视频是正确的任何迹象.Wireshark显示,在发送视频原子数据包之后,发送的大多数数据包都是未知(0x0)一点点,然后它们将切换到视频数据,并在显示未知(0x0)和视频数据之间进行触发.但是,如果我将有效负载最大大小限制为20000字节,Wireshark会将所有内容显示为视频数据.显然,摄取服务器不会在这种情况下显示视频,因为我正在删除大块的数据,因为它只有20k字节.

试图弄清楚出了什么问题我开始了另一个xcode项目,它允许我在我的Lan上欺骗RTMP服务器,以便我可以看到libRTMP IOS进入服务器时的数据.同样使用libRTMP,我可以记录它发送的数据包,它们似乎注入字节0xc4甚至128字节,即使我已经发送Change Chunk size消息作为服务器.当我尝试在我的RTMP客户端库中通过使用128块大小来复制它时,即使它被设置为4096字节,服务器也将关闭我的连接.但是,如果更改libRTMP以尝试转到实时RTMP服务器,它仍会在LibRTMP中打印出它正在以128的块大小发送数据包.并且服务器似乎在视频显示时接受它.当我查看RTMP服务器上的数据时,我发现它就是他们的全部.

任何人都知道会发生什么事吗？

我正在尝试获取单个文件对象,并按指定的块大小将其拆分为块.在我的示例中,尝试将单个文件拆分为1MB块.所以我想出它需要多少块,然后我试图从'offset'开始切片文件(当前块我在*块大小上),并切掉一个块大小.我的第一个切片正确地以1MB出现,但随后的切片变为0,任何想法为什么？在这里有一个工作的codepen:

http://codepen.io/ngalluzzo/pen/VvpYKz?editors=001[1]

var file = $('#uploadFile')[0].files[0];
  var chunkSize = 1024 * 1024;
  var fileSize = file.size;
  var chunks = Math.ceil(file.size/chunkSize,chunkSize);
  var chunk = 0;

  console.log('file size..',fileSize);
  console.log('chunks...',chunks);

  while (chunk <= chunks) {
      var offset = chunk*chunkSize;
      console.log('current chunk..', chunk);
      console.log('offset...', chunk*chunkSize);
      console.log('file blob from offset...', offset)
      console.log(file.slice(offset,chunkSize));
      chunk++;
  }