하나둘셋넷

행동 추론

1] 데이터 불러오기

(1) 라이브러리

# pandas, numpy, matplotlib, seaborn, os 등 필요 라이브러리 호출
# 데이터를 나누기 위한 sklearn.model_selection 모듈의 train_test_split 함수 사용
# 모델 성능 평가 출력을 위해 sklearn.metrics 모듈의 모든 클래스 사용
# XGBClassifier 알고리즘 사용을 위한 모듈 호출
# 진척도 상황을 확인하기 위한 tqdm 라이브러리 호출
# 저장한 모델 사용을 위한 joblib 라이브러리 호출
## 그외 라이브러리는 필요에 따라 호출해서 사용하세요.

import pandas as pd
import numpy as np
import matplotlib.pyplot  as plt
import seaborn as sns
import os
import joblib 
from tqdm import tqdm

from sklearn.model_selection import train_test_split
from sklearn.metrics import *

from xgboost import XGBClassifier

(2) 모델 호출

# 모델별 결과 불러오기
## 모델별 정확도를 비교 할 수 있도록 결과 저장 파일을 불러 옵니다.
## 'data' 폴더에서 /result5.csv 파일을 불러와 result 변수에 할당 합니다.
## result 변수에 할당이 잘 되었는지 확인해 주세요. 

result = pd.read_csv('./data/result5.csv')
result

(3) 중요 feature 불러오기

# 중요 feature 불러오기
## 모델 정확도에 높은 영향을 미치는 feature 이름을 저장한 importance_top.pkl 파일을 불러와 importance_top에 저장 합니다.
## importance_top 변수에 할당이 잘 되었는지 확인해 주세요. 

importance_top = joblib.load('importance_top.pkl')
importance_top

(4) test 데이터 불러오기

# test 데이터 불러오기
## 'data' 폴더에서 test_data.csv 파일을 불러와서 test_data 변수에 할당해 주세요.
## 잘 할당 되었는지 데이터를 확인해 주세요.

test_data = pd.read_csv('./data/test_data.csv')
test_data

(5) train 데이터 불러오기

# train 데이터 불러오기
## 'data' 폴더에서 train_data.csv 파일을 불러와서 train_data 변수에 할당해 주세요.
## 잘 할당 되었는지 데이터를 확인해 주세요.

train_data = pd.read_csv('./data/train_data.csv')
train_data

2] 데이터 합치기, 인덱스 초기화

# 데이터 합치기
## all_data 변수에 train 데이터셋과 test 데이터셋을 위/아래로 합쳐서 할당 합니다.


all_data = pd.concat([train_data, test_data])
all_data

# 데이터 인덱스 초기화
## 데이터셋을 위아래로 합치면 인덱스 중복이 발생 합니다.
## 인덱스가 중복되지 않도록 인덱스를 리셋해 주세요.

all_data.reset_index(drop=True, inplace=True)
all_data

'WALKING_UPSTAIRS' 행동분류에 영향을 미치는 중요 feature 도출

1] X, Y 데이터 나누기

# X, Y 데이터 나누기
## 모델 학습을 위해 feature(X) 데이터와 target(Y) 데이터를 나누어 주어야 합니다.
## target(Y)을 분리를 위해 all_data['Activity'] 값을 숫자로 변환 할 때 'WALKING_UPSTAIRS' 만 인식 할 수 있도록 숫자를 구성해야 합니다.
## [TIP]: {'STANDING':0, 'SITTING':0, 'LAYING':0, 'WALKING':0, 'WALKING_UPSTAIRS':1, 'WALKING_DOWNSTAIRS':0}
## 변환된 결과를 all_y_map 변수에 할당 합니다. 
## all_data 데이터에서 2일차에서 선정한 중요도가 높은 feature 들만 골라 all_x 변수에 할당 합니다.
## 중요도가 높은 feature 들의 이름은 .pkl 파일에서 불러와 importance_top 변수에 저장되어 있습니다.

all_y_map = all_data['Activity'].map({'STANDING':0, 'SITTING':0, 'LAYING':0, 'WALKING':0, 'WALKING_UPSTAIRS':1, 'WALKING_DOWNSTAIRS':0})
all_x = all_data[importance_top]

2] 학습 데이터 나누기

# 학습 데이터 나누기
## 학습에 필요한 all_x 와 all_y_map 데이터를 학습 7 : 검증 3 비율로 나누어 주세요.
## 이때 random_state 는 2023 으로 설정해 주세요.
## 데이터를 할당받을 변수명: all_x_train, all_x_val, all_y_train, all_y_val

all_x_train, all_x_val, all_y_train, all_y_val = train_test_split(all_x,all_y_map,train_size=0.7,random_state=2023)

3] AI 모델링 및 결과 예측

# AI 모델링 및 결과 예측
## XGBClassifier 알고리즘을 사용하여 walkingup_model 변수에 모델을 생성 및 초기화 합니다.
## 파라미터는 최종 조정 파라미터를 사용하고, random_state는 2023 으로 설정해 주세요.
## 모델이 생성되면 all_x_train, all_y_train 로 모델을 학습시켜 줍니다.
## 모델 학습이 완료되면 all_x_val 데이터의 결과를 예측하여 walkingup_pred 변수에 할당 합니다.

walkingup_model = XGBClassifier(learning_rate=0.3, max_depth=2, random_state=2023)
walkingup_model.fit(all_x_train, all_y_train)
walkingup_pred = walkingup_model.predict(all_x_val)
walkingup_pred

4] 성능 평가

# walkingup_model 성능 평가 하기
## 모델이 결과를 잘 예측하였는지 3가지 성능지표로 결과를 평가 합니다.
## 3가지 성능지표: accuracy_score, confusion_matrix, classification_report

print('accuracy_score: ',accuracy_score(all_y_val,walkingup_pred))
print('\n confusion_matrix: \n',confusion_matrix(all_y_val,walkingup_pred))
print('\n classification_report: \n',classification_report(all_y_val,walkingup_pred))

5] 예측결과 저장

# walkingup_xgb_model 예측결과 저장
## result 데이터프레임 12번 인덱스에 'walkingup_xgb'(모델명), 'all'(검증 데이터명), accuracy_score 결과, f1_score 결과를 할당해 주세요.
## f1_score의 평균은 'macro' 파라미터를 사용 합니다.
## 예측 결과가 잘 할당 되었는지 확인해 주세요.

result.loc[12] = ['walkingup_xgb', 'all', accuracy_score(all_y_val,walkingup_pred), f1_score(all_y_val,walkingup_pred, average = 'macro')]
result

모델 정확도 개선

1] 데이터프레임 생성

# feature 명 데이터 파일 생성
## up_importance_sort 데이터프레임 변수를 생성 및 초기화 합니다.

up_importance_sort = pd.DataFrame()

2] feature 명 할당

# feature 명 할당
## up_importance_sort['feature_name'] 열에 walkingup_model 학습에 사용한 all_x 데이터프레임의 모든 feature 명을 할당 합니다.

up_importance_sort['feature_name'] = all_x.columns
up_importance_sort

3] feature 중요도 할당

# feature importances 할당
## up_importance_sort['feature_importance'] 열에 walkingup_model 모델의 feature_importances 를 할당해 줍니다.
## 참고함수: feature_importances_

up_importance_sort['feature_importance'] = walkingup_model.feature_importances_
up_importance_sort

4] 중요도 순으로 인덱스 재정렬

# 중요도 순으로 인덱스 재 정렬
## up_importance_sort 데이터프레임을 up_importance_sort['feature_importance'] 순으로 내림차순 정열 합니다.
## 정렬 후 결과를 확인 합니다.


up_importance_sort.sort_values(by='feature_importance', ascending=False, inplace=True)
up_importance_sort

5] 인덱스 초기화

# 데이터 인덱스 초기화
## 인덱스가 순서대로 나열 되도록 인덱스를 리셋해 주세요.

up_importance_sort.reset_index(drop=True, inplace=True)
up_importance_sort

최적의 Feature Selection 찾기

1] 데이터프레임 생성 및 최적의 Feature Selection 찾기

# 최적의 Feature Selection 찾기
## acc 데이터 프레임을 생성 및 초기화 합니다.(컬럼 지정: columns=['accuracy_score'])
## 전체 feature는 561개에서 도출한 Top feature 개수를(예: 141개) 선별 했기에 feature를 1개 ~ Top feature 개수까지 모델링과 결과를 도출 합니다.
## for 문을 사용해 중요도 상위 feature 1개 모델링부터 Top feature 개수까지 순차적 모델링 실행 후 각 accuracy_score 결과를 acc 변수에 누적 합니다.
## [TIP] tqdm: tqdm은 반복문에서 현재 계산되고 있는 부분의 퍼센테이지를 시각적으로 나태내어 줍니다.
## [TIP] tqdm 사용 예제: for i in range(10) -> for i in tqdm(range(10)):
 
acc = pd.DataFrame(columns=['accuracy_score'])

for i in tqdm(range(len(up_importance_sort))):

    importance_n = up_importance_sort['feature_name'][:i+1]

    x_train_n = all_x_train[importance_n]
    x_val_n = all_x_val[importance_n]

    xgb_n_model = XGBClassifier(learning_rate=0.3, max_depth=2, random_state=2023)
    xgb_n_model.fit(x_train_n, all_y_train)
    xgb_n_pred = xgb_n_model.predict(x_val_n)
    
    acc.loc[i] = accuracy_score(all_y_val,xgb_n_pred)

acc

2] 누적 결과 시각화

# accuracy_score 누적 결과 시각화
## accuracy_score 누적한 acc 변수를 plot으로 시각화 합니다.


plt.figure(figsize=(20,5))
plt.plot(acc, marker='o')
plt.xlabel('train_features')
plt.ylabel('accuracy')
plt.grid()
plt.show()

3] 최고 정확도 Feature 개수 찾기

# 최고 정확도 Feature 개수 찾기
## acc 변수를 accuracy_score 기준 내림차순으로 정렬 합니다.(인덱스 재설정X)
## 인덱스 번호는 누적 학습된 feature의 개수 입니다.
## accuracy_score 값으로 내림차순 정렬 후 이 가장 첫번째 행의 인덱스 번호가 가장 정확도가 좋은 feature 개수를 뜻합니다.

acc.sort_values(by = 'accuracy_score', ascending=False, inplace=True)
acc

4] 최고 정확도 Feature 열 저장

# 최고 정확도 Feature명 저장
## acc 결과에서 확인한 가장 성능좋은 결과를 내는 feature의 개수 만큼 importance_sort['feature_name']를 슬라이싱 하여 
## feature의 이름을 up_importance_top 변수에 할당 합니다.
## 정확도 최고치 인덱스 값 +1 해서 슬라이싱 하세요.
## [TIP] 슬라이싱 할때 [:1] -> feature 0번 까지 짤림, [:100] -> feature 99번 까지 짤림

up_importance_top = up_importance_sort['feature_name'][:acc.index[0]+1]
up_importance_top

5] 훈련 데이터 생성

# 훈련 데이터 생성
## all_x_train 데이터에서 위에서 up_importance_top에 할당한 feature 들의 데이터를 x_train_top 변수에 할당해 줍니다.
## all_x_val 데이터에서 위에서 up_importance_top에 할당한 feature 들의 데이터를 x_val_top 변수에 할당해 줍니다.

all_x_train_top = all_x_train[up_importance_top]
all_x_val_top = all_x_val[up_importance_top]

6] 모델 선언, 학습, 예측

# AI 모델링 및 결과 예측
## XGBClassifier 알고리즘을 사용하여 walkingup_top_model 변수에 모델을 생성 및 초기화 합니다.
## 파라미터는 최종 조정 파라미터를 사용하고, random_state는 2023 으로 설정해 주세요.
## 모델이 생성되면 all_x_train_top, all_y_train 로 모델을 학습시켜 줍니다.
## 모델 학습이 완료되면 all_x_val_top 데이터의 결과를 예측하여 walkingup_pred 변수에 할당 합니다.


