Previsões de matemáticos. Analisamos os principais métodos para detectar anomalias

O uso da inteligência artificial na indústria para manutenção preditiva de vários sistemas está ganhando cada vez mais popularidade no exterior. O objetivo desta metodologia é identificar defeitos na operação do sistema durante a fase de operação antes de sua falha para uma resposta oportuna.

Quão relevante é essa abordagem em nosso país e no Ocidente? A conclusão pode ser feita, por exemplo, em artigos sobre Habré e no Medium. Quase não há artigos sobre Habré sobre a solução de problemas de manutenção preditiva. No Medium, há um conjunto inteiro. Aqui, aqui e aqui , está bem descrito quais são os objetivos e as vantagens dessa abordagem.

Neste artigo, você aprenderá:

  • por que essa técnica é necessária
  • quais abordagens de aprendizado de máquina são mais comumente usadas para manutenção preditiva,
  • como tentei um dos truques com um exemplo simples.

Fonte

Quais recursos o serviço preditivo fornece?

  • um processo controlado de reparos, realizado conforme necessário, economizando dinheiro e sem pressa, o que melhora a qualidade dessas obras;
  • identificação de um mau funcionamento específico na operação do equipamento (a capacidade de adquirir uma peça específica para substituição quando o equipamento estiver em operação oferece enormes vantagens);
  • otimização da operação do equipamento, cargas, etc;
  • redução de custos com parada regular de equipamentos.

O próximo artigo no Medium descreve bem as perguntas que precisam ser respondidas para entender como abordar esse problema em um caso específico.

Ao coletar dados ou ao escolher dados para construir um modelo, é importante responder a três grupos de perguntas:

  1. Todos os problemas do sistema podem ser previstos? Qual previsão é especialmente importante?
  2. O que é um processo de falha? Todo o sistema para de funcionar ou o modo operacional está apenas mudando? É um processo rápido, degradação instantânea ou gradual?
  3. O desempenho do sistema reflete adequadamente seu desempenho? Eles se relacionam com partes individuais do sistema ou com o sistema como um todo?

Também é importante entender com antecedência o que você deseja prever, o que é possível prever e o que não é.

O artigo no Medium também lista perguntas que ajudarão a determinar seu objetivo específico:

  • O que precisa ser previsto? O tempo de vida restante, comportamento anormal ou não, a probabilidade de falha nas próximas N horas / dias / semanas?
  • Existem dados históricos suficientes?
  • Sabe-se quando o sistema forneceu leituras anômalas e quando não. É possível marcar essas indicações?
  • Até que ponto o modelo deve ver? Quão independentes são as leituras que refletem a operação do sistema no intervalo de uma hora / dia / semana
  • O que você precisa otimizar? O modelo deve capturar o maior número possível de violações, ao emitir um alarme falso, ou é suficiente para capturar vários eventos sem falsos positivos.

Espera-se que a situação melhore no futuro. Até o momento, existem dificuldades no campo da manutenção preditiva: poucos exemplos de mau funcionamento do sistema ou momentos de mau funcionamento do sistema são suficientes, mas não estão marcados; o processo de falha é desconhecido.

A principal maneira de superar as dificuldades na manutenção preditiva é usar métodos de pesquisa de anomalias . Esses algoritmos não requerem marcação para treinamento. Para algoritmos de teste e depuração, a marcação de uma forma ou de outra é necessária. Tais métodos são limitados, pois não prevêem uma falha específica, mas apenas sinalizam anormalidade nos indicadores.

Mas isso já não é ruim.

Fonte

Métodos


Agora, quero falar sobre alguns recursos das abordagens de detecção de anomalias e, juntos, testaremos os recursos de alguns algoritmos simples na prática.

Embora uma situação específica exija o teste de vários algoritmos para procurar anomalias e escolher o melhor, é possível determinar algumas vantagens e desvantagens das principais técnicas usadas nesta área.

