వేగవంతమైన డేటా ప్రిప్రాసెసింగ్ కోసం నోట్‌బుక్ చీట్ షీట్

తరచుగా డేటా సైన్స్ రంగంలోకి ప్రవేశించే వ్యక్తులు తమకు ఎదురుచూసే వాస్తవిక అంచనాల కంటే తక్కువగా ఉంటారు. చాలా మంది ప్రజలు ఇప్పుడు కూల్ న్యూరల్ నెట్‌వర్క్‌లను వ్రాస్తారని, ఐరన్ మ్యాన్ నుండి వాయిస్ అసిస్టెంట్‌ని క్రియేట్ చేస్తారని లేదా ఫైనాన్షియల్ మార్కెట్‌లలో ప్రతి ఒక్కరినీ ఓడించాలని అనుకుంటారు.
కానీ పని సమాచారం సైంటిస్ట్ డేటా ఆధారితమైనది మరియు డేటాను న్యూరల్ నెట్‌వర్క్‌లోకి ఫీడ్ చేయడానికి లేదా ఒక నిర్దిష్ట మార్గంలో విశ్లేషించడానికి ముందు డేటాను ప్రాసెస్ చేయడం చాలా ముఖ్యమైన మరియు సమయం తీసుకునే అంశాలలో ఒకటి.

ఈ కథనంలో, దశల వారీ సూచనలు మరియు కోడ్‌తో మీరు డేటాను త్వరగా మరియు సులభంగా ఎలా ప్రాసెస్ చేయవచ్చో మా బృందం వివరిస్తుంది. మేము కోడ్‌ను చాలా సరళంగా చేయడానికి ప్రయత్నించాము మరియు వివిధ డేటాసెట్‌ల కోసం ఉపయోగించవచ్చు.

చాలా మంది నిపుణులు ఈ ఆర్టికల్‌లో అసాధారణంగా ఏమీ కనుగొనలేకపోవచ్చు, కానీ ప్రారంభకులు కొత్తదాన్ని నేర్చుకోగలరు మరియు వేగవంతమైన మరియు నిర్మాణాత్మక డేటా ప్రాసెసింగ్ కోసం ప్రత్యేక నోట్‌బుక్‌ను తయారు చేయాలని దీర్ఘకాలంగా కలలుగన్న ఎవరైనా కోడ్‌ను కాపీ చేసి, దానిని తమకు తాముగా ఫార్మాట్ చేయవచ్చు లేదా Github నుండి పూర్తయిన నోట్‌బుక్‌ని డౌన్‌లోడ్ చేయండి.

మేము డేటాసెట్‌ను స్వీకరించాము. తర్వాత ఏం చేయాలి?

కాబట్టి, ప్రమాణం: మనం దేనితో వ్యవహరిస్తున్నామో, మొత్తం చిత్రాన్ని అర్థం చేసుకోవాలి. దీన్ని చేయడానికి, మేము వివిధ డేటా రకాలను నిర్వచించడానికి పాండాలను ఉపయోగిస్తాము.

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

కాలమ్ విలువలను చూద్దాం:

1. ప్రతి నిలువు వరుసలోని పంక్తుల సంఖ్య మొత్తం పంక్తుల సంఖ్యకు అనుగుణంగా ఉందా?
2. ప్రతి కాలమ్‌లోని డేటా యొక్క సారాంశం ఏమిటి?
3. దాని గురించి అంచనాలు వేయడానికి మనం ఏ కాలమ్‌ని టార్గెట్ చేయాలనుకుంటున్నాము?

ఈ ప్రశ్నలకు సమాధానాలు డేటాసెట్‌ను విశ్లేషించడానికి మరియు మీ తదుపరి చర్యల కోసం సుమారుగా ప్లాన్‌ను రూపొందించడానికి మిమ్మల్ని అనుమతిస్తుంది.

అలాగే, ప్రతి నిలువు వరుసలోని విలువలను లోతుగా పరిశీలించడానికి, మేము పాండాలు వర్ణించే () ఫంక్షన్‌ని ఉపయోగించవచ్చు. అయితే, ఈ ఫంక్షన్ యొక్క ప్రతికూలత ఏమిటంటే ఇది స్ట్రింగ్ విలువలతో నిలువు వరుసల గురించి సమాచారాన్ని అందించదు. మేము వాటిని తరువాత వ్యవహరిస్తాము.

