Neste guia, veremos primeiro a abordagem e depois preveremos o AVC de cada pessoa, analisando os dados passo a passo.
Regressão Logística
A regressão logística, também chamada de “Modelo Logit”, é usada na análise preditiva para problemas de classificação. Este é um modelo de Machine Learning que trabalha apenas na classificação para classificar as classes (categorias). Por exemplo, existem duas categorias em nosso cenário (uma pessoa que sofre um AVC e uma pessoa que não sofre um AVC). As melhores aplicações do modelo são previsão de doenças cardíacas, previsão de gênero, previsão de vida útil da colheita, etc.
Passos:
1. Coleta de Dados: Os dados são necessários para realizar qualquer previsão/análise. Pode ser no formato CSV/XLSX, entre outros. Podemos carregá-lo no ambiente Spark (DataFrame) usando o método spark.read.csv().
2. Análise de dados : A análise dos atributos/colunas é conhecida como “análise de dados”. As colunas que ajudam a prever a classe são conhecidas como “atributos independentes”. A coluna que resulta na predição é conhecida como “atributo dependente ou alvo”. Neste cenário, podemos usar a propriedade de colunas para exibir todas as colunas. O método distinto() é usado para ver os valores únicos.
3. Pré-processamento de dados: Filtrar os valores nulos/ausentes é conhecido como “pré-processamento”. Removemos todos os valores ausentes nesta etapa. A máquina só conhece a linguagem binária. Portanto, todas as categorias de sequência devem ser convertidas em valores categóricos numéricos. No PySpark, podemos usar o “StringIndexer”, que é a classe disponível no módulo pyspark.ml.feature para converter as categorias de string em numéricas. Ele os converte automaticamente internamente. Não precisamos fornecer os valores. Você pode usar a seguinte sintaxe:
indexer_data=StringIndexer(inputCol= 'String_Category_ColumnName' ,outputCol= 'New_Column_name' )
4. Montagem de vetores: Agora, você tem os dados que a máquina pode entender. Nesta etapa, todos os atributos independentes devem ser vetorizados em uma única coluna. Isso pode ser feito usando a classe VectorAssembler. Leva dois parâmetros: O primeiro parâmetro é o inputCols que leva uma lista de atributos independentes. O segundo parâmetro é o outputCol que vetoriza todos os inputCols nesta variável.
assembler=VectorAssembler(inputCols=[colunas…],outputCol=vectorized_data)5. Transformação: Agora, prepare seus dados transformando as colunas atualizadas (Etapa 3) usando a função transform().
assembler.transform(inxed_data)
6. Preparando os dados para treinamento e teste: Nesta etapa, dividimos os dados em “treinamento” e “teste”. Será melhor se dividirmos os dados de 70% para treinar o modelo e os dados de 30% para testar o modelo. Isso pode ser feito usando o método randomSplit(). É preciso uma lista que contém dois valores flutuantes: um para divisão de teste e outro para divisão de trem.
train_data,test_data=final_data.select([ 'características' ,target_column]).randomSplit([0.70.0.30])7. Adequação e avaliação do modelo : É hora de ajustar o modelo de Regressão Logística. O modelo Logistic Regression está disponível no módulo pyspark.ml.classification. Leva o rótulo da classe/coluna de destino. Isso resulta em rawPrediction, probabilidade e colunas de previsão. Nossos resultados são armazenados na coluna de previsão.
# Adaptação do modelologistic_regression_model=LogisticRegression(labelCol=target_column).fit(train_data)
# Avaliação do modelo
train_results=logistic_regression_model.evaluate(train_data).predictions
8. Precisão e resultados: Este é o estágio final em que testamos a precisão do modelo usando qualquer técnica de teste.
Vejamos o seguinte projeto onde prevemos se uma pessoa é afetada por AVC ou não usando o modelo de Regressão Logística.
Previsão de AVC
9. Instale o módulo PySpark em seu ambiente. O seguinte é o comando para instalar:
pip instalar pyspark
10. Vamos criar um PySpark DataFrame com 10 registros relacionados aos detalhes do AVC de 10 pessoas. Para demonstração, criamos um DataFrame sem CSV. Existem 7 colunas neste DataFrame. “Gender”, “Glucose_level”, “married”, “age”, “heart_disease”, “hyper_tension” são atributos independentes e “Stroke” é o rótulo da classe ou atributo dependente. Isso significa que o derrame de uma pessoa depende desses atributos independentes.
importar pysparkde pyspark.sql importar SparkSession
linuxhint_spark_app = SparkSession.builder.appName( 'Dica do Linux' ).getOrCreate()
stoke_data =[
{ 'Gênero' : 'Fêmea' , 'idade' : cinquenta , 'doença cardíaca' : 'Sim' ,
'hipertensão' : 'Sim' , 'casado' : 'Sim' , 'Glucose_level' : 130 , 'AVC' : 1 },
{ 'Gênero' : 'Macho' , 'idade' : vinte , 'doença cardíaca' : 'Não' ,
'hipertensão' : 'Sim' , 'casado' : 'Não' , 'Glucose_level' : 97 , 'AVC' : 0 },
{ 'Gênero' : 'Macho' , 'idade' : 12 , 'doença cardíaca' : 'Não' ,
'hipertensão' : 'Não' , 'casado' : 'Não' , 'Glucose_level' : 98 , 'AVC' : 0 },
{ 'Gênero' : 'Fêmea' , 'idade' : 90 , 'doença cardíaca' : 'Não' ,
'hipertensão' : 'Não' , 'casado' : 'Sim' , 'Glucose_level' : 170 , 'AVC' : 1 },
{ 'Gênero' : 'Macho' , 'idade' : 43 , 'doença cardíaca' : 'Sim' ,
'hipertensão' : 'Sim' , 'casado' : 'Sim' , 'Glucose_level' : 150 , 'AVC' : 1 },
{ 'Gênero' : 'Fêmea' , 'idade' : vinte e um , 'doença cardíaca' : 'Não' ,
'hipertensão' : 'Não' , 'casado' : 'Sim' , 'Glucose_level' : 110 , 'AVC' : 0 },
{ 'Gênero' : 'Fêmea' , 'idade' : cinquenta , 'doença cardíaca' : 'Sim' ,
'hipertensão' : 'Não' , 'casado' : 'Sim' , 'Glucose_level' : 100 , 'AVC' : 0 },
{ 'Gênero' : 'Macho' , 'idade' : 3. 4 , 'doença cardíaca' : 'Não' ,
'hipertensão' : 'Sim' , 'casado' : 'Sim' , 'Glucose_level' : 190 , 'AVC' : 1 },
{ 'Gênero' : 'Macho' , 'idade' : 10 , 'doença cardíaca' : 'Não' ,
'hipertensão' : 'Não' , 'casado' : 'Não' , 'Glucose_level' : 90 , 'AVC' : 0 },
{ 'Gênero' : 'Fêmea' , 'idade' : 56 , 'doença cardíaca' : 'Sim' ,
'hipertensão' : 'Sim' , 'casado' : 'Sim' , 'Glucose_level' : 145 , 'AVC' : 1 }
]
# cria o dataframe a partir dos dados acima
stroke_df = linuxhint_spark_app.createDataFrame(stoke_data)
# Stoke_df real
stroke_df.show()
Saída:
11. Exiba as colunas independentes usando o método select().
# Exibir atributos independentesstroke_df.select(stroke_df[ 'Gênero' ],stroke_df[ 'Glucose_level' ],stroke_df[ 'casado' ],stroke_df[ 'idade' ],stroke_df[ 'doença cardíaca' ],stroke_df[ 'hipertensão' ]).mostrar()
Saída:
12. Exiba os valores exclusivos que estão presentes no atributo de destino (Stroke).
# valores exclusivos do atributo de destinostroke_df.select(stroke_df[ 'AVC' ]).distinct().show()
Saída:
13. Retorne o tipo de dados de todas as colunas usando a função printSchema().
# Retorna o tipo de dados de todas as colunas.stroke_df.printSchema()
Saída:
Podemos ver que 4 colunas são do tipo string. Vamos convertê-los em valores numéricos categóricos.
14. Vamos converter os valores categóricos da string em valores categóricos numéricos usando o StringIndexer nas colunas 'Gender', 'heart_disease', 'hyper_tension' e 'married' e gravá-los nas colunas Categotical_Gender, Categotical_heart_disease, Categotical_hyper_tension e Categotical_married. Armazene as colunas no DataFrame indexed_data usando o método fit().
de pyspark.ml.feature importar StringIndexer# Converta valores categóricos de string em valores categóricos numéricos na coluna 'Sexo'.
indexer_data=StringIndexer(inputCol= 'Gênero' ,outputCol= 'Categotical_Gender' )
indexed_data=indexer_data.fit(stroke_df).transform(stroke_df)
# Converta valores categóricos de string em valores categóricos numéricos na coluna 'heart_disease'.
indexer_data=StringIndexer(inputCol= 'doença cardíaca' ,outputCol= 'Categotical_heart_disease' )
indexed_data=indexer_data.fit(indexed_data).transform(indexed_data)
# Converta valores categóricos de string em valores categóricos numéricos na coluna 'hyper_tension'.
indexer_data=StringIndexer(inputCol= 'hipertensão' ,outputCol= 'Categotical_hyper_tension' )
indexed_data=indexer_data.fit(indexed_data).transform(indexed_data)
# Converta valores categóricos de string em valores categóricos numéricos na coluna 'casado'.
indexer_data=StringIndexer(inputCol= 'casado' ,outputCol= 'Categotical_casado' )
indexed_data=indexer_data.fit(indexed_data).transform(indexed_data)
# Mostra a atualização
indexed_data.show()
Saída:
15. Converta as colunas independentes em um vetor usando o montador de vetores. O nome do vetor é 'recursos'.
de pyspark.ml.feature import VectorAssemblerassembler= VectorAssembler(inputCols=[ 'Categotical_Gender' , 'Categotical_heart_disease' , 'Categotical_hyper_tension' , 'Categotical_casado' , 'idade' ,
'Glucose_level' ],outputCol= 'características' )
16. Transforme os dados anteriores em um DataFrame final usando a função transform() e exiba-os usando a função show().
Saída:
17. Prepare os dados para treinamento e teste dividindo-os em 70-30. Os “features” são armazenados em train_data e “Stroke” são armazenados em test_data.
# Preparar dados para treinamento e testetrain_data,test_data=final.select([ 'características' , 'AVC' ]).randomSplit([ 0,70 , 0,30 ])
18. Ajuste o modelo de Regressão Logística e avalie-o.
from pyspark.ml.classification import LogisticRegression# Adaptação do modelo
logistic_regression_model=LogisticRegression(labelCol= 'AVC' ).fit(train_data)
# Avaliação do modelo
train_results=logistic_regression_model.evaluate(train_data).predictions
train_results.show()
Saída:
19. Use o BinaryClassificationEvaluator para verificar a precisão do modelo. Podemos ver que nosso modelo é 100% preciso.
de pyspark.ml.evaluation import BinaryClassificationEvaluator# chame o BinaryClassificationEvaluator
resultados = BinaryClassificationEvaluator(rawPredictionCol= 'predição' ,labelCol= 'AVC' )
ROC_AUC = resultados.evaluate(train_results)
imprimir(ROC_AUC * 100 , '% Precisão' )
Conclusão
Você pode prever o problema de classificação de blocos reais usando o modelo de regressão logística no PySpark. A remoção dos valores nulos/ausentes é importante, pois diminui a avaliação e a precisão do modelo. O pré-processamento é uma etapa necessária antes de ajustar qualquer modelo de aprendizado de máquina. Certifique-se de executar esta etapa corretamente e com precisão.