Antes de tudo, é importante entender com antecedência qual é a porcentagem de anomalias nos dados.

Se estamos falando de uma variação da abordagem semi-supervisionada (estudamos apenas dados "normais" e trabalhamos (teste) e dados com anomalias), a melhor opção é o método do vetor de suporte com uma classe ( SVM de uma classe ) . Ao usar funções de base radial como núcleo, esse algoritmo constrói uma superfície não linear em torno da origem. Quanto mais limpos os dados de treinamento, melhor eles funcionam.

Em outros casos, a necessidade de conhecer a proporção de pontos anormais e "normais" também permanece - para determinar o limite de corte.

Se o número de anomalias nos dados for superior a 5%, e elas forem bem separáveis ​​da amostra principal, poderão ser utilizados métodos padrão de busca de anomalias.

Nesse caso, o método da floresta de isolamento é o mais estável em termos de qualidade: floresta de isolamento são dados aleatórios. É provável que uma indicação mais característica seja mais profunda, enquanto indicadores incomuns serão separados do restante da amostra nas primeiras iterações.

Outros algoritmos funcionam melhor se "se ajustarem" às especificidades dos dados.

Quando os dados têm uma distribuição normal, o método do envelope elíptico é adequado, aproximando os dados com uma distribuição normal multidimensional. Quanto menos provável que o ponto pertença à distribuição, maior a probabilidade de que seja anômalo.

Se os dados são apresentados de tal maneira que a posição relativa de diferentes pontos reflete bem suas diferenças, os métodos métricos parecem ser uma boa opção: por exemplo, k vizinhos mais próximos, k-ésimo vizinho mais próximo, ABOD (detecção de discrepância de ângulo) ou LOF (fator de discrepância local) )

Todos esses métodos sugerem que os indicadores “certos” estão concentrados em uma área do espaço multidimensional. Se entre os k (ou k-és) vizinhos mais próximos tudo estiver longe do alvo, o ponto será uma anomalia. Para ABOD, o raciocínio é semelhante: se todos os k pontos mais próximos estiverem no mesmo setor de espaço em relação ao considerado, então o ponto é uma anomalia. Para LOF: se a densidade local (predeterminada para cada ponto por k vizinhos mais próximos) for menor que a de k vizinhos mais próximos, o ponto será uma anomalia.

Se os dados estiverem bem agrupados, métodos baseados na análise de cluster são uma boa opção. Se o ponto é equidistante dos centros de vários aglomerados, então é anômalo.

Se as direções da maior variação na variância são bem diferenciadas nos dados, parece ser uma boa opção procurar anomalias com base no método do componente principal . Nesse caso, os desvios do valor médio para n1 (os componentes mais "principais") e n2 (os menos "principais") são considerados como uma medida de anomalia.

Por exemplo, sugere-se examinar o conjunto de dados da Sociedade de Prognóstico e Gerenciamento de Saúde (PHM Society) . Esta organização sem fins lucrativos organiza a concorrência todos os anos. Em 2018, por exemplo, foi necessário prever erros na operação e o tempo antes da falha da planta de gravação por feixe de íons . Tomaremos o conjunto de dados para 2015 . Ele contém as leituras de vários sensores para 30 instalações (amostra de treinamento) e é necessário prever quando e qual erro ocorrerá.

Não encontrei as respostas para a amostra de teste na rede, portanto, jogaremos apenas com a de treinamento.

Em geral, todas as configurações são semelhantes, mas diferem, por exemplo, no número de componentes, no número de anomalias etc. Portanto, aprender nos 20 primeiros e testar nos outros não faz muito sentido.

Então, vamos escolher uma das instalações, carregá-la e dar uma olhada nesses dados. O artigo não será sobre engenharia de recursos , portanto, não faremos pares.

