당뇨병 위험 분류 예측 프로젝트

import pandas as pd import numpy as np train = pd.read_csv('train.csv') test = pd.read_csv('test.csv') submission = pd.read_csv('sample_submission.csv')

from sklearn.ensemble import RandomForestClassifier from sklearn.model_selection import cross_val_score, cross_validate, KFold, StratifiedKFold features_org = train.columns[1:-1] train_x = train[features_org] train_y = train['Outcome'] kf = StratifiedKFold(n_splits=4, shuffle=True, random_state=42) display("####### 기본 교차 검증 성능 #########") RF_model = RandomForestClassifier(random_state = 42) cv_result = cross_validate(RF_model, train_x, train_y, cv=kf, scoring=['accuracy', 'precision', 'recall', 'f1']) df_cv_result = pd.DataFrame(cv_result, columns=['test_accuracy', 'test_precision', 'test_recall', 'test_f1']) display(df_cv_result) display(df_cv_result.describe().loc['mean',:].to_frame().T)

# 이상치를 탐지하는 함수 정의 def detect_outliers(dataframe, column): Q1 = dataframe[column].quantile(0.25) Q3 = dataframe[column].quantile(0.75) IQR = Q3 - Q1 # IQR 기반으로 이상치 범위를 정의 lower_bound = Q1 - 1.5 * IQR upper_bound = Q3 + 1.5 * IQR # 이상치의 인덱스를 반환 return dataframe[(dataframe[column] < lower_bound) | (dataframe[column] > upper_bound)].index # 숫자형 데이터를 대상으로 이상치 탐지 numeric_columns = train.select_dtypes(include=[np.number]).columns.tolist() outliers_dict = {} for column in features_org: outliers = detect_outliers(train, column) if len(outliers) > 0: outliers_dict[column] = outliers display(f"num of outlier of {column} : {len(outliers)}") display(outliers_dict)

train_dout_median = train.copy() #이상치를 중앙값으로 대체 for column, outlier_indices in outliers_dict.items(): median_value = train_dout_median[column].median() train_dout_median.loc[outlier_indices, column] = median_value train_dout_median_x = train_dout_median[features_org] train_dout_median_y = train_dout_median['Outcome'] RF_model = RandomForestClassifier(random_state = 42) # 이상치 처리 후 RandomForest를 사용한 교차 검증 성능 확인 cv_result_dout_median = cross_validate(RF_model, train_dout_median_x, train_dout_median_y, cv=kf, scoring=['accuracy', 'precision', 'recall', 'f1']) df_cv_result_dout_median = pd.DataFrame(cv_result_dout_median, columns=['test_accuracy', 'test_precision', 'test_recall', 'test_f1']) display(df_cv_result_dout_median) display(df_cv_result_dout_median.describe().loc['mean',:].to_frame().T)

train_delete_outlier = train.copy() # 원본 train 데이터에서 이상치 제거 rows_to_drop = set() for column in features_org: outliers_indices = detect_outliers(train_delete_outlier, column) rows_to_drop.update(outliers_indices) train_delete_outlier = train_delete_outlier.drop(rows_to_drop) train_delete_outlier_x = train_delete_outlier[features_org] train_delete_outlier_y = train_delete_outlier['Outcome'] # 이상치를 제거한 후 RandomForest를 사용한 교차 검증 성능 확인 cv_result_delete_outlier = cross_validate(RF_model, train_delete_outlier_x, train_delete_outlier_y, cv=kf, scoring=['accuracy', 'precision', 'recall', 'f1']) df_cv_result_delete_outlier = pd.DataFrame(cv_result_delete_outlier, columns=['test_accuracy', 'test_precision', 'test_recall', 'test_f1']) display(f"IQR 기반의 이상치 제거한 갯수 : {len(train) - len(train_delete_outlier)} 개, 비율 : {(len(train) - len(train_delete_outlier))/len(train) * 100.0}") display(df_cv_result_delete_outlier) display(df_cv_result_delete_outlier.describe().loc['mean',:].to_frame().T)