walkingup_top_model = XGBClassifier(learning_rate=0.3, max_depth=2, random_state=2023)
walkingup_top_model.fit(all_x_train_top, all_y_train)
walkingup_top_pred = walkingup_top_model.predict(all_x_val_top)
walkingup_top_pred

7] 모델 평가

# 모델 평가 출력(accuracy_score, confusion_matrix, classification_report)

print('accuracy_score: ',accuracy_score(all_y_val,walkingup_top_pred))
print('\n confusion_matrix: \n',confusion_matrix(all_y_val,walkingup_top_pred))
print('\n classification_report: \n',classification_report(all_y_val,walkingup_top_pred))

8] 예측 결과 저장

# walkingup_top_model 예측결과 저장
## result 데이터프레임 13번 인덱스에 'walkingup_top'(모델명), 'all'(검증 데이터명), accuracy_score 결과, f1_score 결과 를 할당해 주세요.
## f1_score의 평균은 'macro' 파라미터를 사용 합니다.
## 예측 결과가 잘 할당 되었는지 확인해 주세요.

result.loc[13] = ['walkingup_top', 'all', accuracy_score(all_y_val,walkingup_top_pred), f1_score(all_y_val,walkingup_top_pred, average = 'macro')]
result

'WORKING_UPSTAIRS' 분류에 영향을 미치는 'sensor' 찾기

'WORKING_UPSTAIRS' 분류에 가장 영향 많이 미치는 상위 20개의 sensor 그룹을 찾아 시각화 

1] 파일 불러오기

# features.csv 파일 불러오기
## 'data'폴더에서 features.csv 파일을 읽어와 feature_group 변수에 할당 하세요.
## 변수에 할당이 잘 되었는지 확인해 주세요. 

feature_group =pd.read_csv('./data/features.csv')

2] 데이터프레임 merge

# 데이터프레임 merge 
## merge_df 변수를 데이터프레임 타입으로 생성 및 초기화 합니다.
## feature_group 변수와 up_importance_sort 변수를 merge 하여 merge_df 할당 합니다.
## 데이터가 잘 할당 되었나 merge_df 데이터를 확인 합니다.

merge_df = pd.DataFrame()
merge_df = pd.merge(feature_group, up_importance_sort)
merge_df

3] 데이터그룹화

# 데이터 그룹화
## merge_df 변수를 'sensor' 기준으로 그룹화 하고 'feature_importance' 열의 데이터를 같은 'sensor' 그룹끼리 더해 줍니다.
## groupby 함수는 데이터프레임을 그룹으로 묶으면서 필요한 계산을 동시에 수행할 수 있습니다.
## [TIP] 변수.groupby(by='그룹기준열')['연산 할 열'].연산메서드()


sensor_sum = merge_df.groupby(by='sensor')['feature_importance'].sum()
sensor_sum

4] 중요도 재정렬

# sensor 중요도 재 정렬
## sensor_sum 데이터를 내림차순으로 정렬 후 sensor_sort 변수에 할당합니다.
## sensor_sum 을 데이터프레임 으로 생성했을 경우 기준(by=)을 지정해 주어야 합니다.

sensor_sort = sensor_sum.sort_values(ascending=False)
sensor_sort

5] 중요도 시각화

# 센서별 중요도 시각화
# sensor 별 중요도를 수평막대 그래프로 시각화 합니다.

plt.barh(y=sensor_sort.index, width=sensor_sort)
plt.xticks(rotation = 90)
plt.grid()
plt.show()

# sensor_sort가 데이터프레임 시
# plt.barh(data = sensor_sort, y=sensor_sort.index, width='feature_importance')
# plt.xticks(rotation = 90)
# plt.grid()
# plt.show()

최종결과 저장

모델 별 accuracy_score, f1_score 지수를 수직 그래프로 시각화

(1) 시각화

# 최종결과 결과 시각화
# 모델 별 accuracy_score, f1_score 지수를 수직 그래프로 시각화 하세요.

result.plot(kind='bar')
plt.grid()
plt.legend(loc='center')
plt.show()

(2) 저장

# 최종결과 저장
## 최종 결과(result)를 'final_result.csv' 파일로 저장해 주세요.
## 영향도가 높은 feature 들의 이름을 모아놓은 변수를 'up_importance_top.csv' 파일로 저장해 주세요.


result.to_csv("final_result.csv")
up_importance_top.to_csv("up_importance_top.csv")

'WORKING_UPSTAIRS' 분류에 영향을 미치는 상위 20 agg 찾기

1] 데이터 그룹화

# 데이터 그룹화
## merge_df 변수를 ['sensor','agg'] 기준으로 그룹화 하면서 'feature_importance' 열의 데이터를 더해 줍니다.
## groupby 함수는 데이터프레임을 그룹으로 묶으면서 필요한 계산을 동시에 수행할 수 있습니다.


sensor_agg_sum = merge_df.groupby(['sensor','agg'])['feature_importance'].sum()
sensor_agg_sum

2] sensor_agg 중요도별 데이터 재정렬

# sensor_agg 중요도 별 데이터 재정렬
## sensor_agg_sum 데이터를 내림차순으로 정렬 후 sensor_agg_sort 변수에 할당합니다.


sensor_agg_sort = sensor_agg_sum.sort_values(ascending=False)
sensor_agg_sort

# sensor_agg_sort 변수를 데이터프레임으로 생성시
# sensor_agg_sort = sensor_agg_sum.sort_values(by='feature_importance', ascending=False)
# sensor_agg_sort

3] 중요도 Top20 acc 시각화

# 중요도 Top20 acc 시각화
## 중요도가 높은 센서 20개의 중요도를 수평 막대그래프로 시각화 합니다.

sensor_agg_sort[:20].plot(kind='barh')
plt.grid()
plt.show()

'sensor'를 구성하고있는 'agg' 시각화

1] 데이터 재구조화

# sensor_agg_sort 데이터 재 구조화
# sensor_agg_sort 데이터의 'agg'열의 고유값을 sensor_agg_sort 데이터의 컬럼으로 변환(재구조화) 합니다. 
# 재구조화 한 데이터를 acc 변수에 할당 합니다.
# 참고함수: unstack()

acc = sensor_agg_sort.unstack()
acc

2] 재정렬

# 센서별 합계 재정렬
## acc 데이터의 각 센서의 행 기준(axis=1) 모든 값을 더해서 acc['sort'] 에 할당 합니다.
## 할당 후 acc 데이터를 acc['sort'] 열의 값 기준으로 내림차순으로 정렬 합니다.
## 정렬 후 데이터를 확인 합니다.


acc['sort'] = acc.sum(axis=1)
acc.sort_values(by = 'sort', ascending = False, inplace=True)
acc

3] 정렬 기준열 제거

# 정렬 기준열 제거
# 센서별 정렬을 완료 했으므로 acc 변수에서 acc['sort']열을 삭제 합니다.


acc.drop('sort', axis=1, inplace=True)
acc

4] 누적 막대 그래프 시각화

# 누적 막대 그래프 시각화
# acc 변수를 sensor 별 수평 그래프로 시각화 합니다.

acc.plot(kind='barh', stacked=True, figsize=(20,15))
plt.grid()
plt.show()

Activity 예측

1] real_data 뱐수에 할당

## real_data.csv 파일을 불러와서 real_data 변수에 할당 합니다.
## 잘 할당 되었는지 데이터 확인

real_data = pd.read_csv('./data/real_data.csv')
real_data

2] 불필요 컬럼 제거

## real_data 변수(데이터셋)에서 행동분류에 불필요한 'subject'열 제거한 데이터를 real_x_val 변수에 할당 합니다.
## 나중에 예측 결과를 real_data 데이터 프레임에 병합해서 결과를 확인해야 하므로 real_data 변수에서 'subject'열 제거하지 마세요.

real_x_val = real_data.drop('subject', axis=1)
real_x_val

3] real_x_val 데이터에서 최고의 성능을 내는 학습 feature 데이터를 real_x_top 변수에 할당

## real_x_val 데이터에서 최고의 성능을 내는 학습 feature 데이터를 real_x_top 변수에 할당합니다.
## Feature Selection 된 상위 중요 feature 명 리스트는 up_importance_top 변수를 사용 합니다.

real_x_top = real_x_val[up_importance_top]

4] walkingup_top 모델로 real_x_top 데이터의 'WALKING_UPSTAIRS' 행동분류 예측해서 real_walkingup_pred 변수에 할당

## walkingup_top 모델로 real_x_top 데이터의 'WALKING_UPSTAIRS' 행동분류 예측해서 real_walkingup_pred 변수에 할당 합니다.

real_walkingup_pred = walkingup_top_model.predict(real_x_top)
real_walkingup_pred

5] real_data['WALKING_UPSTAIRS'] 열에 real_walkingup_pred 예측 결과를 할당 하고, 데이터를 확인

## real_data['WALKING_UPSTAIRS'] 열에 real_walkingup_pred 예측 결과를 할당 하고, 데이터를 확인 합니다.

real_data['WALKING_UPSTAIRS'] = real_walkingup_pred
real_data

6] 인덱스 미포함 real_data 변수를 real_result.csv 파일로 저장

# 인덱스 미포함 real_data 변수를 real_result.csv 파일로 저장 합니다.

real_data.to_csv('real_result.csv', index=False)

7] 저장 되었는지 확인

# 잘 저장 되었는지 확인 합니다.

pd.read_csv('real_result.csv')

스마트워치 센서 데이터 기반 행동 분류 3일차

데이터 불러오기

# pandas, numpy, matplotlib, seaborn, os 등 필요 라이브러리 호출
# 데이터를 나누기 위한 sklearn.model_selection 모듈의 train_test_split 함수 사용
# 모델 성능 평가 출력을 위해 sklearn.metrics 모듈의 모든 클래스 사용
# XGBClassifier 알고리즘 사용을 위한 모듈 추가
# 저장한 모델을 불러오기 위한 joblib 라이브러리 추가
## 그외 라이브러리는 필요에 따라 호출 하세요.

import pandas as pd
import numpy as np
import matplotlib.pyplot  as plt
import seaborn as sns
import os
import joblib 

from sklearn.model_selection import train_test_split
from sklearn.metrics import *

from xgboost import XGBClassifier

모델 데이터 불러오기

# 2일차 데이터 불러오기
## 2일차에 만들었던 최고 성능의 모델(hpt_xgb_top_model.pkl)을 불러와 hpt_xgb_top_model 변수에 할당 합니다.
## 모델 결과에 가장 영향을 많이 미친 feature의 이름이 담긴 importance_top 데이터(importance_top.pkl)를 불러와 importance_top 변수에 할당 합니다.

hpt_xgb_top_model = joblib.load('hpt_xgb_top_model.pkl')
importance_top = joblib.load('importance_top.pkl')

결과 데이터 프레임 불러오기

# 2일차 모델 결과 데이터 불러오기
## 모델별 정확도를 비교 할 수 있도록 결과 저장 파일을 불러 옵니다.
## 'data' 폴더에서 2일차에 생성한 result4.csv 파일을 불러와서 result 변수에 할당 합니다.
## result 변수에 할당이 잘 되었는지 확인해 주세요. 


result = pd.read_csv('./data/result4.csv')
result

test 데이터 불러오기

# test 데이터 불러오기
## 'data' 폴더에서 test_data.csv 파일을 불러와서 test_data 변수에 할당해 주세요.
## 잘 할당 되었는지 데이터를 확인해 주세요.

test_data = pd.read_csv('./data/test_data.csv')
test_data

데이터 나누기

