Kladblok-spiekbriefje voor snelle gegevensvoorverwerking

Vaak hebben mensen die het vakgebied Data Science betreden, weinig realistische verwachtingen van wat hen te wachten staat. Veel mensen denken dat ze nu coole neurale netwerken zullen schrijven, een stemassistent van Iron Man zullen creëren of iedereen op de financiële markten zullen verslaan.
Maar werk Data Wetenschappers zijn datagestuurd en een van de belangrijkste en meest tijdrovende aspecten is het verwerken van de gegevens voordat deze in een neuraal netwerk worden ingevoerd of op een bepaalde manier worden geanalyseerd.

In dit artikel beschrijft ons team hoe u met stapsgewijze instructies en code snel en eenvoudig gegevens kunt verwerken. We hebben geprobeerd de code behoorlijk flexibel te maken en voor verschillende datasets te gebruiken.

Veel professionals vinden in dit artikel misschien niets bijzonders, maar beginners zullen iets nieuws kunnen leren, en iedereen die er al lang van droomt een apart notitieboekje te maken voor snelle en gestructureerde gegevensverwerking, kan de code kopiëren en deze voor zichzelf formatteren, of download het voltooide notitieblok van Github.

Wij hebben de dataset ontvangen. Wat nu te doen?

Dus de norm: we moeten begrijpen waar we mee te maken hebben, het totaalbeeld. Om dit te doen, gebruiken we panda's om eenvoudig verschillende gegevenstypen te definiëren.

import pandas as pd #импортируем pandas
import numpy as np  #импортируем numpy
df = pd.read_csv("AB_NYC_2019.csv") #читаем датасет и записываем в переменную df

df.head(3) #смотрим на первые 3 строчки, чтобы понять, как выглядят значения

df.info() #Демонстрируем информацию о колонках

Laten we eens kijken naar de kolomwaarden:

1. Komt het aantal regels in elke kolom overeen met het totale aantal regels?
2. Wat is de essentie van de gegevens in elke kolom?
3. Op welke kolom willen we ons richten om er voorspellingen voor te doen?

Met de antwoorden op deze vragen kunt u de dataset analyseren en grofweg een plan opstellen voor uw volgende acties.

Voor een dieper inzicht in de waarden in elke kolom kunnen we ook de functie Pandas beschrijven() gebruiken. Het nadeel van deze functie is echter dat deze geen informatie geeft over kolommen met tekenreekswaarden. We zullen ze later behandelen.

df.describe()

Magische visualisatie

Laten we eens kijken waar we helemaal geen waarden hebben:

import seaborn as sns
sns.heatmap(df.isnull(),yticklabels=False,cbar=False,cmap='viridis')

Dit was een korte blik van bovenaf, nu gaan we verder met interessantere dingen

Laten we proberen kolommen te vinden en, indien mogelijk, te verwijderen die slechts één waarde in alle rijen hebben (ze hebben op geen enkele manier invloed op het resultaat):

df = df[[c for c
        in list(df)
        if len(df[c].unique()) > 1]] #Перезаписываем датасет, оставляя только те колонки, в которых больше одного уникального значения

Nu beschermen we onszelf en het succes van ons project tegen dubbele regels (regels die dezelfde informatie bevatten in dezelfde volgorde als een van de bestaande regels):

df.drop_duplicates(inplace=True) #Делаем это, если считаем нужным.
                                 #В некоторых проектах удалять такие данные с самого начала не стоит.

We verdelen de dataset in tweeën: één met kwalitatieve waarden en de andere met kwantitatieve waarden

Hier moeten we een kleine verduidelijking aanbrengen: als de regels met ontbrekende gegevens in kwalitatieve en kwantitatieve gegevens niet erg met elkaar gecorreleerd zijn, dan zullen we moeten beslissen wat we opofferen - alle regels met ontbrekende gegevens, slechts een deel ervan, of bepaalde kolommen. Als de lijnen gecorreleerd zijn, hebben we het volste recht om de dataset in tweeën te delen. Anders moet u eerst de lijnen aanpakken die de ontbrekende gegevens niet kwalitatief en kwantitatief correleren, en pas dan de dataset in tweeën delen.

df_numerical = df.select_dtypes(include = [np.number])
df_categorical = df.select_dtypes(exclude = [np.number])

We doen dit om het voor ons gemakkelijker te maken deze twee verschillende soorten gegevens te verwerken. Later zullen we begrijpen hoeveel gemakkelijker dit ons leven maakt.

Wij werken met kwantitatieve data

Het eerste wat we moeten doen is bepalen of er ‘spionagekolommen’ in de kwantitatieve gegevens voorkomen. We noemen deze kolommen zo omdat ze zichzelf presenteren als kwantitatieve gegevens, maar fungeren als kwalitatieve gegevens.

