기본 라이브러리 임포트
#데이터 조작 및 분석을 위한 라이브러리 [데이터 읽기 및 쓰기/ 데이터 정리 및 변환/ 결측치 처리/ 데이터 통계 및 요약]
import pandas as pd
#수치 계산을 위한 라이브러리 [배열 생성 및 조작(1차원, 2차원, 다차원 배열)/ 선형 대수 등 과학 계산/ 배열 간의 빠른 연산
import numpy as np
#기본적인 데이터 시각화를 위한 라이브러리
import matplotlib.pyplot as plt
#데이터 시각화를 위한 라이브러리로 Matplotlib를 기반으로 한다.
!pip install seaborn #seabon은 설치필요
import seaborn as sns
#다양한 머신러닝 알고리즘과 도구를 제공. 데이터 전처리, 모델 선택, 모델 평가 등 머신러닝 워크플로우의 대부분 지원
#Scikit-Learn 패키지는 sklearn이라는 이름으로 임포트
import sklearn
데이터 불러오기
#괄호안에 파일명 작성하기
df = pd.read_csv('') #csv파일 읽어오기
df = pd.read_excel('') #excel파일 읽어오기
dj = pd.read_json('') #json파일 읽어오기
dx = pd.read_xml('') #xml파일 읽어오기
데이터 탐색하기
#col(열-세로), row(행-가로) 인덱스는 데이터프레임의 행을 고유하게 식별하는 레이블
df.head() #처음 5개 행을 출력
df.tail() #마지막 5개 행을 출력
df.info() #데이터프레임의 요약 정보를 출력
df.describe()#데이터프레임의 기술 통계 요약을 출력
df.index #데이터프레임의 인덱스 반환
df.columns #데이터프레임의 열 레이블 반환
df.values #데이터프레임의 값을 numpy 배열 형태로 반환
df.shape #데이터프레임 행, 열 개수 확인
df.isnull().sum() #Null인 데이터 확인. 단순히 isnull()만 사용하기도 하지만 sun()과 함께 사용되어 행이나 열별로의 Null 개수를 세기 위해 주로 사용
결측치(데이터셋에서 특정 값이 누락되거나 비어있는 경우) 확인하기
df.isna().sum() #데이터프레임의 각 요소가 결측치인지 여부를 나타내는 불리언 값
df.isnull().sum() #각 열에서 결측치의 개수를 합산하여 반환
특정 열의 값들의 건수/비율 확인하기
df['A'].value_counts()
#normalize = True를 주면 정규화된 값으로 범주별 비율을 확인할 수 있습니다.
#df[열 이름].value_counts(normalize = False/True)
df['B'].value_counts(normalize=True) #normalize=True를 사용하면 이 빈도수를 전체 값의 비율로 변환
특정 열 삭제
#drop은 한 번에 행이나 열 중 하나만 삭제 가능
cols = ['A','B','C']
df = df.drop(cols, axis=1)
#또는
df.drop(cols, axis=1, inplace=True)
#'axis=1'은 열을 의미, 'axis=0'은 행을 의미
#'inplace=True'는 원본 데이터프레임을 직접 수정한다는 의미
결측치 대체
df.replace('변경전' ,'변경후', inplace=True )
#리스트 딕셔너리도 가능함
#replace: 주로 {'바꾸고자 하는 값': '바뀌는 값'}의 딕셔너리 형태로 주어집니다.
#inplace = True: 변수를 할당하지 않고 바로 적용할 수 있습니다.
df.replace( { '전':'후', '전2':'후2' }, inplace=True )
결측치 채우기
#'value'은 결측치를 대체할 값/ 'method'은 결측치를 채우는 방법/ 'axis'는 결측치를 채울 축.'0'은 행, '1'd은 열
#'inplace'는 원본 데이터프레임을 수정할지 여부/ 'limit'는 결측치를 채울 최대 개수/ 'downcast'는 데이터 타입을 변경하여 메모리 사용량을 줄일 수 있다.
df.fillna(value=None, method=None, axis=None, inplace=False, limit=None, downcast=None)
#데이터프레임의 모든 결측치를 'A'로 대체한다.
df.fillna('A')
df['열이름'].fillna('바뀌는 값', inplace = False/True) #inplace = True: 변수를 할당하지 않고 바로 적용할 수 있습니다.
#특정 열의 결측치를 지정된 값으로 대체한다. 'col1'의 결측치는 'A'로, 'col2'의 결측치는 'B'로.
df.fillna(value={'col1':'A','col2':'B'})
#결측치를 바로 다음 값으로 채운다.
df.fillna(method='bfill')
#결측치를 바로 이전 값을로 채운다.
df.fillna(method='ffill')#df는 데이터가 있는 변수명 예시이다.
median() #중앙값을 계산한다. ex) df['col'].median()
max() #최대값을 계산한다. ex) df['col'].max()
min() #최소값을 계산한다. ex) df['col'].min()
std() #표준편차를 계산한다. ex) df['col'].std()
df['age'].mode()[0] #최빈 값(데이터에서 가장 많이 발생하는 값을 의미) ex)most_frequent_age = df['age'].mode()[0] => 변수에다가 저장해서 사용
df.interpolate() #컴퓨터가 알아서 결측치 바꾸기(보간법) ex)df_interpolated = df.interpolate() => 변수에다가 저장해서 사용
.dropna #결측치 있는 데이터 지우기 ex)df = df.dropna(subset=['sex_type'])
#subset 없이 dropna 사용 ex)df_no_subset = df.dropna()
데이터 타입에 따른 컬럼명
#df.select_dtypes(type)
#type: int, float, str 등의 원하는 데이터 타입의 열만 추출
#데이터프레임 df에서 데이터 타입이 object인 열을 선택하여 그 열 이름을 obj 변수에 저장
obj = df.select_dtypes(include='object').columns
#데이터프레임 df에서 데이터 타입이 object가 아닌 열을 선택하여 그 열 이름을 obj_x 변수에 저장
obj_x = df.select_dtypes(exclude='object').columns
데이터 타입 변환
#특정 열의 데이터 타입 변환 (데이터프레임에서 하나의 열만 선태가는 경우)
df['A'] = df['A'].astype(float) #'A' 열을 int에서 float로 변환
#선택된 열들의 데이터 타입 일괄 변환
cols = ['A', 'B']
df[cols] = df[cols].astype(float)
#열별로 다른 데이터 타입으로 변환
df = df.astype({'A': 'float', 'B': 'int'})그룹 집계
#by: 그룹의 기준이 되는 열로 여러 열을 기준으로도 할 수 있다.
#as_index = bool: 그룹 기준 열을 인덱스화 할지 여부를 선택할 수 있다.
#집계함수: sum(합), mean(평균), count(개수) 등의 집계함수
df.groupby(by=['그룹기준 열'])['집계 대상 열'].집계함수()
# ex)'department' 열을 기준으로 'salary' 열의 합계 계산
grouped_sum = df.groupby(by=['department'])['salary'].sum()
라벨엔코딩 Label Encoding(범부형 데이터를 숫자형 데이터로 변환)
from sklearn.preprocessing import LabelEncoder
#LabelEncoder객체를 생성. 이 객체를 통해 데이터를 변환할 수 있다.
L_en = LabelEncoder()
#데이터프레임 df의 C열에 대해 라벨 인코딩을 수행하고, 변환된 결과를 다시 C열에 저장한다.
#df['범주형 열'] = le.fit_transform(df['범주형 열'])
df['C'] = L_en.fit_transform(df['C'])
원핫엔코딩 One-Hot Encoding (각 범주형 값을 이진 벡터로 변환하는 기법)
from sklearn.preprocessing import OneHotEncoder
O_en = OneHotEncoder()
df['D'] = O_en.fit_transform(df['D'])
#다른 방법
#원-핫 인코딩은 pandas내의 메소드로 적용한다.
#columns: 원-핫 인코딩을 적용할 열 리스트
#drop_first=True: 첫번째 범주는 제외하고 원-핫 인코딩 적용.
df = pd.get_dummies(df, columns=['범주형 열'], drop_first=True)
get_dummies (One-Hot Encoding을 수행하는데 사용하는 라이브러리)
cols = ['',''] #원핫인코딩을 수행할 열들의 이름을 리스트로 저장 ex) cols = ['color', 'size']
df_dummy = pd.get_dummies(df, columns=cols) #데이터프레임 df에서 cols 리스트에 지정된 열들을 원-핫 인코딩하여 df_dummy 데이터프레임에 저장
#drop_first=True옵션도 있음.
#이 옵션을 사용하면 첫 번째 더미 변수를 제거하여 다중 공선성 문제를 줄일 수 있습니다. 이는 각 범주의 첫 번째 값이 기준 값이 되어 나머지 값들이 이를 기준으로 인코딩됩니다.
특정타입 열들을 LabelEncoder 하는법
-모든 오브젝트(문자열) 열을 선택
object_columns = titanic.select_dtypes(include=['object','category'])
-모든 오브젝트(문자열) 열을 Label Encoding
for column in object_columns:
titanic[column] = label_encoder.fit_transform(titanic[column])그래프
#히스토그램
#x는 히스토그램을 그릴 데이터 열 이름 지정/ hue는 색상으로 구분할 또 다른 열 이름 지정/ data는 데이터프레임 지정
# ex) sns.histplot(x='column_name', hue='another_column', data=df)
sns.histplot(x='', hue='',data=df)
#kde플롯 (데이터의 밀도 추정치를 나타내는 커널 밀도 추정 플롯을 그린다.)
#df['A']: KDE 플롯을 그릴 열을 지정합니다.
sns.kdeplot(df['A'])
#카운트 플롯(범주형 데이터의 빈도를 막대 그래프로 나타낸다.)
#x: 빈도를 세어 막대 그래프로 나타낼 범주형 열 이름을 지정합니다./ data: 데이터프레임 df를 지정합니다.
# ex) sns.countplot(x='column_name', data=df)
sns.countplot(x='', data=df)
# 막대그래프
#열 'A'의 값들을 세어 막대 그래프로 나타냅니다./ kind='bar': 막대 그래프의 유형을 지정합니다.
df['A'].value_counts().plot(kind='bar')
#히트맵
#df[['A', 'B', 'C']].corr(): 열 'A', 'B', 'C' 간의 상관 행렬을 계산합니다./ sns.heatmap(heat, annot=True, cmap='Blues'): 상관 행렬 heat을 히트맵으로 나타냅니다.
#annot=True: 각 셀에 상관 계수를 표시합니다./ cmap='Blues': 히트맵의 색상 팔레트를 지정합니다.
heat = df[['A','B','C']].corr()
#fmt='d 옵션을 사용하면 소수점이 없는 정수로 표시된다.
sns.heatmap( heat, annot=True, cmap='Blues' )
sns.heatmap(heat, annot=True, fmt='.2f', cmap='Blues') #소수점 형식으로 표시
#박스
#x: 박스 플롯의 x축에 표시할 범주형 열 이름을 지정합니다./ y: 박스 플롯의 y축에 표시할 연속형 열 이름을 지정합니다./ data: 데이터프레임 df를 지정합니다.
# ex) sns.boxplot(x='category_column', y='value_column', data=df)
sns.boxplot(x= '', y= '', data=df )
데이터 분리하기 (Pandas 라이브러리를 사용하여 데이터를 불러온 후, 립 변수(x_data)와 종속 변수(y_data)로 나누는 과정)
import pandas as pd
#CSV 파일로부터 데이터 읽기
data = pd.read_csv('') # ex)data = pd.read_csv('data.csv')
#독립 변수 (특징) 데이터 추출
#data.drop 함수는 target 열을 제외한 나머지 열들로 구성된 데이터프레임이 x_data에 저장
#target: 제거할 열의 이름/ axis=1: 열을 기준/ axis=0은 행을 기준
x_data = data.drop(target, axis = 1)
#종속 변수 (목표) 데이터 추출
#data.loc는 데이터프레임에서 특정 행과 열을 선택하는 인덱싱 방식
# :은 모든 행을 선택/ target 열을 선택
y_data = data.loc[:, target]
*머신러닝
데이터 분리하기
#scikit-learn 라이브러리의 train_test_split 함수사용
#학습용(train)과 테스트용(test)으로 분할하는 과정
from sklearn.model_selection import train_test_split
#train_test_split 함수는 입력된 데이터셋을 학습용 데이터와 테스트용 데이터로 분할
# ex)x_train, x_test, y_train, y_test = train_test_split(x_data, y_data, test_size=0.2, stratify=None, random_state=42)
# test_size: 테스트용 데이터셋의 비율 또는 개수. 예를 들어, test_size=0.2는 전체 데이터의 20%를 테스트용으로 사용함을 의미
#train_size/test_size: 학습용/검증용 데이터를 분할할 기준이 된다. (주로 8:2나 7:3으로 분할한다.)
# 층화 표본 추출 방법으로, 분할 전 y_data의 클래스 비율을 유지합니다. 주로 분류 문제에서 사용
# 데이터 분할 시 난수 시드(seed)를 지정하여 분할 결과를 재현 가능하게 합니다. 예를 들어, random_state=42는 난수 시드를 42로 설정하여 동일한 데이터 분할 결과를 얻을 수 있다.
x_train,x_test, y_train,y_test = train_test_split(x_data, y_data,test_size=, stratify=y_data, random_state= )
데이터 표준화/ 정규화
# 2개 중 하나만 골라서 쓰기
# 데이터의 최소값과 최대값을 사용하여 모든 값을 0과 1 사이로 변환
from sklearn.preprocessing import MinMaxScaler
scaler = MinMaxScaler()
x_train = scaler.fit_transform(X_train) # fit: 기준이 되는 데이터를 기반으로 스케일러 값을 맞춘다.
x_test = scaler.transform(X_test) #transform: 기준 값을 기반으로 스케일링을 적용한다.#데이터의 평균과 표준편차를 사용하여 모든 값을 평균 0, 표준편차 1로 변환
from sklearn.preprocessing import StandardScaler
scaler = StandardScaler()
x_train = scaler.fit_transform(X_train)
x_test = scaler.transform(X_test)
머신러닝 모델링
=>머신러닝은 분류와 회귀 유형이 있다.
분류는 입력 데이터를 미리 정의된 여러 클래스 중 하나로 분류하는 것
예시: 이메일이 스팸인지 아닌지 분류하기, 손글씨 숫자 인식, 질병 진단 등.
모델은 아래와 같다.
- 로지스틱 회귀 (Logistic Regression)
- 결정 트리 (Decision Tree)
- 랜덤 포레스트 (Random Forest)
- 서포트 벡터 머신 (SVM)
- K-최근접 이웃 (K-Nearest Neighbors, KNN)
- 신경망 (Neural Networks)
회귀는 입력 데이터를 기반으로 연속적인 숫자 값을 예측하는 것이다.
예시: 주택 가격 예측, 주식 가격 예측, 온도 예측 등.
모델은 아래와 같다.
- 선형 회귀 (Linear Regression)
- 다항 회귀 (Polynomial Regression)
- 결정 트리 회귀 (Decision Tree Regression)
- 랜덤 포레스트 회귀 (Random Forest Regression)
- 서포트 벡터 회귀 (Support Vector Regression, SVR)
머신러닝 분류
1) 분류 라이브러리 & 모델선언
#주어진 여러 모델 중 하나를 선택해서 해당 모델을 사용할 수 있도록 초기화
#Logistic Regression : 이진 분류(Binary Classification) 문제에서 주로 사용되는 모델로, 데이터가 특정 클래스에 속할 확률을 예측
# 선형 모델로, 입력 변수들의 선형 결합에 기반하여 예측을 수행
# ex)model = LogisticRegression(max_iter=100, C=1.0)
# max_iter: 최대 반복 횟수. 일반적으로 100이나 200을 사용
# C: 정규화 강도. 기본값은 1.0이며, 값이 작을수록 강한 정규화를 의미
from sklearn.linear_model import LogisticRegression
model = LogisticRegression(max_iter= , C= )
#K-Nearest Neighbors : 주어진 데이터 포인트에서 가장 가까운 k개의 이웃을 찾아 다수결 원칙에 따라 분류하는 모델
#비선형 모델로, 새로운 데이터 포인트의 클래스를 결정하기 위해 훈련 데이터와의 거리를 측정
# ex) model = KNeighborsClassifier(n_neighbors=5)
# n_neighbors: 사용할 이웃의 수. 기본값은 5
from sklearn.neighbors import KNeighborsClassifier
moedel = KNeighborsClassifier(n_neighbors=)
#데이터를 여러 기준으로 분할하여 트리 구조를 형성하는 모델입니다. 각 노드는 특정 기준에 따라 데이터를 분류
# ex)model = DecisionTreeClassifier(max_depth=5, random_state=42)
#max_depth: 트리의 최대 깊이. 과적합을 방지하기 위해 설정
#random_state: 결과의 재현성을 위해 설정하는 난수 시드. 예를 들어, 42를 자주 사용
from sklearn.tree import DecisionTreeClassifier
model = DecisionTreeClassifier(max_depth=, random_state=)
#여러 개의 Decision Tree를 결합하여 예측 성능을 향상시키는 앙상블 모델
# ex)model = RandomForestClassifier(n_estimators=100, random_state=42)
#n_estimators: 사용할 트리의 수. 일반적으로 100에서 200 사이의 값을 사용
#random_state: 결과의 재현성을 위해 설정하는 난수 시드
from sklearn.ensemble import RandomForestClassifier
model = RandomForestClassifier(n_estimators=, random_state=)
#Gradient Boosting 알고리즘을 기반으로 한 고성능 앙상블 학습 모델
# ex)model = XGBClassifier(n_estimators=100)
#n_estimators: 부스팅 단계의 수. 일반적으로 100에서 1000 사이의 값을 사용
from xgboost import XGBClassifier
model = XGBClassifier(n_estimators= )
#Gradient Boosting 알고리즘을 기반으로 한 고성능 앙상블 학습 모델로, 대규모 데이터셋에서 효율적으로 학습할 수 있도록 설계
#model = LGBMClassifier(n_estimators=100)
#n_estimators: 부스팅 단계의 수. 일반적으로 100에서 1000 사이의 값을 사용
from lightgbm import LGBMClassifier
model = LGBMClassifier(n_estimators=)
2) 분류 모델학습
: 머신러닝 모델을 학습시키기위해 사용하는 코드
#fit 메서드는 학습데이터를 사용하여 모델 학습시킴
model.fit(X_train, y_train)
3) 분류 성능평가
-필요한 라이브러리 임포트
-모델 예측
-평가 지표 계산 및 출력
from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score #정확도, 정밀도, 재현율, f1점수 계산
from sklearn.metrics import confusion_matrix #혼동 행렬 생성
from sklearn.metrics import classification_report #정밀도, 재현율, F1 점수를 포함한 종합적인 분류 성능 보고서 출력
#모델 예측
#학습된 모델을 사용하여 테스트 데이터(x_test)에 대한 예측을 수행하고, 예측 결과를 y_pred에 저장
y_pred = model.predict(x_test)
#결과
print(accuracy_score(y_test, y_pred))
print(recall_score(y_test, y_pred))
print(precision_score(y_test, y_pred))
4)분류 히트맵 ( 혼동 행렬(confusion matrix)을 계산하고, 이를 히트맵으로 시각화하는 과정을 보여준다.)
혼동 행렬은 분류 모델의 성능을 평가하는 데 중요한 도구로, 각 클래스의 예측 결과를 요약합니다.
히트맵을 통해 혼동 행렬의 값을 시각적으로 쉽게 이해할 수 있습니다.
#confusion_matrix 함수는 실제 값(y_test)과 예측 값(y_pred)을 비교하여 혼동 행렬을 생성
heat = confusion_matrix(y_test, y_pred)
#seaborn 라이브러리의 heatmap 함수를 사용하여 혼동 행렬을 히트맵으로 시각화
#heat: 시각화할 혼동 행렬./ annot=True: 각 셀에 값을 표시/ fmt='d': 값을 정수 형태로 표시/ cmap='Blues': 히트맵의 색상 팔레트를 'Blues'로 설정
sns.heatmap(heat, annot=True, fmt='d',color='Blues')
plt.show()머신러닝 회귀
1)회귀 라이브러리 & 모델 선언
#주어진 여러 모델 중 하나를 선택해서 해당 모델을 사용할 수 있도록 초기화
# 선형 회귀는 종속 변수와 하나 이상의 독립 변수 간의 선형 관계를 모델링
from sklearn.linear_model import LinearRegression
model = LinearRegression( )
## 데이터 포인트의 k개의 최근접 이웃을 사용하여 예측값을 계산
#ex) model = KNeighborsRegressor(n_neighbors=5)
#n_neighbors: 이웃의 수.
from sklearn.neighbors import KNeighborsRegressor
moedel = KNeighborsRegressor(n_neighbors=)
#데이터를 여러 분할 기준으로 나누어 트리 구조를 형성
#ex) model = DecisionTreeRegressor(max_depth=5, random_state=42)
#max_depth: 트리의 최대 깊이. 과적합을 방지하기 위해 설정
#random_state: 결과의 재현성을 위해 설정하는 난수 시드.
from sklearn.tree import DecisionTreeRegressor
model = DecisionTreeRegressor()
#여러 개의 결정 트리를 결합하여 예측 성능을 향상
# ex)model = RandomForestRegressor(n_estimators=100, random_state=42)
#n_estimators: 트리의 수. 일반적으로 100을 사용
#random_state: 결과의 재현성을 위해 설정하는 난수 시드.
from sklearn.ensemble import RandomForestRegressor
model = RandomForestRegressor()
#Gradient Boosting 알고리즘을 사용한 고성능 회귀 모델
# ex) model = XGBRegressor(n_estimators=100)
# n_estimators: 부스팅 단계의 수.
from xgboost import XGBRegressor
model = XGBRegressor( )
#Gradient Boosting 알고리즘을 사용한 고성능 회귀 모델로, 특히 대규모 데이터셋에서 효율적
# ex) model = LGBMRegressor(n_estimators=100)
#n_estimators: 부스팅 단계의 수.
from lightgbm import LGBMRegressor
model = LGBMRegressor()
2) 회귀 학습
model.fit(X_train, y_train)
3) 모델 검증
생성된 모델의 성능을 평가한다.
분류 모델은 정확도로, 회귀 모델은 결정계수로 검증한다.
# 모델 검증
model.score(X_test, y_test)
4) 회귀 성능평가
from sklearn.metrics import mean_squared_error, mean_absolute_error,r2_score
y_pred = model.predict(x_test)
#결과
print(mean_squared_error(y_test, y_pred, squared=False)) # RMSE(예측값과 실제 값의 평균적인 차이를 루트 씌운 값)를 반환
print(mean_absolute_error(y_test, y_pred)) #MAE(예측값과 실제 값의 절대적인 평균 차이)
print(r2_score(y_test, y_pred)) # R^2 Score(모델이 데이터의 분산을 얼마나 잘 설명하는지)
# 회귀계수 = 가중치 확인 :
model.coef_
# 편향(y절편)
model.intercept_
*머신러닝 모델링 정리
LogisticRegression
Logistic Regression을 사용하기 위해서는 로드하는 과정이 필요하다.
- C: 규제 강도
- max_iter: 반복 횟수
# import
from sklearn.linear_model import LogisticRegression
# 모델 생성
lg = LogisticRegression(C=1.0, max_iter=1000)
# 모델 학습
lg.fit(X_train, y_train)
# 모델 평가
lg.score(X_test, y_test)
DecisionTreeClassifier / DecisionTreeRegressor
Decision Tree를 사용하기 위해서는 로드하는 과정이 필요하다.
- max_depth: 트리 깊이
- random_state: 랜덤 시드
# import
from sklearn.tree import DecisionTreeClassifier # 분류
from sklearn.tree import DecisionTreeRegressor # 회귀
# 모델 생성
dt = DecisionTreeClassifier(max_depth=5, random_state=2023)
# 모델 학습
dt.fit(X_train, y_train)
# 모델 평가
dt.score(X_test, y_test)
RandomForestClassifier / RandomForestRegressor
Random Forest를 사용하기 위해서는 로드하는 과정이 필요하다.
- n_estimators: 사용하는 트리 개수
- random_state: 랜덤 시드
# import
from sklearn.ensemble import RandomForestClassifier # 분류
from sklearn.ensemble import RandomForestRegressor # 회귀
# 모델 생성
rf = RandomForestClassifier(n_estimators=100, random_state=2023)
# 모델 학습
rf.fit(X_train, y_train)
# 모델 평가
rf.score(X_test, y_test)
XGBClassifier / XGBRegressor
XGBoost를 사용하기 위해서는 설치 및 로드하는 과정이 필요하다.
- n_estimators: 사용하는 트리 개수
# install
!pip install xgboost
# import
from xgboost import XGBClassifier # 분류
from xgboost import XGBRegressor # 회귀
# 모델 생성
xgb = XGBClassifier(n_estimators=100)
# 모델 학습
xgb.fit(X_train, y_train)
# 모델 평가
xgb.score(X_test, y_test)
LGBMClassifier / LGBMRegressor
Light GBM을 사용하기 위해서는 설치 및 로드하는 과정이 필요하다.
- n_estimators: 사용하는 트리 개수
# install
!pip install lightgbm
# import
from lightgbm import LGBMClassifier # 분류
from lightgbm import LGBMegressor # 회귀
# 모델 생성
lgbm = LGBMClassifier(n_estimators=100)
# 모델 학습
lgbm.fit(X_train, y_train)
# 모델 평가
lgbm.score(X_test, y_test)
머신러닝 최적화
1. 모델 불러오기 & 그리드서치 & 성능평가
# import
from sklearn.metrics import * # 모든 함수 로드
# 불러오기
from sklearn.linear_model import LinearRegression
from sklearn.neighbors import KNeighborsRegressor
from sklearn.tree import DecisionTreeRegressor
from sklearn.ensemble import RandomForestRegressor
from xgboost import XGBRegressor
from lightgbm import LGBMRegressor
from sklearn.model_selection import cross_val_score, GridSearchCV
from sklearn.metrics import mean_absolute_error, r2_score
1) Linear regression
# 선언하기
model = LinearRegression()
# 성능예측
cv_score = cross_val_score(model, x_train, y_train, cv=5) #cv=5: 교차 검증에서 사용할 폴드(fold)의 수. 여기서는 5-fold 교차 검증을 의미
# 결과확인
print('평균:', cv_score.mean())
# 결과수집
result = {}
result['Linear Regression'] = cv_score.mean()
2) KNN (주어진 데이터 포인트에서 가장 가까운 k개의 이웃을 찾아 다수결 원칙에 따라 분류하는 모델)
# 선언하기
model = KNeighborsRegressor()
# 성능예측
cv_score = cross_val_score(model, x_train_s, y_train, cv=5)
# 결과확인
print('평균:', cv_score.mean())
# 결과수집
result['KNN'] = cv_score.mean()
3) Decision Tree (데이터를 여러 분할 기준으로 나누어 트리 구조를 형성)
# 선언하기
model = DecisionTreeRegressor(random_state=1)
# 성능예측
cv_score = cross_val_score(model, x_train, y_train, cv=5)
# 결과확인
print('평균:', cv_score.mean())
# 결과수집
result['Decision Tree'] = cv_score.mean()
4) RandomForest (여러 개의 결정 트리를 결합하여 예측 성능을 향상)
# 선언하기
model = RandomForestRegressor(random_state=1)
# 성능예측
cv_score = cross_val_score(model, x_train, y_train, cv=5)
# 결과확인
print('평균:', cv_score.mean())
# 결과수집
result['Random Forest'] = cv_score.mean()
5) XGBoost (Gradient Boosting 알고리즘을 사용한 고성능 회귀 모델)
# 선언하기
model = XGBRegressor(random_state=1)
# 성능예측
cv_score = cross_val_score(model, x_train, y_train, cv=5)
# 결과확인
print('평균:', cv_score.mean())
# 결과수집
result['XGBoost'] = cv_score.mean()
6) LightGBM (Gradient Boosting 알고리즘을 사용한 고성능 회귀 모델로, 특히 대규모 데이터셋에서 효율적)
# 선언하기
model = LGBMRegressor(random_state=1, verbose=-100)
# 성능예측
cv_score = cross_val_score(model, x_train, y_train, cv=5)
# 결과확인
print('평균:', cv_score.mean())
# 결과수집
result['LightGBM'] = cv_score.mean()
2. 모델들의 성능 평가하기
# 성능 비교
print('=' * 40)
for m_name, score in result.items():
print(m_name, score.round(3)) #score.round(3): 성능 점수를 소수점 셋째 자리에서 반올림하여 출력
print('=' * 40)
##시각화
# 성능 시각화 비교
plt.barh(list(result.keys()), result.values())
plt.show()
3. 성능 튜닝하기
-위에서 성능이 가장 좋은 모델을 가지고 튜닝 한다.
# 기본 모델 선언
model_rfr = RandomForestRegressor(random_state=1)
# 파라미터 지정
# max_depth: range(1, 21) max_depth: 랜덤 포레스트의 각 결정 트리의 최대 깊이를 설정합니다. 여기서는 1부터 20까지의 값을 시도
param = {'max_depth': range(1, 21)}
# 모델 선언
model = GridSearchCV(model_rfr,
param,
cv=5,
scoring='r2')
# 변수 중요도 시각화
plt.figure(figsize=(6, 5)) #그래프의 크기를 설정합니다. 가로 6인치, 세로 5인치로 설정
plt.barh(list(X.columns), model.best_estimator_.feature_importances_) #수평 막대 그래프를 그린다.
plt.xlabel('Feature Importance') #x축 레이블 설정
plt.ylabel('Features') #y축 레이블 설정
plt.title('Feature Importance in Random Forest') #그래프 제목 설정
plt.show()
# 학습하기 (시간 많이 걸릴수도 있다용)
model.fit(x_train, y_train)
#최적의 파라미터와 성능 확인
print("최적의 파라미터:", model.best_params_)
print("최고 성능 (R^2):", model.best_score_)
4. 최적 파라미터가 적용된 모델의 성능 평가
# 예측하기
y_pred = model.predict(x_test)
# 성능평가
print(mean_absolute_error(y_test, y_pred))
print(r2_score(y_test, y_pred))딥러닝 모델링
주로 Sequential한 방법으로 레이어를 쌓는 문제가 나온다고 한다.
example
# 첫번째 레이어 - unit: 128, activation: relu, input_shape: (26,)
# 두번째 레이어 - unit: 64, activation: relu
# 세번째 레이어 - unit: 32, activation: relu
# 각 히든 레이어 사이에는 0.3비율의 Dropout 적용
# 아웃풋 레이어 - activation: sigmoid
# import
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, Dropout
# 모델 생성
model = Sequential()
# 모델 구조
model.add(Dense(128, input_shape=(26,), activation='relu'))
model.add(Dropout(.3))
model.add(Dense(64, activation='relu'))
model.add(Dropout(.3))
model.add(Dense(32, activation='relu'))
model.add(Dropout(.3))
# output layer의 unit 수는 타겟 변수의 범주 개수와 동일하다.
model.add(Dense(1, activation='sigmoid'))
# 모델 요약
model.summary()
라이브러리 블러오기
import tensorflow as tf
from tensorflow import keras
from tensorflow.keras.models import Sequential, load_model, Model
from tensorflow.keras.layers import Dense, Dropout,Input,Activation, BatchNormalization,Flatten
from tensorflow.keras.callbacks import EarlyStopping, ModelCheckpoint
from tensorflow.keras.utils import to_categorical
from tensorflow.keras.backend import clear_session
clear_session()
x_train :모델 입력값 확인하기
x_train.shape
y_train : 아웃풋값 확인하기
y_train.shape
1) DNN모델링
1. model = Sequential() 의미: Keras 라이브러리에서 Sequential 모델을 생성합니다. Sequential 모델은 레이어를 하나씩 순차적으로 쌓아가는 방식으로 신경망을 구성합니다.
2. model.add(Dense(4, input_shape=(3,), activation='relu')) Dense(4): 4개의 뉴런을 가진 Dense(완전 연결) 레이어를 추가합니다. input_shape=(3,): 입력 데이터의 형태를 정의합니다. 여기서 입력 데이터는 3개의 특성을 가집니다. activation='relu': ReLU(Rectified Linear Unit) 활성화 함수를 사용합니다. ReLU 함수는 음수를 0으로 변환하고 양수를 그대로 통과시키는 함수입니다.
3. model.add(Dropout(0.2)) Dropout(0.2): Dropout 레이어를 추가합니다. 드롭아웃은 과적합을 방지하기 위해 학습 중에 무작위로 20%의 뉴런을 비활성화합니다.
4. model.add(Dense(4, activation='relu')) Dense(4): 또 다른 4개의 뉴런을 가진 Dense 레이어를 추가합니다. activation='relu': ReLU 활성화 함수를 사용합니다.
5. model.add(Dense(1, activation='sigmoid')) Dense(1): 출력 레이어로 1개의 뉴런을 가진 Dense 레이어를 추가합니다. activation='sigmoid': 시그모이드 활성화 함수를 사용합니다. 이 함수는 출력값을 0과 1 사이로 변환하여 이진 분류 문제에 적합합니다.
6. model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy']) loss='binary_crossentropy': 손실 함수를 이진 교차 엔트로피로 설정합니다. 이 함수는 이진 분류 문제에서 사용됩니다. optimizer='adam': Adam 옵티마이저를 사용합니다. Adam은 모멘텀과 RMSProp의 장점을 결합한 옵티마이저로, 학습 속도와 정확도를 높이는 데 도움을 줍니다. metrics=['accuracy']: 모델의 평가 기준으로 정확도를 사용합니다.
7. history = model.fit(X_train, y_train, validation_data=(X_test, y_test), epochs=40, batch_size=10) X_train, y_train: 학습 데이터와 레이블을 모델에 제공합니다. validation_data=(X_test, y_test): 검증 데이터와 레이블을 제공합니다. 모델의 성능을 평가하는 데 사용됩니다. epochs=40: 전체 데이터셋에 대해 40번 학습을 반복합니다. batch_size=10: 한 번에 10개의 샘플을 학습에 사용합니다. 즉, 배치 크기를 10으로 설정합니다. 추가 설명 모델 구조 Input Layer: 입력 데이터의 형태를 정의합니다. 여기서는 3개의 특성을 가진 입력 데이터를 받습니다. Hidden Layers: 두 개의 은닉층을 가지며, 각각 4개의 뉴런으로 구성됩니다. 활성화 함수로 ReLU를 사용하여 비선형성을 모델에 추가합니다. Dropout Layer: 과적합을 방지하기 위해 은닉층 사이에 드롭아웃 레이어를 추가합니다. Output Layer: 최종 출력 레이어는 하나의 뉴런을 가지며 시그모이드 활성화 함수를 사용하여 이진 분류 문제를 해결합니다.
-모델학습 설명
compile
딥러닝은 머신러닝과 달리 모델링 과정에서 컴파일이 필요하다.
- optimizer: 모델링을 최적화하는 방법. 주로 Adam을 사용한다.
- loss: 손실함수 - 타겟변수에 맞는 손실함수를 사용해야 한다.
- 회귀: mse
- 이진분류: binary_crossentropy
- 다중분류: sparse_categorical_crossentropy, categorical_crossentropy
- metrics: 모니터링 지표로, 사용자 정의 함수를 사용할 수 있다. 모델의 성능을 평가할 때 사용할 지표를 정
- 회귀: mse, rmse
- 분류: accuracy
# 모델 컴파일
model.compile(optimizer='adam',
loss='binary_crossentropy',
metrics=['accuracy'])
EarlyStopping
모델의 과대적합을 방지하기 위해 학습이 개선되지 않는다면 학습을 종료시킨다.
- monitor: 학습되는지 확인하는 기준
- mode: 모델 최적화의 기준 - 최대화/최소화
- patience: 모델 성능이 개선되지 않을때 지켜보는 횟수
# import
from tensorflow.keras.callbacks import EarlyStopping
es = EarlyStopping(monitor='val_loss',
mode='min')
ModelCheckpoint
모델을 학습하는 과정에서 일정한 간격으로 모델의 가중치를 저장하며 최적 모델을 선택한다.
- filepath: 모델 저장 경로
- monitor: 모니터링하는 지표
- mode: 모델 최적화의 기준 - 최대화/최소화
- verbose: 정보 표시 정도(0, 1, 2)
- save_best_only=True: 가장 좋은 성능의 모델만 저장
# import
from tensorflow.keras.callbacks import ModelCheckpoint
mc = ModelCheckpoint('my_checkpoibnt.ckpt',
monitor='val_loss',
mode='min',
save_best_only=True)
fit
모델을 학습한다.
- validation_data: 검증용 데이터.
종속변수와 타겟변수의 쌍으로 입력해야 한다. - epochs: 학습 반복 횟수
- batch_size: 학습 시 한 번에 학습하는 데이터 사이즈
- callbacks: EarlyStopping, ModelCheckpoint와 같은 학습 과정에서 호출되는 함수
history = model.fit(X_train, y_train,
validation_data = (X_test, y_test),
epochs=epochs,
batch_size=batch_size,
callbacks=[es, mc])
코드 결합 한 것
model = Sequential() #모델생성
model.add(Dense(64, activation='relu', input_shape=(x인풋값,)))
#model1.add(Flatten()) # 없어도 됨..
model.add(Dropout(0.25)) #학습 중 무작위로 25%의 유닛을 드롭한다. 과적합을 방지하기 위해 상ㅇ한다.
#model1.add( BatchNormalization( )) #없어도 됨..
model.add(Dense(아웃풋, activation='sigmoid')) # 2진분류, 다중분류= softmax
#조기 종료와 모델 체크포인트 콜백
#모델의 과대적합을 방지하기 위해 학습이 개선되지 않는다면 학습을 종료시킨다.
es = EarlyStopping( monitor='val_loss',
patience=0,
mode='min',
verbose=1 )
#모델 체크포인트 콜백을 설정
#모델을 학습하는 과정에서 일정한 간격으로 모델의 가중치를 저장하며 최적모델 선택
ms = ModelCheckpoint( 'my_checkpoint.ckpt', #모델 가중치를 저장할 파일명을 의미. best_model.h5의 경우에는
monitor='val_loss',
mode='min',
verbose=1, # verbose=True 옵션과 동일
save_weights_only=True,) #save_best_only 라고 해야 작동되었음
#모델 컴파일
model.compile(optimizer='adam', loss='binary_crossentropy') #이진분류 metrics=['accuracy']
#다중 분류의 경우 loss='sparse_categorical_crossentropy' #다중손실함수...
# 회귀는 loss='mse'
#모델 학습
history = model.fit(x_train, y_train, #학습 데이터와 레이블
epochs= 10, #학습할 에포크 수
batch_size= 32, #배치크기
validation_data=(x_test,y_test),
callbacks=[es,ms],
verbose=True
).history
#모델의 구조를 요약하고 출력
model.summary()
2) 성능평가
#이진분류
y_pred = model.predict(x_test) #예측수행
y_pred_x = np.where(y_pred>=0.5, 1,0 ) # 0.5 이상의 확률값은 1로, 그 미만은 0으로 변환
print(classification_report(y_test, y_pred_x))
#다중분류
y_pred = model.predict(x_test) #예측수행
y_pred_x= np.argmax(y_pred,axis=1) #각 샘플에 대해 가장 높은 확률값을 가지는 클래스의 인덱스를 반환
print(classification_report(y_test, y_pred_x))
3) 학습/검정손실 그래프
history
모델 학습 과정에서 모델 학습 결과를 저장함으로써 학습 과정의 변화를 확인할 수 있다.
history는 딕셔너리 형태로 저장되어 key값으로 접근할 수 있다.
- loss: 학습 loss.
- val_loss: 검증 loss.
- accuracy: 학습 accuracy.
- val_accuracy: 검증 accuracy.
# 시각화 예시
plt.plot(history.history['loss'], label='Train Loss')
plt.plot(history.history['val_loss'], label='Validation Loss')
plt.xlabel('Epochs') # X축 라벨
plt.ylabel('Loss') # Y축 라벨
plt.legend() # 범례 표시 - label값
plt.show()
코드 결합한
#history['loss']: Keras 모델 학습 시 기록된 학습 손실 값의 배열입니다. 각 에포크마다 계산된 손실 값이 저장
#label='Train_Loss': 범례에 표시될 라벨로, 학습 손실을 의미
plt.plot(history['loss'], label='Train_Loss')
#history['val_loss']: Keras 모델 학습 시 기록된 검증 손실 값의 배열입니다. 각 에포크마다 계산된 검증 손실 값이 저장
#label='Validation_Loss': 범례에 표시될 라벨로, 검증 손실을 의미
plt.plot(history['val_loss'], label='Validation_Loss')
#x축 레이블을 'Epochs'로 설정
plt.xlabel('Epochs')
#y축 레이블을 'Loss'로 설정
plt.ylabel('Loss')
#그래프에 범례 추가
plt.legend()
plt.show()
출처: https://datawithu.tistory.com/34 [Data_with_U:티스토리]