ನೋಟ್‌ಪ್ಯಾಡ್-ಶೀಟ್ ಶೀಟ್ ವೇಗದ ಡೇಟಾ ಪ್ರಿಪ್ರೊಸೆಸಿಂಗ್‌ಗಾಗಿ

ಸಾಮಾನ್ಯವಾಗಿ ಡೇಟಾ ಸೈನ್ಸ್ ಕ್ಷೇತ್ರವನ್ನು ಪ್ರವೇಶಿಸುವ ಜನರು ತಮಗೆ ಏನು ಕಾಯುತ್ತಿದೆ ಎಂಬುದರ ಬಗ್ಗೆ ಅವಾಸ್ತವಿಕ ಕಲ್ಪನೆಗಳನ್ನು ಹೊಂದಿರುತ್ತಾರೆ. ಹಲವರು ಈಗ ತಂಪಾದ ನರಮಂಡಲ ಜಾಲಗಳನ್ನು ಬರೆಯಲು, ಐರನ್ ಮ್ಯಾನ್ ನಿಂದ ಧ್ವನಿ ಸಹಾಯಕವನ್ನು ರಚಿಸಲು ಅಥವಾ ಹಣಕಾಸು ಮಾರುಕಟ್ಟೆಗಳಲ್ಲಿ ಎಲ್ಲರನ್ನು ಸೋಲಿಸಲು ಸಾಧ್ಯವಾಗುತ್ತದೆ ಎಂದು ಭಾವಿಸುತ್ತಾರೆ.
ಆದರೆ ಕೆಲಸ ಡೇಟಾ ವಿಜ್ಞಾನಿ ದತ್ತಾಂಶ ಆಧಾರಿತ, ಮತ್ತು ಅತ್ಯಂತ ಪ್ರಮುಖ ಮತ್ತು ಸಮಯ ತೆಗೆದುಕೊಳ್ಳುವ ಅಂಶವೆಂದರೆ ನರಮಂಡಲಕ್ಕೆ ಡೇಟಾವನ್ನು ಪೂರೈಸುವ ಮೊದಲು ಅಥವಾ ನಿರ್ದಿಷ್ಟ ರೀತಿಯಲ್ಲಿ ವಿಶ್ಲೇಷಿಸುವ ಮೊದಲು ಅದನ್ನು ಸಂಸ್ಕರಿಸುವುದು.

ಈ ಲೇಖನದಲ್ಲಿ, ಹಂತ-ಹಂತದ ಸೂಚನೆಗಳು ಮತ್ತು ಕೋಡ್‌ನೊಂದಿಗೆ ನೀವು ಡೇಟಾವನ್ನು ಸುಲಭವಾಗಿ ಮತ್ತು ತ್ವರಿತವಾಗಿ ಹೇಗೆ ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಬಹುದು ಎಂಬುದನ್ನು ನಮ್ಮ ತಂಡವು ವಿವರಿಸುತ್ತದೆ. ವಿಭಿನ್ನ ಡೇಟಾಸೆಟ್‌ಗಳಿಗೆ ಬಳಸಲು ಕೋಡ್ ಅನ್ನು ಸಾಕಷ್ಟು ಹೊಂದಿಕೊಳ್ಳುವಂತೆ ಮಾಡಲು ನಾವು ಪ್ರಯತ್ನಿಸಿದ್ದೇವೆ.

ಅನೇಕ ವೃತ್ತಿಪರರಿಗೆ ಈ ಲೇಖನದಲ್ಲಿ ಅಸಾಧಾರಣವಾದದ್ದೇನೂ ಸಿಗದಿರಬಹುದು, ಆದರೆ ಆರಂಭಿಕರು ಹೊಸದನ್ನು ಕಲಿಯಲು ಸಾಧ್ಯವಾಗುತ್ತದೆ, ಮತ್ತು ವೇಗದ ಮತ್ತು ರಚನಾತ್ಮಕ ಡೇಟಾ ಸಂಸ್ಕರಣೆಗಾಗಿ ಪ್ರತ್ಯೇಕ ನೋಟ್‌ಬುಕ್ ಮಾಡುವ ಕನಸು ಕಂಡಿರುವ ಯಾರಾದರೂ ಕೋಡ್ ಅನ್ನು ನಕಲಿಸಬಹುದು ಮತ್ತು ಅದನ್ನು ತಮಗಾಗಿ ಫಾರ್ಮ್ಯಾಟ್ ಮಾಡಬಹುದು, ಅಥವಾ ಗಿಥಬ್‌ನಿಂದ ಮುಗಿದ ನೋಟ್‌ಬುಕ್ ಡೌನ್‌ಲೋಡ್ ಮಾಡಿ.

ಡೇಟಾಸೆಟ್ ಸಿಕ್ಕಿತು. ಮುಂದೆ ಏನು ಮಾಡಬೇಕು?

