Compactando dados de ponto flutuante

Existem ferramentas projetadas especificamente para compactar dados científicos de ponto flutuante?

Se uma função é suave, obviamente há muita correlação entre os números que representam essa função; portanto, os dados devem ser compactados bem. Compactar / compactar dados binários de ponto flutuante não o compacta tão bem. Gostaria de saber se existe um método desenvolvido especificamente para compactar dados de ponto flutuante.

Requisitos:

• Compactação sem perdas ou a possibilidade de especificar um número mínimo de dígitos a serem retidos (para alguns aplicativos, doublepode ser mais do que o necessário, enquanto floatpode não ter precisão suficiente).

• Ferramenta de trabalho bem testada (ou seja, não apenas um artigo descrevendo um método teórico).

• Adequado para compactar dados numéricos 1D (como séries temporais)

• Plataforma cruzada (deve funcionar no Windows)

• Ele deve ser rápido - de preferência não muito mais lento que o gzip. Descobri que, se eu tiver os números armazenados como ASCII, compactar o arquivo com zíper poderá acelerar a leitura e o processamento (pois a operação pode estar vinculada à E / S).

Gostaria especialmente de ouvir pessoas que realmente usaram essa ferramenta.

Experimente o Blosc . Em muitos casos, é mais rápido que o memcopy . Pense nisso por um segundo. . . perverso.

É super estável, altamente testado, multiplataforma e funciona como um campeão.

Consegui bons resultados usando o HDF5 e seu filtro GZIP.

O HDF5 também fornece um filtro SZIP que alcança melhores resultados para alguns conjuntos de dados cientificos.

Na minha experiência, a escolha de compressões depende muito do tipo de dados e o benchmarking é provavelmente a única maneira de fazer uma boa escolha.

Os filtros de terceiros para HDF5 incluem BLOSC, BZIP2, LZO, LZF, MAFISC.

$[-1,1]$

Dependendo da função subjacente, você poderá ajustar os dados a um formulário funcional sem erros, exigindo menos coeficientes para descrever o formulário funcional do que o ponto de dados (levando à compactação). Existem resultados de erro para alguns desses métodos, embora eu não saiba se algum deles fornecerá limites ou estimativas a priori (ou a posteriori ) sobre o erro.

Você também pode procurar métodos desenvolvidos especificamente para a compactação de números de ponto flutuante, como o FPC e algoritmos relacionados. Veja os artigos aqui , aqui , aqui , aqui e aqui , juntamente com uma página da web que contém o código-fonte antigo aqui .

O HDF5 pode usar um algoritmo de "reprodução aleatória", em que os bytes para N números de ponto flutuante são reorganizados, de modo que os primeiros bytes dos N números sejam os primeiros, depois o segundo e assim por diante. Isso produz melhores taxas de compactação após a aplicação do gzip, pois é mais provável que produza seqüências mais longas do mesmo valor. Veja aqui alguns benchmarks .

SZ (desenvolvido por Argonne em 2016) pode ser uma boa escolha.

SZ: Compressor de dados rápido de ponto flutuante com limite de erro para aplicações científicas https://collab.cels.anl.gov/display/ESR/SZ

Métodos possíveis, que podem ser usados ​​para compactação de ponto flutuante:

• Transponha 4xN para float e 8xN para double + lz77
  Implementação: Compactação de ponto flutuante no TurboTranspose
  veja também compactação com perdas limitada por erro

• Preditor (ex. Método de Contexto Finito) + codificação (ex. "Compactação inteira").
  Implementação: Compactação de ponto flutuante no TurboPFor
  incluindo compactação especial para séries temporais.

• quando possível, converta todos os números de ponto flutuante em números inteiros (ex. 1,63 -> 163) e use a compactação inteira

• Você pode testar todos esses métodos com seus dados usando a ferramenta icapp para linux e windows.

Temos usado o ZFP com HDF5 para nossos dados de imagens médicas. É feito para compactação de ponto flutuante com perdas.

Estamos executando literalmente tudo e temos mais de 40 TB de dados armazenados (e sendo usados!). É rápido o suficiente para salvar nossos dados em tempo real, e podemos especificar a precisão necessária; portanto, enquanto o formato é com perdas, não vemos diferenças em nossos resultados finais.

Se uma função é suave, obviamente há muita correlação entre os números que representam essa função; portanto, os dados devem ser compactados bem.

Talvez o formato que você precisa precise armazenar apenas as compensações de valor para valor vizinho.

Como alternativa, talvez você possa fazer uso do domínio da frequência, talvez até mesmo salvar esses valores como um arquivo de áudio sem perdas, como "flac lossless", pois você precisa de algumas das mesmas propriedades para um som.

No entanto, vou adotar uma abordagem diferente para tentar responder à pergunta que, espero, possa ser de alguma ajuda. Como o que você está dizendo é também que o tamanho mínimo da descrição para representar esses dados é menor do que fornecer todos os pontos de dados.

https://en.wikipedia.org/wiki/Minimum_description_length

Efetivamente, um programa, código de computador, é um bom exemplo. E se você não se importa que algo seja principalmente dados funcionando executando e também sendo código, você pode compactar seus valores de ponto flutuante em algo como uma função ou fórmula.

Fazer isso de maneira particularmente bem automática e com uma quantidade realista de computação está além do difícil. No entanto, a Wolfram Language fornece algumas funcionalidades para tentar isso:

https://reference.wolfram.com/language/ref/FindSequenceFunction.html https://reference.wolfram.com/language/ref/FindGeneratingFunction.html https://reference.wolfram.com/language/ref/FindFormula. html

https://reference.wolfram.com/language/ref/RSolve.html

Por que não salvar apenas float32 / float16? Num entorpecido,

A.astype( np.float32 )  # 100M: 200 msec imac
A.astype( np.float16 )  # 100M: 700 msec

Isso não funcionará se você estiver simulando o efeito Borboleta na teoria do caos, mas eles são compreensíveis, portáteis, "não exigem nenhum trabalho da minha parte". E a compressão 2: 1/4: 1 sobre float64 é difícil de bater :)

Notas:

"O tipo de matriz float16 não é suportado em np.linalg"; você precisará expandi-lo para 32 ou 64 depois de lê-lo.

Para ver como os parâmetros de ponto flutuante diferem,

import numpy as np
for f in [np.float64, np.float32, np.float16]:
    print np.finfo(f)

Para uma plotagem de um caso de teste trivial comparando float 64 32 e 16, veja aqui .