## 다운받은 모든 파일은 현재 작업 디렉토리로 옮긴다.
import os
os.getcwd() # 현재 작업 디렉토리 출력
## 나의 현재 작업 디렉토리: C:\Users\jkl12\personal activity
## C:\Users\jkl12\Downloads\train.csv ⇨ C:\Users\jkl12\personal activity\train.csv
## 이를 통해 현재 작업 디렉토리에서 상대경로를 사용할 수 있다.
import pandas as pd
# 현재 작업 디렉토리에서 상대경로 설정
file_path = 'train.csv'
# CSV 파일을 DataFrame으로 로드
train = pd.read_csv(file_path)
train
# 현재 작업 디렉토리에서 상대경로 설정
file_path = 'test.csv'
# CSV 파일을 DataFrame으로 로드
test = pd.read_csv(file_path)
test
# 현재 작업 디렉토리에서 상대경로 설정
file_path = 'gender_submission.csv'
# CSV 파일을 DataFrame으로 로드
gender_submission = pd.read_csv(file_path)
gender_submission
# 'Survived' 열의 값을 모두 0으로 변경.
gender_submission['Survived'] = 0
# 변경된 데이터를 sample_submission.csv로 저장.
gender_submission.to_csv('sample_submission.csv', index = False)
print("sample_submission.csv 파일이 성공적으로 저장되었습니다.")
랜덤으로 생존 여부 생성하기.
import pandas as pd
import numpy as np
gender_submission = pd.read_csv('gender_submission.csv')
# 'Survived' 열을 가져오기.
survived_column = gender_submission['Survived']
# 난수 생성기 시드 설정하기.
np.random.seed(0)
# 'Survived' 열과 같은 길이의 난수 배열 생성.
survived = np.random.randint(0, 2, size=len(survived_column))
print(survived)
train_x = train.drop(columns='Survived') # 독립 변수 X: 'Survived' 열을 제외한 나머지 열
train_y = train['Survived'] # 종속 변수 y: 'Survived' 열
# sklearn의 train_test_split 함수를 사용하여 데이터를 훈련, 검증 세트로 나누기
from sklearn.model_selection import train_test_split
# 데이터셋을 훈련, 검증 세트로 분할
# test_size = 0.2: 전체 데이터의 20%를 검증 세트로 사용
# random_state = 0: 분할을 재현 가능하게 하기 위한 시드 값
train_x, val_x, train_y, val_y = train_test_split(
train_x, train_y, test_size=0.2, random_state=0)
로지스틱 회귀(Logistic Regression) 모델을 정의하고 학습시키기.
import statsmodels.api as sm
train_dataset = pd.concat([train_x, train_y], axis=1)
formula = """
Survived ~ Age + SibSp + Parch + Fare
"""
model = sm.Logit.from_formula(formula, data=train_dataset)
result = model.fit()
수치형 변수들에 대한 기술 통계량(descriptive statistics) 출력하기. (4가지 방식)
# 'Survived' 컬럼 제외 / 입력, 타겟 데이터 분리
train_x = train.drop(columns='Survived')
train_y = train['Survived']
from sklearn.model_selection import train_test_split
# 학습, 검증 데이터 분리
train_x, val_x, train_y, val_y = train_test_split(
train_x, train_y, test_size = 0.2, random_state = 0)
import statsmodels.api as sm
# 로지스틱 회귀모델을 위한 데이터셋 생성
train_dataset = train_x.copy()
train_dataset['Survived'] = train_y
# 로지스틱 회귀 모델을 위한 공식 (Survived를 종속 변수로 설정)
formula = """
Survived ~ C(Pclass) + C(Sex) + scale(Age)
+ scale(SibSp) + scale(Parch) + scale(Fare) + C(Embarked)
"""
# 모델 정의 및 학습
model = sm.Logit.from_formula(formula, data = train_dataset)
result = model.fit() # 모델 학습
print(result.summary())
# 검증 데이터로 예측값 생성
# result 객체의 predict() 메서드로 val_x에 대한 예측 수행
y_pred = result.predict(val_x)
y_pred = y_pred.apply(lambda x: 1 if x >= 0.5 else 0)
from sklearn.metrics import confusion_matrix
# 실제 값(val_y)과 예측 값(y_pred) 비교하여 혼동 행렬 출력
print(confusion_matrix(val_y, y_pred))
from sklearn.metrics import classification_report
# 분류 성능 지표(정확도, 정밀도, 재현율 등) 출력
print(classification_report(val_y, y_pred))
# 데이터프레임 복사
train = raw_data_train.copy()
test = raw_data_test.copy()
submission = raw_data_submission.copy()
# 사용할 컬럼 리스트
columns = ['Pclass', 'Sex', 'Age', 'SibSp', 'Parch', 'Fare', 'Embarked']
# 'Survived' 열을 포함하여 train 데이터에서 필요한 컬럼 선택
train = train[columns + ['Survived']]
# test 데이터에서는 'Survived'가 없으므로 선택한 columns만 사용
test = test[columns]
Age, Fare의 데이터 타입이 정수형이 안 되도록 하기.
# 결측값 처리
mean_age = train['Age'].mean()
mean_fare = train['Fare'].mean()
# 데이터 타입을 실수형으로 유지
train['Age'] = train['Age'].fillna(mean_age).astype(float)
test['Age'] = test['Age'].fillna(mean_age).astype(float)
train['Fare'] = train['Fare'].fillna(mean_fare).astype(float)
test['Fare'] = test['Fare'].fillna(mean_fare).astype(float)
# 이상치 제거
train = train[train['Parch'] <= 5]
train = train[train['Fare'] <= 300]
# 데이터 샘플 확인
print("Train Data Sample:")
print(train.head())
print("\nTest Data Sample:")
print(test.head())
Age, Fare의 데이터 타입이 실수형인지 확인하기.
Embarked_Q, Embarked_S의 데이터 타입이 문자형이 안 되도록 하기.
# 'Sex' 컬럼을 숫자로 변환 ('male' ⇨ 1, 'female' ⇨ 0)
train['Sex'] = train['Sex'].apply(lambda x: 1 if x == 'male' else 0)
test['Sex'] = test['Sex'].apply(lambda x: 1 if x == 'male' else 0)
# 'Embarked' 컬럼에 대해 더미 변수를 생성하고 첫 번째 카테고리를 드롭
train = pd.get_dummies(train, columns=['Embarked'], drop_first=True)
test = pd.get_dummies(test, columns=['Embarked'], drop_first=True)
# train 데이터의 Embarked_Q와 Embarked_S를 int로 변환
train[['Embarked_Q', 'Embarked_S']] = train[['Embarked_Q', 'Embarked_S']].astype(int)
# test 데이터의 Embarked_Q와 Embarked_S를 int로 변환
test[['Embarked_Q', 'Embarked_S']] = test[['Embarked_Q', 'Embarked_S']].astype(int)
test
# 입력 변수와 타겟 변수 정의
# 'Survived'를 제외한 나머지 컬럼을 입력 변수로 설정
train_x = train.drop(columns='Survived')
# 'Survived' 컬럼을 타겟 변수로 설정
train_y = train['Survived']
from sklearn.model_selection import train_test_split
# 학습 데이터와 검증 데이터를 80:20 비율로 분리
train_x, val_x, train_y, val_y = train_test_split(
train_x, train_y, test_size=0.2, random_state=0)
train_x
Age와 Fare이 위와 같이 나오는지 확인한다.
데이터 불균형 해소를 위해, 소수 클래스의 샘플을 합성하여 데이터를 증강하기.
# SMOTE를 사용하려면
# 먼저 imbalanced-learn 패키지에서 SMOTE 클래스를 임포트해야 한다.
# pip install imbalanced-learn
from imblearn.over_sampling import SMOTE
# SMOTE 객체 생성
smote = SMOTE(random_state=0)
# SMOTE를 사용하여 데이터의 클래스 불균형 보정
X_resampled, y_resampled = smote.fit_resample(train_x, list(train_y))
# y_resampled을 'Survived' 컬럼으로 추가하여 train_dataset을 생성
X_resampled['Survived'] = y_resampled
train_dataset = X_resampled
# 결과 확인
print("Resampled X shape:", X_resampled.shape)
print("Resampled y length:", len(y_resampled))
의사결정 트리(Decision Tree) 모델을 사용하여 주어진 학습용 데이터에 대한 패턴 학습하기.
# 모델링 학습
from sklearn.tree import DecisionTreeClassifier
# 모델 정의
model = DecisionTreeClassifier(max_depth=6, random_state=0)
# 모델 학습
model.fit(train_dataset.drop(columns='Survived'), train_dataset['Survived'])
import pandas as pd
from imblearn.over_sampling import SMOTE
# 사용할 컬럼 정의
columns = ['Pclass', 'Sex', 'Age', 'SibSp', 'Parch', 'Fare', 'Embarked']
# train과 test 데이터프레임에서 사용할 컬럼 정의
train = train[columns + ['Survived']] # train 데이터는 'Survived' 컬럼도 포함
test = test[columns] # test 데이터는 독립 변수만 사용
# Null 처리 - 'Age'와 'Fare' 컬럼의 결측치를 각 값의 평균으로 대체
train['Age'] = train['Age'].fillna(train['Age'].mean())
test['Age'] = test['Age'].fillna(test['Age'].mean())
train['Fare'] = train['Fare'].fillna(train['Fare'].mean())
test['Fare'] = test['Fare'].fillna(test['Fare'].mean())
# 이상치 제거 - 'Parch': 5 이하 and 'Fare': 300 이하인 데이터만 남김
train = train[(train['Parch'] <= 5) & (train['Fare'] <= 300)]
# 'Sex' 컬럼에 apply 함수 사용하여 female: 0, 아니면: 1로 변환
train['Sex'] = train['Sex'].apply(lambda x: 0 if x == 'female' else 1)
test['Sex'] = test['Sex'].apply(lambda x: 0 if x == 'female' else 1)
# 'Embarked' 컬럼에 원-핫 인코딩 적용
train = pd.get_dummies(train, columns=['Embarked'], drop_first=True)
test = pd.get_dummies(test, columns=['Embarked'], drop_first=True)
# train 데이터의 Embarked_Q와 Embarked_S를 int로 변환
train[['Embarked_Q', 'Embarked_S']] = train[['Embarked_Q', 'Embarked_S']].astype('uint8')
# test 데이터의 Embarked_Q와 Embarked_S를 int로 변환
train[['Embarked_Q', 'Embarked_S']] = train[['Embarked_Q', 'Embarked_S']].astype('uint8')
# 독립변수(train_x)와 종속변수(train_y)로 나누기
train_x = train.drop('Survived', axis=1)
train_y = train['Survived']
# 데이터의 불균형을 해결하기 위해 SMOTE 알고리즘 적용
smote = SMOTE(random_state=0)
train_x_resampled, train_y_resampled = smote.fit_resample(train_x, train_y)
# 증강된 데이터를 다시 합하여 train_dataset 생성
train_dataset = pd.DataFrame(train_x_resampled)
train_dataset['Survived'] = train_y_resampled
print(train_dataset.head())
train_x
로지스틱 회귀(Logistic Regression) 모델을 정의하고 학습시키기.
import pandas as pd
import statsmodels.api as sm
from sklearn.metrics import classification_report, confusion_matrix
# 로지스틱 회귀식 정의
formula = """
Survived ~ C(Pclass)+ C(Sex) + scale(Age) + scale(SibSp)
+ scale(Parch) + scale(Fare) + C(Embarked_Q) + C(Embarked_S)
"""
# 모델 학습
model = sm.Logit.from_formula(formula, data=train_dataset)
result = model.fit()
# 예측
y_pred = result.predict(train_x) # train_x에 대한 예측값 계산
y_pred = (y_pred >= 0.5).astype(int) # 0.5 이상일 때 1로 변환 (이진 분류)
# 혼동 행렬 및 분류 보고서 출력
print(confusion_matrix(train_y, y_pred))
print(classification_report(train_y, y_pred))
의사결정 트리(Decision Tree) 모델을 사용하여 주어진 학습용 데이터에 대한 패턴 학습하기.
from sklearn.model_selection import train_test_split
from sklearn.tree import DecisionTreeClassifier
from sklearn.metrics import confusion_matrix, classification_report
# 기존 train_x, train_y를 이용하여 train/validation 데이터 분할
train_x, val_x, train_y, val_y = train_test_split(
train_x, train_y, test_size = 0.2, random_state = 0)
# DecisionTreeClassifier 모델 생성
model = DecisionTreeClassifier(
max_depth = 6, random_state = 0)
# 모델 학습
model.fit(train_x, train_y)
# 검증 데이터(val_x)에 대한 예측
y_pred = model.predict(val_x)
# 혼동 행렬 및 분류 보고서 출력
print(confusion_matrix(val_y, y_pred))
print(classification_report(val_y, y_pred))
import pandas as pd
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import confusion_matrix, classification_report
# 범주형 데이터 수치형으로 변환
def preprocess_data(df):
return pd.get_dummies(df, drop_first=True)
# 학습 데이터 전처리
X_train = preprocess_data(train.drop(columns='Survived'))
y_train = train['Survived']
# 검증 데이터 전처리
X_val = preprocess_data(val_x)
# 학습, 검증 데이터의 열을 동일하게 맞추기
X_val = X_val.reindex(columns=X_train.columns, fill_value=0)
# RandomForestClassifier 모델 생성
model = RandomForestClassifier(n_estimators=200, max_depth=5, random_state=0)
# 모델 학습
model.fit(X_train, y_train)
# 검증 데이터(val_x)에 대한 예측
y_pred = model.predict(X_val)
# 혼동 행렬 및 분류 보고서 출력
print(confusion_matrix(val_y, y_pred))
print(classification_report(val_y, y_pred))
# 아래 명령을 실행하면 xgboost 라이브러리가 설치된다.
# pip install xgboost
import pandas as pd
from xgboost import XGBClassifier
from sklearn.metrics import confusion_matrix, classification_report
# 데이터 전처리 함수 정의
def preprocess_data(df):
# 범주형 변수 수치형으로 변환
return pd.get_dummies(df, drop_first = True)
# 학습 데이터 전처리
X_train = preprocess_data(train.drop(columns = 'Survived'))
y_train = train['Survived']
# 검증 데이터 전처리
X_val = preprocess_data(val_x)
# 학습, 검증 데이터의 열을 동일하게 맞추기
X_val = X_val.reindex(columns = X_train.columns, fill_value = 0)
# XGBClassifier 모델 생성
model = XGBClassifier(
n_estimators = 200, learning_rate = 0.01,
max_depth = 5, random_state = 0)
# 모델 학습
model.fit(X_train, y_train)
# 검증 데이터(val_x)에 대한 예측
y_pred = model.predict(X_val)
# 혼동 행렬 및 분류 보고서 출력
print(confusion_matrix(val_y, y_pred))
print(classification_report(val_y, y_pred))