from scipy import stats # Z-score 기반 이상치 제거 z_scores = np.abs(stats.zscore(train_x)) threshold = 3 # 이 값을 조절하여 이상치로 간주되는 임계점을 설정합니다. train_zscore = train.copy()[(z_scores < threshold).all(axis=1)] display(f"z_score 기반의 이상치 제거한 갯수 : {len(train) - len(train_zscore)} 개, 비율 : {(len(train) - len(train_zscore))/len(train) * 100.0}") # 데이터 업데이트 train_zscore_x = train_zscore[features_org] train_zscore_y = train_zscore['Outcome'] display("####### Z-score 기반 이상치 제거 후 교차 검증 성능 #########") RF_model = RandomForestClassifier(random_state=42) cv_result_zscore = cross_validate(RF_model, train_zscore_x, train_zscore_y, cv=kf, scoring=['accuracy', 'precision', 'recall', 'f1']) df_cv_result_zscore = pd.DataFrame(cv_result_zscore, columns=['test_accuracy', 'test_precision', 'test_recall', 'test_f1']) display(df_cv_result_zscore) display(df_cv_result_zscore.describe().loc['mean',:].to_frame().T)

from imblearn.over_sampling import SMOTE, BorderlineSMOTE,KMeansSMOTE,SVMSMOTE from sklearn.metrics import accuracy_score rf_model_resampled_ = RandomForestClassifier(random_state = 42) # 교차 검증을 수동으로 구현하기 위한 리스트 초기화 accuracies = [] kf = StratifiedKFold(n_splits=4, shuffle=True, random_state=42) smote_kmeans = KMeansSMOTE(random_state=42) for train_idx, val_idx in kf.split(train_zscore_x, train_zscore_y): # 학습 데이터와 검증 데이터 분할 X_train, X_val = train_zscore_x.iloc[train_idx], train_zscore_x.iloc[val_idx] y_train, y_val = train_zscore_y.iloc[train_idx], train_zscore_y.iloc[val_idx] # 학습 데이터에만 SMOTE 오버샘플링 적용 X_train_resampled, y_train_resampled = smote_kmeans.fit_resample(X_train, y_train) # 오버샘플링된 학습 데이터로 모델 학습 rf_model_resampled_.fit(X_train_resampled, y_train_resampled) # 검증 데이터에 대한 예측 val_predictions = rf_model_resampled_.predict(X_val) # 성능 지표 계산 accuracies.append(accuracy_score(y_val, val_predictions)) # 성능 지표의 평균 계산 mean_accuracy = np.mean(accuracies) display(f"accuracy of each Fold : {accuracies}") display(f"accuracy of mean_accuracy : {mean_accuracy}")

import itertools # 기존 피처의 조합을 생성하고, 새로운 피처를 추가한 후 각 조합에 대한 교차 검증 점수를 계산합니다. # 그 중에서 가장 높은 정확도를 가진 피처만 선택합니다. # RandomForest 모델과 KFold 객체를 생성합니다. rf_model = RandomForestClassifier(random_state = 42) # 주어진 피처의 조합을 생성합니다. features_subset = ['Insulin', 'Age', 'BMI'] feature_combinations = list(itertools.combinations(features_subset, 2)) cv_scores = {} for feature_pair in feature_combinations: feature1, feature2 = feature_pair train_try = train_zscore_x.copy() # 새로운 피처를 추가합니다. train_try[f'{feature1}_{feature2}_Diff'] = train_try[feature1] - train_try[feature2] train_try[f'{feature1}_{feature2}_Sum'] = train_try[feature1] + train_try[feature2] train_try[f'{feature1}_{feature2}_Ratio'] = train_try[feature1] / (train_try[feature2].replace(0, train_try[feature2].median())) features_to_evaluate = [f'{feature1}_{feature2}_Diff', f'{feature1}_{feature2}_Sum', f'{feature1}_{feature2}_Ratio'] # 각 피처에 대한 교차 검증 점수를 계산합니다. feature_scores = {} for feature in features_to_evaluate: scores = cross_validate(rf_model, pd.concat([train_zscore_x, train_try[feature]], axis=1), train_zscore_y, cv=kf, scoring='accuracy') feature_scores[feature] = scores['test_score'].mean() # 가장 높은 점수를 가진 피처만 선택합니다. best_feature = max(feature_scores, key=feature_scores.get) cv_scores[best_feature] = feature_scores[best_feature] display(f"cv_scores[{best_feature}] : {cv_scores[best_feature]}") # 점수를 기준으로 정렬합니다. # 먼저, cv_scores 딕셔너리의 각 항목을 리스트로 변환합니다. items = list(cv_scores.items()) # 그 다음, 이 리스트를 정렬합니다. 각 항목은 (key, value) 쌍이므로, item[1]을 사용하여 값을 기준으로 정렬합니다. sorted_items = sorted(items, key=lambda item: item[1], reverse=True) # 이제 이 정렬된 리스트를 다시 딕셔너리로 변환합니다. cv_scores = dict(sorted_items) display(cv_scores)