ಆದ್ದರಿಂದ, ಮಾನದಂಡ: ನಾವು ಏನು ವ್ಯವಹರಿಸುತ್ತಿದ್ದೇವೆ ಎಂಬುದನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಬೇಕು, ದೊಡ್ಡ ಚಿತ್ರ. ಇದಕ್ಕಾಗಿ, ನಾವು ವಿಭಿನ್ನ ಡೇಟಾ ಪ್ರಕಾರಗಳನ್ನು ಸರಳವಾಗಿ ವ್ಯಾಖ್ಯಾನಿಸಲು ಪಾಂಡಾಗಳನ್ನು ಬಳಸುತ್ತೇವೆ.

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 ಮತ್ತೊಂದು ಮಾದರಿಯಿಂದ ಲೆಕ್ಕಹಾಕಿದ ಮೌಲ್ಯವನ್ನು ಸೇರಿಸುವುದು

ಕೆಲವೊಮ್ಮೆ ಮೌಲ್ಯಗಳನ್ನು sklearn ಲೈಬ್ರರಿ ಅಥವಾ ಇತರ ರೀತಿಯ ಲೈಬ್ರರಿಗಳಿಂದ ಮಾದರಿಗಳನ್ನು ಬಳಸಿಕೊಂಡು ರಿಗ್ರೆಷನ್ ಮಾದರಿಗಳನ್ನು ಬಳಸಿಕೊಂಡು ಲೆಕ್ಕಹಾಕಬಹುದು. ಮುಂದಿನ ದಿನಗಳಲ್ಲಿ ಇದನ್ನು ಹೇಗೆ ಮಾಡಬಹುದು ಎಂಬುದರ ಕುರಿತು ನಮ್ಮ ತಂಡವು ಪ್ರತ್ಯೇಕ ಲೇಖನವನ್ನು ಮೀಸಲಿಡುತ್ತದೆ.

ಹಾಗಾಗಿ, ಈಗ ಪರಿಮಾಣಾತ್ಮಕ ದತ್ತಾಂಶದ ಕಥೆಯನ್ನು ನಿಲ್ಲಿಸಲಾಗುವುದು, ಏಕೆಂದರೆ ವಿಭಿನ್ನ ಕಾರ್ಯಗಳಿಗೆ ದತ್ತಾಂಶ ತಯಾರಿಕೆ ಮತ್ತು ಪೂರ್ವ-ಸಂಸ್ಕರಣೆಯನ್ನು ಹೇಗೆ ಮಾಡುವುದು ಎಂಬುದರ ಕುರಿತು ಇನ್ನೂ ಹಲವು ಸೂಕ್ಷ್ಮ ವ್ಯತ್ಯಾಸಗಳಿವೆ ಮತ್ತು ಪರಿಮಾಣಾತ್ಮಕ ದತ್ತಾಂಶದ ಮೂಲಭೂತ ವಿಷಯಗಳನ್ನು ಈ ಲೇಖನದಲ್ಲಿ ಗಣನೆಗೆ ತೆಗೆದುಕೊಳ್ಳಲಾಗಿದೆ ಮತ್ತು ಈಗ ಗುಣಾತ್ಮಕ ದತ್ತಾಂಶಕ್ಕೆ ಹಿಂತಿರುಗುವ ಸಮಯ ಬಂದಿದೆ, ಅದನ್ನು ನಾವು ಪರಿಮಾಣಾತ್ಮಕದಿಂದ ಕೆಲವು ಹಂತಗಳನ್ನು ಹಿಂದಕ್ಕೆ ಬೇರ್ಪಡಿಸಿದ್ದೇವೆ. ನೀವು ಈ ನೋಟ್‌ಬುಕ್ ಅನ್ನು ನೀವು ಬಯಸಿದಂತೆ ಬದಲಾಯಿಸಬಹುದು, ವಿಭಿನ್ನ ಕಾರ್ಯಗಳಿಗೆ ಅದನ್ನು ಹೊಂದಿಸಬಹುದು, ಇದರಿಂದ ಡೇಟಾ ಪೂರ್ವ-ಸಂಸ್ಕರಣೆಯು ಬಹಳ ಬೇಗನೆ ನಡೆಯುತ್ತದೆ!

ಗುಣಾತ್ಮಕ ದತ್ತಾಂಶ

ಮೂಲತಃ, ಗುಣಾತ್ಮಕ ದತ್ತಾಂಶಕ್ಕಾಗಿ, ಅದನ್ನು ಸ್ಟ್ರಿಂಗ್ (ಅಥವಾ ವಸ್ತು) ದಿಂದ ಸಂಖ್ಯೆಗೆ ಫಾರ್ಮ್ಯಾಟ್ ಮಾಡಲು ಒನ್-ಹಾಟ್-ಎನ್‌ಕೋಡಿಂಗ್ ವಿಧಾನವನ್ನು ಬಳಸಲಾಗುತ್ತದೆ. ನಾವು ಆ ಹಂತಕ್ಕೆ ಹೋಗುವ ಮೊದಲು, ಖಾಲಿ ಮೌಲ್ಯಗಳನ್ನು ಎದುರಿಸಲು ಮೇಲಿನ ರೇಖಾಚಿತ್ರ ಮತ್ತು ಕೋಡ್ ಅನ್ನು ಬಳಸೋಣ.

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