# test X, Y 나누기
## 모델을 검증 하기위해 test 데이터를 사용하여 test_x , test_y_map(target) 데이터를 생성 합니다.
## test_x 에는 test_data 데이터셋에서 2일차에 최고의 성능을 내는 feature 들만(importance_top) 분리하여 할당 합니다.  
## test_y 에는 모델의 예측 결과와 비교할 수 있도록 test_data['Activity'] 열의 값을 숫자형으로 치환하여 할당 합니다.
## 치환 데이터: 'STANDING':0, 'SITTING':1, 'LAYING':2, 'WALKING':3, 'WALKING_UPSTAIRS':4, 'WALKING_DOWNSTAIRS':5


test_x = test_data[importance_top]
test_y_map = test_data['Activity'].map({'STANDING':0, 'SITTING':1, 'LAYING':2, 'WALKING':3, 'WALKING_UPSTAIRS':4, 'WALKING_DOWNSTAIRS':5})

검증

# test 데이터 결과 예측
# 2일차에 생성한 hpt_xgb_top_model 에 text_x 데이터를 적용한 예측 결과를 test_hpt_xgb_top_pred 변수에 할당 합니다.
# 사용할 모델은 .pkl 파일에서 로드한 hpt_xgb_top_model 변수를 사용 합니다.

test_hpt_xgb_top_pred = hpt_xgb_top_model.predict(test_x)
test_hpt_xgb_top_pred

# test 데이터 적용 모델 성능 평가 하기
## 모델이 결과를 잘 예측하였는지 3가지 성능지표로 결과를 평가 합니다.
## 3가지 성능지표: accuracy_score, confusion_matrix, classification_report

print('accuracy_score: ',accuracy_score(test_y_map,test_hpt_xgb_top_pred))
print('\n confusion_matrix: \n',confusion_matrix(test_y_map,test_hpt_xgb_top_pred))
print('\n classification_report: \n',classification_report(test_y_map,test_hpt_xgb_top_pred))

예측 결과 저장

# hpt_xgb_top_model 예측결과 저장
## result 데이터프레임 9번 인덱스에 'test_hpt_xgb_top'(모델명), 'test'(검증 데이터명), accuracy_score 결과, f1_score 결과 를 할당해 주세요.
## f1_score의 평균은 'macro' 파라미터를 사용 합니다.
## 예측 결과가 잘 할당 되었는지 확인해 주세요.


result.loc[9] = ['test_hpt_xgb_top', 'test', accuracy_score(test_y_map,test_hpt_xgb_top_pred), f1_score(test_y_map,test_hpt_xgb_top_pred, average = 'macro')]
result

과대적합 해소

1) 학습량 늘리기

(1) 불러오기

# train 데이터 불러오기
## 'data' 폴더에서 'train_data.csv' 파일을 불러와서 train_data 변수에 할당 합니다.
## 잘 불러와 졌는지 데이터를 확인 합니다.

train_data = pd.read_csv('./data/train_data.csv')
train_data

(2) 합치기

# 데이터 합치기
## train 데이터셋과 test 데이셋을 합쳐 데이터의 양을 늘려 줍니다.
## train 데이터셋과 test 데이터셋을 위/아래로 합쳐서 all_data 변수에 할당 합니다.
## 참고함수: concat


all_data = pd.concat([train_data, test_data])
all_data

(3) 인덱스 초기화

# 데이터 인덱스 초기화
## 데이터셋을 위아래로 합치면 인덱스 중복이 발생 합니다.
## 인덱스가 중복되지 않도록 인덱스를 리셋해 주세요.

all_data.reset_index(drop=True, inplace=True)
all_data

(4) X, Y데이터 나누기

# X, Y 데이터 나누기
## 모델 학습을 위해 feature(X) 데이터와 target(Y) 데이터를 나누어 주어야 합니다.
## target 데이터인 all_data['Activity'] 값을 모델이 인식할 수 있게 숫자로 변환하여 all_y_map 변수에 할당 합니다.
## all_data 데이터에서 2일차에서 선정한 중요도가 높은 feature 들만 골라 all_x 변수에 할당 합니다.
## 중요도가 높은 feature 들의 이름은 .pkl 파일에서 불러와 importance_top 변수에 저장되어 있습니다.

all_y_map = all_data['Activity'].map({'STANDING':0, 'SITTING':1, 'LAYING':2, 'WALKING':3, 'WALKING_UPSTAIRS':4, 'WALKING_DOWNSTAIRS':5})
all_x = all_data[importance_top]
all_x

(5) 학습 데이터 나누기

# 학습 데이터 나누기
## 학습에 필요한 all_x 와 all_y_map 데이터를 학습 7 : 검증 3 비율로 나누어 주세요.
## 이때 random_state 는 2023 으로 설정해 주세요.
## 데이터를 할당받을 변수명: all_x_train, all_x_val, all_y_train, all_y_val


all_x_train, all_x_val, all_y_train, all_y_val = train_test_split(all_x,all_y_map,train_size=0.7,random_state=2023)

(6) 모델링 및 예측

# AI 모델링 및 결과 예측
## XGBClassifier 알고리즘을 사용하여 all_hpt_xgb_model 변수에 모델을 생성 및 초기화 합니다.
## 이때 파라미터는 튜닝에서 가장 성능이 좋았던 값으로 지정하고, random_state는 2023 으로 설정해 주세요.
## 모델이 생성되면 all_x_train, all_y_train 로 모델을 학습시켜 줍니다.
## 모델 학습이 완료되면 test_x 데이터의 결과를 예측합니다.

all_hpt_xgb_model = XGBClassifier(learning_rate=0.3, max_depth=3, random_state=2023)
all_hpt_xgb_model.fit(all_x_train, all_y_train)
all_hpt_xgb_pred = all_hpt_xgb_model.predict(test_x)
all_hpt_xgb_pred

(7) 평가

# all_hpt_xgb_model 성능 평가 하기
## 모델이 결과를 잘 예측하였는지 3가지 성능지표로 결과를 평가 합니다.
## 3가지 성능지표: accuracy_score, confusion_matrix, classification_report

print('accuracy_score: ',accuracy_score(test_y_map,all_hpt_xgb_pred))
print('\n confusion_matrix: \n',confusion_matrix(test_y_map,all_hpt_xgb_pred))
print('\n classification_report: \n',classification_report(test_y_map,all_hpt_xgb_pred))

(8) 예측 결과 저장

# all_hpt_xgb_model 예측결과 저장
## result 데이터프레임 10번 인덱스에 'all_hpt_xgb'(모델명), 'test'(검증 데이터명), accuracy_score 결과, f1_score 결과를 할당해 주세요.
## f1_score의 평균은 'macro' 파라미터를 사용 합니다.
## 예측 결과가 잘 할당 되었는지 확인해 주세요.

result.loc[10] = ['all_hpt_xgb', 'test', accuracy_score(test_y_map,all_hpt_xgb_pred), f1_score(test_y_map,all_hpt_xgb_pred, average = 'macro')]
result

2) 모델 단순화

(1) 결과 예측

# 모델 단순화 및 결과 예측
## XGBClassifier 알고리즘을 사용하여 all_hpt_depth_xgb_model 변수에 모델을 생성 및 초기화 합니다.
## 이때 과대적합이 일어나지 않도록 XGBClassifier의 깊이 파라미터를 조정해 모델을 단순화 하세요.
## random_state는 2023 으로 설정해 주세요.
## 모델이 생성되면 all_x_train, all_y_train 로 모델을 학습시켜 줍니다.
## 모델 학습이 완료되면 test_x 데이터의 결과를 예측합니다.

all_hpt_depth_xgb_model = XGBClassifier(learning_rate=0.3, max_depth=2, random_state=2023)
all_hpt_depth_xgb_model.fit(all_x_train, all_y_train)
all_hpt_depth_xgb_pred = all_hpt_depth_xgb_model.predict(test_x)
all_hpt_depth_xgb_pred

(2) 성능 평가

# all_hpt_depth_xgb_model 성능 평가 하기
## 모델이 결과를 잘 예측하였는지 3가지 성능지표로 결과를 평가 합니다.
## 3가지 성능지표: accuracy_score, confusion_matrix, classification_report

print('accuracy_score: ',accuracy_score(test_y_map,all_hpt_depth_xgb_pred))
print('\n confusion_matrix: \n',confusion_matrix(test_y_map,all_hpt_depth_xgb_pred))
print('\n classification_report: \n',classification_report(test_y_map,all_hpt_depth_xgb_pred))

(3) 예측 결과 저장

# all_hpt_depth_xgb_model 예측결과 저장
## result 데이터프레임 11번 인덱스에 'all_hpt_depth_xgb'(모델명), 'test'(검증 데이터명), accuracy_score 결과, f1_score 결과를 할당해 주세요.
## f1_score의 평균은 'macro' 파라미터를 사용 합니다.
## 예측 결과가 잘 할당 되었는지 확인해 주세요.

result.loc[11] = ['all_hpt_depth_xgb', 'test', accuracy_score(test_y_map,all_hpt_depth_xgb_pred), f1_score(test_y_map,all_hpt_depth_xgb_pred, average = 'macro')]
result

결과 저장

## 모델 저장하기(코드 수정하지 말고 실행해 주세요)
## 과대적합을 해결한 all_hpt_xgb_model 모델을 joblib.dump 매서드를 사용하여 all_hpt_xgb_model.pkl 파일로 저장 합니다.

joblib.dump(all_hpt_xgb_model, 'all_hpt_xgb_model.pkl')

# 결과 저장
# result 변수를 인덱스 미포함하여 'result5.csv' 파일로 저장 합니다.
# 저장경로는 현재 경로의 하위 './data' 폴더로 지정해 주세요.

result.to_csv('./data/result5.csv', index=False)

저장 여부 확인

# 저장 여부 확인
## 데이터가 파일로 잘 저장 되었는지 result5.csv 파일을 로드하여 확인 합니다.
## 로드한 데이터는 save_check 변수에 할당해 주세요.

save_check = pd.read_csv('./data/result5.csv')
save_check

Aivle 미니 프로젝트 3차_4(3)] 최고 정확도를 위한 학습 feature 개수 선별

반복문을 통한 중요도 계산, tqdm

# 반복문을 사용한 feature 개수 별 정확도 계산
## acc 데이터 프레임을 생성 및 초기화(컬럼 지정: columns=['accuracy_score'])
## for 문을 사용해 중요도 상위 feature 1개 모델링부터 상위 feature 150개를 모델에 순차적으로 학습시킨 후 각 accuracy_score 결과를 acc 변수에 누적 합니다.
## 전체 feature는 561개 이지만, feature 1개부터 150개면 까지 학습하면 충분한 결과를 얻을 수 있습니다.
## [TIP] 1번째 학습: feature 1개로 모델 학습 -> 결과 누적, 2번째 학습: feature 2개로 모델 학습 -> 결과 누적 ..... 150번째 학습: feature 150개로 모델 학습 -> 결과 누적 
## [TIP] 슬라이싱 할때 [:1] -> index 0 까지 짤림, [:100] -> index 99 까지 짤림, 슬라이싱 할 인덱스 번호 +1 해서 슬라이싱 할 것
## [TIP] tqdm을 반복문에 사용하였을때 반복문의 현 실행 위치를 퍼센테이지로 나타내 줍니다.

acc = pd.DataFrame(columns=['accuracy_score'])

for i in tqdm(range(150)):

    importance_n = importance_sort['feature_name'][:i+1]

    x_train_n = x_train[importance_n]
    x_val_n = x_val[importance_n]

    xgb_n_model = XGBClassifier(params, random_state=2023)
    xgb_n_model.fit(x_train_n, y_train)
    xgb_n_pred = xgb_n_model.predict(x_val_n)
    
    acc.loc[i] = accuracy_score(y_val,xgb_n_pred)


acc

누적 결과 시각화

# accuracy_score 누적 결과 시각화
## accuracy_score 누적한 acc 변수를 plt.plot 함수를 사용하여 시각화 합니다.