from sklearn.ensemble import RandomForestClassifier # 피쳐 생성 train_try = train_zscore.copy() train_try['Insulin_Age_Sum'] = train_try['Insulin'] + train_try['Age'] train_try['BMI'] = train_try['BMI'].replace(0, train_try['BMI'].median()) train_try['Insulin_BMI_Ratio'] = train_try['Insulin'] / train_try['BMI'] # 피처 추가 train_prep = train_zscore.copy() train_prep['Insulin_Age_Sum'] = train_try['Insulin_Age_Sum'] train_prep['Insulin_BMI_Ratio'] = train_try['Insulin_BMI_Ratio'] train_prep_y= train_prep['Outcome'] train_prep_x = train_prep.drop(['ID', 'Outcome'], axis=1) RF_model_prep = RandomForestClassifier(random_state=42) cv_result_prep = cross_validate(RF_model_prep, train_prep_x, train_zscore_y, cv=kf, scoring=['accuracy', 'precision', 'recall', 'f1']) df_cv_result_prep = pd.DataFrame(cv_result_prep, columns=['test_accuracy', 'test_precision', 'test_recall', 'test_f1']) display(df_cv_result_prep) display(df_cv_result_prep.describe().loc['mean',:].to_frame().T) display(train_prep_x.head(5))

test['Insulin_Age_Sum'] = test['Insulin'] + test['Age'] test['BMI'] = test['BMI'].replace(0, test['BMI'].median()) test['Insulin_BMI_Ratio'] = test['Insulin'] / test['BMI']

rf_model = RandomForestClassifier(random_state = 42) rf_model.fit(train_prep_x, train_prep_y) test_x = test.drop('ID', axis=1) pred = rf_model.predict(test_x) submission['Outcome'] = pred submission.to_csv("submission.csv", index = False)

import matplotlib.pyplot as plt import seaborn as sns features = ['Glucose', 'BloodPressure', 'SkinThickness','Insulin','BMI' ] plt.figure(figsize=(14,4)) for idx, feature in enumerate(features): ax1 = plt.subplot(1,5,idx+1) plt.title(feature) plt.tight_layout() sns.histplot(x=feature, data=train, color='blue', kde=True) plt.show()

features_to_check = ['SkinThickness', 'Insulin', 'Glucose', 'BMI', 'BloodPressure'] for feature in features_to_check: n_missing = len(train[train[feature] == 0]) ratio_missing = round(n_missing / len(train) * 100, 1) print(f'{feature} 결측치 갯수 : {n_missing}/{len(train)} ({ratio_missing})%')

SkinThickness 결측치 갯수 : 195/652 (29.9)% Insulin 결측치 갯수 : 318/652 (48.8)% Glucose 결측치 갯수 : 4/652 (0.6)% BMI 결측치 갯수 : 7/652 (1.1)% BloodPressure 결측치 갯수 : 30/652 (4.6)%

# seaborn의 색상 팔레트를 변경합니다. sns.set_palette('pastel') # Train 데이터의 결측치 비율을 계산합니다. missing_ratio_train = [] for feature in features_to_check: n_missing = len(train[train[feature] == 0]) ratio_missing = round(n_missing / len(train) * 100.0, 1) missing_ratio_train.append(ratio_missing) # Test 데이터의 결측치 비율을 계산합니다. missing_ratio_test = [] for feature in features_to_check: n_missing = len(test[test[feature] == 0]) ratio_missing = round(n_missing / len(test) * 100.0, 1) missing_ratio_test.append(ratio_missing) # 각각의 데이터프레임으로 변환합니다. missing_df_train = pd.DataFrame({'Feature': features_to_check, 'Missing Ratio': missing_ratio_train, 'Data': 'Train'}) missing_df_test = pd.DataFrame({'Feature': features_to_check, 'Missing Ratio': missing_ratio_test, 'Data': 'Test'}) # 두 데이터프레임을 합쳐서 새로운 데이터프레임을 만듭니다. missing_df = pd.concat([missing_df_train, missing_df_test]) # 시각화를 합니다. plt.figure(figsize=(10, 4)) sns.barplot(x='Feature', y='Missing Ratio', hue='Data', data=missing_df) plt.title('Missing Ratio of Each Feature in Train/Test Data') plt.show()