Hoe kunnen we ze identificeren? Het hangt natuurlijk allemaal af van de aard van de gegevens die u analyseert, maar over het algemeen bevatten dergelijke kolommen weinig unieke gegevens (in de buurt van 3-10 unieke waarden).

print(df_numerical.nunique())

Zodra we de spionagekolommen hebben geïdentificeerd, verplaatsen we ze van kwantitatieve gegevens naar kwalitatieve gegevens:

spy_columns = df_numerical[['колонка1', 'колока2', 'колонка3']]#выделяем колонки-шпионы и записываем в отдельную dataframe
df_numerical.drop(labels=['колонка1', 'колока2', 'колонка3'], axis=1, inplace = True)#вырезаем эти колонки из количественных данных
df_categorical.insert(1, 'колонка1', spy_columns['колонка1']) #добавляем первую колонку-шпион в качественные данные
df_categorical.insert(1, 'колонка2', spy_columns['колонка2']) #добавляем вторую колонку-шпион в качественные данные
df_categorical.insert(1, 'колонка3', spy_columns['колонка3']) #добавляем третью колонку-шпион в качественные данные

Tenslotte hebben we kwantitatieve data volledig gescheiden van kwalitatieve data en kunnen we er nu goed mee werken. Het eerste is om te begrijpen waar we lege waarden hebben (NaN, en in sommige gevallen wordt 0 geaccepteerd als lege waarden).

for i in df_numerical.columns:
    print(i, df[i][df[i]==0].count())

Op dit punt is het belangrijk om te begrijpen in welke kolommen nullen ontbrekende waarden kunnen aangeven: komt dit door de manier waarop de gegevens zijn verzameld? Of kan het verband houden met de gegevenswaarden? Deze vragen moeten van geval tot geval worden beantwoord.

Dus als we nog steeds besluiten dat we mogelijk gegevens missen waar nullen staan, moeten we de nullen vervangen door NaN om het later gemakkelijker te maken om met deze verloren gegevens te werken:

df_numerical[["колонка 1", "колонка 2"]] = df_numerical[["колонка 1", "колонка 2"]].replace(0, nan)

Laten we nu eens kijken waar we gegevens missen:

sns.heatmap(df_numerical.isnull(),yticklabels=False,cbar=False,cmap='viridis') # Можно также воспользоваться df_numerical.info()

Hier moeten de waarden in de kolommen die ontbreken, geel gemarkeerd zijn. En nu begint het plezier: hoe ga je om met deze waarden? Moet ik rijen met deze waarden of kolommen verwijderen? Of deze lege waarden vullen met enkele andere?

Hier is een benaderend diagram dat u kan helpen beslissen wat er in principe met lege waarden kan worden gedaan:

0. Verwijder onnodige kolommen

df_numerical.drop(labels=["колонка1","колонка2"], axis=1, inplace=True)

1. Is het aantal lege waarden in deze kolom groter dan 50%?

print(df_numerical.isnull().sum() / df_numerical.shape[0] * 100)

df_numerical.drop(labels=["колонка1","колонка2"], axis=1, inplace=True)#Удаляем, если какая-то колонка имеет больше 50 пустых значений

2. Verwijder regels met lege waarden

df_numerical.dropna(inplace=True)#Удаляем строчки с пустыми значениями, если потом останется достаточно данных для обучения

3.1. Een willekeurige waarde invoegen

import random #импортируем random
df_numerical["колонка"].fillna(lambda x: random.choice(df[df[column] != np.nan]["колонка"]), inplace=True) #вставляем рандомные значения в пустые клетки таблицы

3.2. Een constante waarde invoegen

from sklearn.impute import SimpleImputer #импортируем SimpleImputer, который поможет вставить значения
imputer = SimpleImputer(strategy='constant', fill_value="<Ваше значение здесь>") #вставляем определенное значение с помощью SimpleImputer
df_numerical[["новая_колонка1",'новая_колонка2','новая_колонка3']] = imputer.fit_transform(df_numerical[['колонка1', 'колонка2', 'колонка3']]) #Применяем это для нашей таблицы
df_numerical.drop(labels = ["колонка1","колонка2","колонка3"], axis = 1, inplace = True) #Убираем колонки со старыми значениями

3.3. Voer de gemiddelde of meest voorkomende waarde in

from sklearn.impute import SimpleImputer #импортируем SimpleImputer, который поможет вставить значения
imputer = SimpleImputer(strategy='mean', missing_values = np.nan) #вместо mean можно также использовать most_frequent
df_numerical[["новая_колонка1",'новая_колонка2','новая_колонка3']] = imputer.fit_transform(df_numerical[['колонка1', 'колонка2', 'колонка3']]) #Применяем это для нашей таблицы
df_numerical.drop(labels = ["колонка1","колонка2","колонка3"], axis = 1, inplace = True) #Убираем колонки со старыми значениями