plt.figure(figsize=(20,5))
plt.plot(acc, marker='o')
plt.xlabel('train_features')
plt.ylabel('accuracy')
plt.grid()
plt.show()

최고 정확도 개수 찾기

# 최고 정확도 Feature 개수 찾기
## agg 변수를 accuracy_score 기준 내림차순으로 정렬 합니다.(인덱스 재설정X)
## 인덱스 번호는 누적 학습된 feature의 개수 입니다.
## accuracy_score 값으로 내림차순 정렬 후 이 가장 첫번째 인덱스 번호가 가장 정확도가 좋은 feature 개수를 뜻합니다.

acc.sort_values(by = 'accuracy_score', ascending=False, inplace=True)
acc

최고 정확도 feature열 지정

# 최고 정확도 Feature명 저장
## acc 에서 확인한 최고 결과 feature 개수 만큼 importance_sort['feature_name']를 슬라이싱 하여 importance_top 변수에 할당 합니다.
## 정확도 최고치 인덱스 값 +1 해서 슬라이싱 하세요.
## [TIP] 슬라이싱 할때 [:1] -> feature 0번 까지 짤림, [:100] -> feature 99번 까지 짤림

importance_top = importance_sort['feature_name'][:acc.index[0]+1]
importance_top

중요 feature 지정

# 중요 feature 저장
# importance_top 변수를 인덱스 미포함하여 'importance_top.csv' 파일로 저장 합니다.
# 저장경로는 현재 경로의 하위 './data' 폴더로 지정해 주세요.

importance_top.to_csv('./data/importance_top.csv', index=False)

훈련 데이터 생성

# 훈련 데이터 생성
# x_train_top 변수에 x_train을 중요 feature 만큼 슬라이싱 한 x_train[importance_top] 할당
# x_val_top 변수에 x_val을 중요 feature 만큼 슬라이싱 한 x_val[importance_top] 할당

x_train_top = x_train[importance_top]
x_val_top = x_val[importance_top]

모델링

# 베스트 feature 개수 적용 모델링
## XGBClassifier 모듈에 베스트 파라미터를 적용하여 모델을 생성 및 초기화 합니다.
## 파라미터는 params 변수에 사용된 파라미터와, random_state=2023 으로 설정해 주세요.
## 이때 생성한 모델을 hpt_xgb_top_model 변수에 할당 합니다.
## 모델이 생성되면 최적의 feature 개수만 선별한 x_train_top 데이터와 y_train 으로 모델을 학습시켜 줍니다.
## 모델 학습이 완료되면 x_val_top의 결과를 예측하고 결과를 hpt_xgb_top_pred 변수에 할당 합니다.


hpt_xgb_top_model = XGBClassifier(learning_rate=0.3, max_depth=3, random_state=2023)
hpt_xgb_top_model.fit(x_train_top, y_train)
hpt_xgb_top_pred = hpt_xgb_top_model.predict(x_val_top)
hpt_xgb_top_pred

평가

# hpt_xgb_top_model 성능 평가 하기
## 모델이 결과를 잘 예측하였는지 3가지 성능지표로 결과를 평가 합니다.
## 3가지 성능지표: accuracy_score, confusion_matrix, classification_report

print('accuracy_score: ',accuracy_score(y_val,hpt_xgb_top_pred))
print('\n confusion_matrix: \n',confusion_matrix(y_val,hpt_xgb_top_pred))
print('\n classification_report: \n',classification_report(y_val,hpt_xgb_top_pred))

예측 결과 지정

# hpt_xgb_top_model 예측결과 저장
## result 데이터프레임 8번 인덱스에 'hpt_xgb_top'(모델명), 'train'(검증 데이터명), accuracy_score 결과, f1_score 결과를 할당해 주세요.
## f1_score의 평균은 'macro' 파라미터를 사용 합니다.
## 예측 결과가 잘 할당 되었는지 확인해 주세요.


result.loc[8] = ['hpt_xgb_top', 'train', accuracy_score(y_val, hpt_xgb_top_pred), f1_score(y_val, hpt_xgb_top_pred, average = 'macro')]
result

결과 저장 및 시각화

# 결과 저장
# result 변수를 인덱스 미포함하여 'result4.csv' 파일로 저장 합니다.
# 저장경로는 현재 경로의 하위 './data' 폴더로 지정해 주세요.

result.to_csv('./data/result4.csv', index=False)

# 저장 여부 확인
## 데이터가 파일로 잘 저장 되었는지 result4.csv 파일을 로드하여 확인 합니다.
## 로드한 데이터는 save_check 변수에 할당해 주세요.


save_check = pd.read_csv('./data/result4.csv')
save_check

컬럼 인덱스 변환

# 컬럼-인덱스 변환
## save_check 데이터 프레임의 ['model_name', 'valid_data'] 컬럼을 지정하여 인덱스로 설정해 줍니다.
## 변환한 값은 result_comp 변수에 할당해 주세요.

result_comp = save_check.set_index(['model_name','valid_data'])
result_comp

시각화

# 모델별 결과 시각화
# pandas의 plot 함수을 사용하여 AI모델 별 accuracy_score, f1_score 수직 그래프 시각화 합니다.
# grid를 추가해 주세요.
# legend를 표시하고, 위치는 center 입니다.

result_comp.plot(kind='bar')
plt.grid()
plt.legend(loc='center')
plt.show()

모델 저장

## 모델 저장하기
## 오늘 만들었던 최고 성능의 모델과 학습 데이터를 저장 합니다.
## 아래의 코드에서 한글로 씌여진 곳에 본인이 생성한 변수명을 기입해 주세요.

import joblib 

# joblib.dump(최고의 모델, 'hpt_xgb_top_model.pkl')
# joblib.dump(중요 feature명 모음, 'importance_top.pkl')

# joblib.dump(최종 학습 X 데이터, 'x_train_top.pkl')
# joblib.dump(최종 학습 Y 데이터, 'y_train.pkl')


# 작성 예시
joblib.dump(hpt_xgb_top_model, 'hpt_xgb_top_model.pkl')
joblib.dump(importance_top, 'importance_top.pkl')

joblib.dump(x_train_top, 'x_train_top.pkl')
joblib.dump(y_train, 'y_train.pkl')

Feature Selection

Feature Selection

ㆍ 모델 결과에 영향이 큰 상위 feature 들만 추출하여 모델을 학습

ㆍ  총 562개의 feature 중 중요도 상위 150개, 중요도 상위 50개의 feature 를 선별하여 모델을 학습

ㆍ  feature 선별은 가장 정확도가 높았던 XGBoost에 하이퍼파라미터를 적용하여 선별

ㆍ  result 변수에 그동안 저장된 모델별 결과와 Feature Selection 기법을 사용한 모델의 정확도를 비교

데이터 프레임 생성

# importance_sort 데이터프레임 변수 생성 초기화
## feature 별 중요도 정보를 할당할 importance_sort 변수를 데이터 프레임 타입으로 생성해 주세요.

importance_sort = pd.DataFrame()

feature 할당

# feature명 추출
## importance_sort['feature_name'] 열에 x 변수의 컬럼명을 할당해 주세요.

importance_sort['feature_name'] = x.columns
importance_sort

중요도 할당

# feature(feature) 중요도 할당
## hpt_xgb_model 모델의 feature_importances 를 importance_sort['feature_importance'] 열에 할당 합니다.
## 모델 feature_importances 확인하는 방법은 .feature_importances_ 함수를 사용합니다.


importance_sort['feature_importance'] = hpt_xgb_model.feature_importances_
importance_sort

중요도 순으로 인덱스 재정렬, 인덱스 리셋

# 중요도 순으로 인덱스 재 정렬
## importance_sort 데이터프레임을 importance_sort['feature_importance'] 순으로 내림차순 정열 합니다.
## 정렬 후 결과를 확인 합니다.
## 데이터의 순서가 위에 있을 수록 중요도 순위가 높은 feature 입니다.

importance_sort.sort_values(by='feature_importance', ascending=False, inplace=True)
importance_sort

# 인덱스 리셋
## importance_sort['feature_importance'] 내림차순 때문에 엉킨 데이터프레임의 인덱스를 리셋 합니다.
## 인덱스 리셋 후 결과를 확인 합니다.
## 중요도 순위가 높은 feature 일수록 인덱스 번호가 낮게 부여 됩니다.


importance_sort.reset_index(drop=True, inplace=True)
importance_sort

중요 150개 재선정

# 중요 feature 150 개 선정
## 중요도로 정렬된 importance_sort['feature_importance']의 상위 150 순위의 feature_name 을 importance_150 변수에 할당 합니다.
## 인덱스 번호가 낮을 수록 중요도 순위가 높은 feature 입니다.

importance_150 = importance_sort['feature_name'][:150]
importance_150

훈련 데이터 생성

# importance_150 훈련 데이터 생성
# x_train 에서 importance_150 순위에 해당하는 feature 만 찾아 x_train_150 변수에 할당 합니다.
# x_val 에서 importance_150 순위에 해당하는 feature 만 찾아 x_val_150 변수에 할당 합니다.
# 상위 150 순위의 feature 인덱싱은 importance_150 사용 합니다.

x_train_150 = x_train[importance_150]
x_val_150 = x_val[importance_150]

AI 모델링 학습, 선언, 예측

# AI 모델링
## XGBClassifier 함수를 사용하여 hpt_xgb_150_model 변수에 모델을 생성 및 초기화 합니다.
## 이때 파라미터는 params 변수와 random_state=2023 으로 설정해 주세요.
## 모델이 생성되면 x_train_150, y_train 으로 모델을 학습시켜 줍니다.
## 모델 학습이 완료되면 x_val_150의 결과를 예측하고 출력 합니다.

hpt_xgb_150_model = XGBClassifier(params, random_state=2023)
hpt_xgb_150_model.fit(x_train_150, y_train)
hpt_xgb_150_pred = hpt_xgb_150_model.predict(x_val_150)
hpt_xgb_150_pred

평가

# hpt_xgb_150_model 모델 성능 평가 하기
## 모델이 결과를 잘 예측하였는지 3가지 성능지표로 결과를 평가 합니다.
## 3가지 성능지표: accuracy_score, confusion_matrix, classification_report

print('accuracy_score: ',accuracy_score(y_val,hpt_xgb_150_pred))
print('\n confusion_matrix: \n',confusion_matrix(y_val,hpt_xgb_150_pred))
print('\n classification_report: \n',classification_report(y_val,hpt_xgb_150_pred))

예측 결과 저장

# hpt_xgb_150 예측결과 저장
## result 데이터프레임 6번 인덱스에 'hpt_xgb_150'(모델명), 'train'(검증 데이터명), accuracy_score 결과, f1_score 결과를 할당해 주세요.
## f1_score의 평균은 'macro' 파라미터를 사용 합니다.
## 예측 결과가 잘 할당 되었는지 확인해 주세요.


result.loc[6] = ['hpt_xgb_150', 'train', accuracy_score(y_val, hpt_xgb_150_pred), f1_score(y_val, hpt_xgb_150_pred, average = 'macro')]
result

중요 feature 50개 선정

# 중요 feature 50개 선정
## 중요도로 정렬된 importance_sort['feature_importance']의 상위 50 순위의 feature_name 을 importance_50 변수에 할당 합니다.
## 인덱스 번호가 낮을 수록 중요도 순위가 높은 feature 입니다.

importance_50 = importance_sort['feature_name'][:50]
importance_50

모델링 선언, 훈련, 예측

# importance_50 적용 모델링
## XGBClassifier 모듈에 베스트 파라미터를 적용하여 모델을 생성 및 초기화 합니다.
## 파라미터는 params 변수에 사용된 파라미터와, random_state=2023 으로 설정해 주세요.
## 이때 생성한 모델을 hpt_xgb_50_model 변수에 할당 합니다.
## 모델이 생성되면 x_train_50, y_train으로 모델을 학습시켜 줍니다.
## 모델 학습이 완료되면 x_val_50 의 결과를 예측하고 결과를 hpt_xgb_50_pred 변수에 할당 합니다.


