നോട്ട്പാഡ്-ചീറ്റ് ഷീറ്റ് വേഗത്തിലുള്ള ഡാറ്റ പ്രീപ്രോസസിംഗിനായി

പലപ്പോഴും ഡാറ്റാ സയൻസ് മേഖലയിലേക്ക് പ്രവേശിക്കുന്ന ആളുകൾക്ക് തങ്ങളെ കാത്തിരിക്കുന്ന കാര്യങ്ങളെക്കുറിച്ചുള്ള യഥാർത്ഥ പ്രതീക്ഷകളേക്കാൾ കുറവാണ്. ഇപ്പോൾ അവർ രസകരമായ ന്യൂറൽ നെറ്റ്‌വർക്കുകൾ എഴുതുമെന്നും അയൺ മാനിൽ നിന്ന് ഒരു വോയ്‌സ് അസിസ്റ്റന്റിനെ സൃഷ്ടിക്കുമെന്നും അല്ലെങ്കിൽ സാമ്പത്തിക വിപണിയിലെ എല്ലാവരേയും തോൽപ്പിക്കുമെന്നും പലരും കരുതുന്നു.
എന്നാൽ പ്രവർത്തിക്കുക ഡാറ്റ ശാസ്ത്രജ്ഞൻ ഡാറ്റാധിഷ്ഠിതമാണ്, ഏറ്റവും പ്രധാനപ്പെട്ടതും സമയമെടുക്കുന്നതുമായ ഒരു വശം ഒരു ന്യൂറൽ നെറ്റ്‌വർക്കിലേക്ക് ഡാറ്റ നൽകുന്നതിനുമുമ്പ് അല്ലെങ്കിൽ ഒരു പ്രത്യേക രീതിയിൽ വിശകലനം ചെയ്യുന്നതിന് മുമ്പ് ഡാറ്റ പ്രോസസ്സ് ചെയ്യുക എന്നതാണ്.

ഈ ലേഖനത്തിൽ, ഘട്ടം ഘട്ടമായുള്ള നിർദ്ദേശങ്ങളും കോഡും ഉപയോഗിച്ച് നിങ്ങൾക്ക് എങ്ങനെ വേഗത്തിലും എളുപ്പത്തിലും ഡാറ്റ പ്രോസസ്സ് ചെയ്യാമെന്ന് ഞങ്ങളുടെ ടീം വിവരിക്കും. കോഡ് തികച്ചും അയവുള്ളതാക്കാൻ ഞങ്ങൾ ശ്രമിച്ചു, വ്യത്യസ്ത ഡാറ്റാസെറ്റുകൾക്ക് ഇത് ഉപയോഗിക്കാം.

പല പ്രൊഫഷണലുകൾക്കും ഈ ലേഖനത്തിൽ അസാധാരണമായ ഒന്നും കണ്ടെത്താനായില്ല, പക്ഷേ തുടക്കക്കാർക്ക് പുതിയ എന്തെങ്കിലും പഠിക്കാൻ കഴിയും, കൂടാതെ വേഗത്തിലും ഘടനാപരമായ ഡാറ്റാ പ്രോസസ്സിംഗിനായി ഒരു പ്രത്യേക നോട്ട്ബുക്ക് നിർമ്മിക്കാൻ ദീർഘനാളായി സ്വപ്നം കാണുന്ന ആർക്കും കോഡ് പകർത്തി അത് സ്വയം ഫോർമാറ്റ് ചെയ്യാൻ കഴിയും, അല്ലെങ്കിൽ പൂർത്തിയാക്കിയ നോട്ട്ബുക്ക് 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