Mirrors/hacktricks
2
0
Fork 0
mirror of https://github.com/carlospolop/hacktricks synced 2024-12-01 00:49:40 +00:00
Code Issues Projects Releases Packages Wiki Activity
hacktricks/a.i.-exploiting/bra.i.nsmasher-presentation/ml-basics/feature-engineering.md

18 KiB
Raw Blame History

Aprenda hacking AWS do zero ao herói com htARTE (HackTricks AWS Red Team Expert)!

Outras maneiras de apoiar o HackTricks:

Tipos básicos de dados possíveis

Os dados podem ser contínuos (valores infinitos) ou categóricos (nominais) onde a quantidade de valores possíveis é limitada.

Tipos Categóricos

Binário

Apenas 2 valores possíveis: 1 ou 0. No caso de um conjunto de dados em que os valores estão em formato de string (por exemplo, "Verdadeiro" e "Falso"), você atribui números a esses valores com:

dataset["column2"] = dataset.column2.map({"T": 1, "F": 0})

Ordinal

Os valores seguem uma ordem, como em: 1º lugar, 2º lugar... Se as categorias são strings (como: "iniciante", "amador", "profissional", "especialista") você pode mapeá-las para números como vimos no caso binário.

column2_mapping = {'starter':0,'amateur':1,'professional':2,'expert':3}
dataset['column2'] = dataset.column2.map(column2_mapping)
  • Para colunas alfabéticas você pode ordená-las mais facilmente:
# First get all the uniq values alphabetically sorted
possible_values_sorted = dataset.column2.sort_values().unique().tolist()
# Assign each one a value
possible_values_mapping = {value:idx for idx,value in enumerate(possible_values_sorted)}
dataset['column2'] = dataset.column2.map(possible_values_mapping)

Cíclico

Parece um valor ordinal porque há uma ordem, mas isso não significa que um seja maior que o outro. Além disso, a distância entre eles depende da direção que você está contando. Exemplo: Os dias da semana, domingo não é "maior" que segunda-feira.

  • Existem diferentes maneiras de codificar características cíclicas, algumas podem funcionar apenas com alguns algoritmos. Em geral, a codificação dummy pode ser usada.
column2_dummies = pd.get_dummies(dataset.column2, drop_first=True)
dataset_joined = pd.concat([dataset[['column2']], column2_dummies], axis=1)

Datas

Datas são variáveis contínuas. Podem ser vistas como cíclicas (porque se repetem) ou como variáveis ordinais (porque um tempo é maior que outro anterior).

  • Geralmente as datas são usadas como índice
# Transform dates to datetime
dataset["column_date"] = pd.to_datetime(dataset.column_date)
# Make the date feature the index
dataset.set_index('column_date', inplace=True)
print(dataset.head())

# Sum usage column per day
daily_sum = dataset.groupby(df_daily_usage.index.date).agg({'usage':['sum']})
# Flatten and rename usage column
daily_sum.columns = daily_sum.columns.get_level_values(0)
daily_sum.columns = ['daily_usage']
print(daily_sum.head())

# Fill days with 0 usage
idx = pd.date_range('2020-01-01', '2020-12-31')
daily_sum.index = pd.DatetimeIndex(daily_sum.index)
df_filled = daily_sum.reindex(idx, fill_value=0) # Fill missing values


# Get day of the week, Monday=0, Sunday=6, and week days names
dataset['DoW'] = dataset.transaction_date.dt.dayofweek
# do the same in a different way
dataset['weekday'] = dataset.transaction_date.dt.weekday
# get day names
dataset['day_name'] = dataset.transaction_date.apply(lambda x: x.day_name())

Multi-categoria/nominal