hpt_xgb_50_model = XGBClassifier(learning_rate=0.3, max_depth=3, random_state=2023)
hpt_xgb_50_model.fit(x_train_50, y_train)
hpt_xgb_50_pred = hpt_xgb_50_model.predict(x_val_50)
hpt_xgb_50_pred

평가

# hpt_xgb_50_model 성능 평가 하기
## 모델이 결과를 잘 예측하였는지 3가지 성능지표로 결과를 평가 합니다.
## 3가지 성능지표: accuracy_score, confusion_matrix, classification_report

print('accuracy_score: ',accuracy_score(y_val,hpt_xgb_50_pred))
print('\n confusion_matrix: \n',confusion_matrix(y_val,hpt_xgb_50_pred))
print('\n classification_report: \n',classification_report(y_val,hpt_xgb_50_pred))

예측 결과 저장

# hpt_xgb_50 모델 예측결과 저장
## result 데이터프레임 7번 인덱스에 'hpt_xgb_50'(모델명), 'train' (검증 데이터명), accuracy_score 결과, f1_score 결과를 할당해 주세요.
## f1_score의 평균은 'macro' 파라미터를 사용 합니다.
## 예측 결과가 잘 할당 되었는지 확인해 주세요.


result.loc[7] = ['hpt_xgb_50', 'train', accuracy_score(y_val, hpt_xgb_50_pred), f1_score(y_val, hpt_xgb_50_pred, average = 'macro')]
result

모델 튜닝

불러오기

# pandas, numpy, matplotlib, seaborn, os 등 필요 라이브러리 호출
## 데이터를 나누기 위한 sklearn.model_selection 모듈의 train_test_split 함수 사용
## 모델 성능 평가 출력을 위해 sklearn.metrics 모듈의 모든 클래스 사용
## 추가로 필요한 라이브러리는 설치/호출 하세요

import pandas as pd
import numpy as np
import matplotlib.pyplot  as plt
import seaborn as sns
import os


from sklearn.model_selection import train_test_split
from sklearn.metrics import *

tqdm

# 진행상황을 확인 하기 위한 라이브러리
from tqdm import tqdm

데이터 불러오기, 전처리

# 데이터셋 파일 불러오기
## data 변수에 train_data.csv 파일을 불러와서 할당해 주세요.
## train_data.csv 파일은 현재위치의 하위 data 폴더안에 있습니다. 
## 변수에 할당이 잘 되었는지 확인해 주세요. 

data = pd.read_csv('./data/train_data.csv')
data.head()

# 불필요한 열 제거
## 'subject'열 은 데이터를 수집한 사람을 구별하기 위한 데이터 입니다.
## 'subject'열을 data 데이터프레임 변수 에서 제거해 주세요.
## 'subject'열이 잘 제거 되었는지 확인해 주세요.


data.drop('subject', axis=1, inplace=True)
data

학습 결과 데이터 불러오기

# 데이터셋 파일 불러오기
## result3.csv 파일을 불러와서 result 변수에 할당해 주세요.
## result3.csv 파일은 현재위치의 하위 data 폴더안에 있습니다. 
## 변수에 할당이 잘 되었는지 확인해 주세요. 


result = pd.read_csv('./data/result3.csv')
result

Hyperparameter Tuning

라이브러리 불러오기

# XGBClassifier 알고리즘 사용을 위한 모듈 추가
# GridSearchCV 을 사용하기 위한 모듈 추가(scikit-learn 라이브러리에 포함)

from xgboost import XGBClassifier
from sklearn.model_selection import GridSearchCV

데이터 전처리

# X, Y 데이터 나누기
## y 변수에 target으로 사용할 data['Activity']을 할당해 주세요.
## data 에서 data['Activity'] 열을 뺀 나머지 x 변수에 할당해 주세요.

y = data['Activity']
x = data.drop('Activity', axis=1)

# target 값 변경
## XGBoost 는 문자형 데이터로 학습할 수 없습니다. 
## target 데이터인 y 변수를 숫자형 형태로 치환하여 각각 y_map 변수에 할당해 주세요.
## 데이터 치환 함수: map
# 치환 데이터: 'STANDING':0, 'SITTING':1, 'LAYING':2, 'WALKING':3, 'WALKING_UPSTAIRS':4, 'WALKING_DOWNSTAIRS':5

y_map = y.map({'STANDING':0, 'SITTING':1, 'LAYING':2, 'WALKING':3, 'WALKING_UPSTAIRS':4, 'WALKING_DOWNSTAIRS':5})
y_map

# 학습 데이터 나누기
## 학습에 필요한 x 와 y_map 데이터를 학습 7 : 검증 3 비율로 나누어 주세요.
## 이때 random_state 는 2023 으로 설정해 주세요.
## 데이터를 할당받을 변수명: x_train, x_val, y_train, y_val

x_train, x_val, y_train, y_val = train_test_split(x,y_map,train_size=0.7,random_state=2023)

하이퍼 파라미터 찾기

# 하이퍼 파라미터 찾기
## 파라미터 그리드를 생성할 initial_params 변수를 생성 후 파라미터의 범위를 할당 합니다.
## initial_params 파라미터 범위: {'learning_rate': [0.1, 0.2, 0.3], 'max_depth': [2,3,4]}
## XGBClassifier 모듈을 초기화(random_state=2023) 해서 xgb_model 변수에 할당 합니다.
## GridSearchCV 에 아래의 파라미터를 적용한 뒤 모델을 학습합니다.
## GridSearchCV 파라미터: estimator=xgb_model, param_grid=initial_params, cv=3, verbose=2
## GridSearchCV가 적용된 모델을 hpt_xgb_model 변수에 할당 합니다.
## GridSearchCV가 적용된 모델의 예측결과를 hpt_xgb_pred 변수에 할당 합니다.
## 그리드 서칭은 실습 노트북 기준 약 20분이 소요 됩니다.(실행해 놓고 티 타임)

initial_params = {'learning_rate': [0.1, 0.2, 0.3], 'max_depth': [2,3,4]}
xgb_model = XGBClassifier(random_state=2023)
hpt_xgb_model = GridSearchCV(estimator=xgb_model, param_grid=initial_params, cv=3, verbose=2)
hpt_xgb_model.fit(x_train, y_train)
hpt_xgb_pred = hpt_xgb_model.predict(x_val)

ㆍ GridSearchCV를 사용하면 지정한 파라미터 그리드에서 최적의 파라미터 조합을 찾아내고, 해당 조합으로 모델을 학습시킵니다.

ㆍ hpt_xgb_model.fit(x_train, y_train)을 실행한 후에는 hpt_xgb_model 객체가 최적의 파라미터로 학습된 XGBClassifier 모델을 포함

그리드 서치를 통한 모델 정확도 출력

# 그리드 서치를 적용한 모델 정확도 출력
## 그리드 서치에서 학습한 모델의 accuracy_score를 출력 합니다.

print('accuracy_score: ', accuracy_score(y_val,hpt_xgb_pred))

최적 파라미터 확인

# 최적 파라미터 확인
## GridSearchCV 실핼 후 최적의 성능 모델링에 사용된 베스트 파라미터를 params 변수에 할당 합니다.
## 베스트 파라미터 확인 매서드: .best_params_

params = hpt_xgb_model.best_params_
params

모델 선언, 학습, 예측

# 베스트 파라미터 적용 모델링
## XGBClassifier 모듈에 베스트 파라미터를 적용하여 모델을 생성 및 초기화 합니다.
## 파라미터는 params 변수에 사용된 파라미터와, random_state=2023 으로 설정해 주세요.
## 이때 생성한 모델을 hpt_xgb_model 변수에 할당 합니다.
## 모델이 생성되면 x_train, y_train 으로 모델을 학습시켜 줍니다.
## 모델 학습이 완료되면 x_val의 결과를 예측하고 결과를 hpt_xgb_pred 변수에 할당 합니다.



hpt_xgb_model = XGBClassifier(params, random_state=2023)
hpt_xgb_model.fit(x_train, y_train)
hpt_xgb_pred = hpt_xgb_model.predict(x_val)
hpt_xgb_pred

평가

# hpt_xgb_model 모델 성능 평가 하기
## 모델이 결과를 잘 예측하였는지 3가지 성능지표로 결과를 평가 합니다.
## 3가지 성능지표: accuracy_score, confusion_matrix, classification_report

print('accuracy_score: ',accuracy_score(y_val,hpt_xgb_pred))
print('\n confusion_matrix: \n',confusion_matrix(y_val,hpt_xgb_pred))
print('\n classification_report: \n',classification_report(y_val,hpt_xgb_pred))

예측 결과

# 하이퍼 파라미터 튜닝 XGB 예측결과 저장
## result 데이터프레임 5번 인덱스에 'hpt_xgb'(모델명), 'train'(검증 데이터명), accuracy_score 결과, f1_score 결과를 할당해 주세요.
## f1_score의 평균은 'macro' 파라미터를 사용 합니다.
## 예측 결과가 잘 할당 되었는지 확인해 주세요.


result.loc[5] = ['hpt_xgb', 'train', accuracy_score(y_val, hpt_xgb_pred), f1_score(y_val, hpt_xgb_pred, average = 'macro')]
result

Aivle 미니 프로젝트 3차_3] SVM, KNN, Logistic Regression, GBM, XGB

데이터 불러오기, 전처리

# pandas, numpy, matplotlib, seaborn, os 등 필요 라이브러리 호출
# 데이터를 나누기 위한 sklearn.model_selection 모듈의 train_test_split 함수 사용
# 모델 성능 평가 출력을 위해 sklearn.metrics 모듈의 모든 클래스 사용
## 추가로 필요한 라이브러리는 설치/호출 하세요

import pandas as pd
import numpy as np
import matplotlib.pyplot  as plt
import seaborn as sns
import os

from sklearn.model_selection import train_test_split
from sklearn.metrics import *

# 데이터셋 파일 불러오기
## data 변수에 train_data.csv 파일을 불러와서 할당해 주세요.
## train_data.csv 파일은 현재위치의 하위 data 폴더안에 있습니다. 
## 변수에 할당이 잘 되었는지 확인해 주세요. 

data = pd.read_csv('./data/train_data.csv')
data

# 불필요한 열 제거
## 'subject'열 은 데이터를 수집한 사람을 구별하기 위한 데이터 입니다.
## 'subject'열을 data 데이터프레임 변수 에서 제거해 주세요.
## 'subject'열이 잘 제거 되었는지 확인해 주세요.


data.drop('subject', axis=1, inplace=True)
data

# 모델 결과 저장 데이터 프레임 생성
## result 데이터프레임 생성 및 아래와 같은 컬럼을 생성해 주세요. 
## result 컬럼명: 'model_name', 'valid_data', 'accuracy_score', 'f1_score'

result = pd.DataFrame(columns=['model_name', 'valid_data', 'accuracy_score', 'f1_score'])
result

다양한 모델링

SVM

데이터 불러오기

# SVM 라이브러리 설치(scikit-learn에 포함)
#!pip install scikit-learn

# SVM(Support Vector Machine) 알고리즘 모듈 호출
## 분류 모델 생성을 위해 sklearn.svm(Support Vector Machine) 라이브러리의 SVC 알고리즘 호출 합니다.

from sklearn.svm import SVC

데이터 전처리

# 데이터 나누기
## y 변수에 target으로 사용할 data['Activity']을 할당해 주세요.
## data 에서 data['Activity'] 열을 뺀 나머지 x 변수에 할당해 주세요.
## 학습에 필요한 x 와 y 데이터를 학습 7 : 검증 3 비율로 나누어 주세요.
## 이때 random_state 는 2023 으로 설정해 주세요.
## 데이터를 할당받을 변수명: x_train, x_val, y_train, y_val

