O sensor que enche a memória

De onde veio a pergunta

O painel de vibração do Neon grava 199 amostras por segundo. Parece pouco até você deixar rodando: uma noite de máquina são 6,7 milhões de amostras — 9 horas e 21 minutos de gravação. Em float64, o padrão de quem só abre o arquivo e não pensa, isso são 51,1 MB na memória. Salvo em CSV, 127 MB em disco.

A pergunta que eu quis responder medindo, não achando: até onde dá pra encolher esse sinal sem mudar o que o diagnóstico diz? Porque economizar memória é fácil; o difícil é economizar sem trocar o defeito do motor.

Todo o código abaixo roda de ponta a ponta num notebook — no Google Colab ele roda sem instalar nada. O próprio notebook gera o sinal, então não depende de arquivo meu nenhum.

Em português claro, antes das contas

Se as palavras abaixo forem novas pra você, leia esta parte primeiro. O resto do estudo fica fácil depois dela.

• amostraCada anotação que o sensor faz do quanto a máquina está tremendo. São 199 por segundo. É como filmar: quanto mais quadros por segundo, mais detalhe — e mais pesado o arquivo fica.
• formato do númeroO tamanho da caixa onde cada anotação é guardada. É a diferença entre escrever 2,4718634 kg e 2,47 kg: pra pesar fruta na feira, as casas extras não mudam nada — só gastam papel.
• espectro e picoO espectro separa a vibração por frequência, como as barrinhas de um equalizador de som mostram grave e agudo. O pico é a barra mais alta: o ritmo em que a máquina mais treme.
• RMSUm número só que resume o quanto ela treme no total — a média geral do boletim. É por ele que a norma diz se está dentro do limite.
• aliasingQuando faltam amostras, o computador enxerga um movimento que não existe. É a roda do carro que parece girar pra trás no cinema: a câmera não pegou quadros suficientes, e o olho monta uma mentira.

Com isso na mão, o estudo inteiro cabe em três frases: trocar o formato do número é de graça e economiza 75%; jogar amostra fora é traiçoeiro, porque troca o defeito do motor e o número de conferência não acusa; e um minuto de gravação responde o mesmo que nove horas quando o que você quer é achar a frequência.

O campo de testes

Um sinal que imita o que o acelerômetro vê num motor de 3600 RPM (60 voltas por segundo, ou seja, pico em 60 Hz), com dois harmônicos, um defeito fraco de rolamento em 91 Hz — de propósito, bem no limite de aparecer — e o chiado do próprio sensor:

import numpy as np

fs, N = 199.0, 6_700_000          # 199 amostras por segundo, 9,35 horas
t = np.arange(N, dtype=np.float64) / fs
rng = np.random.default_rng(42)   # pra você medir os MESMOS números

x = (0.55*np.sin(2*np.pi*60.0*t)   # a rotação: 3600 RPM
   + 0.20*np.sin(2*np.pi*20.0*t)   # uma frequência baixa da estrutura
   + 0.08*np.sin(2*np.pi*80.0*t)   # um harmônico
   + 0.004*np.sin(2*np.pi*91.0*t)  # o defeito FRACO de rolamento
   + rng.normal(0, 0.02, N))       # o chiado do sensor

E a "máquina de diagnosticar", que é o que a gente compara em cada teste: o pico do espectro (em que frequência a máquina vibra mais), o RMS (o quanto ela vibra, que é o número que a ISO 10816 usa) e a altura do defeito fraco:

def diagnostica(sinal, fs):
    y = np.asarray(sinal, dtype=np.float64)
    esp = np.abs(np.fft.rfft(y - y.mean()))
    f = np.fft.rfftfreq(len(y), 1/fs)
    janela = (f > 90) & (f < 92)
    return f[esp.argmax()], np.sqrt(np.mean(y**2)), esp[janela].max()/len(y)*2

Teste 1 — trocar o formato do número

Mesmo sinal, guardado de quatro jeitos. O int16 é o formato cru, do jeito que o conversor do sensor entrega: a faixa de ±2 g repartida em 65.536 degraus.

Por que o int16 não estraga: o degrau dele é 0,000061 g, quase cinquenta vezes menor que o ruído do próprio sensor parado, que no painel do Neon mede 0,00294 g. Guardar mais casas decimais do que o ruído do sensor é guardar chiado com precisão de laboratório.

Teste 2 — o atalho que parece esperto

Aqui mora o motivo deste estudo existir. A economia mais óbvia do mundo é pegar uma amostra a cada duas: metade do arquivo, metade da memória, e "o sinal continua lá".

pico, rms, defeito = diagnostica(x[::2], fs/2)   # 1 amostra a cada 2

O nome disso é aliasing, e a conta é simples: quando você fica com fs' = 99,5 amostras por segundo, tudo que passa de fs'/2 é rebatido pra baixo, em |f − fs'|. Daí 99,5 − 60 = 39,5 Hz. Com 1 a cada 3, 66,33 − 60 = 6,33 Hz.

Regra prática que sai daí: você só pode jogar amostra fora se a taxa que sobrar for mais que o dobro da maior frequência que te interessa. Pra enxergar 91 Hz, nada abaixo de 182 amostras por segundo — ou seja, com 199 não sobra folga nenhuma.

Teste 3 — de quanto tempo o diagnóstico precisa?

Se o problema é a memória, talvez o erro seja carregar a noite inteira. Medi o mesmo diagnóstico em pedaços cada vez maiores do sinal:

O que melhora com mais tempo é a resolução: com 10 segundos, cada raia do espectro vale 0,1 Hz; com 10 minutos, 0,002 Hz. Isso importa quando você precisa separar duas frequências quase coladas — não pra achar um pico que está sozinho.

Teste 4 — o que o pandas cobra, e o que você paga sem ver

Eu esperava encontrar um "imposto do pandas". Medi: um DataFrame com a mesma coluna float32 gastou 132 bytes a mais que o array puro do numpy. Nada.

O que pesa mesmo é o que você decide guardar. Guardar a coluna de tempo junto do sinal dobra a memória, de 25,56 para 51,12 MB — e essa coluna não precisa existir: ela se recria com uma conta, porque as amostras são igualmente espaçadas.

t = np.arange(len(sinal)) / fs   # o tempo se recria; não precisa ser guardado

E, para somar sem carregar tudo, o velho truque dos lotes: acumulei a soma dos quadrados em 67 lotes de 100 mil amostras. O RMS deu 0,418152 g, exatamente o mesmo do sinal inteiro — diferença de 0,00. A memória passa a depender do lote, não do arquivo.

E em disco

O CSV custa dez vezes o arquivo binário em int16 — porque ele guarda cada número como texto, com vírgula, sinal e quebra de linha. Pra guardar sinal de sensor, o CSV é o formato mais caro que existe.

O que eu levo deste estudo

• medir primeiroEu apostei que o float16 ia estragar o defeito fraco. Não estragou. A medição derrubou o meu palpite — e esse foi o melhor resultado do dia.
• trocar o tipo é de graça75% de economia sem custo nenhum no diagnóstico. É a primeira coisa a fazer.
• jogar amostra fora, nuncaEconomiza igual e troca o defeito. E o RMS, que é onde a gente confere, continua bonito.
• a janela certaUm minuto responde a mesma coisa que nove horas, com 0,2% da memória.
• o que não se guardaColuna de tempo de sinal igualmente espaçado é memória jogada fora.

Vale pra qualquer sinal de sensor: vibração, corrente, temperatura, pressão. Antes de pedir uma máquina maior na nuvem, é isto que eu faço — e, nos meus testes, o arquivo da noite inteira virou um problema de 0,09 MB.