No contexto da regressão, um outlier é um ponto de dados que é diferente do comportamento geral dos demais pontos de dados. Existem vários modelos de regressão, e a detecção de outliers na regressão também depende do modelo de regressão. Na Biblioteca de Análise Preditiva (PAL) do SAP HANA, temos um procedimento chamado _SYS_AFL.PAL_OUTLIER_DETECTION_FOR_REGRESSION para detectar outliers em conjuntos de dados de regressão. No hana-ml, temos a função correspondente hana_ml.algorithms.pal.preprocessing.OutlierDetectionRegression. Você pode encontrar mais detalhes sobre o procedimento em Detecção de Outliers para Regressão | Portal de Ajuda SAP e Documentação do hana-ml 2.23.2401217. Também incorporamos a detecção de outliers de regressão no AutoML do PAL. Para mais detalhes sobre a detecção de outliers de regressão no AutoML, você pode encontrá-los em AutoML | Portal de Ajuda SAP e Otimização | Portal de Ajuda SAP. Em breve também incorporaremos a detecção de outliers de regressão no AutomaticRegression do hana-ml.
Neste post do blog, você aprenderá:
- como detectar outliers de regressão no hana-ml
- como usar a detecção de outliers de regressão no AutoML do PAL
Para facilitar a leitura e mostrar os resultados, chamamos os procedimentos do hana-ml e do PAL no Jupyter Notebook. Para chamar os procedimentos e plotar os resultados, precisamos de algumas funções. Colocamos as funções no Apêndice.
Na regressão, os outliers podem ter muitas causas, como erros de medição, anomalias experimentais e variação natural. Na análise de regressão, os outliers podem ter um grande impacto no modelo e nos parâmetros de regressão, afetando os resultados da previsão.
A detecção de outliers de regressão é dependente do modelo. No procedimento de detecção de outliers de regressão, dois modelos de regressão comumente usados são incluídos. Eles são o modelo linear baseado em MLR e o modelo de árvore baseado em HGBT. No AutoML, todos os regressores atuais suportam a detecção de outliers. Eles são EXP_Regressor, GEO_Regressor, GLM_Regressor, HGBT_Regressor, LOG_Regressor, MLP_Regressor, MLP_M_TASK_Regressor, MLR_Regressor, POL_Regressor, RDT_Regressor, DT_Regressor e SVM_Regressor. Para mais informações sobre os regressores, consulte o Operador Pipeline | Portal de Ajuda SAP.
Introdução
Na função hana-ml hana_ml.algorithms.pal.preprocessing.OutlierDetectionRegression, incluímos dois modelos de regressão comumente usados, o modelo linear baseado em Regressão Linear Múltipla (MLR) e o modelo de árvore baseado em Árvore de Impulso Híbrida (HGBT). O procedimento de detecção de outliers é dividido em duas etapas. Na etapa 1, obtemos o resíduo dos dados originais e do modelo selecionado. Na etapa 2, detectamos os outliers a partir do resíduo. Especificamente, calculamos o escore de outlier de cada ponto de dados a partir do resíduo e comparamos o escore com o limite na etapa 2. Para o modelo linear, o escore de outlier é o resíduo studentizado excluído. Para o modelo de árvore, o escore de outlier é o z-score do resíduo.
Na saída deste procedimento, temos uma tabela de resultados e uma tabela de estatísticas. Na tabela de resultados, o resíduo, o escore de outlier e o rótulo de outlier estão incluídos. Na tabela de estatísticas, algumas informações sobre o método de detecção de outliers estão incluídas.
Casos de Teste
Para demonstrar as características dos modelos de regressão e exibir melhor os gráficos, escolhemos dados bidimensionais nos casos de teste. Para chamar o procedimento do PAL com python, precisamos importar alguns pacotes python.
Caso 1: modelo linear
Dados
Os dados são sobre o gasto médio semanal com tabaco (x, em libras britânicas) e o gasto médio semanal com álcool (y, em libras britânicas) para famílias em n = 11 diferentes regiões do Reino Unido. Os dados são provenientes de pesquisas regulares do governo britânico sobre gastos familiares em 1981. Você pode encontrar os dados em O dados são os seguintes.
df = pd.read_csv(‘seu caminho e arquivo’, sep = "\t")
dfVamos adicionar a coluna ID e manter a característica e o alvo para a regressão.
X = np.array(df["Tabaco"])
y = np.array(df["Álcool"])
df_com_id = pd.DataFrame("ID":list(range(len(df))), "Tabaco":X, "Álcool":y)
plt.scatter(X, y)
plt.grid()Detecção de outliers
Chamamos a função hana-ml hana_ml.algorithms.pal.preprocessing.OutlierDetectionRegression para detectar outliers. Usamos o modelo linear para fazer a detecção de outliers neste caso. O código python e os resultados são os seguintes.
df_hana = create_dataframe_from_pandas(connection_context=cc, pandas_df=df_com_id, table_name="DADOS", force=True, replace=True)
tsreg = OutlierDetectionRegression(regression_model="linear")
res = tsreg.fit_predict(data=df_hana, key=’ID’, label="Álcool")
res.collect()stats = tsreg.get_model_metrics()
stats.collect()plot_resultado_outlier(res.collect(), X)
Podemos ver que o outlier é detectado corretamente pelo modelo linear.
Caso 2: modelo de árvore
Dados
Os dados são sobre a relação entre as notas dos alunos e o tempo de estudo deles. Você pode encontrar os dados em Também há uma característica chamada número de cursos no conjunto de dados. No entanto, para plotar o alvo e a característica em um plano bidimensional, eliminamos essa característica na análise de outliers de regressão. Os dados são os seguintes.
file="seu caminho e arquivo"
df = pd.read_csv(file)
dfVamos eliminar a coluna "número de cursos" e plotar os dados.
y = np.array(df["Notas"])
X = np.array(df["tempo_estudo"])
num = len(y)
ID = np.arange(num)
df_com_id = pd.DataFrame("ID":ID, "tempo_estudo": X, "Notas": y)
plt.scatter(X, y)
plt.grid()Detecção de outliers com o modelo linear
Chamamos a função hana-ml hana_ml.algorithms.pal.preprocessing.OutlierDetectionRegression para detectar outliers. Vamos também usar o modelo linear para fazer a detecção de outliers neste caso. O código python e os resultados são os seguintes.
df_hana = create_dataframe_from_pandas(connection_context=cc, pandas_df=df_com_id, table_name="DADOS", force=True, replace=True)
tsreg = OutlierDetectionRegression(regression_model="linear")
res = tsreg.fit_predict(data=df_hana, key=’ID’, label="Notas")
res.collect()stats = tsreg.get_model_metrics()
stats.collect()plot_resultado_outlier(res.collect(), X)
Podemos ver que não há outliers detectados pelo modelo linear. Este resultado é razoável a partir do gráfico dos dados. No entanto, podemos observar que os resíduos são bastante grandes e não seguem uma distribuição gaussiana. Parece que a relação entre o resíduo e a característica é aproximadamente quadrática. Isso mostra que o modelo linear não é adequado para este conjunto de dados.
detecção de outliers com modelo de árvore
Agora vamos nos voltar para o modelo de árvore.
tsreg = OutlierDetectionRegression(regression_model="tree")
res = tsreg.fit_predict(data=df_hana, key=’ID’, label="Marks")
res.collect()stats = tsreg.get_model_metrics()
stats.collect()Não há outliers detectados pelo modelo de árvore e isso é razoável. Os resíduos são muito menores do que no modelo linear e são mais consistentes com a distribuição gaussiana do que no modelo linear. Este conjunto de dados é adequado para análise usando o modelo de árvore.
dados com um outlier adicionado
Agora colocamos um outlier no conjunto de dados.
y = np.array(df["Marks"])
X = np.array(df["time_study"])
X = np.append(X, 6)
y = np.append(y, 48)
num = len(y)
ID = np.arange(num)
df_with_id = pd.DataFrame("ID":ID, "time_study": X, "Marks": y)
plt.scatter(X, y)
plt.grid()detecção de outliers com modelo de árvore
Vamos usar o modelo de árvore para detectar outliers neste caso.
df_hana = create_dataframe_from_pandas(connection_context=cc, pandas_df=df_with_id, table_name="DATA", force=True, replace=True)
tsreg = OutlierDetectionRegression(regression_model="tree")
res = tsreg.fit_predict(data=df_hana, key=’ID’, label="Marks")
res.collect()stats = tsreg.get_model_metrics()
stats.collect()A partir dos resultados acima, podemos ver que o outlier é detectado corretamente pelo modelo de árvore.
Para conjuntos de dados adequados para regressão linear, podemos usar o modelo linear para detectar outliers. No entanto, se o conjunto de dados não seguir a regressão linear, precisamos usar o modelo de árvore ou fazer algumas transformações nos dados para que sigam a regressão linear e, em seguida, usar o modelo linear.
Introdução
Também incorporamos a detecção de outliers de regressão no AutoML. É muito fácil usar a detecção de outliers de regressão no AutoML. Quando PIPELINE_TYPE é definido como regressor no AutoML, só precisamos definir o parâmetro REGRESSION_OUTLIER como 1 e chamar o procedimento PAL _SYS_AFL.PAL_AUTOML_FIT. Na parte seguinte desta seção, vou apresentar como a detecção de outliers de regressão funciona no AutoML.
No AutoML, obteremos o melhor pipeline a partir do resultado da validação cruzada. Quando PIPELINE_TYPE é definido como regressor, podemos realizar a sintonia de outliers de regressão no melhor pipeline. O processo de como a detecção de outliers de regressão funciona é mostrado abaixo.
O processo de ajuste de outliers de regressão recém-adicionado está no quadrado vermelho. No processo de ajuste de outliers de regressão, começaremos com o melhor pipeline (referido como BP) gerado na etapa anterior. A partir do BP, criaremos um conjunto de pipelines, denotado como Pset = i = 1, 2, …, N. A única diferença entre os pipelines em Pset e BP são os parâmetros do regressor. Cada pipeline em Pset aplicará a detecção de outliers de regressão e a eliminação antes de realizar a regressão. O método específico para detecção de outliers dependerá do tipo de regressor usado.
Para a geração de Pset, vamos considerar um exemplo. Suponha que definimos o parâmetro REGRESSION_OUTLIER_PIPELINE_NUM como 4 e REGRESSION_OUTLIER_THRESHOLDS como [3,4,5] (valor padrão), e BP é o seguinte:
{"HGBT_Regressor":{"args":"ITER_NUM":100,"OBJ_FUNC":2,"ETA":0.5,"MAX_DEPTH":9,"MIN_CHILD_HESSIAN":6.0,"inputs":"data:"SCALE":"args":"NEW_MAX":3.0,"NEW_MIN":1.0,"SCALING_METHOD":0 ,"inputs":"data":"ROWDATA"}}
Pset pode consistir nos quatro pipelines a seguir.
{"HGBT_Regressor":{"args":"ITER_NUM":100,"OBJ_FUNC":2,"ETA":0.5,"MAX_DEPTH":9,"MIN_CHILD_HESSIAN":6.0,"REGRESSION_OUTLIER":1,"REGRESSION_OUTLIER_THRESHOLD":3.0,"inputs":"data:"SCALE":"args":"NEW_MAX":3.0,"NEW_MIN":1.0,"SCALING_METHOD":0 ,"inputs":"data":"ROWDATA"}}
{"HGBT_Regressor":{"args":"ITER_NUM":100,"OBJ_FUNC":2,"ETA":0.5,"MAX_DEPTH":9,"MIN_CHILD_HESSIAN":6.0,"REGRESSION_OUTLIER":1,"REGRESSION_OUTLIER_THRESHOLD":4.0,"inputs":"data:"SCALE":"args":"NEW_MAX":3.0,"NEW_MIN":1.0,"SCALING_METHOD":0 ,"inputs":"data":"ROWDATA"}}
{"HGBT_Regressor":{"args":"ITER_NUM":100,"OBJ_FUNC":2,"ETA":0.5,"MAX_DEPTH":9,"MIN_CHILD_HESSIAN":6.0,"REGRESSION_OUTLIER":1,"REGRESSION_OUTLIER_THRESHOLD":5.0,"inputs":"data:"SCALE":"args":"NEW_MAX":3.0,"NEW_MIN":1.0,"SCALING_METHOD":0 ,"inputs":"data":"ROWDATA"}}
{"HGBT_Regressor":{"args":"ITER_NUM":100,"OBJ_FUNC":2,"ETA":0.5,"MAX_DEPTH":11,"MIN_CHILD_HESSIAN":4.0,"REGRESSION_OUTLIER":1,"REGRESSION_OUTLIER_THRESHOLD":4.0,"inputs":"data:"SCALE":"args":"NEW_MAX":3.0,"NEW_MIN":1.0,"SCALING_METHOD":0 ,"inputs":"data":"ROWDATA"}}
Os três primeiros pipelines apenas adicionam os parâmetros REGRESSION_OUTLIER e REGRESSION_OUTLIER_THRESHOLD ao BP, e esses pipelines sempre serão gerados. No último pipeline de Pset, além de adicionar os dois parâmetros REGRESSION_OUTLIER e REGRESSION_OUTLIER_THRESHOLD, outros parâmetros do regressor HGBT também foram modificados. Esses parâmetros adicionais são ajustados aleatoriamente. Neste exemplo, usaremos o método HGBT para detecção de outliers porque o regressor utilizado é HGBT.
A validação cruzada em pipelines com detecção de outliers é mostrada abaixo.
Após a divisão da validação cruzada (CV), detectaremos e eliminaremos outliers nos dados de treinamento da CV e, em seguida, realizaremos o procedimento de treinamento e teste e, finalmente, calcularemos as pontuações de validação cruzada. Para lidar com os outliers nos dados de treinamento da CV, basta eliminar os pontos outlier. Os outliers também podem estar nos dados de teste da CV. Considerando que os outliers podem impactar significativamente certas métricas, ajustamos as medidas de pontuação da validação cruzada EVAR, MAE, MSE, RMSE, R2, MAPE e WMAPE nesta etapa para mitigar a influência dos outliers. As métricas ajustadas correspondentes são denominadas EVAROUTLIER, MAEOUTLIER, MSEOUTLIER, RMSEOUTLIER, R2OUTLIER, MAPEOUTLIER e WMAPEOUTLIER, respectivamente. As pontuações ajustadas também são calculadas para BP no resultado de sintonia de outliers de regressão. Vamos usar MAE como exemplo. Vamos eliminar alguns dos resíduos absolutos mais pequenos e maiores. O procedimento é o seguinte.
A barra é a classificação dos resíduos absolutos de teste na CV. Na segunda barra, eliminamos a parte cinza e mantemos a parte azul. Em mais detalhes, eliminamos M pontos de dados de teste com os maiores resíduos absolutos e M pontos de dados de teste com os menores resíduos absolutos, onde M é no máximo 5% dos dados de teste. Supondo que os resíduos sejam x = xi, calculamos i = 1,2,…,N, onde si = 0.67449×|xi|/mediana(|x|). Este é o escore MAD com mediana zero. Eliminamos os pontos com si > 5 e um número equivalente de pontos com o menor si. Após soltar esses pontos, calculamos a medida ajustada MAEDROP, e MAEOUTLIER é definida como 0,5 × (MAE + MAEDROP). Outras medidas são ajustadas da mesma forma.
Para a comparação no processo de ajuste de outliers de regressão, se um pipeline com detecção de outliers de regressão superar BP em todas as medidas especificadas por SCORINGS, e for igual ou melhor que os outros pipelines, será considerado o melhor pipeline para esta etapa. Se nenhum pipeline em Pset superar BP em todas as medidas de acordo com SCORINGS, BP permanecerá como o melhor pipeline para esta etapa. Os pipelines restantes são então classificados usando um método de classificação multiobjetivo.
Na Tabela de Pipelines, os pipelines de saída da etapa anterior permanecem e são controlados pelo parâmetro ELITE_NUMBER. Os pipelines de saída do processo de ajuste de outliers de regressão também são incluídos na Tabela de Pipelines e são controlados pelo parâmetro REGRESSION_OUTLIER_TUNE_ELITE_NUMBER. Se o melhor pipeline desta etapa incluir a detecção de outliers, ele é colocado no topo da Tabela de Pipelines. Caso contrário, o melhor pipeline da etapa anterior é colocado no topo. Além disso, os IDs dos pipelines desta etapa são exibidos na Tabela de Estatísticas.
Casos de Teste
Nesta parte, vou apresentar dois casos de teste. Em um caso, o melhor pipeline final é sem detecção de outliers. No outro caso, o melhor pipeline final é com detecção de outliers. Nos casos de teste, vou usar o conjunto de dados Resistência à Compressão do Concreto. É sobre a relação entre a resistência à compressão do concreto e algumas variáveis, como água e idade. Você pode encontrá-lo em
Caso 1: O melhor pipeline final é sem detecção de outliers.
Dados
Os dados são de. Também adiciono uma coluna de ID no conjunto de dados.
file="seu caminho e nome do arquivo"
df_com_id = pd.read_csv(file)
df_com_idA coluna alvo é "Resistência à compressão do concreto".
Para fazer o ajuste e a previsão do AutoML, vamos dividir os dados em parte de treinamento e parte de teste com a função hana-ml algorithms.pal.partition.train_test_val_split. A parte de treinamento é para o ajuste do AutoML e a produção do modelo. A parte de teste é para testar a previsão do modelo. Também selecionamos a coluna alvo e produzimos os valores alvo da parte de teste.Ajuste do AutoML
Nesta parte, ajustaremos os dados de treinamento com o AutoML e obteremos um modelo.
fit_parameters =
"REGRESSION_OUTLIER": 1,
"THREAD_RATIO": 1.0,
"PIPELINE_TYPE":’regressor’,
"DEPENDENT_VARIABLE":alvo,
"RANDOM_SEED": 123,
"GENERATIONS": 1000,
"POPULATION_SIZE": 20,
"CONFIG_DICT":json.dumps(config_dict),
"ELITE_NUMBER": 5,
"REGRESSION_OUTLIER_PIPELINE_NUM": 4,
"REGRESSION_OUTLIER_TUNE_ELITE_NUMBER": 5,pipeline_table_pd, model_table_pd, stats_table_pd = AutoML_fit(df_treino, fit_parameters, cc)
stats_table_pd
Da tabela de estatísticas, podemos ver que os IDs dos pipelines de ajuste de outliers de regressão são 5, 6, 7, 8, 9. Isso mostra que o melhor pipeline é sem detecção de outliers. Vamos imprimir a tabela de pipelines.
print_pipeline_table(pipeline_table_pd)
Os pipelines com ID = 0,1,2,3,4 são do processo original. Em outras palavras, se tomarmos o parâmetro REGRESSION_OUTLIER como 0 (valor padrão), obteremos e somente obteremos os pipelines acima com ID = 0,1,2,3,4. Para os pipelines com ID = 5,6,7,8,9, eles são do processo de ajuste de outliers. Para o pipeline com ID = 5, é o mesmo que o pipeline com ID = 0. Porque é o antigo melhor pipeline, o levamos para comparar com os pipelines com detecção de outliers. Portanto, há "EVAROUTLIER" e "MAEOUTLIER" nas pontuações de ID = 5,6,7,8,9. Essas duas medidas são medidas ajustadas de EVAR e MAE, e são as pontuações para o processo de ajuste de outliers. Como nenhum pipeline com detecção de outliers supera o antigo melhor pipeline (ID = 5) em ambos "EVAROUTLIER" e "MAEOUTLIER", o melhor pipeline final ainda é o antigo melhor pipeline. Portanto, colocamos os pipelines de saída do processo original na frente do processo de ajuste de outliers. Embora os pipelines com ID = 0 e ID = 5 sejam os mesmos, as pontuações podem ser diferentes, porque seus dados de treinamento e teste de validação cruzada podem ser diferentes. Os pipelines no processo de ajuste de outliers compartilham os mesmos dados de treinamento e teste de validação cruzada.
Previsão do modelo AutoML
Vamos ver os erros de previsão do modelo do melhor pipeline.
test_parameters =
test_result_table_pd, test_stats_table_pd = AutoML_predict(df_test_X, test_parameters, model_table_pd, cc)
pred = produce_predict(test_result_table_pd, key = "ID")
mae = mae_fun(y_test, pred)
ever = evar_fun(y_test, pred)
print("mae = , evar = ".format(mae, ever))mae = 3.131938162929128, evar = 0.9244784555351252
Previsão do pipeline com detecção de outliers
Vamos ver a previsão do pipeline com ID = 6, que é o melhor pipeline com detecção de outliers. Vamos obter o modelo ajustando o pipeline e depois prever com o modelo.
pipe_parameters =
"DEPENDENT_VARIABLE":alvo,
"PIPELINE":json.dumps(pipe),model_table_pipe, stats_table_pipe = Pipeline_fit(df_treino, pipe_parameters, cc)
test_result_table_pipe, test_stats_table_pipe = AutoML_predict(df_test_X, test_parameters, model_table_pipe, cc)
pred_pipe = produce_predict(test_result_table_pipe, key = "ID")
mae_pipe = mae_fun(y_test, pred_pipe)
ever_pipe = evar_fun(y_test, pred_pipe)
print("mae_pipe = , ever_pipe = ".format(mae_pipe, ever_pipe))mae_pipe = 3.0678810742472957, ever_pipe = 0.9212280312761948
Podemos ver que os erros de teste não são os mesmos do modelo AutoML. Isso ocorre porque alguns outliers são detectados pelo pipeline com detecção de outliers. Os resultados do pipeline com detecção de outliers são comparáveis com o modelo AutoML. Tanto o MAE quanto o EVER são um pouco menores do que os resultados do modelo AutoML. Para o MAE, menor é melhor, enquanto para o EVAR o oposto é verdadeiro.
Caso 2: O melhor pipeline final é com detecção de outliers.
Neste caso de teste, incluímos alguns outliers nos dados de treinamento df_train do caso de teste 1.
y = np.array(df_with_id["Força compressiva do concreto"])
y_std = np.std(y)
np.random.seed(234)
outlier_idxes = np.random.randint(0, len(df_train), size=8)
outlier_amplitude = 3
for idx in outlier_idxes:
df_train["Força compressiva do concreto"][idx] = df_train["Força compressiva do concreto"][idx] + (-1)*idx outlier_amplitude * y_std
df_trainAjuste do AutoML
Nesta parte, ajustaremos os novos dados de treinamento com o AutoML e obteremos um modelo.
fit_parameters =
"REGRESSION_OUTLIER": 1,
"THREAD_RATIO": 1.0,
"PIPELINE_TYPE":’regressor’,
"DEPENDENT_VARIABLE":target,
"RANDOM_SEED": 123,
"GENERATIONS": 1000,
"POPULATION_SIZE": 20,
"CONFIG_DICT":json.dumps(config_dict),
"ELITE_NUMBER": 5,
"REGRESSION_OUTLIER_PIPELINE_NUM": 4,
"REGRESSION_OUTLIER_TUNE_ELITE_NUMBER": 5,pipeline_table_pd, model_table_pd, stats_table_pd = AutoML_fit(df_train, fit_parameters, cc)
stats_table_pd
Da tabela de estatísticas, podemos ver que os IDs dos pipelines de ajuste de outliers para regressão são 0,1,2,3,4. Isso mostra que o melhor pipeline é com detecção de outliers. Vamos imprimir a tabela de pipeline.
print_pipeline_table(pipeline_table_pd)
Ao contrário do caso de teste 1, os pipelines com ID = 0,1,2,3,4 são do processo de ajuste de outliers. O pipeline com ID = 0 é com detecção de outliers e o pipeline com ID = 2 é o antigo melhor pipeline. O pipeline com ID = 0 supera o pipeline com ID = 1 tanto em "EVAROUTLIER" quanto em "MAEOUTLIER", e iguala ou supera os outros pipelines no processo de ajuste de outliers.
Previsão do modelo AutoML
Vamos ver os erros de previsão do modelo do melhor pipeline.
test_parameters =
test_result_table_pd, test_stats_table_pd = AutoML_predict(df_test_X, test_parameters, model_table_pd, cc)
pred = produce_predict(test_result_table_pd, key = "ID")
mae = mae_fun(y_test, pred)
ever = evar_fun(y_test, pred)
print("mae = , evar = ".format(mae, ever))mae = 2.9165821766760427, evar = 0.9275281312643902
Previsão do antigo melhor pipeline
Vamos ver a previsão do pipeline com ID = 5, que é o melhor pipeline do processo original. Vamos obter o modelo ajustando o pipeline e depois prever com o modelo.
pipe = {"HGBT_Regressor":{"args":"SEED":2024,"ITER_NUM":100,"OBJ_FUNC":2,"ETA":0.5,"MAX_DEPTH":8,"MIN_CHILD_HESSIAN":4.0,"inputs":"data":"SCALE":"args":"SCALING_METHOD":2,"inputs":"data":"ROWDATA"}}
pipe_parameters =
"DEPENDENT_VARIABLE":target,
"PIPELINE":json.dumps(pipe),model_table_pipe, stats_table_pipe = Pipeline_fit(df_train, pipe_parameters, cc)
test_result_table_pipe, test_stats_table_pipe = AutoML_predict(df_test_X, test_parameters, model_table_pipe, cc)
pred_pipe = produce_predict(test_result_table_pipe, key = "ID")
mae_pipe = mae_fun(y_test, pred_pipe)
ever_pipe = evar_fun(y_test, pred_pipe)
print("mae_pipe = , ever_pipe = ".format(mae_pipe, ever_pipe))mae_pipe = 2.968404778787287, ever_pipe = 0.9250418298900762
Podemos ver que mae_pipe é maior que mae e ever_pipe é menor que ever no caso de teste 2. A detecção de outliers e a exclusão melhoram a previsão neste caso.
Neste post do blog, explicamos o que é um outlier na regressão e fornecemos um procedimento PAL e sua função correspondente hana-ml para detectar outliers em dados de regressão. O procedimento é baseado em dois modelos, o modelo linear baseado em MLR e o modelo de árvore baseado em HGBT. Também incorporamos a detecção de outliers de regressão no AutoML, o que pode ajudar a melhorar a previsão de regressão quando há alguns outliers nos dados de entrada do AutoML. Espero que você goste de ler este blog!
A detecção de outliers de regressão já está incluída no hana-ml. A incorporação da detecção de outliers de regressão no AutoML também será incluída no hana-ml. Se você quiser aprender mais sobre este tópico na Biblioteca de Análise Preditiva (PAL) SAP HANA e hana-ml, consulte os seguintes links:
OutlierDetectionRegression — hana-ml 2.23.2401217 documentação
Deteção de Outliers para Regressão | Portal de Ajuda SAP
AutoML | Portal de Ajuda SAP
Otimização | Portal de Ajuda SAP
[1]: "Resistência à Compressão do Concreto" por I-Cheng Yeh está licenciado sob CC BY 4.0.
Conexão SAP HANA
import hana_ml
from hana_ml import dataframe
conn = dataframe.ConnectionContext('host', 'porta', 'nome de usuário', 'senha')Funções para Plotagem de Resultados de Deteção de Outliers de Regressão
def outlier_result_plot(dResults, X):
dResults.sort_values(by = list(dResults)[0], inplace = True, ascending = True)
raw_data = np.array(dResults['TARGET'])
residual = np.array(dResults['RESIDUAL'])
outlier_score = np.array(dResults['OUTLIER_SCORE'])
is_outlier = np.array(dResults['IS_OUTLIER'])
plt.figure(figsize = (24,4.5))
plt.subplot(1,4,1)
plt.scatter(X, raw_data)
plt.grid()
plt.xlabel("X")
plt.title('TARGET')
plt.subplot(1,4,2)
plt.scatter(X, residual)
plt.grid()
plt.xlabel("X")
plt.title('RESIDUAL')
plt.subplot(1,4,3)
plt.scatter(X, outlier_score)
plt.grid()
plt.xlabel("X")
plt.title('OUTLIER_SCORE')
plt.subplot(1,4,4)
plt.scatter(X, is_outlier)
plt.grid()
plt.xlabel("X")
plt.title('IS_OUTLIER')def outlier_plot(dResults, X):
dResults.sort_values(by = list(dResults)[0], inplace = True, ascending = True)
raw_data = np.array(dResults['TARGET'])
is_outlier = np.array(dResults['IS_OUTLIER'])
outlier_idx = np.array([],dtype = int)
for i in range(len(is_outlier)):
if is_outlier[i] == 1:
outlier_idx = np.append(outlier_idx,i)
plt.figure()
plt.scatter(X, raw_data)
plt.scatter(X[outlier_idx],raw_data[outlier_idx],color="red")
plt.grid()
plt.title("dados de regressão e outlier")Funções para Deteção de Outliers de Regressão no AutoML
Funções para Tabela
def createEmptyTable(table_name, proto, cc):
with cc.connection.cursor() as cur:
try:
joint = []
for key in proto:
joint.append(" ".join(['":s"'.format(key), proto[key]]))
cur.execute('CREATE COLUMN TABLE %s (%s);' %
(table_name, ",".join(joint)))
except:
print(
f"CREATE TABLE table_name foi mal sucedido. Talvez a tabela já exista.")def dropTable(table_name, cc):
with cc.connection.cursor() as cur:
try:
cur.execute(f"DROP TABLE table_name")
except:
print(f"DROP TABLE table_name foi mal sucedido. Por favor, reescreva em português brasileiro. rewrite in Brazilian Portuguese"Olá, como você está hoje?"
"Oi, tudo bem?"
"Sim, estou bem, obrigado. Como posso te ajudar?"
"Estou procurando informações sobre os eventos desta semana."
"Claro, posso te ajudar com isso. Qual evento você está interessado?"
"Estou interessado no festival de música que vai acontecer no sábado."
"Ah, sim! Eu posso te fornecer mais detalhes sobre o festival de música. Ele vai acontecer no parque da cidade e terá diversas bandas se apresentando. Você gostaria de saber mais alguma coisa?"
"Não, isso já me ajudou bastante. Obrigado pela ajuda!"
"De nada, estou aqui para ajudar. Se precisar de mais alguma informação, é só me chamar."
"Muito obrigado, tenha um bom dia!" I am going to the beach tomorrow. Reescreva em português brasileiro: rewrite in Brazilian Portuguese
reformular em português brasileiro