y = data['Activity']
x = data.drop('Activity', axis=1)
x_train, x_val, y_train, y_val = train_test_split(x,y,train_size=0.7,random_state=2023)

모델링 선언, 학습, 예측

# AI 모델링
## SVC 알고리즘 사용하여 svc_model 변수에 모델을 생성 및 초기화 합니다.
## 이때 random_state 는 2023 으로 설정해 주세요.
## 모델이 생성되면 x_train, y_train 으로 모델을 학습시켜 줍니다.
## 모델 학습이 완료되면 x_val의 결과를 예측하고 출력 합니다.

svc_model = SVC(random_state=2023)
svc_model.fit(x_train, y_train)
svc_pred = svc_model.predict(x_val)
svc_pred

평가

# SVC 모델 성능 평가 하기(accuracy_score, confusion_matrix, classification_report)
## 모델이 결과를 잘 예측하였는지 3가지 성능지표로 결과를 평가 합니다.
## 3가지 성능지표: accuracy_score, confusion_matrix, classification_report

print('accuracy_score: ',accuracy_score(y_val,svc_pred))
print('\n confusion_matrix: \n',confusion_matrix(y_val,svc_pred))
print('\n classification_report: \n',classification_report(y_val,svc_pred))

SVM 예측 결과 저장

# SVC 예측결과 저장
## result 데이터프레임 0번 인덱스의 각 열에 SVC 예측결과인 'svc'(모델명), 'train'(검증 데이터명), accuracy_score 결과, f1_score 결과를 할당해 주세요.
## 데이터프레임의 특정 행(인덱스)에 데이터를 삽입 하려면 .loc[인덱스] 매서드를 사용합니다.
## f1_score의 평균은 'macro' 파라미터를 사용 합니다.
## 예측 결과가 잘 할당 되었는지 확인해 주세요.

result.loc[0] = ['svc', 'train', accuracy_score(y_val,svc_pred), f1_score(y_val,svc_pred,average='macro')]
result

Logistic Regression 모델링

라이브러리 호출

# LogisticRegression 라이브러리 설치(scikit-learn에 포함)
#!pip install scikit-learn

# LogisticRegression 알고리즘 모듈 호출
## 분류 모델 생성을 위해 sklearn.linear_model 라이브러리의 LogisticRegression 알고리즘 호출 합니다.

from sklearn.linear_model import LogisticRegression

모델링 선언,학습 예측

# AI 모델링
## LogisticRegression 사용하여 lr_model 변수에 모델을 생성 및 초기화 합니다.
## 이때 random_state 는 2023 으로 설정해 주세요.
## 모델이 생성되면 x_train, y_train 으로 모델을 학습시켜 줍니다.
## 모델 학습이 완료되면 x_val의 결과를 예측하고 출력 합니다.


lr_model = LogisticRegression(random_state=2023)
lr_model.fit(x_train, y_train)
lr_pred = lr_model.predict(x_val)
lr_pred

평가

# LogisticRegression 모델 성능 평가 하기
## 모델이 결과를 잘 예측하였는지 3가지 성능지표로 결과를 평가 합니다.
## 3가지 성능지표: accuracy_score, confusion_matrix, classification_report

print('accuracy_score: ',accuracy_score(y_val,lr_pred))
print('\n confusion_matrix: \n',confusion_matrix(y_val,lr_pred))
print('\n classification_report: \n',classification_report(y_val,lr_pred))

예측 결과 저장

# LogisticRegression 예측결과 저장
## result 데이터프레임 1번 인덱스의 각 열에 LogisticRegression 예측결과인 'lr'(모델명), 'train'(검증 데이터명), accuracy_score 결과, f1_score 결과를 할당해 주세요.
## 데이터프레임의 특정 행(인덱스)에 데이터를 삽입 하려면 .loc[인덱스] 매서드를 사용합니다.
## f1_score의 평균은 'macro' 파라미터를 사용 합니다.
## 예측 결과가 잘 할당 되었는지 확인해 주세요.

result.loc[1] = ['lr', 'train', accuracy_score(y_val,lr_pred), f1_score(y_val,lr_pred,average='macro')]
result

KNN

라이브러리 불러오기

# NeighborsClassifier 라이브러리 설치(scikit-learn에 포함)
#!pip install scikit-learn

# AI 모델링 필요 모듈 추가
# NeighborsClassifier 알고리즘 사용을 위해 라이브러리를 호출 합니다.

from sklearn.neighbors import KNeighborsClassifier

선언, 학습, 예측

# AI 모델링
## KNeighborsClassifier 함수를 사용하여 knn_model 변수에 모델을 생성 및 초기화 합니다.
## 이때 n_neighbors=3 으로 설정해 주세요.
## 모델이 생성되면 x_train, y_train 으로 모델을 학습시켜 줍니다.
## 모델 학습이 완료되면 x_val의 결과를 예측하고 출력 합니다.
## knn 모델 초기화,학습,예측(파라미터: n_neighbors=3, random_state=2023)
## AI모델 변수명: knn_model , 예측결과 변수명: knn_pred
## predict 과정에서 아래의 에러가 날 경우 예측 데이터를 np.array 데이터 형식으로 바꾸어서 진행 보세요.
## 에러 메세지: 'Flags' object has no attribute 'c_contiguous'
## 해결 방법: predict(x_val) -> predict(np.array(x_val)) 

knn_model = KNeighborsClassifier(n_neighbors=3)
knn_model.fit(x_train, y_train)
knn_pred = knn_model.predict(np.array(x_val))
knn_pred

성능평가

# KNN 모델 성능 평가 하기
## 모델이 결과를 잘 예측하였는지 3가지 성능지표로 결과를 평가 합니다.
## 3가지 성능지표: accuracy_score, confusion_matrix, classification_report

print('accuracy_score: ',accuracy_score(y_val,knn_pred))
print('\n confusion_matrix: \n',confusion_matrix(y_val,knn_pred))
print('\n classification_report: \n',classification_report(y_val,knn_pred))

예측 결과 저장

# KNeighborsClassifier 예측결과 저장
## result 데이터프레임 2번 인덱스의 각 열에 KNeighborsClassifier 예측결과인 'knn'(모델명), 'train'(검증 데이터명), accuracy_score 결과, f1_score 결과를 할당해 주세요.
## 데이터프레임의 특정 행(인덱스)에 데이터를 삽입 하려면 .loc[인덱스] 매서드를 사용합니다.
## f1_score의 평균은 'macro' 파라미터를 사용 합니다.
## 예측 결과가 잘 할당 되었는지 확인해 주세요.

result.loc[2] = ['knn', 'train', accuracy_score(y_val,knn_pred), f1_score(y_val,knn_pred,average='macro')]
result

GBM

불러오기

# GBM 라이브러리 설치(scikit-learn에 포함)


#!pip install scikit-learn

# GradientBoostingClassifier 알고리즘 사용을 위한 모듈 추가

from sklearn.ensemble import GradientBoostingClassifier

선언, 학습, 예측

# AI 모델링
## GradientBoostingClassifier 함수를 사용하여 gbc_model 변수에 모델을 생성 및 초기화 합니다.
## 이때 random_state 는 2023 으로 설정해 주세요.
## 모델이 생성되면 x_train, y_train 으로 모델을 학습시켜 줍니다.
## 모델 학습이 완료되면 x_val의 결과를 예측하고 출력 합니다.
## GradientBoosting 모델 학습은 실습 노트북 기준 약 20분정도 소요 됩니다.(돌려 놓고 티타임~)

gbc_model = GradientBoostingClassifier(random_state=2023)
gbc_model.fit(x_train, y_train)
gbc_pred = gbc_model.predict(x_val)
gbc_pred

평가

# GBM(GBC) 모델 성능 평가 하기
## 모델이 결과를 잘 예측하였는지 3가지 성능지표로 결과를 평가 합니다.
## 3가지 성능지표: accuracy_score, confusion_matrix, classification_report


print('accuracy_score: ',accuracy_score(y_val,gbc_pred))
print('\n confusion_matrix: \n',confusion_matrix(y_val,gbc_pred))
print('\n classification_report: \n',classification_report(y_val,gbc_pred))

XGB

불러오기

# XGBClassifier 사용을 위한 xgboost 라이브러리 설치

#!pip install xgboost

# XGBClassifier 알고리즘 사용을 위한 모듈 추가

from xgboost import XGBClassifier

전처리

# target 값 변경
## XGBoost 는 문자형 데이터로 학습할 수 없습니다. 
## target 데이터인 y_trian과 y_val 변수를 숫자형 형태로 치환하여 각각 y_train_map, y_val_map 변수에 할당해 주세요.
## 데이터 치환 함수: map
## 치환 데이터: 'STANDING':0, 'SITTING':1, 'LAYING':2, 'WALKING':3, 'WALKING_UPSTAIRS':4, 'WALKING_DOWNSTAIRS':5