Mais de 2 categorias sem ordem relacionada. Use dataset.describe(include='all') para obter informações sobre as categorias de cada recurso.

  • Uma string de referência é uma coluna que identifica um exemplo (como o nome de uma pessoa). Isso pode ser duplicado (porque 2 pessoas podem ter o mesmo nome), mas a maioria será única. Esses dados são inúteis e devem ser removidos.
  • Uma coluna chave é usada para vincular dados entre tabelas. Neste caso, os elementos são únicos. Esses dados são inúteis e devem ser removidos.

Para codificar colunas de múltiplas categorias em números (para que o algoritmo de ML as entenda), é usada a codificação dummy (e não a codificação one-hot porque não evita a multicolinearidade perfeita).

Você pode obter uma coluna de múltiplas categorias codificada one-hot com pd.get_dummies(dataset.column1). Isso transformará todas as classes em recursos binários, criando uma nova coluna para cada classe possível e atribuirá 1 valor verdadeiro a uma coluna, e o restante será falso.

Você pode obter uma coluna de múltiplas categorias codificada dummy com pd.get_dummies(dataset.column1, drop_first=True). Isso transformará todas as classes em recursos binários, criando uma nova coluna para cada classe possível menos uma, pois as últimas 2 colunas refletirão "1" ou "0" na última coluna binária criada. Isso evitará a multicolinearidade perfeita, reduzindo as relações entre as colunas.

Colinear/Multicolinearidade

Colinear aparece quando 2 recursos estão relacionados entre si. Multicolinearidade aparece quando há mais de 2.

No ML, você deseja que seus recursos estejam relacionados com os resultados possíveis, mas não deseja que estejam relacionados entre si. Por isso, a codificação dummy mistura as duas últimas colunas disso e é melhor do que a codificação one-hot, que não faz isso, criando uma relação clara entre todos os novos recursos da coluna de múltiplas categorias.

VIF é o Fator de Inflação da Variância que mede a multicolinearidade dos recursos. Um valor acima de 5 significa que um dos dois ou mais recursos colineares deve ser removido.

from statsmodels.stats.outliers_influence import variance_inflation_factor
from statsmodels.tools.tools import add_constant

#dummies_encoded = pd.get_dummies(dataset.column1, drop_first=True)
onehot_encoded = pd.get_dummies(dataset.column1)
X = add_constant(onehot_encoded) # Add previously one-hot encoded data
print(pd.Series([variance_inflation_factor(X.values,i) for i in range(X.shape[1])], index=X.columns))

Desequilíbrio Categórico

Isso ocorre quando não há a mesma quantidade de cada categoria nos dados de treinamento.

# Get statistic of the features
print(dataset.describe(include='all'))
# Get an overview of the features
print(dataset.info())
# Get imbalance information of the target column
print(dataset.target_column.value_counts())

Em um desequilíbrio, sempre há uma classe ou classes majoritárias e uma classe ou classes minoritárias.

Existem 2 maneiras principais de resolver esse problema:

  • Undersampling: Remover dados selecionados aleatoriamente da classe majoritária para que ela tenha o mesmo número de amostras que a classe minoritária.
from imblearn.under_sampling import RandomUnderSampler
rus = RandomUserSampler(random_state=1337)

X = dataset[['column1', 'column2', 'column3']].copy()
y = dataset.target_column

X_under, y_under = rus.fit_resample(X,y)
print(y_under.value_counts()) #Confirm data isn't imbalanced anymore
  • Oversampling: Gerar mais dados para a classe minoritária até que ela tenha tantas amostras quanto a classe majoritária.
from imblearn.under_sampling import RandomOverSampler
ros = RandomOverSampler(random_state=1337)

X = dataset[['column1', 'column2', 'column3']].copy()
y = dataset.target_column

X_over, y_over = ros.fit_resample(X,y)
print(y_over.value_counts()) #Confirm data isn't imbalanced anymore

Pode usar o argumento sampling_strategy para indicar a porcentagem que deseja subamostrar ou sobreamostrar (por padrão é 1 (100%) o que significa igualar o número de classes minoritárias com as classes majoritárias)