features_org = train.columns[1:-1] # 특성들의 분포를 시각화하기 위한 함수 def plot_feature_distribution(df1, df2, label1, label2, features): i = 0 sns.set_style('whitegrid') plt.figure(figsize=(14,8)) for feature in features: i += 1 plt.subplot(3,3,i) sns.kdeplot(df1[feature], bw_adjust=0.5, label=label1) sns.kdeplot(df2[feature], bw_adjust=0.5, label=label2) plt.title(feature, fontsize=14) plt.legend() plt.tight_layout() plt.show() # train_normal과 train_abnormal 데이터셋의 특성 분포 시각화 plot_feature_distribution(train_normal_insuline, train_missing_insuline, 'train_normal', 'train_abnormal', features_org)

from sklearn.ensemble import RandomForestClassifier from sklearn.model_selection import cross_val_score, cross_validate, StratifiedKFold from sklearn.metrics import accuracy_score, recall_score, f1_score, precision_score, roc_auc_score, confusion_matrix features = train.columns[1:-1] train_normal_insulin_x = train_normal_insulin[features] train_noraml_insulin_y = train_normal_insulin['Outcome'] train_missing_insulin_x = train_missing_insulin[features].drop('Insulin', axis=1) train_missing_insulin_y = train_missing_insulin['Outcome'] kf = StratifiedKFold(n_splits=4, shuffle=True, random_state=42) display("####### Insulin 결측치 없는 데이터셋 #########") RF_model_normal = RandomForestClassifier(random_state = 42) cv_result_normal = cross_validate(RF_model_normal, train_normal_insulin_x, train_noraml_insulin_y, cv=kf, scoring=['accuracy', 'precision', 'recall', 'f1']) df_cv_result_normal = pd.DataFrame(cv_result_normal, columns=['test_accuracy', 'test_precision', 'test_recall', 'test_f1']) display(df_cv_result_normal) display(df_cv_result_normal.describe().loc['mean',:].to_frame().T) display("####### Insulin 결측치 데이터셋 #########") RF_model_abnormal = RandomForestClassifier(random_state = 42) cv_result_abnormal = cross_validate(RF_model_abnormal, train_missing_insulin_x, train_missing_insulin_y, cv=kf, scoring=['accuracy', 'precision', 'recall', 'f1']) df_cv_result_abnormal = pd.DataFrame(cv_result_abnormal, columns=['test_accuracy', 'test_precision', 'test_recall', 'test_f1']) display(df_cv_result_abnormal) display(df_cv_result_abnormal.describe().loc['mean',:].to_frame().T)

from sklearn.preprocessing import StandardScaler from sklearn.ensemble import RandomForestClassifier # feature set 정의 : 첫번째 열부터 Age 열까지를 선택 features_org = list(train.columns)[:-2] # train 데이터에서 Insulin이 0이 아닌 데이터 추출 train_normal = train.copy() train_normal = train_normal.loc[train_normal['Insulin'] != 0] train_normal_x = train_normal[features_org] train_normal_y = train_normal['Outcome'] display(train_normal.head(5))

from scipy import stats features_org = train.columns[1:-1] train_normal_x = train_normal[features_org] # z-score 기반 이상치 제거 z_scores = np.abs(stats.zscore(train_normal_x)) threshold = 3 train_zscore = train_normal.copy()[(z_scores < threshold).all(axis=1)] display(f'z_score 기반의 이상치 제거한 갯수 : {len(train_normal) - len(train_zscore)} 개, 비율 : {(len(train_normal) - len(train_zscore))/len(train_normal) * 100.0}')

from sklearn.model_selection import cross_val_score, cross_validate, KFold, StratifiedKFold kf = StratifiedKFold(n_splits=4, shuffle=True, random_state=42) train_normal_x = train_normal[features_org] train_normal_y = train_normal['Outcome'] RF_model_normal = RandomForestClassifier(random_state = 42) cv_result_normal = cross_validate(RF_model_normal, train_normal_x, train_normal_y, cv=kf, scoring=['accuracy', 'precision', 'recall', 'f1']) df_cv_result_normal = pd.DataFrame(cv_result_normal, columns=['test_accuracy', 'test_precision', 'test_recall', 'test_f1']) display(df_cv_result_normal) display(df_cv_result_normal.describe().loc['mean',:].to_frame().T)