df.describe()

మేజిక్ విజువలైజేషన్

మనకు ఎక్కడ విలువలు లేవు అని చూద్దాం:

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

ఇది పై నుండి చిన్న చూపు, ఇప్పుడు మేము మరింత ఆసక్తికరమైన విషయాలకు వెళ్తాము

వీలైతే, అన్ని అడ్డు వరుసలలో ఒకే విలువ కలిగిన నిలువు వరుసలను కనుగొని, తీసివేయడానికి ప్రయత్నిద్దాం (అవి ఫలితాన్ని ఏ విధంగానూ ప్రభావితం చేయవు):

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

ఇప్పుడు మనల్ని మనం రక్షించుకుంటాము మరియు మా ప్రాజెక్ట్ యొక్క విజయాన్ని డూప్లికేట్ లైన్‌ల నుండి (ఇప్పటికే ఉన్న లైన్‌లలో ఒకదానిలో అదే సమాచారాన్ని కలిగి ఉన్న లైన్‌లు):

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

మేము డేటాసెట్‌ను రెండుగా విభజిస్తాము: ఒకటి గుణాత్మక విలువలతో మరియు మరొకటి పరిమాణాత్మక వాటితో

ఇక్కడ మనం ఒక చిన్న వివరణ ఇవ్వాలి: గుణాత్మక మరియు పరిమాణాత్మక డేటాలో తప్పిపోయిన డేటా ఉన్న పంక్తులు ఒకదానితో ఒకటి చాలా సంబంధం కలిగి ఉండకపోతే, మనం ఏమి త్యాగం చేయాలో నిర్ణయించుకోవాలి - తప్పిపోయిన డేటా ఉన్న అన్ని పంక్తులు, వాటిలో కొంత భాగం మాత్రమే, లేదా నిర్దిష్ట నిలువు వరుసలు. పంక్తులు పరస్పర సంబంధం కలిగి ఉంటే, డేటాసెట్‌ను రెండుగా విభజించడానికి మాకు ప్రతి హక్కు ఉంటుంది. లేకపోతే, మీరు మొదట తప్పిపోయిన డేటాను గుణాత్మకంగా మరియు పరిమాణాత్మకంగా పరస్పరం అనుసంధానించని పంక్తులతో వ్యవహరించాలి, ఆపై మాత్రమే డేటాసెట్‌ను రెండుగా విభజించండి.

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

ఈ రెండు విభిన్న రకాల డేటాను ప్రాసెస్ చేయడాన్ని సులభతరం చేయడానికి మేము దీన్ని చేస్తాము - ఇది మన జీవితాన్ని ఎంత సులభతరం చేస్తుందో తర్వాత మేము అర్థం చేసుకుంటాము.

మేము పరిమాణాత్మక డేటాతో పని చేస్తాము

పరిమాణాత్మక డేటాలో “గూఢచారి నిలువు వరుసలు” ఉన్నాయో లేదో నిర్ణయించడం మనం చేయవలసిన మొదటి విషయం. మేము ఈ నిలువు వరుసలను పిలుస్తాము ఎందుకంటే అవి తమని తాము పరిమాణాత్మక డేటాగా ప్రదర్శిస్తాయి, కానీ గుణాత్మక డేటాగా పనిచేస్తాయి.

మనం వారిని ఎలా గుర్తించగలం? వాస్తవానికి, ఇవన్నీ మీరు విశ్లేషించే డేటా స్వభావంపై ఆధారపడి ఉంటాయి, అయితే సాధారణంగా ఇటువంటి నిలువు వరుసలు తక్కువ ప్రత్యేకమైన డేటాను కలిగి ఉండవచ్చు (3-10 ప్రత్యేక విలువలు ఉన్న ప్రాంతంలో).

print(df_numerical.nunique())

మేము గూఢచారి నిలువు వరుసలను గుర్తించిన తర్వాత, మేము వాటిని పరిమాణాత్మక డేటా నుండి గుణాత్మక డేటాకు తరలిస్తాము:

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

