Notepad-trompanta folio por rapida datumpretigo

Ofte homoj enirantaj la kampon de Datuma Scienco havas malpli ol realismajn atendojn pri tio, kio atendas ilin. Multaj homoj pensas, ke nun ili skribos bonegajn neŭralajn retojn, kreos voĉan asistanton de Iron Man aŭ venkos ĉiujn en la financaj merkatoj.
Sed laboro datumoj Sciencisto estas datuma movita, kaj unu el la plej gravaj kaj tempopostulaj aspektoj estas prilaborado de la datumoj antaŭ ol enigi ĝin en neŭralan reton aŭ analizi ĝin laŭ certa maniero.

En ĉi tiu artikolo, nia teamo priskribos kiel vi povas prilabori datumojn rapide kaj facile per paŝo post paŝo instrukcioj kaj kodo. Ni provis fari la kodon sufiĉe fleksebla kaj povus esti uzata por malsamaj datenoj.

Multaj profesiuloj eble ne trovas ion eksterordinaran en ĉi tiu artikolo, sed komencantoj povos lerni ion novan, kaj ĉiu, kiu longe revas fari apartan kajeron por rapida kaj strukturita datumtraktado, povas kopii la kodon kaj formati ĝin por si mem, aŭ elŝutu la finitan kajeron el Github.

Ni ricevis la datumaron. Kion fari poste?

Do, la normo: ni devas kompreni, kion ni traktas, la ĝeneralan bildon. Por fari tion, ni uzas pandojn por simple difini malsamajn datumtipojn.

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() #Демонстрируем информацию о колонках

Ni rigardu la kolumnvalorojn:

1. Ĉu la nombro da linioj en ĉiu kolumno respondas al la tuta nombro da linioj?
2. Kio estas la esenco de la datumoj en ĉiu kolumno?
3. Kiun kolumnon ni volas celi por fari antaŭdirojn pri ĝi?

La respondoj al ĉi tiuj demandoj permesos al vi analizi la datumaron kaj proksimume desegni planon por viaj venontaj agoj.

Ankaŭ, por pli profunde rigardi la valorojn en ĉiu kolumno, ni povas uzi la funkcion describe() pandas. Tamen, la malavantaĝo de ĉi tiu funkcio estas ke ĝi ne provizas informojn pri kolumnoj kun kordaj valoroj. Ni traktos ilin poste.

df.describe()

Magia bildigo

Ni rigardu kie ni tute ne havas valorojn:

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

Ĉi tio estis mallonga rigardo de supre, nun ni transiros al pli interesaj aferoj

Ni provu trovi kaj, se eble, forigi kolumnojn kiuj havas nur unu valoron en ĉiuj vicoj (ili neniel influos la rezulton):

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

Nun ni protektas nin kaj la sukceson de nia projekto kontraŭ duplikataj linioj (linioj, kiuj enhavas la samajn informojn en la sama ordo kiel unu el la ekzistantaj linioj):

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

Ni dividas la datumaron en du: unu kun kvalitaj valoroj, kaj la alia kun kvantaj

Ĉi tie ni devas fari malgrandan klarigon: se la linioj kun mankantaj datumoj en kvalitaj kaj kvantaj datumoj ne tre korelacias unu kun la alia, tiam ni devos decidi kion ni oferas - ĉiujn liniojn kun mankantaj datumoj, nur parton de ili, aŭ certaj kolumnoj. Se la linioj estas korelaciitaj, tiam ni rajtas dividi la datumaron en du. Alie, vi unue devos trakti la liniojn, kiuj ne korelacias la mankantajn datumojn en kvalita kaj kvanta, kaj nur tiam dividi la datumaron en du.

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

Ni faras tion por faciligi al ni prilabori ĉi tiujn du malsamajn specojn de datumoj - poste ni komprenos kiom pli facilas ĉi tio faciligas nian vivon.

Ni laboras kun kvantaj datumoj

La unua afero, kiun ni devas fari, estas determini ĉu estas "spionaj kolumnoj" en la kvantaj datumoj. Ni nomas ĉi tiujn kolumnojn tiel ĉar ili prezentas sin kiel kvantajn datumojn, sed agas kiel kvalitaj datumoj.

Kiel ni povas identigi ilin? Kompreneble, ĉio dependas de la naturo de la datumoj, kiujn vi analizas, sed ĝenerale tiaj kolumnoj povas havi malmulte da unikaj datumoj (en la regiono de 3-10 unikaj valoroj).

print(df_numerical.nunique())

Post kiam ni identigis la spionkolumnojn, ni movos ilin de kvantaj datumoj al kvalitaj datumoj:

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']) #добавляем третью колонку-шпион в качественные данные