import seaborn as sns import matplotlib.pyplot as plt import scipy.stats import pointbiserialr correlation_org_lst, correlation_dealout_lst = [], [] p_value_org_list, p_value_dealout_lst = [], [] # 점 이연 상관계수 계산 및 출력 for feature in features_org: correlation_org, p_value_org = pointbiserialr(train_normal[feature], train_normal['Outcome']) correlation_org_lst.append(correlation_org) p_value_org_list.append(p_value_org) # 데이터프레임 생성 correlation_dict = { 'Feature' : features_org, 'correlation_org' : correlation_org_lst, 'p_value_org' : p_value_org_list} correlation_df = pd.DataFrame(correlation_dict) display(correlation_df) plt.figure(figsize=(18,6)) plt.subplot(1,3,1) sns.barplot(x='Feature', y='correlation_org', data=correlation_df) plt.gca().set_title('Point Biserial Correlation [original train]') plt.gca().set_xticklabels(features_org, rotation=30) plt.subplot(1,3,2) sns.barplot(x='Feature', y='p_value_org', data=correlation_df) plt.gca().set_xticklabels(features_org, rotation=30) plt.gca().set_title('p_value [original train']) plt.subplot(1,3,3) sns.heatmap(train_normal[features_org].corr(), cmap='coolwarm', annot=True) plt.tight_layout() plt.show()

from sklearn.ensemble import RandomForestClassifier from sklearn.model_selection import cross_val_score, cross_validate, KFold from sklearn.preprocessing import LabelEncoder train_normal_try2 = train_normal.copy() # BloodPressure 사분위수 계산 q1 = np.percentile(train_normal_try2['BloodPressure'],25) q2 = np.percentile(train_normal_try2['BloodPressure'],50) q3 = np.percentile(train_normal_try2['BloodPressure'],75) q4 = np.percentile(train_normal_try2['BloodPressure'],100) # BloodPressure 2개 범주로 나누기 q_BloodPressure_lst = [0, q1, q4] BloodPressure_labels_train = pd.cut(train_normal_try2['BloodPressure'], bins=q_BloodPressure_lst, labels=['q1','q2']) # LabelEncoder로 범주형 데이터 인코딩 le_train_ = LabelEncoder() train_normal_try2['BloodPressure_cat'] = le_train_.fit_transform(BloodPressure_labels_train) # BloodPressure_cat 범주에 따른 DiabetesPedigreeFunction의 빈도수 계산 train_normal_try2['DiabetesPedigreeFunction_by_BloodPressure_cat'] = train_normal_try2.groupby('BloodPressure_cat')['DiabetesPedigreeFunction'].transform('count') # BloodPressure_cat 범주에 따른 DiabetesPedigreeFunction의 빈도수 dict 형태로 backup DPF_counts_by_BloodPressure_cat_train = train_normal_try2.groupby('BloodPressure_cat')['DiabetesPedigreeFunction'].count().to_dict() display(DPF_counts_by_BloodPressure_cat_train) # 피처가 추가된 데이터로 교차 검증 수행 train_normal_try2_x = train_normal_try2.drop(['ID','Outcome','BloodPressure_cat'], axis=1) rf_model = RandomForestClassifier(random_state=42) # 결과 출력 cv_result_try = cross_val_score(rf_model, train_normal_try2_x, train_normal_y, cv=kf, scoring='accuracy') display(f'accuacy : {cv_result_try.mean()}') display(train_normal_try2.head(5))

train_normal_prep = train_normal.copy() train_normal_prep['BloodPressure_BMI_Sum'] = train_normal_try1['BloodPressure_BMI_Sum'] train_normal_prep['DiabetesPedigreeFunction_by_BloodPressure_cat'] = train_normal_try2['DiabetesPedigreeFunction_by_BloodPressure_cat'] # 점이연 상관 관계 유의성 없는 'BloodPressure', 'DiabetesPedigreeFunction' 제거 train_normal_prep = train_normal_prep.drop('BloodPressure', axis=1) train_normal_prep = train_normal_prep.drop('DiabetesPedigreeFunction', axis=1) train_normal_prep_x = train_normal_prep.drop(['ID','Outcome'], axis=1) # RandomForestClassifier로 오버샘플링된 데이터에 대한 교차 검증 RF_model_prep = RandomForestClassifier(random_state=42) cv_result_normal_prep = cross_validate(RF_model_prep, train_normal_prep_x, train_normal_y, cv=kf, scoring=['accuracy', 'precision', 'recall', 'f1']) df_cv_result_normal_prep = pd.DataFrame(cv_result_normal_prep, columns=['test_accuracy', 'test_precision', 'test_recall', 'test_f1']) display(df_cv_result_normal_prep) display(df_cv_result_normal_prep.describe().loc['mean',:].to_frame().T) display(train_normal_prep_x.head(5))