3.4. Voer de waarde in die door een ander model is berekend

Soms kunnen waarden worden berekend met behulp van regressiemodellen met behulp van modellen uit de sklearn-bibliotheek of andere soortgelijke bibliotheken. Ons team zal in de nabije toekomst een apart artikel wijden aan hoe dit kan worden gedaan.

Dus voorlopig zal het verhaal over kwantitatieve data worden onderbroken, omdat er veel andere nuances zijn over hoe je data beter kunt voorbereiden en voorbewerken voor verschillende taken, en in dit artikel is rekening gehouden met de basiszaken voor kwantitatieve data, en nu is het tijd om terug te keren naar kwalitatieve gegevens, die we een aantal stappen terug hebben gescheiden van de kwantitatieve gegevens. U kunt dit notebook naar eigen inzicht veranderen en aanpassen aan verschillende taken, zodat de voorverwerking van gegevens zeer snel gaat!

Kwalitatieve data

Kortom, voor kwalitatieve gegevens wordt de One-hot-encoding-methode gebruikt om deze van een string (of object) naar een getal te formatteren. Voordat we verder gaan met dit punt, gebruiken we het bovenstaande diagram en de code om met lege waarden om te gaan.

df_categorical.nunique()

sns.heatmap(df_categorical.isnull(),yticklabels=False,cbar=False,cmap='viridis')

0. Verwijder onnodige kolommen

df_categorical.drop(labels=["колонка1","колонка2"], axis=1, inplace=True)

1. Is het aantal lege waarden in deze kolom groter dan 50%?

print(df_categorical.isnull().sum() / df_numerical.shape[0] * 100)

df_categorical.drop(labels=["колонка1","колонка2"], axis=1, inplace=True) #Удаляем, если какая-то колонка 
                                                                          #имеет больше 50% пустых значений

2. Verwijder regels met lege waarden

df_categorical.dropna(inplace=True)#Удаляем строчки с пустыми значениями, 
                                   #если потом останется достаточно данных для обучения

3.1. Een willekeurige waarde invoegen

import random
df_categorical["колонка"].fillna(lambda x: random.choice(df[df[column] != np.nan]["колонка"]), inplace=True)

3.2. Een constante waarde invoegen

from sklearn.impute import SimpleImputer
imputer = SimpleImputer(strategy='constant', fill_value="<Ваше значение здесь>")
df_categorical[["новая_колонка1",'новая_колонка2','новая_колонка3']] = imputer.fit_transform(df_categorical[['колонка1', 'колонка2', 'колонка3']])
df_categorical.drop(labels = ["колонка1","колонка2","колонка3"], axis = 1, inplace = True)

We hebben dus eindelijk grip op nulwaarden in kwalitatieve gegevens. Nu is het tijd om one-hot-encoding uit te voeren op de waarden die zich in uw database bevinden. Deze methode wordt heel vaak gebruikt om ervoor te zorgen dat jouw algoritme kan leren van data van hoge kwaliteit.

def encode_and_bind(original_dataframe, feature_to_encode):
    dummies = pd.get_dummies(original_dataframe[[feature_to_encode]])
    res = pd.concat([original_dataframe, dummies], axis=1)
    res = res.drop([feature_to_encode], axis=1)
    return(res)

features_to_encode = ["колонка1","колонка2","колонка3"]
for feature in features_to_encode:
    df_categorical = encode_and_bind(df_categorical, feature))

We zijn dus eindelijk klaar met het verwerken van afzonderlijke kwalitatieve en kwantitatieve gegevens - tijd om ze weer te combineren

new_df = pd.concat([df_numerical,df_categorical], axis=1)

Nadat we de datasets tot één hebben gecombineerd, kunnen we eindelijk datatransformatie gebruiken met MinMaxScaler uit de sklearn-bibliotheek. Hierdoor komen onze waarden tussen 0 en 1, wat zal helpen bij het trainen van het model in de toekomst.

from sklearn.preprocessing import MinMaxScaler
min_max_scaler = MinMaxScaler()
new_df = min_max_scaler.fit_transform(new_df)

Deze gegevens zijn nu voor alles gereed: neurale netwerken, standaard ML-algoritmen, enz.!

In dit artikel hebben we geen rekening gehouden met het werken met tijdreeksgegevens, omdat je voor dergelijke gegevens iets andere verwerkingstechnieken moet gebruiken, afhankelijk van je taak. In de toekomst zal ons team een ​​apart artikel aan dit onderwerp wijden, en we hopen dat het iets interessants, nieuws en nuttigs in je leven zal kunnen brengen, net als dit.

Bron: www.habr.com