చివరగా, మేము గుణాత్మక డేటా నుండి పరిమాణాత్మక డేటాను పూర్తిగా వేరు చేసాము మరియు ఇప్పుడు మనం దానితో సరిగ్గా పని చేయవచ్చు. మొదటి విషయం ఏమిటంటే, మనకు ఖాళీ విలువలు ఎక్కడ ఉన్నాయో అర్థం చేసుకోవడం (NaN, మరియు కొన్ని సందర్భాల్లో 0 ఖాళీ విలువలుగా అంగీకరించబడుతుంది).

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

ఈ సమయంలో, ఏ కాలమ్‌లలో సున్నాలు తప్పిపోయిన విలువలను సూచిస్తాయో అర్థం చేసుకోవడం ముఖ్యం: డేటా ఎలా సేకరించబడింది? లేదా అది డేటా విలువలకు సంబంధించినదా? ఈ ప్రశ్నలకు ఒక్కొక్కటిగా సమాధానం ఇవ్వాలి.

కాబట్టి, మేము ఇప్పటికీ సున్నాలు ఉన్న డేటాను కోల్పోవచ్చని నిర్ణయించుకుంటే, ఈ కోల్పోయిన డేటాతో పని చేయడం సులభతరం చేయడానికి మేము సున్నాలను NaNతో భర్తీ చేయాలి:

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

ఇప్పుడు మనం డేటాను ఎక్కడ కోల్పోతున్నామో చూద్దాం:

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

ఇక్కడ తప్పిపోయిన నిలువు వరుసల లోపల ఆ విలువలు పసుపు రంగులో గుర్తించబడాలి. మరియు ఇప్పుడు సరదాగా ప్రారంభమవుతుంది - ఈ విలువలతో ఎలా వ్యవహరించాలి? నేను ఈ విలువలు లేదా నిలువు వరుసలను తొలగించాలా? లేదా ఈ ఖాళీ విలువలను మరికొన్ని వాటితో పూరించాలా?

సూత్రప్రాయంగా, ఖాళీ విలువలతో ఏమి చేయాలో నిర్ణయించడంలో మీకు సహాయపడే సుమారు రేఖాచిత్రం ఇక్కడ ఉంది:

0. అనవసరమైన నిలువు వరుసలను తొలగించండి

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

1. ఈ నిలువు వరుసలో ఖాళీ విలువల సంఖ్య 50% కంటే ఎక్కువగా ఉందా?

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

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

2. ఖాళీ విలువలతో పంక్తులను తొలగించండి

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

3.1 యాదృచ్ఛిక విలువను చొప్పించడం

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

3.2 స్థిరమైన విలువను చొప్పించడం

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 సగటు లేదా అత్యంత తరచుగా ఉండే విలువను చొప్పించండి

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 మరొక మోడల్ ద్వారా లెక్కించబడిన విలువను చొప్పించండి

కొన్నిసార్లు స్క్లెర్న్ లైబ్రరీ లేదా ఇతర సారూప్య లైబ్రరీల నుండి నమూనాలను ఉపయోగించి రిగ్రెషన్ నమూనాలను ఉపయోగించి విలువలను లెక్కించవచ్చు. సమీప భవిష్యత్తులో దీన్ని ఎలా చేయవచ్చనే దానిపై మా బృందం ప్రత్యేక కథనాన్ని కేటాయిస్తుంది.

కాబట్టి, ప్రస్తుతానికి, పరిమాణాత్మక డేటా గురించిన కథనం అంతరాయం కలిగిస్తుంది, ఎందుకంటే వివిధ పనుల కోసం డేటా తయారీ మరియు ప్రీప్రాసెసింగ్‌ను ఎలా మెరుగ్గా చేయాలనే దాని గురించి అనేక ఇతర సూక్ష్మ నైపుణ్యాలు ఉన్నాయి మరియు పరిమాణాత్మక డేటా కోసం ప్రాథమిక విషయాలు ఈ వ్యాసంలో పరిగణనలోకి తీసుకోబడ్డాయి మరియు ఇప్పుడు గుణాత్మక డేటాకు తిరిగి రావడానికి సమయం ఆసన్నమైంది. మేము పరిమాణాత్మక వాటి నుండి అనేక దశలను వెనుకకు వేరు చేసాము. మీరు ఈ నోట్‌బుక్‌ను మీకు నచ్చినట్లుగా మార్చవచ్చు, దీన్ని వివిధ పనులకు అనుగుణంగా మార్చుకోవచ్చు, తద్వారా డేటా ప్రిప్రాసెసింగ్ చాలా త్వరగా జరుగుతుంది!