y_train_map = y_train.map({'STANDING':0, 'SITTING':1, 'LAYING':2, 'WALKING':3, 'WALKING_UPSTAIRS':4, 'WALKING_DOWNSTAIRS':5})
y_val_map = y_val.map({'STANDING':0, 'SITTING':1, 'LAYING':2, 'WALKING':3, 'WALKING_UPSTAIRS':4, 'WALKING_DOWNSTAIRS':5}

선언, 학습, 예측

# AI 모델링
## XGBClassifier 함수를 사용하여 xgb_model 변수에 모델을 생성 및 초기화 합니다.
## 모델의 파라미터는 learning_rate=0.2, max_depth=2, random_state=2023 으로 설정해 주세요.
## 모델이 생성되면 x_train, y_train 으로 모델을 학습시켜 줍니다.
## 모델 학습이 완료되면 x_val의 결과를 예측하고 출력 합니다.


xgb_model = XGBClassifier(learning_rate=0.2, max_depth=2, random_state=2023)
xgb_model.fit(x_train, y_train_map)
xgb_pred = xgb_model.predict(x_val)
xgb_pred

평가

# 모델 평가 출력(accuracy_score, confusion_matrix, classification_report)

print('accuracy_score: ',accuracy_score(y_val_map,xgb_pred))
print('\n confusion_matrix: \n',confusion_matrix(y_val_map,xgb_pred))
print('\n classification_report: \n',classification_report(y_val_map,xgb_pred))

결과 저장

# XGBClassifier 예측결과 저장
## result 데이터프레임 4번 인덱스에 모델 'xgb'(모델명), 'train'(검증 데이터명), accuracy_score 결과, f1_score 결과를 할당해 주세요.
## 데이터프레임의 특정 행(인덱스)에 데이터를 삽입 하려면 .loc[인덱스] 매서드를 사용합니다.
## f1_score의 평균은 'macro' 파라미터를 사용 합니다.
## 예측 결과가 잘 할당 되었는지 확인해 주세요.

result.loc[4] = ['xgb', 'train', accuracy_score(y_val_map,xgb_pred), f1_score(y_val_map,xgb_pred,average='macro')]
result

결과 저장 및 시각화

저장 및 저장 여부 확인

# 결과 저장
# result 변수를 인덱스 미포함하여 'result3.csv' 파일로 저장 합니다.
# 저장경로는 현재 경로의 하위 './data' 폴더로 지정해 주세요.

result.to_csv('./data/result3.csv', index=False)

# 저장 여부 확인
## 데이터가 파일로 잘 저장 되었는지 result3.csv 파일을 로드하여 확인 합니다.
## 로드한 데이터는 save_check 변수에 할당해 주세요.


save_check = pd.read_csv('./data/result3.csv')
save_check

컬럼 인덱스 변환

# 컬럼-인덱스 변환
## save_check 데이터 프레임의 ['model_name', 'valid_data'] 컬럼을 지정하여 인덱스로 설정해 줍니다.
## 변환한 값은 result_comp 변수에 할당해 주세요.
## 참고함수: set_index


result_comp = save_check.set_index(['model_name','valid_data'])
result_comp

시각화

# 모델별 결과 시각화
# pandas의 plot 함수을 사용하여 AI모델 별 accuracy_score, f1_score 수직 그래프 시각화 합니다.
# grid를 추가해 주세요.
# legend를 표시하고, 위치는 center 입니다.

result_comp.plot(kind='bar')
plt.grid()
plt.legend(loc='center')
plt.show()

센서별 중요도 merge, groupby

데이터 확인

# features.csv 파일 불러오기
## 'data'폴더에서 features.csv 파일을 읽어와 feature_group 변수에 할당 하세요.
## 변수에 할당이 잘 되었는지 확인해 주세요. 

feature_group =pd.read_csv('./data/features.csv')
display(feature_group)

# importance_sort 데이터 프레임 확인
# importance_sort 데이터프레임 사용전 데이터를 다시한번 확인 합니다.

importance_sort

데이터 merge

# 데이터프레임 merge 
## merge_df 변수를 데이터프레임 타입으로 생성 및 초기화 합니다.
## feature_group 변수와 importance_sort 변수를 merge 하여 merge_df 변수에 할당 합니다
## 데이터가 잘 할당 되었나 merge_df 데이터를 확인 합니다.

merge_df = pd.DataFrame()
merge_df = pd.merge(feature_group, importance_sort)
merge_df

그룹화

# 데이터 그룹화
## merge_df 변수를 'sensor' 기준으로 그룹화 하고,
## 'feature_importance' 열의 데이터를 같은 'sensor' 그룹끼리 더해 줍니다.
## groupby 함수는 데이터프레임을 그룹으로 묶으면서 필요한 덧셈을 동시에 수행할 수 있습니다.'
## 그룹화 및 덧셈을 수행한 결과를 sensor_sum 변수에 할당해 주세요.
## [TIP] 변수.groupby(by='그룹기준열')['연산 할 열'].연산메서드()


sensor_sum = merge_df.groupby(by='sensor')['feature_importance'].sum()
sensor_sum

# sensor 중요도 재정렬
## sensor_sum 데이터를 내림차순으로 정렬 후 sensor_sort 변수에 할당합니다.
## sensor_sum 변수를 데이터프레임으로 생성했을 경우 기준(by=)을 지정해 주어야 합니다.

sensor_sort = sensor_sum.sort_values(ascending=False)
sensor_sort

센서별 중요도 시각화

# 센서별 중요도 시각화
# sensor 별 중요도를 수평막대 그래프로 시각화 합니다.
# matploltlib를 사용하여 sensor 별 중요도를 수평막대 그래프로 시각화 합니다.


# sensor_sort가 시리즈 타입 일시
plt.barh(y=sensor_sort.index, width=sensor_sort)
plt.xticks(rotation = 90)
plt.grid()
plt.show()

# sensor_sort가 데이터프레임 타입 일시
# plt.barh(data = sensor_sort, y=sensor_sort.index, width='feature_importance')
# plt.xticks(rotation = 90)
# plt.grid()
# plt.show()

# seaborn 라이브러리 사용 sensor 별 중요도 시각화
## seaborn 라이브러리를 사용하여 sensor 별 중요도를 시각화 해보세요.

sns.barplot(x=sensor_sort, y=sensor_sort.index, orient='h')
plt.xticks(rotation = 90)
plt.grid()
plt.show()


# sensor_sort가 데이터프레임 시
# sns.barplot(x=sensor_sort['feature_importance'], y=sensor_sort.index, orient='h')
# plt.xticks(rotation = 90, )
# plt.grid()
# plt.show()

sensor_agg 별 상위 20 중요도 시각화

# 데이터 그룹화
## merge_df 변수를 ['sensor','agg'] 기준으로 그룹화 하고 'feature_importance' 열의 데이터를 같은 그룹끼리 더해 sensor_agg_sum 변수에 할당 합니다.
## groupby 함수는 데이터프레임을 그룹으로 묶으면서 필요한 계산을 동시에 수행할 수 있습니다.


sensor_agg_sum = merge_df.groupby(['sensor','agg'])['feature_importance'].sum()
sensor_agg_sum

# sensor_agg 중요도 재정렬
## sensor_agg_sum 데이터를 내림차순으로 정렬 후 sensor_agg_sort 변수에 할당합니다.


sensor_agg_sort = sensor_agg_sum.sort_values(ascending=False)
sensor_agg_sort

# sensor_agg_sort 변수를 데이터프레임으로 생성시
# sensor_agg_sort = sensor_agg_sum.sort_values(by='feature_importance', ascending=False)
# sensor_agg_sort

# Top20 센서 중요도 시각화
## 중요도가 높은 센서 20개의 중요도를 수평 막대그래프로 시각화 합니다.
## [HINT] Pandas의 plot 함수를 사용

sensor_agg_sort[:20].plot(kind='barh')
plt.grid()
plt.show()

sensor 별 agg 중요도 누적 그래프 시각화

데이터 재구조화

# sensor_agg_sort 데이터 재 구조화
# sensor_agg_sort 데이터셋의 'agg'열의 고유값들을 sensor_agg_sort 데이터셋의 컬럼으로 변환(재구조화) 합니다. 
# 재구조화 한 데이터를 acc 변수에 할당 합니다.
# 참고함수: unstack()

acc = sensor_agg_sort.unstack()
acc

센서별 합계 재정렬

# 센서별 합계 재정렬
## acc 데이터의 각 센서의 행 방향으로(axis=1) 모든 값을 더해서 acc['sort'] 에 할당 합니다.
## 할당 후 acc 데이터를 acc['sort'] 열의 값 기준으로 내림차순으로 정렬 합니다.
## 정렬 후 데이터를 확인 합니다.


acc['sort'] = acc.sum(axis=1)
acc.sort_values(by = 'sort', ascending = False, inplace=True)
acc

정렬 기준열 제거

# 정렬 기준열 제거
# 센서별 정렬을 완료 했으므로 acc 변수에서 acc['sort']열을 삭제 합니다.


acc.drop('sort', axis=1, inplace=True)
acc

누적 막대 그래프 시각화

# 누적 막대 그래프 시각화
# acc 변수를 sensor 별 수평 그래프로 시각화 합니다.

acc.plot(kind='barh', stacked=True, figsize=(20,15))
plt.grid()
plt.show()

Aivle 미니 프로젝트 3차] 변수별 중요도

라이브러리

# pandas, numpy, matplotlib.pyplot, seaborn, os 등 필요 라이브러리 호출
## 추가로 필요한 라이브러리는 설치/호출 하세요.

import pandas as pd
import numpy as np
import matplotlib.pyplot  as plt
import seaborn as sns
import os

데이터 전처리

# 데이터셋 파일 불러오기
## data 변수에 train_data.csv 파일을 불러와서 할당해 주세요.
## train_data.csv 파일은 현재위치의 하위 data 폴더안에 있습니다. 
## 변수에 할당이 잘 되었는지 확인해 주세요. 

data = pd.read_csv('./data/train_data.csv')
data

# 불필요한 열 제거
## 'subject'열 은 데이터를 수집한 사람을 구별하기 위한 데이터 입니다.
## 'subject'열을 data 데이터프레임 변수 에서 제거해 주세요.
## 'subject'열이 잘 제거 되었는지 확인해 주세요.


data.drop('subject', axis=1, inplace=True)
data

범주 개수 시각화

# 고유값(범주) 개수 시각화
## seaborn 라이브러리의 countplot 함수을 사용하여 data['Activity'] 열의 고유값(범주) 별 개수를 시각화 합니다. 


sns.countplot(data=data, x='Activity')
plt.xticks(rotation=90)
plt.grid()
plt.show()

예측 AI 모델링 라이브러리 호출, 데이터 전처리

# RandomForestClassifier 알고리즘 불러오기
## AI 모델링을 위해 sklearn.ensemble 라이브러리의 RandomForestClassifier 알고리즘 호출 합니다.
## 데이터를 나누기 위해 sklearn.model_selection 모듈의 train_test_split 함수를 호출 합니다.
## 모델 성능평가 출력을 위해 sklearn.metrics 모듈의 모든 클래스 호출 합니다.

from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import train_test_split
from sklearn.metrics import *

# X, Y 데이터 나누기
## y 변수에 target으로 사용할 data['Activity']을 할당해 주세요.
## data 에서 data['Activity'] 열을 뺀 나머지 x 변수에 할당해 주세요.

y = data['Activity']
x = data.drop('Activity', axis=1)

# 학습 데이터 나누기
## 학습에 필요한 x 와 y 데이터를 학습 7 : 검증 3 비율로 나누어 주세요.
## 이때 random_state 는 2023 으로 설정해 주세요.
## 데이터를 할당받을 변수명: x_train, x_val, y_train, y_val

x_train, x_val, y_train, y_val = train_test_split(x,y,train_size=0.7,random_state=2023)

선언, 학습, 예측

# AI 모델링
# 모델 선언, 학습, 예측
## rf_model 변수에 RandomForestClassifier 함수를 사용하여 모델을 호출 및 초기화 합니다.
## 이때 random_state 는 2023 으로 설정해 주세요.
## 생성한 rf_model 모델 변수에 x_train, y_train 데이터를 대입하여 모델을 학습시킵니다.
## 학습이 완료된 모델에 x_val 데이터를 대입하여 예측결과를 도출하고 rf_pred 변수에 할당 합니다.

rf_model = RandomForestClassifier(random_state=2023)

rf_model.fit(x_train, y_train)

rf_pred = rf_model.predict(x_val)
rf_pred

평가

# 모델 성능 평가 하기
## 모델이 결과를 잘 예측하였는지 3가지 성능지표로 결과를 평가 합니다.
## 3가지 성능지표: accuracy_score, confusion_matrix, classification_report

print('accuracy_score: ',accuracy_score(y_val,rf_pred))

print('\n confusion_matrix: \n',confusion_matrix(y_val,rf_pred))

print('\n classification_report: \n',classification_report(y_val,rf_pred))

변수별 중요도 추출

중요도 데이터프레임

# 중요도 데이터프레임 변수 생성
## importance_sort 변수를 판다스 데이터프레임 타입으로 생성 및 초기화 합니다.

importance_sort = pd.DataFrame()

# feature명 할당
## importance_sort['feature_name'] 열에 모델링에서 사용한 x 데이터셋의 feature명을 할당 합니다.

importance_sort['feature_name'] = x.columns

# feature 중요도 할당
# 모델링에서 사용한 모델의 feature_importances 를 importance_sort['feature_importance'] 열에 할당 합니다.
# 모델 feature_importances 확인하는 방법은 .feature_importances_ 매서드를 사용합니다.
# ex: 모델명.feature_importances_

importance_sort['feature_importance'] = rf_model.feature_importances_

# 데이터 프레임 확인
# importance_sort 데이터프레임에 데이터가 제대로 할당 되었는지 확인 합니다.
importance_sort

중요도 순으로 재정렬

# 중요도 순으로 인덱스 재정렬
## importance_sort 데이터프레임을 importance_sort['feature_importance'] 순으로 내림차순 정열 합니다.
## 정렬 후 결과를 확인 합니다.
## 참고함수: sort_values
## 참고 파라미터: by='feature_importance', ascending=False, inplace=True


importance_sort.sort_values(by='feature_importance', ascending=False, inplace= True)
importance_sort

인덱스 리셋

# 인덱스 리셋
## importance_sort['feature_importance'] 내림차순 때문에 엉킨 데이터프레임의 인덱스를 리셋 합니다.
## 인덱스 리셋 후 결과를 확인 합니다.
## 참고함수: reset_index (위에서 부터 0 -> 아래로 갈수록 +1)
## 참고 파라미터: inplace=True, drop=True


importance_sort.reset_index(inplace=True, drop=True)
importance_sort

feature 별 중요도 시각화