Fine, ni tute apartigis kvantajn datumojn de kvalitaj datumoj kaj nun ni povas labori kun ĝi ĝuste. La unua afero estas kompreni, kie ni havas malplenajn valorojn (NaN, kaj en iuj kazoj 0 estos akceptita kiel malplenaj valoroj).

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

Je ĉi tiu punkto, estas grave kompreni en kiuj kolumnoj nuloj povas indiki mankantajn valorojn: ĉu tio estas pro kiel la datumoj estis kolektitaj? Aŭ ĉu ĝi povus rilati al la datumvaloroj? Ĉi tiuj demandoj devas esti responditaj laŭkaze.

Do, se ni ankoraŭ decidas, ke eble mankas al ni datumoj kie estas nuloj, ni devus anstataŭigi la nulojn per NaN por plifaciligi labori kun ĉi tiuj perditaj datumoj poste:

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

Nun ni vidu, kie ni mankas datumoj:

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

Ĉi tie tiuj valoroj ene de la mankantaj kolumnoj devus esti markitaj flava. Kaj nun komenciĝas la amuzo - kiel trakti ĉi tiujn valorojn? Ĉu mi forigu vicojn kun ĉi tiuj valoroj aŭ kolumnoj? Aŭ plenigu ĉi tiujn malplenajn valorojn per iuj aliaj?

Jen proksimuma diagramo, kiu povas helpi vin decidi, kion oni principe povas fari kun malplenaj valoroj:

0. Forigu nenecesajn kolumnojn

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

1. Ĉu la nombro da malplenaj valoroj en ĉi tiu kolumno estas pli granda ol 50%?

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

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

2. Forigu liniojn kun malplenaj valoroj

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

3.1. Enmetante hazardan valoron

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

3.2. Enmetante konstantan valoron

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. Enmetu la mezan aŭ plej oftan valoron

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. Enigu la valoron kalkulitan de alia modelo

Kelkfoje valoroj povas esti kalkulitaj per regresaj modeloj uzante modelojn de la sklearn-biblioteko aŭ aliaj similaj bibliotekoj. Nia teamo dediĉos apartan artikolon pri kiel tio povas esti farita baldaŭ.

Do, nuntempe, la rakonto pri kvantaj datumoj estos interrompita, ĉar ekzistas multaj aliaj nuancoj pri kiel pli bone fari datumpreparon kaj antaŭtraktadon por malsamaj taskoj, kaj la bazaj aferoj por kvantaj datumoj estis konsiderataj en ĉi tiu artikolo, kaj nun estas la tempo reveni al kvalitaj datumoj.kiujn ni apartigis plurajn paŝojn malantaŭen de la kvantaj. Vi povas ŝanĝi ĉi tiun kajeron laŭplaĉe, adaptante ĝin al malsamaj taskoj, por ke datumpretigo iru tre rapide!

Kvalitaj datumoj

Esence, por kvalitaj datenoj, la Unu-varma-kodiga metodo estas uzata por formati ĝin de ĉeno (aŭ objekto) al nombro. Antaŭ ol pluiri al ĉi tiu punkto, ni uzu la diagramon kaj kodon supre por trakti malplenajn valorojn.

df_categorical.nunique()

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

0. Forigu nenecesajn kolumnojn

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

1. Ĉu la nombro da malplenaj valoroj en ĉi tiu kolumno estas pli granda ol 50%?

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

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

2. Forigu liniojn kun malplenaj valoroj

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

3.1. Enmetante hazardan valoron

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

3.2. Enmetante konstantan valoron

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)

Do, ni finfine ektraktis nulojn en kvalitaj datumoj. Nun estas tempo fari unu-varman kodigon sur la valoroj, kiuj estas en via datumbazo. Ĉi tiu metodo estas tre ofte uzata por certigi, ke via algoritmo povas lerni de altkvalitaj datumoj.

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))

Do, ni finfine finis prilabori apartajn kvalitajn kaj kvantajn datumojn - tempo por kombini ilin reen

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

Post kiam ni kombinis la datumarojn kune en unu, ni povas finfine uzi datuman transformon uzante MinMaxScaler de la sklearn-biblioteko. Ĉi tio faros niajn valorojn inter 0 kaj 1, kio helpos dum trejnado de la modelo estonte.

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

Ĉi tiuj datumoj nun estas pretaj por io ajn - neŭralaj retoj, normaj ML-algoritmoj, ktp.!

En ĉi tiu artikolo, ni ne konsideris labori kun temposerio-datumoj, ĉar por tiaj datumoj vi devus uzi iomete malsamajn prilaborajn teknikojn, depende de via tasko. Estonte nia teamo dediĉos apartan artikolon al ĉi tiu temo, kaj ni esperas, ke ĝi povos alporti ion interesan, novan kaj utilan en vian vivon, same kiel ĉi tiu.

fonto: www.habr.com