Usando dados de séries temporais de um sensor para ML

Eu tenho os seguintes dados para um pequeno projeto paralelo. É de um acelerômetro sentado em cima de uma lavadora / secadora e eu gostaria que ele me dissesse quando a máquina terminasse.

x são os dados de entrada (movimento x / y / z como um valor), y é o rótulo ativado / desativado

Como os valores de x se sobrepõem para y = 1 e y = 0, eu estava pensando em usar x e uma janela rolante de 3 minutos como entradas para um SVM:

xyz60=res.xyz.resample("60S").max()
X["x"]=xyz60
X["max3"]=xyz60.rolling(window=3, min_periods=1).max()

Essa é uma boa abordagem para esse tipo de problema? Existem alternativas que podem produzir melhores resultados?

Você tem dados de séries temporais que são usados ​​para medir a aceleração. Você deve identificar quando a máquina está em seu estado nominal (DESLIGADO) e estado anômalo (LIGADO). Esse problema seria melhor resolvido usando algoritmos de detecção de anomalias. Mas existem muitas maneiras de abordar esse problema.

Preparando seus dados

Todos os métodos dependerão do método de extração de recurso que você selecionar. Supondo que continuemos a usar a janela de tempo de 3 amostras, conforme sugerido. Neste algoritmo, você calculará uma estatística para esse estado nominal$y = 0$. Sugiro a média, como suponho que você já esteja fazendo, calcule a média das três acelerações resultantes da amostra. Você ficará com um grande número de valores em um conjunto de treinamento$S$ definido como

$S = \{s_0, s_1, ..., s_n \}$

Onde $s$ é a média das amostras de árvore em uma janela. $s$ é definido como

$s_i = \frac{1}{3} \sum_{k=i-2}^{i} x_k$

Onde $x$ é a sua amostra de observações e $i\geq2$.

Em seguida, colete mais dados, se possível, com a máquina ativa, de modo que $y = 1$.

Agora você pode escolher se deseja treinar seu algoritmo em um conjunto de dados de uma classe (detecção pura de anomlay). Um conjunto de dados tendencioso (detecção de anomalias) ou um conjunto de dados bem equilibrado. O saldo do conjunto de dados é a proporção entre as duas classes no seu conjunto de dados. Um conjunto de dados perfeito para um classificador de 2 classes seria 1: 1. 50% dos dados pertencentes a cada classe. Você parece ter um conjunto de dados tendencioso, supondo que não queira desperdiçar muita eletricidade.

Observe que nada impede que você mantenha as amostras vizinhas divididas como uma instância em seu conjunto de dados. Por exemplo:

$x_i$ $x_{i-1}$ $x_{i-2}$ | $y_i$

Isso criaria um espaço de entrada tridimensional para uma saída específica, definida para a amostra coletada atualmente.

Um conjunto de dados tendencioso

Solução Fácil

A maneira mais fácil que eu sugeriria. Suponha que você esteja usando uma única estatística para definir o que está acontecendo na janela de 3 amostras. A partir dos dados coletados, obtenha o máximo$s$ dos seus pontos nominais ($y=0$) e o mínimo $s$ dos seus pontos anômalos ($y=1$) Então pegue a marca intermediária entre esses dois e use-a como seu limite.

Se uma nova amostra de teste $\hat{s}$ for maior que o limite, atribua $y=1$.

Você pode estender isso calculando a média $s$ para todas as suas amostras nominais $y=0$. Em seguida, calcule a média para suas amostras anômalas$y=1$. Se uma nova amostra se aproximar da média das amostras anômalas, classifique-a como$y=1$.

Mas eu quero ser chique!

Existem várias outras técnicas que você pode usar para executar esta tarefa exata.

• k-vizinhos mais próximos
• Redes neurais
• Regressão linear
• SVM

Simplificando, quase todos os algoritmos de aprendizado de máquina são adequados para essa finalidade. Depende apenas da quantidade de dados disponíveis e de sua distribuição.

Eu realmente quero usar SVM

Nesse caso, mantenha as três amostras completamente separadas. Sua matriz de treinamento terá 3 colunas, conforme discutido acima. E então você terá suas saídas$y$. Usar o SVM em python é muito fácil: http://scikit-learn.org/stable/modules/svm.html .

from sklearn import svm

X = [[0, 0, 0], [1, 1, 1], ..., [1, 0, 1]] 
y = [0, 1, ..., 1]
clf = svm.SVC()
clf.fit(X, y)  

Isso treina seu modelo. Então você desejará prever o resultado para uma nova amostra.

clf.predict([[2., 2., 1]])