import pandas as pd import matplotlib.pyplot as plt %matplotlib inline import seaborn as sns from sklearn.covariance import EllipticEnvelope from sklearn.neighbors import LocalOutlierFactor from sklearn.ensemble import IsolationForest from sklearn.svm import OneClassSVM dfa=pd.read_csv('plant_12a.csv',names=['Component number','Time','S1','S2','S3','S4','S1ref','S2ref','S3ref','S4ref']) dfa.head(10) 


Como você pode ver, existem sete componentes para cada um dos quais existem leituras de quatro sensores que são realizados a cada 15 minutos. S1ref-S4ref na descrição da competição são listados como valores de referência, mas os valores são muito diferentes das leituras dos sensores. Para não perder tempo pensando no que eles significam, nós os removemos. Se você observar a distribuição de valores para cada característica (S1-S4), as distribuições são contínuas para S1, S2 e S4 e discretas para S3. Além disso, se você observar a distribuição conjunta de S2 e S4, elas são inversamente proporcionais.


Embora um desvio de uma dependência direta possa indicar um erro, não verificaremos isso, mas simplesmente removeremos o S4.

Mais uma vez, processamos o conjunto de dados. Deixe S1, S2 e S3. Escale S1 e S2 com StandardScaler (subtraímos a média e dividimos pelo desvio padrão), convertemos S3 em OHE (One Hot Encoding). Costuramos leituras de todos os componentes da instalação em uma linha. Total de 89 recursos. 2 * 7 = 14 - leituras S1 e S2 para 7 componentes e 75 valores únicos de R3. Apenas 56 mil dessas linhas.

Carregue o arquivo com erros.

 dfc=pd.read_csv('plant_12c.csv',names=['Start Time', 'End Time','Type']) dfc.head() 


Antes de tentar esses algoritmos em nosso conjunto de dados, vou me permitir outra pequena digressão. Você precisa ser testado. Para isso, propõe-se tomar a hora de início do erro e a hora de término. E todas as indicações dentro deste intervalo são consideradas anormais e fora do normal. Essa abordagem tem muitas desvantagens. Mas, especialmente, um comportamento anormal provavelmente ocorre antes que o erro seja corrigido. Por fidelidade, vamos mudar a janela de anomalias meia hora atrás no tempo. Avaliaremos a medida F1, precisão e recall.

