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

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

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

ಅನೇಕ ವೃತ್ತಿಪರರು ಈ ಲೇಖನದಲ್ಲಿ ಅಸಾಮಾನ್ಯವಾದುದನ್ನು ಕಂಡುಕೊಳ್ಳದಿರಬಹುದು, ಆದರೆ ಆರಂಭಿಕರು ಹೊಸದನ್ನು ಕಲಿಯಲು ಸಾಧ್ಯವಾಗುತ್ತದೆ, ಮತ್ತು ವೇಗದ ಮತ್ತು ರಚನಾತ್ಮಕ ಡೇಟಾ ಸಂಸ್ಕರಣೆಗಾಗಿ ಪ್ರತ್ಯೇಕ ನೋಟ್‌ಬುಕ್ ಮಾಡುವ ಕನಸು ಹೊಂದಿರುವ ಯಾರಾದರೂ ಕೋಡ್ ಅನ್ನು ನಕಲಿಸಬಹುದು ಮತ್ತು ಅದನ್ನು ಸ್ವತಃ ಫಾರ್ಮ್ಯಾಟ್ ಮಾಡಬಹುದು ಅಥವಾ 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)

ನಾವು ಡೇಟಾಸೆಟ್‌ಗಳನ್ನು ಒಂದಾಗಿ ಸಂಯೋಜಿಸಿದ ನಂತರ, ನಾವು ಅಂತಿಮವಾಗಿ ಸ್ಕ್ಲೀರ್ನ್ ಲೈಬ್ರರಿಯಿಂದ 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