분류: accuracy, precision, recall, f1-score —> 높을수록
회귀: MAE, MSE, RMSE —> E로 끝나는 것들은 낮을 수록 좋음 // R2-score —> 높을 수록 좋음
데이터 프레임 기초 구조
df.shape # (행, 열)
df.columns # 열 이름
df.info() # 데이터 타입, 결측치 등 요약 정보
df.describe() # 기초 통계치 (평균, 표준편차 등)
df.head() # 상위 5개 행 출력
df.tail() # 하위 5개 행 출력
from sklearn.metrics import mean_absolute_error
1. 의사결정나무 예측 및 MAE
y_pred_dt = dt.predict(X_valid)
dt_mae = mean_absolute_error(y_valid, y_pred_dt)
2. 랜덤포레스트 예측 및 MAE
y_pred_rf = rf.predict(X_valid)
rf_mae = mean_absolute_error(y_valid, y_pred_rf)
3. MAE 비교하여 더 성능이 좋은 모델 선택
답안12 = ‘decisiontree’ if dt_mae < rf_mae else ‘randomforest’
확인용 출력 (선택)
print(“dt_mae =”, dt_mae)
print(“rf_mae =”, rf_mae)
print(“답안12 =”, 답안12)
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, Dropout
from tensorflow.keras.optimizers import Adam
모델 구성
model = Sequential()
model.add(Dense(64, activation=‘relu’, input_shape=(X_train.shape[1],)))
model.add(Dense(32, activation=‘relu’))
model.add(Dropout(0.2)) # Dropout 레이어 1개 삽입
model.add(Dense(1)) # 출력층
모델 컴파일
model.compile(optimizer=Adam(), loss=‘mse’, metrics=[‘mae’])
모델 학습
history = model.fit(
X_train, y_train,
validation_data=(X_valid, y_valid),
epochs=30,
batch_size=16,
verbose=1
)
import matplotlib.pyplot as plt
학습 및 검증 손실 시각화
plt.plot(history.history[‘mse’], label=‘mse’)
plt.plot(history.history[‘val_mse’], label=‘val_mse’)
plt.title(‘Model MSE’)
plt.xlabel(‘Epochs’)
plt.ylabel(‘MSE’)
plt.legend()
plt.show()
공백(‘’) 또는 공백문자(’ ')를 0으로 교체
df = df.replace([‘’, ’ ‘], 0)
df[‘col’] = df[‘col’].str.replace[’ ', “0”]
숫자로 변환 (선택사항: 문자열이 숫자처럼 생겼을 경우)
df = df.astype(int)
만약 데이터가 숫자처럼 보이지만 문자열로 되어 있다면, astype(int)로 변환 필요
df = df.replace([‘’, ’ '], None) # 공백 먼저 None으로
df = df.apply(pd.to_numeric, errors=‘coerce’) # 숫자 아닌 값 → NaN
df = df.fillna(0).astype(int)
| 목적 | 코드 |
|---|---|
| 평균 | df['컬럼'].mean() |
| 중앙값 | df['컬럼'].median() |
| 최빈값 | df['컬럼'].mode() |
| 표준편차 | df['컬럼'].std() |
| 분산 | df['컬럼'].var() |
| 최대값 | df['컬럼'].max() |
| 최소값 | df['컬럼'].min() |
| 합계 | df['컬럼'].sum() |
| 고유값 개수 | df['컬럼'].nunique() |
| 값별 개수 세기 | df['컬럼'].value_counts() |
| 목적 | 코드 |
|---|---|
| 전체 상관계수 계산 | df.corr() |
| 특정 컬럼과의 상관관계 | df['기준컬럼'].corr(df['다른컬럼']) |
| 목적 | 코드 예시 |
|---|---|
| 그룹별 평균 | df.groupby('기준컬럼')['계산컬럼'].mean() |
| 그룹별 중앙값 | df.groupby('기준컬럼')['계산컬럼'].median() |
| 그룹별 합계 | df.groupby('기준컬럼')['계산컬럼'].sum() |
| 그룹별 개수 | df.groupby('기준컬럼')['계산컬럼'].count() |
| 그룹별 여러 함수 적용 | df.groupby('기준컬럼')['계산컬럼'].agg(['mean', 'max', 'min']) |
결측치 처리
df.isnull().sum() # 결측치 개수 확인
df.dropna() # 결측치 제거
df.fillna(0) # 결측치 0으로 채우기
df[‘column’].fillna(df[‘column’].mean()) # 평균으로 채우기
| 목적 | 코드 |
|---|---|
| 결측치 개수 확인 | df.isnull().sum() |
| 결측치 있는 행 제거 | df.dropna() |
| 결측치 0으로 채우기 | df.fillna(0) |
| 평균으로 채우기 | df['컬럼'].fillna(df['컬럼'].mean()) |
이상치 시각화 및 제거 예시 (IQR 방법)
Q1 = df[‘col’].quantile(0.25)
Q3 = df[‘col’].quantile(0.75)
IQR = Q3 - Q1
df = df[(df[‘col’] >= Q1 - 1.5IQR) & (df[‘col’] <= Q3 + 1.5IQR)]
Q1 = df[‘컬럼’].quantile(0.25)
Q3 = df[‘컬럼’].quantile(0.75)
IQR = Q3 - Q1
df_out = df[(df[‘컬럼’] >= Q1 - 1.5IQR) & (df[‘컬럼’] <= Q3 + 1.5IQR)]
데이터 시각화
import matplotlib.pyplot as plt
import seaborn as sns
df[‘col1’].plot(kind=‘hist’) # 간단한 히스토그램
df[[‘col1’, ‘col2’]].plot(kind=‘line’) # 선 그래프
df[‘category’].value_counts().plot(kind=‘bar’) # 범주형 데이터 막대그래프
| 목적 | 코드 |
|---|---|
| 히스토그램 | plt.hist(df['컬럼'], bins=20) |
| 박스플롯 | plt.boxplot(df['컬럼']) |
| 산점도 | plt.scatter(df['컬럼1'], df['컬럼2']) |
| 막대그래프 | df['컬럼'].value_counts().plot(kind='bar') |
| 선 그래프 | df['컬럼'].plot(kind='line') |
| 상관관계 히트맵 | sns.heatmap(df.corr(), annot=True) |
| 범주형 평균 막대그래프 | sns.barplot(x='기준컬럼', y='계산컬럼', data=df) |
결측치 처리
| 목적 | 코드 |
|---|---|
| 결측치 개수 확인 | df.isnull().sum() |
| 결측치 있는 행 제거 | df.dropna() |
| 결측치 0으로 채우기 | df.fillna(0) |
| 평균으로 채우기 | df['컬럼'].fillna(df['컬럼'].mean()) |
| 최빈값으로 채우기 | df['컬럼'].fillna(df['컬럼'].mode()[0]) |
이상치 처리 (IQR 기반)
Q1 = df[‘컬럼’].quantile(0.25)
Q3 = df[‘컬럼’].quantile(0.75)
IQR = Q3 - Q1
df = df[(df[‘컬럼’] >= Q1 - 1.5IQR) & (df[‘컬럼’] <= Q3 + 1.5IQR)]
* Q1, Q3: 사분위수 * IQR: 사분범위 (Q3 - Q1) * 1.5*IQR 기준 이상치 제거
인코딩 (범주형 → 숫자형)
(1) Label Encoding (순서 X, 숫자 부여)
from sklearn.preprocessing import LabelEncoder
le = LabelEncoder()
df[‘컬럼’] = le.fit_transform(df[‘컬럼’])
(2) One-Hot Encoding (순서 X, 더미변수)
pd.get_dummies(df, columns=[‘컬럼’], drop_first=True)
pd.get_dummies(df, columns=[‘col’])
from sklearn.preprocessing import OneHotEncoder
encoder = OneHotEncoder()
encoded = encoder.fit_transform(df[[‘col’]]).toarray()
스케일링 (정규화 / 표준화)
Min-Max Scaling (0~1)
from sklearn.preprocessing import MinMaxScaler
scaler = MinMaxScaler()
df[[‘col1’, ‘col2’]] = scaler.fit_transform(df[[‘col1’, ‘col2’]])
Standard Scaling (평균=0, 표준편차=1)
from sklearn.preprocessing import StandardScaler
scaler = StandardScaler()
df[[‘col1’, ‘col2’]] = scaler.fit_transform(df[[‘col1’, ‘col2’]])
| 종류 | 설명 | 코드 예시 |
|---|---|---|
| 표준화 (StandardScaler) | 평균 0, 표준편차 1로 변환 |
from sklearn.preprocessing import StandardScaler
scaler = StandardScaler()
scaled = scaler.fit_transform(df[[‘col’]])
정규화 (MinMaxScaler) | 0~1 범위로 변환 |
from sklearn.preprocessing import MinMaxScaler
scaler = MinMaxScaler()
scaled = scaler.fit_transform(df[[‘col’]])
머신러닝 모델링 기본 구조 (4단계)
from sklearn.linear_model import LogisticRegression
1. 모델 생성
model = LogisticRegression()
2. 모델 학습
model.fit(X_train, y_train)
3. 예측
pred = model.predict(X_test)
4. 평가
from sklearn.metrics import accuracy_score
print(“정확도:”, accuracy_score(y_test, pred))
분류(Classification) 모델 예시
로지스틱 회귀 (Logistic Regression)
from sklearn.linear_model import LogisticRegression
model = LogisticRegression(random_state=21)
model.fit(X_train, y_train)
pred = model.predict(X_test)
K-최근접 이웃 (KNN)
from sklearn.neighbors import KNeighborsClassifier
model = KNeighborsClassifier(n_neighbors=5)
model.fit(X_train, y_train)
pred = model.predict(X_test)
의사결정나무 (Decision Tree)
from sklearn.tree import DecisionTreeClassifier
model = DecisionTreeClassifier(max_depth=3, random_state=21)
model.fit(X_train, y_train)
pred = model.predict(X_test)
회귀(Regression) 모델 예시
선형 회귀 (Linear Regression)
from sklearn.linear_model import LinearRegression
model = LinearRegression()
model.fit(X_train, y_train)
pred = model.predict(X_test)
[4] 딥러닝 모델 예시 (TensorFlow/Keras)
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, Dropout
model = Sequential()
model.add(Dense(64, activation=‘relu’))
model.add(Dense(128, activation=‘relu’))
model.add(Dropout(0.2))
model.add(Dense(1)) # 이진분류: sigmoid 쓰는 경우도 있음
model.compile(loss=‘mse’, optimizer=‘adam’, metrics=[‘accuracy’])
history = model.fit(
X_train, y_train,
validation_data=(X_valid, y_valid),
epochs=10, batch_size=16
)
모델 평가 지표
from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score
print(“정확도:”, accuracy_score(y_test, pred))
print(“정밀도:”, precision_score(y_test, pred))
print(“재현율:”, recall_score(y_test, pred))
print(“F1-score:”, f1_score(y_test, pred))
T AI Asso Text
모델 시각화 및 비교 (결과표 + 그래프)
result = pd.DataFrame(, columns=[‘acc’, ‘recall’, ‘precision’, ‘F1’])
def result_view(model_name, pred, actual):
acc = round(accuracy_score(actual, pred), 3)
recall = round(recall_score(actual, pred), 3)
precision = round(precision_score(actual, pred), 3)
F1 = round(f1_score(actual, pred), 3)
result.loc[model_name] = (acc, recall, precision, F1)
모델 불러오기 (Import)
from sklearn.linear_model import LogisticRegression
from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import RandomForestClassifier
from sklearn.svm import SVC
from sklearn.neighbors import KNeighborsClassifier
모델 객체 생성
model = LogisticRegression()
model = DecisionTreeClassifier()
model = RandomForestClassifier()
model = SVC()
model = KNeighborsClassifier()
모델 학습 (Training)
model.fit(X_train, y_train)
예측 (Prediction)
y_pred = model.predict(X_test)
모델 평가 (Evaluation)
정확도(Accuracy)
from sklearn.metrics import accuracy_score
accuracy_score(y_test, y_pred)
혼동 행렬 (Confusion Matrix), 오답패턴 파악 문제로 자주 출제
from sklearn.metrics import confusion_matrix
confusion_matrix(y_test, y_pred)
분류 리포트
from sklearn.metrics import classification_report
print(classification_report(y_test, y_pred))
훈련/검증 데이터 분할
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
| 출제 항목 | 예시 코드 또는 설명 |
|---|---|
fit() 의미 |
모델 훈련 (X_train, y_train) |
predict() 의미 |
예측 수행 (X_test → y_pred) |
| 정확도 계산 | accuracy_score(y_test, y_pred) |
| 훈련/테스트 분리 | train_test_split() |
| 혼동 행렬 해석 | TP, FP, FN, TN 이해 필요 |
| 모델 비교 문제 | 정확도 비교 또는 오버피팅 여부 |
데이터 타입 변환
| 목적 | 코드 |
|---|---|
| 정수형으로 변환 | df['col'] = df['col'].astype(int) |
| 문자열로 변환 | df['col'] = df['col'].astype(str) |
| 범주형으로 변환 | df['col'] = df['col'].astype('category') |
기타 전처리 함수
| 목적 | 코드 |
|---|---|
| 중복 제거 | df.drop_duplicates() |
| 컬럼 이름 변경 | df.rename(columns={'old':'new'}, inplace=True) |
| 인덱스 초기화 | df.reset_index(drop=True) |
| 컬럼 정렬 | df.sort_values(by='col') |
| 특정 조건 필터링 | df[df['col'] > 100] |
| 컬럼 추가 | df['new_col'] = df['col1'] + df['col2'] |
| 출제 포인트 | 이해 방법 |
|---|---|
fillna()와 dropna() 사용 구분 |
결측값 보존 vs 제거 여부 구분 필요 |
LabelEncoder vs get_dummies |
분류 모델용, 순서성 여부 판단 |
MinMaxScaler vs StandardScaler |
분포 형태에 따라 선택 |
astype() |
타입 불일치로 발생하는 오류 예방용 |
| 이상치 제거 시 IQR 방법 | boxplot 이상치 정의 기준과 연계됨 |
랜덤 포레스트 (Random Forest)
from sklearn.ensemble import RandomForestClassifier
model_rf = RandomForestClassifier(
n_jobs=-1,
n_estimators=100,
min_samples_split=2,
min_samples_leaf=1,
max_features=‘auto’,
max_depth=None,
random_state=21
)
model_rf.fit(X_train, y_train) # 학습
pred_rf = model_rf.predict(X_test) # 예측
* n_estimators: 트리 개수 max_depth: 트리 깊이 (None이면 자동) random_state: 결과 재현을 위해 고정
XGBoost (eXtreme Gradient Boosting)
import xgboost as xgb
import matplotlib.pyplot as plt
model_xgb = xgb.XGBClassifier(
learning_rate=0.1,
n_estimators=500,
max_depth=3,
subsample=0.8,
gamma=0.1,
random_state=21,
n_jobs=-1
)
eval_set = [(X_valid, y_valid)]
model_xgb.fit(
X_train, y_train,
eval_metric=“logloss”,
eval_set=eval_set,
early_stopping_rounds=10,
verbose=True
)
pred_xgb = model_xgb.predict(X_test)
* eval_metric: 평가 지표 (ex: "logloss", "auc")
early_stopping_rounds: 조기 종료 기준 (연속 N번 성능 개선 없을 시 중단)
XGBoost는 부스팅(Boosting) 기반으로, 오답에 가중치를 부여하며 성능을 점진적으로 향상시킵니다
Feature Importance
Random Forest에서 변수 중요도 확인
from sklearn.ensemble import RandomForestClassifier
model = RandomForestClassifier()
model.fit(X_train, y_train)
변수 중요도 추출
importances = model.feature_importances_
변수명과 함께 보기
for name, score in zip(X_train.columns, importances):
print(f"{name}: {score:.4f}")
XGBoost에서 변수 중요도 시각화
import xgboost as xgb
import matplotlib.pyplot as plt
model = xgb.XGBClassifier()
model.fit(X_train, y_train)
중요도 시각화
xgb.plot_importance(model)
plt.show()
xgb.plot_importance()함수는 기본적으로 F score 기준으로 변수 중요도를 그려줍니다.- 다양한 기준 사용 가능:
'weight','gain','cover'등 선택 가능
xgb.plot_importance(model, importance_type=‘gain’)
gain: 분할 노드에서 평균 정보 이득 (예측 성능 향상 기준)weight: 해당 변수가 얼마나 자주 사용되었는지 (빈도 기준)
전체 칼럼에 대한 요약 통계량 확인
df.describe(include=‘all’)
고유값 수 (unique), 최빈값 (top), 빈도 (freq) 포함
컬럼별 결측치 개수 확인
df.isnull().sum()
결측치가 많은 순서대로 보기
df.isnull().sum().sort_values(ascending=False)
상관계수 계산
df.corr()
seaborn 히트맵으로 시각화
import seaborn as sns
import matplotlib.pyplot as plt
plt.figure(figsize=(10, 10))
sns.heatmap(df.corr(), annot=True, cmap=‘RdYlBu_r’)
plt.show()
annot=True는 상관계수 숫자를 표기, cmap='RdYlBu_r'는 컬러맵: 양의 상관관계는 붉은색, 음의 상관관계는 파란색
groupby를 이용
df.groupby(‘기준컬럼’)[‘계산컬럼’].함수()
평균 구하기: 호텔별 평균 총 숙박일수
df.groupby(‘hotel’)[‘total_nights’].mean()
여러 통계 함께보기: 국가별 평균 숙박일수와 총 요청 수
df.groupby(‘country’)[[‘total_nights’, ‘total_of_special_requests’]].mean()
count()로 개수 세기: 고객 유형별 예약 수 세기
df.groupby(‘customer_type’)[‘is_canceled’].count()
그룹별 조건 비율 구하기: 호텔별 취소율 평균
df.groupby(‘hotel’)[‘is_canceled’].mean()
is_canceled가 1이면 취소, 0이면 미취소이므로 평균 = 취소 비율
결과를 DataFrame으로 보고 싶다면 .reset_index() 추가
df.groupby(‘hotel’)[‘is_canceled’].mean().reset_index()
예: 'days_left’별 평균 가격
df.groupby(‘days_left’)[[‘price’]].mean()
여러 컬럼 평균 → df.groupby('A')[['B','C']].mean()
개수 세기 → df.groupby('A').size() 또는 count()
시각과 함수
선 그래프 line plot
import seaborn as sns
import matplotlib.pyplot as plt
plt.plot(df[‘days_left’], df[‘price’])
plt.xlabel(‘Days_left’)
plt.ylabel(‘Price’)
plt.show()
히스토그램
plt.hist(df[‘duration’], bins=20) # bins=20전체 데이터를 20개의 구간으로 나눠서 시각화
plt.xlabel(‘Duration’)
plt.ylabel(‘Flights’)
plt.show()
상자 그래프
sns.boxplot(x=‘class’, y=‘price’, data=df)
산점도 + 회귀선
sns.lmplot(x=‘duration’, y=‘price’, data=df, line_kws={‘color’: ‘red’})
범주형 변수 빈도 시각화 (countplot)
sns.countplot(x=‘airline’, hue=‘class’, data=df)
다중공선성 확인용 상관계수 필터링
상관계수 0.9 이상인 변수쌍 찾기
corr = df.corr()
high_corr = [(i, j) for i in corr.columns for j in corr.columns if i != j and abs(corr.loc[i, j]) > 0.9]
pandas 라이브러리를 별칭 pd로 임포트하는 코드를 작성하고 실행
import pandas as pd
pandas 함수로 hotel_bookings.csv 파일을 읽어 original_df 할당
df_original = pd.read_csv(“hotel_bookings.csv”)
df에 original_df 를 복사하세요.
df = df_original.copy()
arrival_date 컬럼을 arrival_date_Year, arrival_date_Month, arrival_date_Day_of_month로 각각 분리하여 df에 저장하세요. → 새로운 컬럼 생성
df[‘arrival_date_Year’] = df[‘arrival_date’].str.split(‘-’).str[0]
df[‘arrival_date_Month’] = df[‘arrival_date’].str.split(‘-’).str[1]
df[‘arrival_date_Day_of_month’] = df[‘arrival_date’].str.split(‘-’).str[2]
* df에서 arrival_date 컬럼을 삭제하세요. → 컬럼 삭제
df.drop(‘arrival_date’, axis=1, inplace=True)
"arrival_date_Year"의 분포도를 알아보려고 합니다. 분포도. seaborn, countplot
import seaborn as sns
sns.countplot(data=df, x=‘arrival_date_Year’)
4. children과 babies에 대한 관계를 알아보려고 합니다.
* seaborn을 사용하세요.
children과 babies에 대해 jointplot그래프를 그리세요. - * x축은 children, y축은 babies를 표시하세요
sns.jointplot(data=df, x=‘children’, y=‘babies’, kind=‘scatter’)
##[결측치를 처리]
* 대상 데이터프레임: df, * 결측치를 확인하는 코드를 작성하세요.
print(df.isnull().sum())
company 컬럼은 삭제합니다.
df_na = df.drop(“company”, axis=1)
결측치가 있는 행(raw)을 삭제 하세요. 전처리 반영된 결과를 새로운 데이터프레임 변수명 df_na 에 저장하세요.
df_na = df_na.dropna()
##불필요한 데이터 삭제
* 대상 데이터프레임: df_na, * “Unnamed: 0”, “reservation_status”, “reservation_status_date” 3개 컬럼을 삭제하세요. * 전처리 반영된 결과를 새로운 데이터프레임 변수명 df_del에 저장하세요.
df_del = df_na.drop([“Unnamed: 0”, “reservation_status”, “reservation_status_date” ], axis=1)
##hotel 중 "City Hotel"에 한정하여 상관관계를 분석 – 가장 상관관계가 높은 변수**를 heatmap을 통해 **빠르고 정확하게 찾기 위해 사용
sns.heatmap((df_del[df_del[“hotel”] == “City Hotel”]).corr(), annot=True)
** corr()로 수치형 변수들 간 상관관계 계산, heatmap()으로 그 결과를 시각적으로 보여줌, annot=True는 각 칸에 수치도 함께 표시하는 옵션
##원-핫 인코딩으로 아래 조건에 해당하는 컬럼 데이터를 변환
대상 데이터프레임: df_del, * 원-핫 인코딩 대상: object 타입의 전체 컬럼, * 활용 함수: Pandas의 get_dummies, 해당 전처리가 반영된 결과를 데이터프레임 변수 df_preset에 저장
df_preset = pd.get_dummies(data=df_del)
**문제에서 "object 타입의 전체 컬럼"이라고 명시했기 때문에 →columns= 옵션 없이 get_dummies()만 사용하면 자동으로 object 타입 전부 인코딩
'gender', 'hotel'만 원핫인코딩, 다른 컬럼은 그대로 유지 하는 경우
pd.get_dummies(df, columns=[‘gender’, ‘hotel’])
* 다중공선성(multicollinearity) 방지를 위해 가장 앞 범주(첫 번째 범주 제거)를 제거하고 원핫인코딩 하는 경우"drop_first=True" 사용
pd.get_dummies(df, drop_first=True)
##훈련과 검증에 사용할 데이터셋 분리. is_canceled 컬럼을 y로, 나머지 컬럼을 feature값 X로 할당한 후, 훈련데이터셋과 검증데이터셋으로 분리
from sklearn.model_selection import train_test_split
X=df_preset.drop(‘is_canceled’, axis=1)
y=df_preset[‘is_canceled’]
훈련과 검증 데이터셋 분리, * 훈련 데이터셋 label: y_train, 훈련 데이터셋 Feature: X_train, * 검증 데이터셋 label: y_valid, 검증 데이터셋 Feature: X_valid, * 훈련 데이터셋과 검증데이터셋의 비율은 80:20, * random_state: 42, * Scikit-learn의 train_test_split 함수를 활용하세요
X_train, X_valid, y_train, y_valid = train_test_split(X, y, random_state=42, test_size=0.2)
StandardScaler 스케일링 수행, * sklearn.preprocessing의 StandardScaler함수 사용, * 훈련데이터셋의 Feature는 StandardScaler의 fit_transform 함수를 활용하여 X_train 변수로 할당, * 검증데이터셋의 Feature는 StandardScaler의 transform 함수를 활용하여 X_valid 변수로 할당
from sklearn.processing import StandardScaler
scaler = StandardScaler
X_train = scaler.fit_transform(X_train)
X_valid = sxaler.transform(X_valid)
is_canceled를 예측하는 머신러닝 모델, 의사결정나무(decision tree)와 랜덤포레스트(RandomForest)는 여러가지 규칙을 순차적으로 적용하면서 독립변수공간을 분할하는 모형으로 분류와 회귀분석에 모두 사용
의사결정나무(decision tree), * 트리의 최대 깊이 : 5로 설정, * 노드를 분할하기 위한 최소한의 샘플 데이터수(min_samples_split) : 3로 설정, * random_state : 120로 설정, * 의사결정나무(decision tree) 모델을 dt 변수에 저장해 주세요.
from sklearn.tree import DecisionTreeClassifier
dt = DecisionTreeClassifier(max_depth=5, min_samples_split=3, random_state=120)
##랜덤포레스트(RandomForest), * 트리의 최대 깊이 : 5로 설정, * 노드를 분할하기 위한 최소한의 샘플 데이터수(min_samples_split) : 3로 설정, * random_state : 120로 설정, * 랜덤포레스트(RandomForest) 모델을 rf 변수에 저장해 주세요.
from sklearn.ensemble import DecisionTreeClassifier
rf = DecisionTreeCalssifier(max_depth=5, min_sample_split=3, random_state=120 )
##2개의 모델에 대해 fit을 활용해 모델을 학습해 주세요. 학습 시 훈련데이터 셋을 활용해 주세요
dt.fit(X_train, y_train)
rf.fit(X_train, y_train)
성능평가, 의사결정나무(decision tree)와 랜덤포레스트(RandomForest) 모델의 성능을 평가하려고 합니다. 아래 가이드에 따라 예측 결과의 Accuracy를 구하고 평가
성능 평가는 검증 데이터셋을 활용, 의사결정나무(decision tree) 모델로 y값을 예측(predict)하여 y_pred_dt에 저장
from sklearn.metrics import accuracy_score
y_pred_dt = dt.predict(X_valid)
램덤포레스트(RandomForest) 모델로 y값을 예측(predict)하여 y_pred_rf에 저장
y_pred_rf = rf.predict(X_valid)
검증 정답(y_valid)과 예측값(y_pred_rf)의 accuracy를 구하고 rf_acc 변수
from skleaern.metrics import accuracy_score
rf_acc = accuracy_score(y_valid, y_pred_rf)
dt_acc= accuracy_score(y_valid, y_predic_dt)
2개의 모델에 대한 accuracy 성능 평가 결과를 확인하여 성능 좋은 모델 이름을 ‘답안11’ 변수에 저장
print(dt_acc)
print(rf_acc)
답안11 = ‘decisiontree’
import tensorflow as tf
from tensorflow.keras.models import Sequential, load_model
from tensorflow.keras.layers import Dense, Activation, Dropout, BatchNormalization
from tensorflow.keras.callbacks import EarlyStopping, ModelCheckpoint
from tensorflow.keras.utils import to_categorical
tf.random.set_seed(1)
모델 만들기
is_canceled를 예측하는 딥러닝 모델
Tensorflow framework를 사용하여 딥러닝 모델
히든레이어(hidden layer) 2개이상으로 모델
dropout 비율 0.2로 Dropout 레이어 1개
손실함수는 MSE(Mean Squared Error)를 사용
손실함수를 최적화하기 위해 ‘adam’ 알고리즘을 사용
매 에폭마다 검증데이터 를 'accuracy’로 평가
하이퍼파라미터 epochs : 10, batch_size : 16 으로 설정
각 에포크마다 loss와 metrics 평가하기 위한 데이터로 X_valid, y_valid 사용
학습정보는 history 변수에 저장
model = Sequential() # Sequential 모델: 층을 순차적으로 쌓는 기본 구조
model.add(Dense(units=64, activation=‘relu’))
model.add(Dense(units=128, activation=‘relu’))
model.add(Dropout(0.2))
model.add(Dense(units=1)) ## 출력 뉴런 1개 (is_canceled은 0 또는 1이므로 이진 예측), activation 없이 선형 출력 (MSE 사용 시 적절함)
model.compile(loss=‘mse’, optimizer = ‘adam’, metrics=[‘accuracy’]) # 컴파일 설정
history = model.fit(X_train, y_train, epochs=10, batch_size=16, validation_data=(X_valid, y_valid)) # 모델 학습
모델 성능 평가
Matplotlib 라이브러리 활용해서 학습 acc와 검증 acc를 그래프로 표시
1개의 그래프에 학습 acc과 검증 acc 2가지를 모두 표시
위 2가지 각각의 범례를 ‘acc’, 'val_acc’로 표시
그래프의 타이틀은 'Model acc’로 표시
X축에는 'Epochs’라고 표시하고 Y축에는 'acc’라고 표시
import matplotlib.pyplot as plt
plt.fiture()
plt.plot(history.history[‘accuracy’], label=‘acc’)
plt.plot(history.history[‘val_accuracy’], label=‘val_acc’)
plt.title(“Model acc”)
plt.xlabel(“Epochs”)
plt.xlabel(“acc”)
plt.show()
pandas 라이브러리를 별칭 pd로 임포트하는 코드를 작성
import pandas as pd
Metro_Traffic_Volume_Data.csv 파일을 읽어 df_a에 할당
Days_Information_Data.csv 파일을 읽어 df_b에 할당
두 데이터프레임은 중복값을 가지고 있습니다. 중복된 행을 삭제
답안02 변수에 각 데이터프레임의 중복값의 총합를 저장
df_a =pd.read_csv(‘Metro_Traffic_Volume_Data.csv’)
df_b = pd.read_csv(‘Days_Information_Data.csv’)
dup_a = df_a.duplicated().sum () # 중복 개수 세기
dup_b = df_b.duplicated().sum()
print(dup_a+dup_b)
답안02 = dup_a + dup_b
df_a와 df_b 데이터프레임을 판다스의 merge 함수를 활용하여 합쳐 데이터프레임 변수명 df에 저장하세요
* 합칠때 사용하는 키(on) : ‘date_time’, * 합지는 방법(how) : ‘inner’
df = pd.merge(df_a, df_b, on=‘date_time’, how=‘inner’)
"holiday"의 분포
holiday에 대해 countplot그래프로 만드는 코드와 답안을 작성
Seaborn을 활용, value_counts()를 사용하여 더 자세한 내용을 확인
print(df[‘holiday’])
import seaborn as sns
sns.countplot(data=df, x=‘holiday’)
print(df[‘holiday’]).value_counts())
원본을 보관하기 위해 df_temp에 df를 복사하여 저장
df_temp = df.copy()
전처리를 수행, * 대상 데이터프레임 : df_temp, "holiday"의 값이 "None"인 경우에 N, 그 외인 경우에 Y로 채워진 "is_holiday"라는 컬럼을 추가, 불필요한 ‘holiday’ 컬럼을 삭제, 전처리 반영 후에 새로운 데이터프레임 변수명 df_temp 에 저장
index_holiday = df_temp[df_temp[‘holiday’] != ‘None’]. index
→ holiday 컬럼의 값이 'None’이 아닌 인덱스들을 선택
df_temp[‘is_holiday’] = “Y”
df_temp[‘is_holiday’][index_holiday] = “N”
→공휴일이 아닌 행들(idx_holiday)만 "N"으로 덮어씀
* 불필요한 ‘holiday’ 컬럼을 삭제 하세요. 전처리 반영 후에 새로운 데이터프레임 변수명 df_temp 에 저장
df_temp = df_temp.drop(“holiday”, axis =1)
import matplotlib.pyplot as plt
import matplotlib.font_manager as fm
plt.rc(“font”, family=“NanumGothicCoding”)
"traffic_volume"의 상관관계
seaborn을 사용, "traffic_volume"과 가장 상관관계가 높은 feature를 답안05에 저장
import seaborn as sns
sns.heatmap(df_temp.corr(numeric_only=True) ,annot=True)
→ annot=True숫자 표기, numeric_only=True 숫자형 컬럼만 사용
결측치 처리, * 대상 데이터프레임 : df_temp, “date_time”, “weather_description” 3개 컬럼을 제거, 전처리 반영된 결과를 새로운 데이터프레임 변수명 df_del 에 저장
df_del = df_temp.drop([“date_time”, “weather_description”], axis=1)
불필요한 변수와 결측치 처리
* 대상 데이터프레임 : df_del, 결측치를 확인하는 코드를 작성
print(df_del.isnull().sum())
결측치가 있는 행(raw)를 삭제, 전처리 반영된 결과를 새로운 데이터프레임 변수명 df_na
df_na = df_del.dropna()
결측치 개수를 '답안07 변수에 저장
답안07 = df_del.isnull().sum().sum()
원-핫 인코딩으로 아래 조건에 해당하는 컬럼 데이터를 변환, * 대상 데이터프레임: df_na, * 원-핫 인코딩 대상: object 타입의 전체 컬럼, * 활용 함수: Pandas의 get_dummies, 해당 전처리가 반영된 결과를 데이터프레임 변수 df_preset에 저장
df_preset = pd.get_dummies(data=df_na)
훈련과 검증 각각에 사용할 데이터셋을 분리
traffic_volume 컬럼을 y로, 나머지 컬럼을 feature값 X로 할당한 후, 훈련데이터셋과 검증데이터셋으로 분리
X = df_preset.drop(‘traffic_volume’, axis=1)
y = df_preset[‘traffic_volume’]
훈련데이터셋과 검증데이터셋에 스케일링을 수행
* 훈련 데이터셋 label: y_train, 훈련 데이터셋 Feature: X_train
* 검증 데이터셋 label: y_valid, 검증 데이터셋 Feature: X_valid
* 훈련 데이터셋과 검증데이터셋의 비율은 80:20
* random_state: 42
* Scikit-learn의 train_test_split 함수를 활용하세요
from sklearn.model_selection import train_test_split
X_train, y_train, X_valid, y_valid = train_test_split(X, y, random_state = 42, test_size=0.2)
MinMaxScaler 스케일링, * 대상 컬럼: “temp”, “clouds_all”, sklearn.preprocessing의 MinMaxScaler함수, 훈련데이터셋의 Feature는 MinMaxScaler의 fit_transform 함수를 활용하여 X_train 변수, 검증데이터셋의 Feature는 MinMaxScaler의 transform 함수를 활용하여 X_valid 변수
from sklearn.preprocessing import MinMaxScaler
ms = MinMaxScaler()
X_train = ms.fit_transform(X_train[[“temp”, “clouds_all”]])
X_valid = ms.transform(X_valid[[“temp”, “clouds_all”]])
StandardScaler 스케일링, * 대상 컬럼: MinMaxScaler를 적용하지 않은 모든 컬럼, sklearn.preprocessing의 StandardScaler함수, * 훈련데이터셋의 Feature는 StandardScaler의 fit_transform 함수를 활용하여 X_train 변수로 할당, * 검증데이터셋의 Feature는 StandardScaler의 transform 함수를 활용하여 X_valid 변수로 할당
from sklearn.preprogressing import StandardScaler
ss = StandardScaler()
left_cols = X_train.columns.tolist()
left_cols.remove(‘temp’)
left_cols.remove(‘clouds_all’)
X_train[left_cols] = ss.fit_transform(X_train[left_cols])
X_valid[left_cols] = ss.transform(X_valid[left_cols])
traffic_volume을 예측하는 머신러닝 모델
다양한 모델을 학습하세요 (fit 사용), * 선형 모델 : LinearRegression, * 트리기반 회귀모델 : DecisionTreeRegressor, * 트리기반 앙상블 모델 (배깅 기법) : RandomForestRegressor, GradientBoostingRegressor, ExtraTreesRegressor, * 트리기반 앙상블 모델 (부스팅 기법) : XGBRegressor, random_state : 42, * n_jobs : -1
from sklearn.linear_model import LinearRegression
from sklearn.tree import DecisionTreeRegressor
from sklearn.ensemble import RandomForestRegressor, GradientBoostingRegressor, ExtraTreesRegressor
from xgboost import XGBRegressor
lr = LinearRegression(n_jobs=-1)
dt = DecisionTreeRegressor(random_state=42)
rf = RandomForestRegressor(random_state=42, n_jobs=-1)
gbr = GradientBoostingRegressor(random_state=42,)
etr = ExtraTreesRegressor(random_state=42, n_jobs=-1)
xgb = XGBRegressor(random_state=42, n_jobs=-1)
lr.fit(X_train, y_train)
…
모델의 성능을 평가, 가이드에 따라 예측 결과의 R2_score와 rmse(Root Mean Squere Error)를 구하고 평가
성능 평가는 검증 데이터셋을 활용
#sklearn.metrics의 r2_score와 mean_squared_error를 이용
설명력이 가장 좋은 성능을 보인 모델 이름을 ‘답안11’ 변수, * 예) 답안11=‘LinearRegression’ 혹은 답안11=‘GradientBoostingRegressor’
from sklearn.metrics import r2_score, mean_squared_error
lr_y_pred = lr.predict(X_valid)
…
lr_r2 = r2_score(lr_y_pred, y_valid)
…
lr_rmse = mean_squared_error(lr_y_pred, y_valid, squared=False)
…
print(lr_r2, dt_r2, rf_r2, gbr_r2, etr_r2, xgb_r2)
답안11 = “RandomForestRegressor”
models = {
‘LinearRegression’: lr_r2,
‘DecisionTree’: dt_r2,
‘RandomForest’: rf_r2,
‘GradientBoosting’: gbr_r2,
‘ExtraTrees’: etr_r2,
‘XGBoost’: xgb_r2
}
답안11 = max(models, key=models.get) # R² 기준으로 최고 모델
import tensorflow as tf
from tensorflow.keras.models import Sequential, load_model
from tensorflow.keras.layers import Dense, Activation, Dropout, BatchNormalization
from tensorflow.keras.callbacks import EarlyStopping, ModelCheckpoint
from tensorflow.keras.utils import to_categorical
tf.random.set_seed(1)
traffic_volume을 예측하는 딥러닝 모델
Tensorflow framework를 사용하여 딥러닝 모델
히든레이어(hidden layer) 2개이상으로 모델
dropout 비율 0.2로 Dropout 레이어 1개를 추가
손실함수는 MSE(Mean Squared Error)를 사용
손실함수를 최적화하기 위한 알고리즘은 'adam’을 사용하고, 매 에폭마다 'mae’와 'mse’로 검증을 수행
하이퍼파라미터 epochs : 10, batch_size : 16 으로 설정
각 에포크마다 loss와 metrics 평가하기 위한 데이터로 X_valid, y_valid 사용
학습정보는 history 변수에 저장
model = Sequential() # 순차적인 구조의 모델을 생성 (층을 하나씩 쌓는 방식)
model.add(Dense(units=64, activation=‘relu’, input_shape=(X_train.shape[1],)))
→ 입력값 개수 지정: X_train.shape[1] (= 입력 특성 수)
model.add(Dense(units=32, activation=‘relu’))
model.add(Dropout(0.2))
model.add(Dense(1)) # 회귀 문제이므로 출력 뉴런 수는 1, 출력층에는 일반적으로 활성화 함수 사용 안 함
model.summary() # 모델 구조를 출력 (층별 파라미터 수 등)
model.compile(optimizer=‘adam’,
loss=‘mse’,
metrics=[‘mae’,‘mse’])
history = model.fit(X_train, y_train, epochs=10, batch_size=16,
verbose=1, validation_data=(X_valid, y_valid), )
X_train,y_train: 학습 데이터epochs=10: 데이터 전체를 10회 반복 학습batch_size=16: 학습 중 16개씩 나눠서 학습validation_data: 에폭마다 검증할 데이터verbose=1: 학습 진행상황을 출력history: 학습 이력(loss, mae 등)을 저장하는 객체
Matplotlib 라이브러리 활용해서 학습 mse와 검증 mse를 그래프로 표시
plt.figure()
plt.plot(history.history[‘mse’], label=‘mse’)
plt.plot(history.history[‘val_mse’], label=‘val_mse’)
plt.title(‘Model MSE’)
plt.xlabel(‘Epochs’)
plt.ylabel(‘MSE’)
plt.legend()
plt.show()
성별(gender)별로 평균 점수를 구하세요. 결과를 답안01에 저장, groupby 함수를 사용
답안01 = df.groupby(‘gender’)[‘score’].mean()
만족하도록 전처리를 수행
- 결측값이 있는 행은 제거하세요.
category열에 있는 공백('',' ')과"unknown"값을"Other"로 바꾸세요.- 변경된 데이터프레임은
df_cleaned에 저장하세요.
df_cleaned = df.dropna()
df_cleaned[‘cartegory’] = df_claened[‘cartegory’].replace([‘’, ’ ', ‘unknown’ ], ‘Other’)
시각화 및 상관관계
import seaborn as sns
import matplotlib.pyplot as plt
corr = df.corr(numeric_only=True) #numeric_only=True: 수치형 변수만 계산 대상에 포함
sns.heatmap(corr, annot = True) # annot=True: 각 셀에 상관계수 숫자도 표시됨
plt.show()
target_corr = corr[‘target’].drop(‘target’)
- 전체 상관계수에서
'target'열만 가져옴 drop('target'): 자기 자신과의 상관관계 1.0은 제거
답안03 = target_corr.abs().idmax()
abs(): 음/양 구분 없이 절대값 기준idxmax(): 가장 큰 상관계수를 가진 변수 이름 반환
AI 모델링 – Scikit-learn
from sklearn.ensemble import RandomForestRegressor
from sklearn.metrics import r2_score, mean_squared_error
rfr = RandomForestRegressor()
rfr.fit(X_train, y_train)
y_pred = model.predict(X_valid)
r2 = r2_score(y_valid, y_pred) # 1에 가까울수록 예측이 정답과 유사
rmse = mean_squared_error(y_valid, y_pred, squared=False) # squared=False로 설정하면 RMSE(제곱근 오차)를 반환, 값이 작을수록 예측이 실제값에 가까움
답안04 = ‘RandomForestRegressor’
딥러닝 모델 TensorFlow
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, Dropout
model = Sequential()
model.add(Dense(64, activation=‘relu’, input_shape=(X_train.shape[1],)))
model.add(Dense(32, activation=‘relu’))
model.add(Dropout(0.2))
model.add(Dense(1)) # 예측하고자 하는 출력값이 2개일때 사용 “Dense(2, activation=‘softmax’)”
model.compile(optimizer=‘adam’, loss=‘mse’, metrics=[‘mae’, ‘mse’])
history = model.fit(X_train, y_train,
epochs=10,
batch_size=16,
validation_data=(X_valid, y_valid),
verbose=1) “verbose=1: 학습 상태를 터미널에 출력”