Código para distinguir recursos e determinar a qualidade do modelo:

 def load_and_preprocess(plant_num):   #      ,       dfa=pd.read_csv('plant_{}a.csv'.format(plant_num),names=['Component number','Time','S1','S2','S3','S4','S1ref','S2ref','S3ref','S4ref'])   dfc=pd.read_csv('plant_{}c.csv'.format(plant_num),names=['Start Time','End Time','Type']).drop(0,axis=0)   N_comp=len(dfa['Component number'].unique())   #  15    dfa['Time']=pd.to_datetime(dfa['Time']).dt.round('15min')   #  6    (  ,    )   dfc=dfc[dfc['Type']!=6]   dfc['Start Time']=pd.to_datetime(dfc['Start Time'])   dfc['End Time']=pd.to_datetime(dfc['End Time'])   #      ,       OHE  3-    dfa=pd.concat([dfa.groupby('Time').nth(i)[['S1','S2','S3']].rename(columns={"S1":"S1_{}".format(i),"S2":"S2_{}".format(i),"S3":"S3_{}".format(i)}) for i in range(N_comp)],axis=1).dropna().reset_index()   for k in range(N_comp):       dfa=pd.concat([dfa.drop('S3_'+str(k),axis=1),pd.get_dummies(dfa['S3_'+str(k)],prefix='S3_'+str(k))],axis=1).reset_index(drop=True)   #          df_train,df_test=train_test_split(dfa,test_size=0.25,shuffle=False)   cols_to_scale=df_train.filter(regex='S[1,2]').columns   scaler=preprocessing.StandardScaler().fit(df_train[cols_to_scale])   df_train[cols_to_scale]=scaler.transform(df_train[cols_to_scale])   df_test[cols_to_scale]=scaler.transform(df_test[cols_to_scale])   return df_train,df_test,dfc #       def get_true_labels(measure_times,dfc,shift_delta):   idxSet=set()   dfc['Start Time']-=pd.Timedelta(minutes=shift_delta)   dfc['End Time']-=pd.Timedelta(minutes=shift_delta)   for idx,mes_time in tqdm_notebook(enumerate(measure_times),total=measure_times.shape[0]):       intersect=np.array(dfc['Start Time']<mes_time).astype(int)*np.array(dfc['End Time']>mes_time).astype(int)       idxs=np.where(intersect)[0]       if idxs.shape[0]:           idxSet.add(idx)   dfc['Start Time']+=pd.Timedelta(minutes=shift_delta)   dfc['End Time']+=pd.Timedelta(minutes=shift_delta)   true_labels=pd.Series(index=measure_times.index)   true_labels.iloc[list(idxSet)]=1   true_labels.fillna(0,inplace=True)   return true_labels #          def check_model(model,df_train,df_test,filt='S[123]'):   model.fit(df_train.drop('Time',axis=1).filter(regex=(filt)))   y_preds = pd.Series(model.predict(df_test.drop(['Time','Label'],axis=1).filter(regex=(filt)))).map({-1:1,1:0})   print('F1 score: {:.3f}'.format(f1_score(df_test['Label'],y_preds)))   print('Precision score: {:.3f}'.format(precision_score(df_test['Label'],y_preds)))   print('Recall score: {:.3f}'.format(recall_score(df_test['Label'],y_preds)))   score = model.decision_function(df_test.drop(['Time','Label'],axis=1).filter(regex=(filt)))   sns.distplot(score[df_test['Label']==0])   sns.distplot(score[df_test['Label']==1]) df_train,df_test,anomaly_times=load_and_preprocess(12) df_test['Label']=get_true_labels(df_test['Time'],dfc,30) 

Resultados do teste para algoritmos simples de pesquisa de anomalias no conjunto de dados do PHM 2015 Data Challenge

Voltar para os algoritmos. Vamos tentar nossos SVM de uma classe SVM (OCSVM), IsolationForest (IF), EllipticEnvelope (EE) e LocalOutlierFactor (LOF). Para começar, não definiremos nenhum parâmetro. Observo que o LOF pode funcionar em dois modos. Se novidade = Falso for capaz de procurar anomalias apenas no conjunto de treinamento (só existe fit_predict), se Verdadeiro, o objetivo é procurar anomalias fora do conjunto de treinamento (pode caber e prever separadamente). O IF possui um modo de comportamento antigo e novo. Nós usamos novo. Ele dá melhores resultados.

O OCSVM detecta bem as anomalias, mas há muitos falsos positivos. Para outros métodos, o resultado é ainda pior.

Mas suponha que sabemos a porcentagem de anomalias nos dados. No nosso caso, 27%. O OCSVM possui nu - a estimativa superior para a porcentagem de erros e a menor para a porcentagem de vetores de suporte. Outros métodos de contaminação têm uma porcentagem de erros de dados. Nos métodos IF e LOF, é determinado automaticamente, enquanto para OCSVM e EE é definido como 0,1 por padrão. Vamos tentar definir a contaminação (nu) para 0,27. Agora, o melhor resultado para EE.

Código para verificação de modelos:

 def check_model(model,df_train,df_test,filt='S[123]'):   model_type,model = model   model.fit(df_train.drop('Time',axis=1).filter(regex=(filt)))   y_preds = pd.Series(model.predict(df_test.drop(['Time','Label'],axis=1).filter(regex=(filt)))).map({-1:1,1:0})   print('F1 score for {}: {:.3f}'.format(model_type,f1_score(df_test['Label'],y_preds)))   print('Precision score for {}: {:.3f}'.format(model_type,precision_score(df_test['Label'],y_preds)))   print('Recall score for {}: {:.3f}'.format(model_type,recall_score(df_test['Label'],y_preds)))   score = model.decision_function(df_test.drop(['Time','Label'],axis=1).filter(regex=(filt)))   sns.distplot(score[df_test['Label']==0])   sns.distplot(score[df_test['Label']==1])   plt.title('Decision score distribution for {}'.format(model_type))   plt.show() 