{% hint style="info" %} A subamostragem ou sobreamostragem não são perfeitas, se você obter estatísticas (com .describe()) dos dados sobreamostrados/subamostrados e compará-los com os originais, verá que eles mudaram. Portanto, a sobreamostragem e subamostragem estão modificando os dados de treinamento. {% endhint %}

Sobreamostragem SMOTE

SMOTE é geralmente uma maneira mais confiável de sobreamostrar os dados.

from imblearn.over_sampling import SMOTE

# Form SMOTE the target_column need to be numeric, map it if necessary
smote = SMOTE(random_state=1337)
X_smote, y_smote = smote.fit_resample(dataset[['column1', 'column2', 'column3']], dataset.target_column)
dataset_smote = pd.DataFrame(X_smote, columns=['column1', 'column2', 'column3'])
dataset['target_column'] = y_smote
print(y_smote.value_counts()) #Confirm data isn't imbalanced anymore

Categorias Raramente Ocorrentes

Imagine um conjunto de dados onde uma das classes alvo ocorre muito poucas vezes.

Isso é semelhante ao desequilíbrio de categorias da seção anterior, mas a categoria raramente ocorrente ocorre ainda menos do que a "classe minoritária" nesse caso. Os métodos de sobreamostragem e subamostragem brutos também podem ser usados aqui, mas geralmente essas técnicas não fornecerão resultados realmente bons.

Pesos

Em alguns algoritmos, é possível modificar os pesos dos dados alvo para que alguns deles tenham por padrão mais importância ao gerar o modelo.

weights = {0: 10 1:1} #Assign weight 10 to False and 1 to True
model = LogisticRegression(class_weight=weights)

Pode misturar os pesos com técnicas de oversampling/undersampling para tentar melhorar os resultados.

PCA - Análise de Componentes Principais

É um método que ajuda a reduzir a dimensionalidade dos dados. Vai combinar diferentes características para reduzir a quantidade delas gerando características mais úteis (é necessária menos computação).

As características resultantes não são compreensíveis por humanos, então também anonimiza os dados.

Categorias de Rótulos Incongruentes

Os dados podem ter erros devido a transformações mal sucedidas ou apenas por erro humano ao escrever os dados.

Portanto, você pode encontrar o mesmo rótulo com erros de digitação, diferentes maiúsculas, abreviações como: AZUL, Azul, a, azul. Você precisa corrigir esses erros de rótulo nos dados antes de treinar o modelo.

Você pode resolver esses problemas colocando tudo em minúsculas e mapeando rótulos com erros de digitação para os corretos.

É muito importante verificar se todos os dados que você possui estão corretamente rotulados, porque, por exemplo, um erro de digitação nos dados, ao codificar as classes, irá gerar uma nova coluna nas características finais com consequências ruins para o modelo final. Esse exemplo pode ser detectado facilmente codificando um atributo e verificando os nomes das colunas criadas.

Dados Ausentes

Alguns dados do estudo podem estar faltando.

Pode acontecer que alguns dados completos estejam faltando por algum erro. Esse tipo de dado é Completamente Ausente de Forma Aleatória (MCAR).

Pode ser que alguns dados aleatórios estejam faltando, mas algo está tornando alguns detalhes específicos mais prováveis de estar faltando, por exemplo, os homens frequentemente informam sua idade, mas não as mulheres. Isso é chamado de Ausente de Forma Aleatória (MAR).

Por fim, pode haver dados Não Ausentes de Forma Aleatória (MNAR). O valor dos dados está diretamente relacionado com a probabilidade de ter os dados. Por exemplo, se você quiser medir algo embaraçoso, quanto mais embaraçoso alguém for, menos provável é que ele vá compartilhar.

As duas primeiras categorias de dados ausentes podem ser ignoradas. Mas a terceira requer considerar apenas porções dos dados que não são impactadas ou tentar modelar os dados ausentes de alguma forma.