test_normal = test.copy() test_normal = test_normal.loc[test_normal['Insulin'] != 0] # 'BloodPressure_BMI_Sum' 생성 test_normal_prep = test_normal.copy() test_normal_prep.loc[:,'BloodPressure_BMI_Sum'] = test_normal_prep['BloodPressure'] + test_normal_prep['BMI'] # 'DiabetesPedigreeFunction_by_BloodPressure_cat' 생성 BloodPressure_labels_test = pd.cut(test_normal_prep['BloodPressure'], bins = q_BloodPressure_lst, labels = ['q1', 'q2']) test_normal_prep['BloodPressure_cat'] = le_train_.fit_transform(BloodPressure_labels_test) # "BloodPressure_cat" 범주 (train 데이터, train_normal_try1 기준)에 따른 "DiabetesPedigreeFunction"의 빈도수 (train 데이터, train_normal_try2의 통계치) 로 대입 test_normal_prep['DiabetesPedigreeFunction_by_BloodPressure_cat'] = test_normal_prep['BloodPressure_cat'].apply(lambda x: DPF_counts_by_BloodPressure_cat_train.get(x)) # 불필요한 feature 제거 test_normal_prep = test_normal_prep.drop('BloodPressure_cat', axis=1) test_normal_prep = test_normal_prep.drop('BloodPressure', axis=1) test_normal_prep = test_normal_prep.drop('DiabetesPedigreeFunction', axis=1) display(test_normal_prep.head(7))

train_normal_prep.to_csv("train_normal_prep.csv", index = False) test_normal_prep.to_csv("test_normal_prep.csv", index = False) display(train_normal_prep.head(7))

features_org = list(train.columns)[1:-1] # ID열 제외 # train 데이터에서 insulin이 0인 데이터 추출 train_abnormal = train.copy() train_abnormal = train_abnormal.loc[train_abnormal['Insulin'] == 0] test_abnormal = test.copy() test_abnormal = test_abnormal.loc[test_abnormal['Insulin'] == 0] display(train_abnormal.head(5))

from sklearn.ensemble import RandomForestClassifier from sklearn.model_selection import cross_validate, cross_val_score, KFold train_abnormal_x = train_abnormal[features_org] train_abnormal_y = train_abnormal['Outcome'] kf = KFold(n_splits=4, shuffle=True, random_state=42) RF_model_abnormal = RandomForestClassifier(random_state=42) cv_result_abnormal = cross_validate(RF_model_abnormal, train_abnormal_x, train_abnormal_y, cv=kf, scoring=['accuracy','precision','recall','f1']) df_cv_result_abnormal = pd.DataFrame(cv_result_abnormal, columns=['test_accuracy','test_precision','test_recall','test_f1']) display(cv_result_abnormal) display(df_cv_result_abnormal) display(df_cv_result_abnormal.describe().loc['mean',:].to_frame().T)

train_applied = train.copy() from sklearn.preprocessing import StandardScaler # SkinThickness 결측치 대체에 사용할 피처 선택 features_for_skin = ['Pregnancies','Glucose','BloodPressure','BMI','DiabetesPedigreeFunction','Age'] # SkinThickness 값이 0인 데이터와 그렇지 않은 데이터로 분리 train_normal_skin = train_applied[train_applied['SkinThickness']!=0] train_normal_skin_x = train_normal_skin[features_for_skin] train_normal_skin_y = train_normal_skin['SkinThickness'] scaler_reg_train = StandardScaler() train_normal_skin_x_scaled = scaler_reg_train.fit_transform(train_normal_skin_x) display(train[features_for_skin].head()) display(pd.DataFrame(train_normal_skin_x_scaled, columns=features_for_skin).head())