É interessante observar a distribuição de indicadores de anomalia para diferentes métodos. Pode-se observar que o LOF não funciona bem para esses dados. O EE tem pontos que o algoritmo considera extremamente anormais. No entanto, pontos normais caem lá. O IsoFor e o OCSVM mostram que a escolha do limiar de corte (contaminação / nu) é importante, o que alterará a troca entre precisão e perfeição.


É lógico que as leituras dos sensores tenham uma distribuição próxima da normal, perto de valores estacionários. Se realmente tivermos uma amostra de teste rotulada e, de preferência, também uma de validação, o valor da contaminação poderá ser colorido. A próxima pergunta é: quais erros são mais orientados: falso positivo ou falso negativo?

O resultado do LOF é muito baixo. Não é muito impressionante. Mas lembre-se de que as variáveis ​​OHE vão para a entrada junto com as variáveis ​​transformadas pelo StandardScaler. E as distâncias padrão são euclidianas. Mas se você contar apenas as variáveis ​​de acordo com S1 e S2, a situação será corrigida e o resultado será comparável com outros métodos. É importante, no entanto, entender que um dos principais parâmetros dos classificadores de métricas listados é o número de vizinhos. Isso afeta significativamente a qualidade e deve ser ajustado. A métrica de distância em si também seria interessante de entender.

Agora tente combinar os dois modelos. No início de um, removemos as anomalias do conjunto de treinamento. E então treinaremos o OCSVM em um conjunto de treinamento "mais limpo". De acordo com os resultados anteriores, observamos a maior completude em EE. Limpamos a amostra de treinamento por meio de EE, treinamos OCSVM nele e obtemos F1 = 0,50, Precisão = 0,34, completude = 0,95. Não é impressionante. Mas nós apenas perguntamos nu = 0,27. E os dados que temos são mais ou menos "limpos". Se assumirmos que a plenitude do EE na amostra de treinamento é a mesma, 5% dos erros permanecerão. Nós estabelecemos tal nu e obtemos F1 = 0,69, Precisão = 0,59, completude = 0,82. Ótimo. É importante observar que em outros métodos essa combinação não funcionará, pois implica que o número de anomalias no conjunto de treinamento e o número do teste são os mesmos. Ao treinar esses métodos em um conjunto de dados de treinamento puro, você precisará especificar menos contaminação do que em dados reais e não próximo de zero, mas é melhor selecioná-lo para validação cruzada.

É interessante observar o resultado da pesquisa na sequência de indicações:


A figura mostra um segmento das leituras do primeiro e do segundo sensores para 7 componentes. Na legenda, a cor dos erros correspondentes (o início e o fim são mostrados por linhas verticais da mesma cor). Os pontos indicam as previsões: verde - previsões verdadeiras, vermelho - falso positivo, roxo - falso negativo. Pode-se ver pela figura que é difícil determinar visualmente o tempo de erro, e o algoritmo lida com essa tarefa muito bem. Embora seja importante entender que as leituras do terceiro sensor não são fornecidas aqui. Além disso, existem leituras de falsos positivos após o final do erro. I.e. o algoritmo vê que também há valores errados e marcamos essa área como livre de erros. O lado direito da figura mostra a área antes do erro, que marcamos como incorreta (meia hora antes do erro), que foi reconhecida como livre de erros, o que leva a erros de modelo falso-negativos. No centro da figura, uma peça coerente é reconhecida, reconhecida como um erro. A conclusão pode ser tirada da seguinte maneira: ao resolver o problema de procurar anomalias, você precisa interagir de perto com os engenheiros que entendem a essência dos sistemas cuja saída você precisa prever, pois a verificação dos algoritmos usados ​​na marcação não reflete completamente a realidade e não simula as condições nas quais esses algoritmos poderiam ser usado.