# feature별 중요도 시각화
## sns.barplot을 사용하여 feature(feature) 별 중요도를 시각화 합니다.
## 그래프 사이즈: (10,100)
## 파라미터: data = importance_sort, x='feature_importance', y='feature_name'
## x축 label을 'feature_importance' 으로, y축 label 을 'feature_name' 으로 설정해 주세요.

plt.figure(figsize=(10,100))
sns.barplot(data = importance_sort, x='feature_importance', y='feature_name')
plt.xlabel('feature_importance')
plt.ylabel('feature_name')
plt.show()

영향도 상위/하위 중요 feature 데이터 분석

상위 5개 중요 feature 확인

# 중요도 상위 5개 중요 feature 확인
## head 함수를 사용하여 중요도 상위 top 5 feature의 feature_name 과 feature_importance 확인하세요.
## 행동 분류에 영향을 미치는 feature의 중요도는 importance_sort 변수를 참고 하세요.

importance_sort.head()

상위 5개 feature 시각화(boxplot 그래프)

상위 1위 feature에 대한 시각화

# 상위 1위 feature_name에 대한 BoxPlot 그래프 그리기
## f_name 변수를 생성하여 상위 1위 feature의 컬럼명을 할당해 줍니다.
## sns.boxplot를 사용하여 data 데이터 프레임의 데이터 분포를 시각화 합니다.
## 파라미터: x=f_name, y='Activity', data=data

f_name = 'tGravityAcc-min()-X'
sns.boxplot(x=f_name, y='Activity', data=data)
plt.show()

상위 2위 feature에 대한 시각화

# 상위 2위 feature_name에 대한 BoxPlot 그래프 그리기
## f_name 변수를 생성하여 상위 2위 feature의 컬럼명을 할당해 줍니다.
## sns.boxplot를 사용하여 data 데이터 프레임의 데이터 분포를 시각화 합니다.
## 파라미터: x=f_name, y='Activity', data=data


f_name = 'tGravityAcc-max()-X'
sns.boxplot(x=f_name, y='Activity', data=data)
plt.show()

하위 3개 feature 시각화(boxplot 그래프)

# 중요도 하위 3개 중요 feature 확인
## tail 함수를 사용하여 중요도 하위 3개의 feature의 feature_name 과 feature_importance 확인하세요.
## 행동 분류에 영향을 미치는 feature의 중요도는 importance_sort 변수를 참고 하세요.

importance_sort.tail(3)

하위 1위

# 하위 1위 feature_name에 대한 BoxPlot 그래프 그리기
## f_name 변수를 생성하여 하위 1위 feature의 컬럼명을 할당해 줍니다.
## sns.boxplot를 사용하여 data 데이터 프레임의 데이터 분포를 시각화 합니다.
## 파라미터: x=f_name, y='Activity', data=data

f_name = importance_sort['feature_name'].iloc[-1]
sns.boxplot(x=f_name, y='Activity', data=data)
plt.show()

하위 2위

# 하위 2위 feature_name에 대한 BoxPlot 그래프 그리기
## f_name 변수를 생성하여 하위 2위 feature의 컬럼명을 할당해 줍니다.
## sns.boxplot를 사용하여 data 데이터 프레임의 데이터 분포를 시각화 합니다.
## 파라미터: x=f_name, y='Activity', data=data

f_name = importance_sort['feature_name'].iloc[-2]
sns.boxplot(x=f_name, y='Activity', data=data)
plt.show()

하위 3개 시각화 한 번에 하기

# 하위 3개의 BoxPlot 그래프 시각화
## for 문을 이용하여 하위 3개의 feature에 대한 BoxPlot 차트들을 한 번에 시각화 합니다. 
## 그래프의 위치는 하위1(상), 하위2(중), 하위3(하) 순서로 표시 합니다.

for i in range(-1,-4,-1):
    f_name = importance_sort['feature_name'].iloc[i]
    sns.boxplot(x=f_name, y='Activity', data=data)
    plt.show()

RandomForestClassifier

라이브러리

# RandomForestClassifier 알고리즘 불러오기
## AI 모델링을 위해 sklearn.ensemble 라이브러리의 RandomForestClassifier 알고리즘 호출 합니다.
## 데이터를 나누기 위해 sklearn.model_selection 모듈의 train_test_split 함수를 호출 합니다.
## 모델 성능평가 출력을 위해 sklearn.metrics 모듈의 모든 클래스 호출 합니다.

from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import train_test_split
from sklearn.metrics import *

데이터 처리

# 모델 학습을 위한 X, Y 데이터 나누기
## y 변수에 target으로 사용할 data['Activity']을 할당해 주세요.
## data 에서 data['Activity'] 열을 뺀 나머지 x 변수에 할당해 주세요.


y = data['Activity']
x = data.drop('Activity', axis=1)

# 데이터 나누기
## 학습에 필요한 x 와 y 데이터를 학습 7 : 검증 3 비율로 나누어 주세요.
## 이때 random_state 는 2023 으로 설정해 주세요.
## 데이터를 할당받을 변수명: x_train, x_val, y_train, y_val

x_train, x_val, y_train, y_val = train_test_split(x,y,train_size=0.7, random_state=2023)

모델 선언, 학습, 예측

# 모델 선언하기
## rf_model 변수에 RandomForestClassifier 함수를 사용하여 모델을 호출 및 초기화 합니다.
## 이때 random_state 는 2023 으로 설정해 주세요.

rf_model = RandomForestClassifier(random_state=2023)

# 모델 학습하기
## 생성한 rf_model 모델 변수에 x_train, y_train 데이터를 대입하여 모델을 학습시킵니다.

rf_model.fit(x_train, y_train)

# 모델 예측하기
## 학습이 완료된 모델에 x_val 데이터를 대입하여 예측결과를 도출하고 rf_pred 변수에 할당 합니다.

rf_pred = rf_model.predict(x_val)
rf_pred

모델 성능 평가

# 모델 성능 평가
## 모델이 결과를 잘 예측하였는지 3가지 성능지표로 결과를 평가 합니다.
## 3가지 성능지표: accuracy_score, confusion_matrix, classification_report

print('accuracy_score: ',accuracy_score(y_val,rf_pred))

print('\n confusion_matrix: \n',confusion_matrix(y_val,rf_pred))

print('\n classification_report: \n',classification_report(y_val,rf_pred))

미니 프로젝트 3차

Data 변경

y_train_map = y_train.map({'STANDING':0, 'SITTING':1, 'LAYING':2, 'WALKING':3, 'WALKING_UPSTAIRS':4, 'WALKING_DOWNSTAIRS':5})

y_val_map = y_val.map({'STANDING':0, 'SITTING':1, 'LAYING':2, 'WALKING':3, 'WALKING_UPSTAIRS':4, 'WALKING_DOWNSTAIRS':5})

y_val_map

GridSearchCV

## GridSearchCV가 적용된 모델의 예측결과를 hpt_xgb_pred 변수에 할당 합니다.

## 그리드 서칭은 실습 노트북 기준 약 20분이 소요 됩니다.(실행해 놓고 티 타임)

initial_params = {'learning_rate': [ 0.1, 0.2, 0.3 ], 'max_depth': [2,3,4]}

xgb_model = XGBClassifier(random_state = 2023)

hpt_xgb_model = GridSearchCV(estimator=  xgb_model  , param_grid= initial_params  , cv= 3, verbose= 2 )

hpt_xgb_model.fit( x_train, y_train )

hpt_xgb_pred = hpt_xgb_model.predict( x_val )

AI 모델링

# AI 모델링

## XGBClassifier 함수를 사용하여 xgb_model 변수에 모델을 생성 및 초기화 합니다.

## 모델의 파라미터는 learning_rate=0.2, max_depth=2, random_state=2023 으로 설정해 주세요.

## 모델이 생성되면 x_train, y_train 으로 모델을 학습시켜 줍니다.

## 모델 학습이 완료되면 x_val의 결과를 예측하고 출력 합니다.

xgb_model = XGBClassifier(learning_rate=0.2, max_depth=2, random_state=2023)

xgb_model.fit(x_train, y_train_map)

xgb_pred = xgb_model.predict(x_val)

xgb_pred

# GradientBoostingClassifier 예측결과 저장

# GradientBoostingClassifier 예측결과 저장

## result 데이터프레임 3번 인덱스의 열에 GradientBoostingClassifier 예측결과인 'gbc'(모델명), 'train'(검증 데이터명), accuracy_score 결과, f1_score 결과를 할당해 주세요.

## 데이터프레임의 특정 행(인덱스)에 데이터를 삽입 하려면 .loc[인덱스] 매서드를 사용합니다.

## f1_score의 평균은 'macro' 파라미터를 사용 합니다.

## 예측 결과가 잘 할당 되었는지 확인해 주세요.

result.loc[3] = ["gbc","train",accuracy_score(y_val, gbc_pred), f1_score(y_val, gbc_pred,average='macro')]

result

중요 feature 150 개 선정

# 중요 feature 150 개 선정

## 중요도로 정렬된 importance_sort['feature_importance']의 상위 150 순위의 feature_name 을 importance_150 변수에 할당 합니다.

## 인덱스 번호가 낮을 수록 중요도 순위가 높은 feature 입니다.

importance_150 = importance_sort[ 'feature_name'  ][:150]

importance_150

# importance_150 훈련 데이터 생성

# x_train 에서 importance_150 순위에 해당하는 feature 만 찾아 x_train_150 변수에 할당 합니다.

# x_val 에서 importance_150 순위에 해당하는 feature 만 찾아 x_val_150 변수에 할당 합니다.

# 상위 150 순위의 feature 인덱싱은 importance_150 사용 합니다.

x_train_150 = x_train[importance_150]

x_val_150 = x_val[importance_150 ]

# AI 모델링

## XGBClassifier 함수를 사용하여 hpt_xgb_150_model 변수에 모델을 생성 및 초기화 합니다.

## 이때 파라미터는 params 변수와 random_state=2023 으로 설정해 주세요.

## 모델이 생성되면 x_train_150, y_train 으로 모델을 학습시켜 줍니다.

## 모델 학습이 완료되면 x_val_150의 결과를 예측하고 출력 합니다.

print("x_train_150:",x_train_150.shape)

print("y_train.shape:",y_train.shape)

hpt_xgb_150_model = XGBClassifier()

hpt_xgb_150_model.fit(x_train_150, y_train)

hpt_xgb_150_pred = hpt_xgb_150_model.predict(x_val_150)

hpt_xgb_150_pred


# hpt_xgb_150_model 모델 성능 평가 하기

## 모델이 결과를 잘 예측하였는지 3가지 성능지표로 결과를 평가 합니다.

## 3가지 성능지표: accuracy_score, confusion_matrix, classification_report

print("accuracy_score:", accuracy_score( y_val, hpt_xgb_150_pred))

print("confusion_matrix:\n",confusion_matrix( y_val, hpt_xgb_150_pred))

print("confusion_matrix:\n",classification_report( y_val, hpt_xgb_150_pred))


result.loc[6] = ['hpt_xgb_150', 'train', accuracy_score( y_val, hpt_xgb_150_pred), f1_score( y_val, hpt_xgb_150_pred, average='macro')]

result

initial_params = {'learning_rate': [ 0.1, 0.2, 0.3 ], 'max_depth': [2,3,4]}

xgb_model = XGBClassifier(random_state = 2023)

hpt_xgb_model = GridSearchCV(estimator=  xgb_model  , param_grid= initial_params  , cv= 3, verbose= 2 )

hpt_xgb_model.fit( x_train, y_train )

hpt_xgb_pred = hpt_xgb_model.predict( x_val )




hpt_xgb_model = XGBClassifier(learning_rate= 0.3, max_depth= 2, random_state=2023)

hpt_xgb_model.fit(x_train, y_train)

hpt_xgb_pred = hpt_xgb_model.predict(x_val)

hpt_xgb_pred