గుణాత్మక డేటా

ప్రాథమికంగా, గుణాత్మక డేటా కోసం, స్ట్రింగ్ (లేదా వస్తువు) నుండి సంఖ్యకు ఫార్మాట్ చేయడానికి వన్-హాట్-ఎన్‌కోడింగ్ పద్ధతి ఉపయోగించబడుతుంది. ఈ పాయింట్‌కి వెళ్లే ముందు, ఖాళీ విలువలతో వ్యవహరించడానికి పైన ఉన్న రేఖాచిత్రం మరియు కోడ్‌ని ఉపయోగిస్తాము.

df_categorical.nunique()

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

0. అనవసరమైన నిలువు వరుసలను తొలగించండి

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

1. ఈ నిలువు వరుసలో ఖాళీ విలువల సంఖ్య 50% కంటే ఎక్కువగా ఉందా?

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

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

2. ఖాళీ విలువలతో పంక్తులను తొలగించండి

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

3.1 యాదృచ్ఛిక విలువను చొప్పించడం

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

3.2 స్థిరమైన విలువను చొప్పించడం

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)

కాబట్టి, మేము చివరకు గుణాత్మక డేటాలో శూన్యాలపై హ్యాండిల్‌ని పొందాము. ఇప్పుడు మీ డేటాబేస్‌లో ఉన్న విలువలపై వన్-హాట్-ఎన్‌కోడింగ్ చేసే సమయం వచ్చింది. మీ అల్గోరిథం అధిక-నాణ్యత డేటా నుండి నేర్చుకోగలదని నిర్ధారించడానికి ఈ పద్ధతి చాలా తరచుగా ఉపయోగించబడుతుంది.

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

కాబట్టి, మేము ఎట్టకేలకు ప్రత్యేక గుణాత్మక మరియు పరిమాణాత్మక డేటాను ప్రాసెస్ చేయడం పూర్తి చేసాము - వాటిని తిరిగి కలపడానికి సమయం

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

మేము డేటాసెట్‌లను ఒకదానితో ఒకటి కలిపిన తర్వాత, చివరకు sklearn లైబ్రరీ నుండి MinMaxScalerని ఉపయోగించి డేటా ట్రాన్స్‌ఫర్మేషన్‌ని ఉపయోగించవచ్చు. ఇది మా విలువలను 0 మరియు 1 మధ్య చేస్తుంది, ఇది భవిష్యత్తులో మోడల్‌కు శిక్షణ ఇచ్చేటప్పుడు సహాయపడుతుంది.

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

ఈ డేటా ఇప్పుడు దేనికైనా సిద్ధంగా ఉంది - న్యూరల్ నెట్‌వర్క్‌లు, ప్రామాణిక ML అల్గారిథమ్‌లు మొదలైనవి!

ఈ కథనంలో, సమయ శ్రేణి డేటాతో పని చేయడాన్ని మేము పరిగణనలోకి తీసుకోలేదు, ఎందుకంటే అటువంటి డేటా కోసం మీరు మీ పనిని బట్టి కొద్దిగా భిన్నమైన ప్రాసెసింగ్ పద్ధతులను ఉపయోగించాలి. భవిష్యత్తులో, మా బృందం ఈ అంశానికి ప్రత్యేక కథనాన్ని కేటాయిస్తుంది మరియు ఇది మీ జీవితంలో ఆసక్తికరమైన, కొత్త మరియు ఉపయోగకరమైన వాటిని తీసుకురాగలదని మేము ఆశిస్తున్నాము.

మూలం: www.habr.com