Código para plotar o gráfico:

 def plot_time_course(df_test,dfc,y_preds,start,end,vert_shift=4):   plt.figure(figsize=(15,10))   cols=df_train.filter(regex=('S[12]')).columns   add=0   preds_idx=y_preds.iloc[start:end][y_preds[0]==1].index   true_idx=df_test.iloc[start:end,:][df_test['Label']==1].index   tp_idx=set(true_idx.values).intersection(set(preds_idx.values))   fn_idx=set(true_idx.values).difference(set(preds_idx.values))   fp_idx=set(preds_idx.values).difference(set(true_idx.values))   xtime=df_test['Time'].iloc[start:end]   for col in cols:       plt.plot(xtime,df_test[col].iloc[start:end]+add)       plt.scatter(xtime.loc[tp_idx].values,df_test.loc[tp_idx,col]+add,color='green')       plt.scatter(xtime.loc[fn_idx].values,df_test.loc[fn_idx,col]+add,color='violet')       plt.scatter(xtime.loc[fp_idx].values,df_test.loc[fp_idx,col]+add,color='red')       add+=vert_shift   failures=dfc[(dfc['Start Time']>xtime.iloc[0])&(dfc['Start Time']<xtime.iloc[-1])]   unique_fails=np.sort(failures['Type'].unique())   colors=np.array([np.random.rand(3) for fail in unique_fails])   for fail_idx in failures.index:       c=colors[np.where(unique_fails==failures.loc[fail_idx,'Type'])[0]][0]       plt.axvline(failures.loc[fail_idx,'Start Time'],color=c)       plt.axvline(failures.loc[fail_idx,'End Time'],color=c)   leg=plt.legend(unique_fails)   for i in range(len(unique_fails)):       leg.legendHandles[i].set_color(colors[i]) 

Se a porcentagem de anomalias for inferior a 5% e / ou estiverem mal separadas dos indicadores "normais", os métodos acima funcionarão mal e vale a pena usar algoritmos baseados em redes neurais. No caso mais simples, seriam:

  • codificadores automáticos (um erro alto de um codificador automático treinado sinalizará uma anormalidade na leitura);
  • redes recorrentes (aprendendo por sequência para prever a última leitura. Se a diferença for grande - o ponto é anormal).

Separadamente, vale a pena observar as especificidades do trabalho com séries temporais. É importante entender que a maioria dos algoritmos acima (exceto auto-codificadores e isolamento de florestas) provavelmente fornecerá pior qualidade ao adicionar recursos de defasagem (leituras de pontos anteriores no tempo).

Vamos tentar adicionar recursos de lag no nosso exemplo. A descrição da competição diz que os valores 3 horas antes do erro não estão relacionados com o erro de forma alguma. Em seguida, adicione os sinais em 3 horas. Total de 259 sinais.

Como resultado, os resultados para o OCSVM e o IsolationForest permaneceram praticamente inalterados, enquanto os do Elliptic Envelope e LOF caíram.

Para usar informações sobre a dinâmica do sistema, auto-codificadores com redes neurais recorrentes ou convolucionais devem ser usados. Ou, por exemplo, uma combinação de codificadores automáticos, informações de compactação e abordagens convencionais para procurar anomalias com base em informações compactadas. A abordagem inversa também parece promissora. Triagem primária dos pontos mais incomuns por algoritmos padrão e, em seguida, treinando o codificador automático já em dados mais limpos.

Fonte

Há um conjunto de técnicas para trabalhar com séries temporais unidimensionais. Todos eles têm como objetivo prever leituras futuras, e os pontos que divergem da previsão são considerados anomalias.