Uma maneira de descobrir sobre dados ausentes é usar a função .info() pois indicará o número de linhas, mas também o número de valores por categoria. Se alguma categoria tiver menos valores do que o número de linhas, então há dados faltando:

# Get info of the dataset
dataset.info()

# Drop all rows where some value is missing
dataset.dropna(how='any', axis=0).info()

Geralmente é recomendado que se uma característica está ausente em mais de 20% do conjunto de dados, a coluna deve ser removida:

# Remove column
dataset.drop('Column_name', axis='columns', inplace=True)
dataset.info()

{% hint style="info" %} Note que nem todos os valores ausentes estão faltando no conjunto de dados. É possível que os valores ausentes tenham sido atribuídos como "Desconhecido", "n/a", "", -1, 0... Você precisa verificar o conjunto de dados (usando conjunto_de_dados.nome_da_coluna.valor_contagens(dropna=False) para verificar os possíveis valores). {% endhint %}

Se alguns dados estiverem faltando no conjunto de dados (e não forem muitos), você precisa encontrar a categoria dos dados ausentes. Para isso, basicamente você precisa saber se os dados ausentes estão em aleatório ou não, e para isso você precisa descobrir se os dados ausentes estavam correlacionados com outros dados do conjunto de dados.

Para descobrir se um valor ausente está correlacionado com outra coluna, você pode criar uma nova coluna que coloca 1s e 0s se os dados estão faltando ou não e então calcular a correlação entre eles:

# The closer it's to 1 or -1 the more correlated the data is
# Note that columns are always perfectly correlated with themselves.
dataset[['column_name', 'cloumn_missing_data']].corr()

Se decidir ignorar os dados em falta, ainda precisa fazer o que com eles: Você pode remover as linhas com dados em falta (os dados de treino para o modelo serão menores), pode remover completamente a feature, ou pode modelá-la.

Você deve verificar a correlação entre a feature em falta com a coluna alvo para ver o quão importante essa feature é para o alvo, se for realmente pequena, você pode descartá-la ou preenchê-la.

Para preencher dados contínuos em falta, você pode usar: a média, a mediana ou usar um algoritmo de imputação. O algoritmo de imputação pode tentar usar outras features para encontrar um valor para a feature em falta:

from sklearn.impute import KNNImputer

X = dataset[['column1', 'column2', 'column3']]
y = dataset.column_target

# Create the imputer that will fill the data
imputer = KNNImputer(n_neightbors=2, weights='uniform')
X_imp = imputer.fit_transform(X)

# Check new data
dataset_imp = pd.DataFrame(X_imp)
dataset.columns = ['column1', 'column2', 'column3']
dataset.iloc[10:20] # Get some indexes that contained empty data before

Para preencher dados categóricos, primeiro você precisa pensar se há alguma razão pela qual os valores estão faltando. Se for por escolha dos usuários (eles não quiseram fornecer os dados), talvez você possa criar uma nova categoria indicando isso. Se for por erro humano, você pode remover as linhas ou a característica (verifique os passos mencionados anteriormente) ou preenchê-la com a moda, a categoria mais utilizada (não recomendado).

Combinando Características

Se você encontrar duas características que estão correlacionadas entre si, geralmente você deve descartar uma delas (a menos correlacionada com o alvo), mas também pode tentar combiná-las e criar uma nova característica.

# Create a new feautr combining feature1 and feature2
dataset['new_feature'] = dataset.column1/dataset.column2

# Check correlation with target column
dataset[['new_feature', 'column1', 'column2', 'target']].corr()['target'][:]

# Check for collinearity of the 2 features and the new one
X = add_constant(dataset[['column1', 'column2', 'target']])
# Calculate VIF
pd.Series([variance_inflation_factor(X.values, i) for i in range(X.shape[1])], index=X.columns)
Aprenda hacking AWS do zero ao herói com htARTE (HackTricks AWS Red Team Expert)!

Outras maneiras de apoiar o HackTricks: