1차 미니프로젝트 (3일차) [KT 에이블스쿨 7기] 2025.04.16(수)

2025.04.16 (수)
 
 
 
오늘은 1차미니프로젝트 1, 2일차에서 진행한 군집 분석과 인사이트 도출을 마무리하고 
3, 4일차에는 KT에서 개발하고, 한국경제와 공동 주관하는 대한민국 최초의 인공지능 활용평가인
AICE(AI Certification for Everyone) 시험 대비를 진행했습니다.
다양한 기출을 풀고 시험에 대비했습니다.
이 과정에서 중요한 것은 시험에서 나오는 문제의 형식과
그에 맞춰 라인 바이 라인으로 따라가며 모든 수행 사항을 체크하는 것이라 하셨습니다 !
 
시작하겠습니다 ! 
 

 
 
 

---

※ (**)표시는 개인적으로 추가 공부해야할 아직 헷갈리는 문제임.
 
 

[VOC를 제기한 고객의 해지 여부 예측 문제]

 

○ 미션 안내 

  : VOC를 제기한 고객의 데이터를 읽어들여 데이터를 분석 및 전처리한 후 머신러닝과 딥어닝으로 해지 여부를 예측하고 결과를 분석하세요.
 

1. 필요한 라이브러리 설치

# 문제 : pip를 이용해 seaborn을 설치하세요.
!pip install seaborn

# 문제 : 각 라이브러리를 별칭으로 임포트 하세요.
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
import sklearn as sk

 

2. Tubular 데이터 로딩

# 문제 : read_csv 함수를 사용해 voc_data.csv파일을 읽어온 후 df에 저장하세요.
df = pd.read_csv(path+'voc_data.csv')

 

3. 데이터 구성 확인

# 문제 : 데이터프레임의 인덱스를 확인하세요.
df.index   

# 문제 : 데이터프레임의 컬럼을 확인하세요.
df.columns

# 문제 : 데이터프레임의 값을 확인하세요.
df.values

→ 이 세가지는 특히 괄호가 없음에 주의해야 한다.

df.head()
df.tail()

# 문제 : 데이터프레임의 정보(컬럼정보, 타입, Null)를 출력하세요.
df.info()

# **문제 : 데이터프레임의 계산 가능한 값들의 통계치를 확인하세요.
df.describe()

# 문제 : 데이터프레임 컬럼 항목에 Null이 존제하는지 확인하세요.
df.isnull().sum()

# **문제 : '컬럼1' 컬럼의 데이터별 건수를 나열하세요.
df['컬럼1'].value_counts()

→ 다소 헷갈리는 (info / describe)두 함수를 조심하자.
→ df 전체가 아니라 한 컬럼에 대한 이야기면 앞에서 지정해주는 것을 잊지 말자.
 

4. 데이터 결측치 처리

# 문제 : 어떠한 조건에 맞는 컬럼을 확인하고, 조건에 부합하지 않은 컬럼들을 삭제한다.
# (컬럼이 삭제된 데이터를 df1에 저장)
df1 = df1.drop(columns=['컬럼1', '컬럼2', '컬럼3'])

# **문제 : 데이터프레임의 특정 컬럼('컬럼1')에서 특정 문제('!')가 몇 개 있는지 확인하여 출력하세요.

#1 : 이 방법이 훨씬 간단
count = (df1['컬럼1'] == '!').sum()
print(count)

#2
count = df[df['컬럼1'] == '!']['컬럼1'].value_counts()[0]
print(count)

# **문제 : 특정 문자('!')을 Null값으로 변경
df2 = df1.replace('!', np.nan)

# **문제 : 최빈값을 확인하고, Null값을 최빈값으로 변경하세요. [ mode(), fillna() ]
mode_value = df2['컬럼1'].mode()
print(mode_value)

df2['컬럼1'].fillna('A', inplace = True)

df3 = df2.copy()

→ mode() 메소드로 최빈값을 확인하고, fillna() 메소드로 결측치를 대체(inplace=True)한다.

# **문제 : df3에 대해 '컬럼2'의 null값을 중앙값으로 변경하고 데이터 타입을 정수(int)로 변경하세요.
# 데이터 처리 후 데이터프레임을 df4에 저장하세요.

# step 1 : df4로 반환하고 df3원본을 살리기 위해 미리 변수 정의
df4 = df3.copy()

# step 2 : dropna를 이용해 결측치가 포함된 행을 삭제
df4.dropna(axis=0, inplace=True)

# step 3 : astype을 이용해 int형식으로 변경
df4 = df4.astype({'컬럼2' : 'int'})  # 형식만 입력하면 df전체 형식 변환

# step 4 : 중앙값으로 치환
median_value = df4['컬럼2'].median()
print(median_value)

# step 5 : 값 대체하기
df4['컬럼2'].replace('NaN', median_value)

→ 중앙값을 구하는 과정에서는 결측치가 영향을 주지 않도록 유의한다.

# 문제 : '컬럼3'의 null값을 최빈값으로 변경하고, 데이터 처리 후 df5에 저장하세요.

# 1
mode_value = df4['컬럼3'].mode()
print(mode_value)

df5 = df4.copy()
df5['컬럼3'] = df5['컬럼3'].fillna(mode_value)

df['컬럼3'].isnull().sum()  # 변경되었나 확인하기

# 2
df4.replace({'컬럼3' : {np.nan : df4['컬럼3'].mode()}}, inplace = True)
df5 = df4.copy()

# 3
df4['컬럼3'].value_counts()
df4['컬럼3'].replace(np.nan,'10003', inplace=True)

 

5. 라벨 인코딩, 원핫 인코딩

!pip install scikit-learn

→ 시작하기 전에 scikit-learn를 pip install로 불러오기

# 문제 : df5에서 object 타입의 컬럼들을 cat_cols에 저장하세요.
# 그 중에 '컬럼4'에 대해 LabelEncoder를 적용하세요.

cat_cols = df5.select_dtypes(include='object')

from sklearn.preprocessing import LabelEncoder

Encoder = LabelEncoder()
df5['컬럼4'] = Encoder.fit_transform(cat_cols['컬럼4'])

→ select_dtypes() 메소드를 이용해 특정 데이터 타입만 포함/제외 규칙으로 컬럼을 추려낼 수 있다.

# 문제 : df5의 나머지 object 컬럼에 대해 One-Hot Encoding이 되도록 get_dummies 함수를 적용하세요.

df5.info()

df6 = pd.get_dummies(df5, columns=['컬럼1', '컬럼2', '컬럼3'], drop_first=True)
df6.info()

# *** 다중공선성 방지를 위해 'drop_first=True'는 반드시 붙혀주기

 

6. x, y 데이터 분리

# 문제 : df6에 대해 x, y값을 가지고 8:2 비율로 Train, Test dataset으로 나누세요.

import numpy as np
from sklearn.model_selection import train_test_split

#1
del = 'trm_yn_Y'
X = df6.drop(del, axis = 1)
y = df6.loc[:, target]

#2
y = df6.iloc[:,-1]
X = df6.iloc[:, :-1]

X_train, X_test, y_train, y_test =train_test_split(
   X, y, test_size=0.2, stratify=y, random_state=42
   )
   
# 잘 나눠졌나 확인
print(x_train.shape)
print(x_test.shape)
print(y_train.shape)
print(y_test.shape)

 

7. 데이터 정규분포화, 표준화

# 문제 : 사이킷런의 StandardScaler로 훈련데이터셋은 정규분포화(fit_transform)하고 
#        테스트 데이터셋은 표준화(transform)하세요.

from sklearn.preprocessing import StandardScaler

scaler = StandardScaler()
X_train = scaler.fit_transform(X_train)
X_test = scaler.transform(X_test)

 

8. 머신러닝 모델링 & 모델 성능평가 및 그래프 출력

○ 로지스틱 회귀 (LogisticRegression, 분류)

# 문제 : LogisticRegression 모델을 만들고 학습을 진행하세요. 
# (규제강도C는 10, max_iter는 2000으로 설정)

from sklearn.linear_model import LogisticRegression

LR = LogisticRegression(C=10, max_iter=2000)
LR.fit(X_train, y_train)

 

# 문제 : 위 모델 평가를 위해, y값을 예측하여 confusion matrix를 구하고 heatmap 그래프를 시각화하세요.
# 그리고 Scikit-learn의 classification_report를 활용해 성능을 출력하세요.

from sklearn.metrics import confusion_matrix
from sklearn.metrics import classification_report

y_pred = LR.predict(X_test)
cm = confusion_matrix(y_test, y_pred)
sns.heatmap(cm, annot = True)     # annot=True : 각 셀에 숫자를 표시

print(classification_report(y_test, y_pred)

 

○ DecisionTree 모델

# 문제 : DecisionTree 모델을 만들고 학습을 진행하세요.
# (트리 최대 깊이(max_depth)는 10, 
#  노드 분할 최소 샘플 데이터수(min_samples_split)은 3으로,
#  random_state는 42로 설정)
# 3-2. 만든 의사결정나무 모델로 y값을 예측(predict)하여 y_pred_df에 저장하세요.
#      검증 정답(y_valid)과 예측값(y_pred_dt)의 MAE(Mean Absolute Error)를 구하고 dt_mae에 저장하세요.

# 1. 모델 생성
from sklearn.tree import DecisionTreeClassifier

dt = DecisionTreeClassifier(
	max_depth = 10,
    min_samples_split = 3,
    random_state = 42
)

# 2. 모델 학습
dt.fit(X_train, y_train)

# 3-1. 성능 평가 (결정 계수, R^2)
dt.score(X_test, y_test)

# 3-2. 성능 평가 (MAE)
from sklearn.metrics import mean_absolute_error, mean_squared_error

	# 예측값 생성
	y_pred_dt = dt.predict(X_test)
	# MAE 산출
	dt_mae = mean_absolute_error(y_valid, y_pred_dt)

 

○ RandomForest 모델

# 문제 : RandomForest 모델을 만들고 학습하세요.
# (n_estimators=100
#  트리 최대 깊이(max_depth)는 10, 
#  노드 분할 최소 샘플 데이터수(min_samples_split)은 3으로,
#  random_state는 42로 설정)

# 3-2. 만든 의사결정나무 모델로 y값을 예측(predict)하여 y_pred_df에 저장하세요.
#      검증 정답(y_valid)과 예측값(y_pred_dt)의 MAE(Mean Absolute Error)를 구하고 rt_mae에 저장하세요.


# 1. 모델 생성
from sklearn.ensemble import RandomForestClassifier

rf = RandomForestClassifier(
	n_estimator = 100,
    max_depth = 10,
    min_samles_split = 3,
    random_state=42
)

# 2. 모델 학습
rf.fit(X_train, y_train)

# 3-1. 모델 성능 평가 (결정 계수, R^2)
rf.score(X_test, y_test)

# 3-2. 모델 성능 평가 (MAE)
from sklearn.metrics import mean_absolute_error

	# 모델 예측
    y_pred_rf = rf.predict(X_test)
    # MAE 계산
    rf_mae = mean_absolute_error(y_test, y_pred_rf)

 

○ XGBoost 모델

# 문제 : XGBoost 모델을 만들고 학습을 진행하세요.
# (n_estimators=50)

!pip install xgboost
import xgboost as xgb

xgb_model = xgb.XGBClassifier(n_estimators=5)
xgb_model.fit(X_train, y_train)
xgb_model.score(X_test, y_test)

y_pred = xgb_model.predict(X_test)
print(confusion_matrix(y_test, y_pred)

 

○ Linear Regression 모델

# 문제 : Linear Regression 모델을 만들고 학습하세요.
# 임의의 x, y data 이용

from sklearn.linear_model import LinearRegression

lr = LinearRegression()

lr.fit(x_data, y_data)
lr.score(x_data, y_data)
lr.predict([[5]])   # x=5일 때 결과를 예측

 

9. 딥러닝 모델링 & 모델 성능평가 및 그래프 출력

!pip install tensorflow

 

# 문제 : 
# 첫번째 Hidden Layer : unit 64 , activation='relu'
# 두번째 Hidden Layer : unit 32 , activation='relu'
# 세번째 Hidden Layer : unit 16 , activation='relu'
# 각 Hidden Layer 마다 Dropout 0.2 비율로 되도록 하세요.
# EarlyStopping 콜백을 적용하고 ModelCheckpoint 콜백으로 validation performance가 좋은 모델을 best_model.keras 모델로 저장하세요.
# batch_size는 10, epochs는 10으로 설정하세요.

import tensorflow as tf
from tensorflow import keras
from tensorflow.keras.models import Sequential, load_model
from tensorflow.keras.layers import Dense, Dropout
from tensorflow.keras.callbacks import EarlyStopping, ModelCheckpoint

model = Sequential()

model.add(Dense(64, activation='relu', input_shape=(X_train.shape[1],)))
model.add(Dropout(0.2))
model.add(Dense(32, activation='relu'))
model.add(Dropout(0.2))
model.add(Dense(16, activation='relu'))
model.add(Dropout(0.2))
model.add(Dense(1, activation='sigmoid'))

model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['acc'])

es = EarlyStopping(monitor='val_loss', patience=4, verbose=1)
mc = ModelCheckpoint('best_model.keras', monitor='val_loss', save_best_only=True, verbose=1)

history = model.fit(X_train, y_train, batch_size=10, epochs=10, callbacks=[es, mc],
                    vaildaion_data=(X_test, y_test), verbose=1)

 

# 문제 : y data를 원핫 인코딩을 해서 다중 분류하는 딥러닝 모델을 만들라고 한 경우

from keras.utils import to_categorical
y_train_ohe = to_categorical(y_train)
y_test_ohe = to_categorical(y_test)

model = Sequential()
# 중간은 이전과 동일
model.add(Dense(2, activation='softmax'))

model.compile(optimizer='adam', loss='categorical_corossentropy', metrics=['acc'])

history = model.fit(X_train, y_train_ohe, 
                    batch_size=10, epochs=10, callbacks=[es, mc],
                    vaildation_data=(X_test, y_test_ohe), verbose=1)  
                    
model.save('voc_model.keras')

 

# 문제 : 모델 성능을 그래프로 표현, (xlabel : Epochs, ylabel : Accuracy, 범례 : Train, Vaildation)

plt.plot(history.history['acc'], label='Train')
plt.plot(history.history['val_acc'], label='Vaildation')
plt.xlabel('Epochs')
plt.ylable('Accuracy')
plt.legend()

 

# 문제 : y값을 예측하여 y_test_pred에 저장하고 정확도를 출력하세요.

y_test_pred = model.predict(X_test, batch_size=10, verbose=1)

y_test = np.argmax(y_test_ohe, axis=1)
y_test_pred = np.argmax(y_test_pred, axis=1)

from sklearn.metrics import accuracy_score
accuracy_score(y_test, y_test_pred)