Modelo de Holt-Winters


Suavização exponencial tripla, divide a série em 3 componentes: nível, tendência e sazonalidade. Por conseguinte, se a série for apresentada neste formulário, o método funcionará bem. O Profeta do Facebook opera com um princípio semelhante, mas avalia os próprios componentes de uma maneira diferente. Mais detalhes podem ser lidos, por exemplo, aqui .

S (ARIMA)


Nesse método, o modelo preditivo baseia-se na regressão automática e na média móvel. Se estamos falando sobre a expansão de S (ARIMA), isso nos permite avaliar a sazonalidade. Leia mais sobre a abordagem aqui , aqui e aqui .

Outras abordagens preditivas de serviço


Quando se trata de séries temporais e há informações sobre os tempos de ocorrência de erros, você pode aplicar métodos de ensino com um professor. Além da necessidade de dados marcados, neste caso, é importante entender que a previsão de erros dependerá da natureza do erro. Se houver muitos erros e de natureza diferente, provavelmente será necessário prever cada um separadamente, o que exigirá ainda mais dados rotulados, mas as perspectivas serão mais atraentes.

Existem maneiras alternativas de usar o aprendizado de máquina na manutenção preditiva. Por exemplo, prever uma falha do sistema nos próximos N dias (tarefa de classificação). É importante entender que tal abordagem exige que a ocorrência de um erro na operação do sistema seja precedida por um período de degradação (não necessariamente gradual). Nesse caso, a abordagem mais bem-sucedida parece ser o uso de redes neurais com camadas convolucionais e / ou recorrentes. Separadamente, vale a pena mencionar métodos para o aumento de séries temporais. Duas abordagens me parecem as mais interessantes e ao mesmo tempo simples:

  • a parte contínua da linha é selecionada (por exemplo, 70% e o restante é removido) e esticada até o tamanho original
  • uma porção contínua da linha (por exemplo, 20%) é selecionada e esticada ou comprimida. Depois disso, a linha inteira é compactada ou esticada de acordo com o tamanho original.

Há também uma opção para prever a vida útil restante do sistema (tarefa de regressão). Aqui podemos distinguir uma abordagem separada: a previsão não é da vida útil, mas dos parâmetros de distribuição Weibull.

Você pode ler sobre a distribuição em si aqui e aqui sobre seu uso em conjunto com malhas recorrentes. Essa distribuição possui dois parâmetros α e β. α indica quando o evento ocorrerá e β indica a confiança do algoritmo. Embora a aplicação dessa abordagem seja promissora, surgem dificuldades no treinamento da rede neural nesse caso, uma vez que é mais fácil para o algoritmo ser inseguro a princípio do que prever uma vida útil adequada.

Separadamente, vale ressaltar a regressão de Cox . Permite prever a tolerância a falhas do sistema para cada momento após o diagnóstico, apresentando-o como um produto de duas funções. Uma função é a degradação do sistema, independente de seus parâmetros, ou seja, comum a esses sistemas. E o segundo é uma dependência exponencial dos parâmetros de um sistema específico. Portanto, para uma pessoa, existe uma função comum associada ao envelhecimento, mais ou menos a mesma para todos. Mas a deterioração da saúde também está associada ao estado dos órgãos internos, que é diferente para todos.

Espero que agora você saiba um pouco mais sobre manutenção preditiva. Estou certo de que você terá perguntas sobre os métodos de aprendizado de máquina mais frequentemente usados ​​para esta tecnologia. Ficarei feliz em responder a cada um deles nos comentários. Se você está interessado em não apenas perguntar sobre o que está escrito, mas quer fazer algo semelhante, nossa equipe do CleverDATA está sempre satisfeita com profissionais talentosos e entusiasmados.

Existem vagas? Claro!

Source: https://habr.com/ru/post/pt447190/


All Articles