어깨빠진보부상

8주차 Note: 딥러닝

가라어퍼 — Sun, 31 May 2026 23:30:11 +0900

8주차: 5월 25일 ~ 5월 29일

멀티캠퍼스 부트캠프 8주차 요약✍️

[ 5/25 ] 대체공휴일 휴강

[ 5/26 ] 딥러닝: RNN, LSTM_회귀

[ 5/27 ] 딥러닝: LSTM_분류

[ 5/28 ] 투자 전략: Bollinger Band, BuyandHold

[ 5/29 ] 투자 전략: Momentum

5월 26일 ‍

오늘의 소감: 틀리면서 배우는 딥~러~닝~

학습률 0.001을 0.01로 바꾸니까 MSE 진짜 난리나던데 하...

0 하나를 못봐서 점심시간 내내 코드를 보고 있었다.

RNN

AAPL(애플 주식) 데이터 활용

라이브러리, 데이터 로드

import pandas as pd 
import matplotlib.pyplot as plt
import torch 
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import Dataset, DataLoader
from sklearn.preprocessing import StandardScaler, MinMaxScaler
from sklearn.metrics import mean_squared_error, r2_score

df = pd.read_csv("../csv/aapl.csv")
df.info()

데이터 전처리

df.dropna(inplace=True)

df = df[['Date', 'Adj Close']]
values = df[['Adj Close']].values

df['Adj Close'].values.reshape(-1, 1)

split_idx = int(len(values) * 0.75)

train_data = values[:split_idx]
test_data = values[split_idx:]

# MinMaxScaler로 데이터 정규화
scaler = MinMaxScaler()
train_sc = scaler.fit_transform(train_data)
test_sc = scaler.transform(test_data)

# 스케일링이 완료된 데이터를 Tensor로 변환 
train_sc = torch.tensor(train_sc, dtype=torch.float32)
test_sc = torch.tensor(test_sc, dtype=torch.float32)

Dataset 생성, DataLoader 사용을 통한 train_dl/test_dl 생성

class WindowDataset(Dataset):
    def __init__(self, _data, _window):
        # _data : tensor, array 1차원 데이터 형태
        # _window : 구간의 크기 
        self.data = _data
        self.window = _window
        # DataLoader에서 사용 가능한 인덱스의 최대 값
        self.n = len(_data) - _window

    def __len__(self):
        return self.n
    
    def __getitem__(self, idx):
        # idx : 0 ~ self.n-1 사이의 정수가 대입 (DataLoader에서 자동으로 대입)
        x = self.data[idx:idx + self.window]
        y = self.data[idx + self.window]
        return x, y
 
# WindowDataset에 데이터를 대입 
train_ds = WindowDataset(train_sc, _window=60)
test_ds = WindowDataset(test_sc, _window=60)

# Dataset를 DataLoader로 생성 
train_dl = DataLoader(train_ds, batch_size=128, shuffle = True, drop_last = True)
test_dl = DataLoader(test_ds, batch_size=256, shuffle=False, drop_last = False)

RNN Model, 검증 데이터 평가 함수 생성

RNN Model

# RNN 모델 정의 
class RNNModel(nn.Module):
    def __init__(self,
                 input_size, 
                 hidden_size = 64, 
                 num_layers = 1, 
                 dropout = 0.0, 
                 nonlinearity = 'tanh', 
                 bidirectional = False):
        super(RNNModel, self).__init__()
        # super().__init__()
        self.rnn = nn.RNN(
            input_size = input_size,
            hidden_size = hidden_size, 
            num_layers = num_layers, 
            dropout = dropout, 
            nonlinearity = nonlinearity, 
            bidirectional = bidirectional, 
            # batch_first가 False인 경우, 입력 데이터(구간의 개수, 배치크기, 입력 데이터 피쳐의 수)
            # (배치 크기, 구간의 크기, 입력 피쳐의 개수) --> True로 변경 
            batch_first = True
        )

        # output_feature가 역방향을 포함한다면 2배로 늘어난다. 
        if bidirectional:
            hidden_size *= 2
        print(f"hidden_size : {hidden_size}")
        self.model = nn.Linear(hidden_size, 1)
        
        
    def forward(self, x):
        out, h_n = self.rnn(x)
        last_hidden = h_n[-1]
        result = self.model(last_hidden)
        return result

# 모델 학습 시 검증 데이터를 이용하여 모델의 성능을 평가 할수 있도록 검증 데이터 평가 함수 

@torch.no_grad()
def evaluate_mse(dataloader, model):
    # dataloader -> 검증 데이터셋의 dataloader
    model.eval()
    total_loss = 0
    total_n = 0
    for x, y in dataloader:
        x = x.float()
        y = y.float()
        pred = model(x)
        loss = nn.MSELoss()(pred, y)
        total_loss += loss.item() * x.size(0)
        total_n += x.size(0)
    return total_loss / max(total_n, 1)

RNN Model 호출, 평가 지표, optimizer 생성

aapl_model = RNNModel(
    input_size = 1, 
    hidden_size = 128
)

criterion = nn.MSELoss()
optimizer = optim.Adam(aapl_model.parameters(), lr = 0.001)		# 문제의 0.01과 0.001...

train_history, test_history = [], []
for epoch in range(20):
    aapl_model.train()
    running, n_seen = 0.0, 0
    for x, y in train_dl:
        x = x.float()
        y = y.float()
        pred = aapl_model(x)
        loss = criterion(pred, y)
        optimizer.zero_grad()
        loss.backward()
        # 가중치 발산 방지 
        nn.utils.clip_grad_norm_(aapl_model.parameters(), 1.0)
        optimizer.step()

        running += loss.item() * y.size(0)
        n_seen += y.size(0)
        
    train_mse = running / n_seen
    test_mse = evaluate_mse(test_dl, aapl_model)
    
    train_history.append(train_mse)
    test_history.append(test_mse)
    print(f"Epoch {epoch+1} Train MSE: {round(train_mse, 8)} Test MSE: {round(test_mse, 8)}")

시각화

aapl_model.eval()		# 평가 모드

preds = []
trues = []

with torch.no_grad():
    for x, y in test_dl:
        x = x.float()
        y = y.float()

        pred = aapl_model(x)
        preds.append(pred.cpu())
        trues.append(y.cpu())
        

# cat 함수: pd.concat() 과 같은 역할
preds = torch.cat(preds, dim=0).squeeze(-1).numpy()
trues = torch.cat(trues, dim=0).squeeze(-1).numpy()


# 시각화
plt.figure(figsize = (14, 10))
plt.plot(preds[:600], label = 'Preds')
plt.plot(trues[:600], label = 'Trues')
plt.legend()
plt.grid()
plt.show()

성능 뭐야 대박

LSTM

AAPL 데이터 활용

코드는 RNN과 매우 유사하지만, 예측값을 2개 돌려주는 RNN과 달리 LSTM은 3개를 돌려준다.

또한 nn.LSTM에는 nn.RNN에 없는 head_type이라는 인자가 존재한다.

라이브러리

import pandas as pd
import matplotlib.pyplot as plt
import torch
import torch.nn as nn
import torch.optim as optim

from torch.utils.data import Dataset, DataLoader
from sklearn.preprocessing import MinMaxScaler
from sklearn.model_selection import train_test_split

함수화를 위한 작업

# 하나의 함수화
# 매개변수로 사용할 데이터들은 어떤 것이 있을까?

# 파일의 경로를 지정하는 변수 (read_csv)
file_path = '../csv/aapl.csv'

# 구간(window) 설정 (Dataset)
window = 60

# batch size 지정 (DataLoader)
x_batch = 64
y_batch = 256

# 기여도 (optimizer)
lr = 0.001

# 반복 학습 횟수
epochs = 20

# 은닉층에서의 뉴런(feature)의 개수
hidden_cnt = 64

# Layer 설정값
layer_cnt = 1

# train, test 비율
train_ratio = 0.8

# 은닉층, 셀 구조에서 어떤 부분을 사용할 것인가?
    # 'h': 은닉층 사용 // 'c': 셀 사용 // 'h_c': 둘 다 사용
head_type = 'h_c'

데이터 로드, 전처리

df = pd.read_csv(file_path)
df.dropna(inplace=True)

df['Date'] = pd.to_datetime(df['Date'])
X = df[['Adj Close', 'Volume']].astype(float).values
y = df[['Adj Close']].astype(float).values

X_train, X_test, y_train, y_test = train_test_split(
    X, y, train_size = train_ratio, shuffle = False
)

scaler_x = MinMaxScaler()
scaler_y = MinMaxScaler()

X_train_sc = scaler_x.fit_transform(X_train)
X_test_sc = scaler_x.transform(X_test)
y_train_sc = scaler_y.fit_transform(y_train)
y_test_sc = scaler_y.transform(y_test)

Dataset 생성, DataLoader 사용을 통한 train_dl/test_dl 생성

class WindowDataset(Dataset):
    def __init__(self, _x, _y, _window):
        self.x = _x
        self.y = _y
        self.window = _window
        self.n = (len(_x) - _window)
    
    def __len__(self):
        return max(self.n, 1)
    
    def __getitem__(self, idx):
        x = self.x[idx  :  idx + self.window]
        y = self.y[idx + self.window]
        x_tensor = torch.tensor(x, dtype = torch.float32)
        y_tensor = torch.tensor(y, dtype = torch.float32)
        return x_tensor, y_tensor

train_ds = WindowDataset(X_train_sc, y_train_sc, window)
test_ds = WindowDataset(X_test_sc, y_test_sc, window)

train_dl = DataLoader(train_ds, shuffle = True, drop_last = True, batch_size = x_batch)
test_dl = DataLoader(test_ds, shuffle = False, drop_last=False, batch_size = y_batch)

LSTM 정의

class LSTMModel(nn.Module):
    
    def __init__(
            self,
            input_size,
            hidden_size = 64,
            num_layers = 1,
            dropout = 0.0,
            bidirectional = False,
            batch_first = True,
            head_type = 'h'
    ):
        super(LSTMModel, self).__init__()

        # LSTM 기본 설정
        self.lstm = nn.LSTM(
            input_size = input_size,
            hidden_size = hidden_size,
            num_layers = num_layers,
            dropout = dropout,
            bidirectional = bidirectional,
            batch_first = batch_first
        )

        # bidirectional이 True면 out feature의 개수가 2배
        hidden_size = hidden_size * (2 if bidirectional else 1)

        # head_type에 따라서 출력의 feature 개수가 달라진다.
        if head_type in ['h', 'c']:
        #if (head_type == 'h') | (head_type == 'c')
            pass
        elif head_type == 'h_c':
            hidden_size = hidden_size * 2
        else:
            print('head_type의 인자값을 잘못 입력하였습니다. ("h", "c", "h_c")를 사용해주세요')
        
        # 선형 모델 생성
        self.model = nn.Linear(hidden_size, 1)
            # 객체 안에 독립적인 데이터를 저장
        self.head_type = head_type

    # 순전파 함수 정의
    def forward(self, x):
        # 순전파의 예측값 (RNN은 2개를 되돌려줌, LSTM은 3개를 되돌려줌)
        out, (h_n, c_n) = self.lstm(x)
        # 은닉층의 가장 마지막값 저장
        h_last = h_n[-1]
        c_last = c_n[-1]

        if self.head_type == 'h':
            feat = h_last
        elif self.head_type == 'c':
            feat = c_last
        elif self.head_type == 'h_c':
            feat = torch.cat([h_last, c_last], dim = -1)
        
        return self.model(feat)

여기서 __init__ 함수에 들어간 parameter들은 기본값으로 사용될 것이다.

모델 생성

model = LSTMModel(input_size = 2, hidden_size = hidden_cnt, head_type = head_type)
model

손실 함수, 옵티마이저 정의

criterion = nn.MSELoss()
optimizer = optim.Adam(model.parameters(), lr = lr)

평가 함수 생성

# 검증 데이터의 loss값 확인하는 함수

# @torch.no_grad()
def evaluate_mse(dl):
    model.eval()

    total_loss, total_n = 0.0, 0
    # 데코레이터 또는 여기 사용
    with torch.no_grad():
        for x, y in dl:
            x = x.float()
            y = y.float()
            pred = model(x)
            loss = criterion(pred, y)
            total_loss += loss.item() * y.size(0)
            total_n += y.size(0)
    
    return total_loss / max(total_n, 1)

반복 학습

# 반복 학습

test_history = []

for epoch in range(epochs):
    model.train()

    total_loss, total_n = 0.0, 0
    
    for x, y in train_dl:
        x = x.float()
        y = y.float()

        pred = model(x)
        loss = criterion(pred, y)

        optimizer.zero_grad()
        loss.backward()
        # 기울기 발산 방지 (이 자리 아니면 소용 없음)
        nn.utils.clip_grad_norm_(model.parameters(), 1.0)
        optimizer.step()

        total_loss += loss.item() * y.size(0)
        total_n += y.size(0)
    
    train_loss = total_loss / max(total_n, 1)
    test_loss = evaluate_mse(test_dl)
    test_history.append(test_loss)
    print(f"Epoch: {epoch+1}, train_mse: {round(train_loss, 4)}, test_mse: {round(test_loss, 4)}")

간단 시각화

# test_history를 그래프로 시각화

plt.plot(test_history)
plt.show()

끝에서 mse 값이 상승하는 것은 과적합으로 볼 수 있다.

예측값 생성

model.eval()

preds, trues = [], []

with torch.no_grad():
    for x, y in test_dl:
        x = x.float()
        pred = model(x)
        preds.append(pred)
        trues.append(y)

# tensor 데이터들을 하나로 합쳐주고 차원을 벗겨낸 다음 array로 변환
preds = torch.cat(preds, dim=0).numpy()
trues = torch.cat(trues, dim=0).numpy()

# 스케일링 데이터를 원본 데이터로 변환
pred_origin = scaler_y.inverse_transform(preds).squeeze(-1)
true_origin = scaler_y.inverse_transform(trues).squeeze(-1)

시각화

plt.figure(figsize = (16, 10))
plt.plot(pred_origin, label = 'Pred Origin')
plt.plot(true_origin, label = 'True Origin')

plt.legend()
plt.grid()
plt.xlabel('Date')
plt.ylabel('Adj Close')

plt.show()

성능 대박

5월 27일 ‍

오늘의 소감: 시간이 순식간에 흘러간다... 분명 한 건 많지 않은 것 같은데 뇌에 과부하가 걸려서 진행을 못 하는 느낌

LSTM_분류

날씨 데이터 활용

라이브러리, 데이터 로드

import pandas as pd
import numpy as np
import requests
import torch
import torch.nn as nn
import torch.optim as optim
import matplotlib.pyplot as plt
import platform

from sklearn.metrics import accuracy_score
from torch.utils.data import Dataset, DataLoader
from sklearn.preprocessing import MinMaxScaler

---

url = "https://archive-api.open-meteo.com/v1/archive"

params = {
    'latitude': 37.5665,
    'longitude': 126.9780,
    'start_date': '2025-01-01',
    'end_date': '2025-12-31',
    'hourly': 'temperature_2m,relative_humidity_2m,surface_pressure,wind_speed_10m,rain'
}

res = requests.get(url, params = params)
data = res.json()


# 날씨 데이터들을 따로 추출
df = pd.DataFrame(data['hourly'])
df.columns = ['측정 시간', '기온', '상대 습도', '지면 기압', '풍속', '강수량']

데이터 전처리

x = df[['기온', '상대 습도', '지면 기압', '풍속']].values
y = df['target'].values

x_sc = MinMaxScaler().fit_transform(x)

Dataset 생성, DataLoader 사용 train_dl/test_dl 생성

class windowDS(Dataset):
    def __init__(self, _x, _y, _window):
        self.x = _x
        self.y = _y
        self.window = _window
        self.n = len(_x) - _window
    
    def __len__(self):
        return self.n

    def __getitem__(self, idx):
        x = self.x[ idx : idx + self.window ]
        y = self.y[ idx + self.window ]
        x_tensor = torch.tensor(x).float()
        y_tensor = torch.tensor(y).long()

        return x_tensor, y_tensor

window = 72
train_ds = windowDS(x_sc, y, window)
train_dl = DataLoader(train_ds, batch_size = 64, shuffle=False)

LSTM 모델 생성

class LSTMclf(nn.Module):
    def __init__(
            self,
            input_size,
            hidden_size
    ):
        super(LSTMclf, self).__init__()
        self.lstm = nn.LSTM(
            input_size = input_size,
            hidden_size = hidden_size,
            batch_first = True
        )
        self.model = nn.Linear(hidden_size, 2)
    
    def forward(self, x):
        out, (h_n, c_n) = self.lstm(x)
        # h_n[-1], c_n[-1]: bidirectional이 False인 경우 사용 가능
            # True인 경우 역방향의 아웃풋 피쳐만 불러온다.
        # out: 3차원 데이터셋 → [batch, window, feature]
        # 2차원 데이터셋의 형태로 변경 → out[:, -1, :] → [batch, feature]
        pred = self.model(out[:, -1, :])
        return pred

모델 정의, 손실 함수, 옵티마이저 생성

model = LSTMclf(input_size = x.shape[1], hidden_size=32)
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)

반복 학습

model.train()

for epoch in range(20):
    total_loss, total_n = 0.0, 0
    current1 = current2 = 0
    acc_list = []
    
    for x, y in train_dl:
        res = model(x)
        loss = criterion(res, y)
        optimizer.zero_grad()
        loss.backward()
        nn.utils.clip_grad_norm_(model.parameters(), 1.0)
        optimizer.step()

        total_loss += loss.item()
        total_n += y.size(0)
        _, pred = torch.max(res, 1)
        acc = accuracy_score(y.numpy(), pred.numpy())
        acc_list.append(acc)

        current1 += (y == pred).sum().item()
    
    train_loss = total_loss / len(train_dl)
    mean_current = (current1 / max(total_n, 1)) * 100
    current2 = np.mean(acc_list)

    print(f'Epoch: {epoch+1}, EntropyLoss: {round(train_loss, 3)}, \
    Acc1: {round(mean_current, 3)}, Acc2: {round(current2, 3)}')

예측

model.eval()

eval_loader = DataLoader(train_ds, batch_size = 1000, shuffle=False)

# 첫번째 데이터만 로드
x, y = next(iter(eval_loader))

with torch.no_grad():
    test_out = model(x)
    _, test_pred = torch.max(test_out, 1)

시각화

# 한글 인코딩을 위해
if platform.system() == 'Windows':
    plt.rc('font', family = 'Malgun Gothic')

plt.rcParams['axes.unicode_minus'] = False

# 시각화
plt.figure(figsize=(15, 5))
plt.plot(y.numpy(), label = '실제 강수 여부', color = 'gray', drawstyle = 'steps-mid', alpha = 0.5)
plt.plot(test_pred.numpy(), label = 'LSTM의 결과', color = 'blue', linestyle = '--', drawstyle = 'steps-mid', alpha=0.7)
plt.yticks([0, 1], ['맑음(0)', '비(1)'])
plt.legend()
plt.show()

5월 28일 ‍

오늘의 소감: 클래스 지옥

Bollllinger Band

Amazon 주식 데이터(AMZN) 활용

라이브러리, 데이터 로드

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from datetime import datetime

df = pd.read_csv('../csv/AMZN.csv', index_col = 'Date')
df.head()

데이터 전처리, 파생 변수 생성

flag = df.isin( [np.nan, np.inf, -np.inf] ).any(axis = 1)
df = df.loc[~flag, ]

# 종가 이외의 데이터를 제외
df = df[['Adj Close']]

# 이동평균선 → rolling
df['center'] = df['Adj Close'].rolling(20).mean()

# 상단 밴드, 하단 밴드 생성
std_value = 2 * df['Adj Close'].rolling(20).std()
df['ub'] = df['center'] + std_value
df['lb'] = df['center'] - std_value

# index 값을 시계열로 변경
df.index = pd.to_datetime(df.index)

# 투자 시작 시간 설정
start = '2010-01-01'
test_df = df.loc[start: , ]
test_df.head()

보유 내역 추가

# 구매 상태를 입력할 수 있는 공간 생성

test_df['trade'] = ''
test_df.head()

상단 밴드보다 수정 주가가 높거나 같은 경우인데 현재 보유 중: 매도

상단 밴드보다 수정 주가가 높거나 같은 경우인데 보유 중 아님: 유지

하단 밴드보다 수정 주가가 낮거나 같은 경우인데 현재 보유 중: 유지

하단 밴드보다 수정 주가가 낮거나 같은 경우인데 보유 중 아님: 매수

수정 주가가 밴드 사이에 존재하는 경우인데 현재 보유 중: 유지

수정 주가가 밴드 사이에 존재하는 경우인데 보유 중 아님: 유지

for i in test_df.index:

    # 상단 밴드보다 수정 종가가 높은 경우
    if test_df.loc[i, 'Adj Close'] >= test_df.loc[i, 'ub']:
        # 보유 중이라면 trade = '', 아니라면 trade = ''
        test_df.loc[i, 'trade'] = ''

    # 하단 밴드보다 수정 종가가 낮은 경우
    elif test_df.loc[i, 'Adj Close'] <= test_df.loc[i, 'lb']:
        # 보유 중이라면 trade = 'buy', 아니라면 trade = 'buy'
        test_df.loc[i, 'trade'] = 'buy'
    
    else:
        # 보유 중인 경우 trade = 'buy', 보유 중이 아니면 trade = ''
        # 전날의 trade가 buy인 경우: 보유 중
        if test_df.shift().loc[i, 'trade'] == 'buy':
            test_df.loc[i, 'trade'] = 'buy'
        else:
            test_df.loc[i, 'trade'] = ''

수익률 계산

# 수익률 column 생성, 1로 채워준다

test_df['rtn'] = 1.0

for i in test_df.index:
    # 매수 가격 형성
    if (test_df.shift().loc[i, 'trade'] == '') & (test_df.loc[i, 'trade'] == 'buy'):
        buy = test_df.loc[i, 'Adj Close']
        print(f'매수일: {i}, 매수가: {buy}')

    # 매도 가격 형성
    elif (test_df.shift().loc[i, 'trade'] == 'buy') & (test_df.loc[i, 'trade'] == ''):
        sell = test_df.loc[i, 'Adj Close']

        # 수익률 계산
        rtn = sell / buy
        test_df.loc[i, 'rtn'] = rtn
        print(f'매도일: {i}, 매도가: {sell}, 수익률: {rtn}')

누적 수익률 계산 → rtn 누적곱

acc_rtn = 1.0

for i in test_df.index:
    rtn = test_df.loc[i, 'rtn']
    acc_rtn *= rtn

test_df['acc_rtn'] = test_df['rtn'].cumprod()
test_df.iloc[-1, -1]
	# np.float64(3.138061358619031)

번외: Buy and Hold

계산이 간단해서 제목을 따로 사용하진 않은 Buy and Hold...

# 투자 기간 첫날 → 매수가
# 투자 마지막 날 → 매도가

bnh_rtn = test_df.iloc[-1, 0] / test_df.iloc[0, 0]
print(bnh_rtn)
	# 14.249095911087196

함수화

지금까지 만든 것들을 매개변수를 통일하여 하나의 클래스 속 3개의 함수로 연결짓는 과정

def create_band(
        _df,
        _col = 'Adj Close',
        _start = '2010-01-01',
        _end = datetime.now(),
        _cnt = 20
):
    
    df = _df.copy()

    if 'Date' in df.columns:
        df.set_index('Date', inplace=True)
    
    df.index = pd.to_datetime(df.index)

    df.index = df.index.tz_localize(None)

    flag = df.isin( [ np.nan, np.inf, -np.inf ] ).any(axis=1)
    df = df.loc[~flag, ]

    df = df[[_col]]

    df['center'] = df[_col].rolling(_cnt).mean()

    std_value = 2 * df[_col].rolling(_cnt).std()
    df['ub'] = df['center'] + std_value
    df['lb'] = df['center'] - std_value

    df = df.loc[_start:_end, ]

    return df

df2 = pd.read_csv('../csv/aapl.csv')

band_df = create_band2(df2)

2. 보유 내역 생성 함수

def create_trade(_df):
    # 기준 컬럼 이름을 어떻게 알 것인가?: 첫번째 함수의 return으로 나온 df의 첫번째 컬럼만
    col = _df.columns[0]
    df = _df.copy()
    df['trade'] = ''

    for i in df.index:
        if df.loc[i, col] >= df.loc[i, 'ub']:
            # 매도
            df.loc[i, 'trade'] = ''
        elif df.loc[i, col] <= df.loc[i, 'lb']:
            # 매수
            df.loc[i, 'trade'] = 'buy'
        else:
            if df.shift().loc[i, 'trade'] == 'buy':
                df.loc[i, 'trade'] = 'buy'
            else:
                df.loc[i, 'trade'] = ''
    
    return df

trade_df = create_trade(band_df)

3. 수익률 계산 함수

def create_rtn(_df):
    col = _df.columns[0]
    df = _df.copy()
    
    df['rtn'] = 1.0

    # 수익률 계산
    for i in df.index:
        # 매수
        if (df.shift().loc[i, 'trade'] == '') & (df.loc[i, 'trade'] == 'buy'):
            buy = df.loc[i, col]
            print(f"매수일: {i}, 매수가: {buy}")
            print()
        elif (df.shift().loc[i, 'trade'] == 'buy') & (df.loc[i, 'trade'] == ''):
            sell = df.loc[i, col]
            rtn = sell / buy
            df.loc[i, 'rtn'] = rtn
            print(f"매도일: {i}, 매도가: {sell}, 수익률: {rtn}")
            print()
    # 누적 수익률
    df['acc_rtn'] = df['rtn'].cumprod()
    # 최종 수익률
    acc_rtn = df.iloc[-1, -1]

    return df, acc_rtn

rtn_df, acc_rtn = create_rtn(trade_df)

acc_rtn		# np.float64(1.3923287814461949)
rtn_df

Class로 묶기

class Investing():
    def __init__(self, _df, _col = 'Adj Close', _start = '2010-01-01', _end = datetime.now()):
        self.df = _df
        self.col = _col
        self.start = _start
        self.end = _end
    
    # 바이앤홀드 함수
    def bnh(self):
        df = self.df.copy()
        if 'Date' in df.columns:
            df.set_index('Date', inplace=True)
        df.index = pd.to_datetime(df.index)
        df = df.loc[self.start:self.end, [self.col]]
        buy = df.iloc[0, 0]
        sell = df.iloc[-1, 0]
        return sell / buy
    
    # 볼린져 밴드 함수
    def boll(self, _cnt = 20):
        band_df = create_band(self.df, self.col, self.start, self.end, _cnt)
        trade_df = create_trade(band_df)
        rtn_df, acc_rtn = create_rtn(trade_df)
        return rtn_df, acc_rtn

간이 테스트

df3 = pd.read_csv('../csv/MSFT.csv')
invest = Investing(df3)
invest.bnh()		# np.float64(5.6387313298309785)

5월 29일 ‍

오늘의 소감: 그래도 딥러닝을 하다가 pandas 활용하니까 살겠다...

Momentum

(전 월의 수정 주가/전 년도의 수정 주가) - 1로 구매 타이밍을 잡는 투자 전략

라이브러리, 데이터 로드

import pandas as pd
import numpy as np
from datetime import datetime

df = pd.read_csv('../csv/AMZN.csv', index_col='Date')
df.head()

데이터 전처리

# index 시계열로 변환
df.index = pd.to_datetime(df.index)

# index 데이터에서 년-월을 추출하여 STD-YM에 대입
df['STD-YM'] = df.index.strftime('%Y-%m')

# 월말만 모아놓은 데이터
month_last_df = df.groupby('STD-YM').tail(1)

# 전월의 수정 주가, 전년도의 수정 주가 컬럼 생성
month_last_df['BF-1M'] = month_last_df.shift(1)['Adj Close'].fillna(0)
month_last_df['BF-12M'] = month_last_df.shift(12)['Adj Close'].fillna(0)

month_last_df.head()

거래 내역 추가

# month_last = 구매 신호(momentum_index)를 확인하기 위함

for i in month_last_df.index:
    signal = ''

    # 절대 모멘텀의 계산식 → (전월의 수정 주가 / 전년의 수정 주가) - 1
    momentum_index = (month_last_df.loc[i, 'BF-1M'] / month_last_df.loc[i, 'BF-12M']) - 1

    # 0보다 크고 무한대가 아닌 경우가 구매 신호
    flag = (momentum_index > 0) & (momentum_index != np.inf)
    if flag:
        signal = 'buy'

    print(f'날짜: {i}, momentum_index: {momentum_index}, signal: {signal}')

    df.loc[i:, 'trade'] = signal

수익률, 누적 수익률 계산

# 수익률, 누적 수익률 계산

df['rtn'] = 1.0

# 수익률 계산
for i in df.index:
    # 매수
    if (df.shift().loc[i, 'trade'] == '') & (df.loc[i, 'trade'] == 'buy'):
        buy = df.loc[i, 'Adj Close']
        print(f"매수일: {i}, 매수가: {buy}")
    elif (df.shift().loc[i, 'trade'] == 'buy') & (df.loc[i, 'trade'] == ''):
        sell = df.loc[i, 'Adj Close']
        rtn = sell / buy
        df.loc[i, 'rtn'] = rtn
        print(f"매도일: {i}, 매도가: {sell}, 수익률: {rtn}")
# 누적 수익률
df['acc_rtn'] = df['rtn'].cumprod()
# 최종 수익률
acc_rtn = df.iloc[-1, -1]

acc_rtn

번외: BuyandHold

# byandhold 수익률 계산

buy = df['Adj Close'].iloc[0]
sell = df['Adj Close'].iloc[-1]

print(sell/buy)
	# 974.2744757914

함수화

1. STD-YM 생성 함수

def create_ym(_df, _col = 'Adj Close'):
    df = _df.copy()
    # Date가 column에 포함되어 있는가?
    if 'Date' in df.columns:
        df.set_index('Date', inplace = True)
    df.index = pd.to_datetime(df.index)
    df.index = df.index.tz_localize(None)
    flag = df.isin([np.nan, np.inf, -np.inf]).any(axis=1)
    df = df.loc[~flag, [_col]]
    df['STD-YM'] = df.index.strftime('%Y-%m')

    return df

df = pd.read_csv('../csv/AAPL.csv')
ym_df = create_ym(df)
ym_df.info()

2. 월말 데이터 생성, BF1, BF2 column 생성 함수

def create_month(
        _df,
        _start = '2010-01-01',
        _end = datetime.now(),
        _momentum = 12,
        _last = 1
):

    if _last == 1:
        df = _df.groupby('STD-YM').tail(1)
    elif _last == 0:
        df = _df.groupby('STD-YM').head(1)
    else:
        return "_last 값은 0 또는 1만 가능합니다."
    
    col = _df.columns[0]

    df['BF1'] = df.shift(1)[col].fillna(0)
    df['BF2'] = df.shift(_momentum)[col].fillna(0)
    
    df = df.loc[ _start : _end, ]
    return df

month_df = create_month(ym_df)
month_df.head()

3. 거래 내역 추가, 수익률 계산 함수

def create_rtn(_df1, _df2, _score = 1):
    df = _df1.copy()

    df['trade'] = ''
    df['rtn'] = 1.0

    col = df.columns[0]

    # _df2를 이용해서 거래 내역을 생성
    for i in _df2.index:
        signal = ''
        
        # momentum 계산
        momentum_index = _df2.loc[i, 'BF1'] / _df2.loc[i, 'BF2'] - _score
        flag = (momentum_index > 0) & (momentum_index != np.inf)
        
        if flag:
            signal = 'buy'
        
        # 거래 내역 생성
        df.loc[i:, 'trade'] = signal
        print(f'날짜: {i}, momentum_index: {momentum_index}, signal: {signal}')
    
    # 수익률 계산
    for i in df.index:
        if (df.shift(1).loc[i, 'trade'] == '') & (df.loc[i, 'trade'] == 'buy'):
            buy = df.loc[i, col]
            print(f'매수일: {i}, 매수가: {buy}')
        elif (df.shift(1).loc[i, 'trade'] == 'buy') & (df.loc[i, 'trade'] == ''):
            sell = df.loc[i, col]
            rtn = sell / buy
            df.loc[i, 'rtn'] = rtn
            print(f'매도일: {i}, 매도가: {sell}, 수익률: {rtn}')
    
    # 누적 수익률 계산
    df['acc_rtn'] = df['rtn'].cumprod()
    acc_rtn = df.iloc[-1, -1]

    return df, acc_rtn

df_final, acc_rtn = create_rtn(ym_df, month_df)

print(acc_rtn)

8주차 소감

다음 주 자연어 처리라서 쉬고 가는 타이밍을 만들어주셨는데 벌써부터 걱정된다...

한글이 자연어 처리 중 가장 어렵다고 하는데... 물론 수업은 영어로 할 거지만 괜히 한글 자연어 처리에 대한 욕심이 생겼다고 할까?

원래 아무것도 모를 때 용감하다고 하지... 정신 바짝 차리자

7주차 Note: 머신러닝/딥러닝

가라어퍼 — Sun, 24 May 2026 17:53:46 +0900

️ 7주차: 5월 18일 ~ 5월 22일

멀티캠퍼스 부트캠프 7주차 요약✍️

[ 5/18 ] 머신러닝: XGBoost, PCA, K-Means, t-SNE

[ 5/19 ] 머신러닝: DBSCAN

[ 5/20 ] 딥러닝: 이론 학습. 본문에서는 생략

[ 5/21 ] 딥러닝: torch

[ 5/22 ] 딥러닝: RNN

5월 18일 ‍

오늘의 소감: 월요일 힘들지만... 힘들다 응.. 힘들어. ㅋㅋㅋㅋㅋ정신줄 붙잡자

XGBoost

부스팅의 대표적인 모델로, 빠른 속도, 높은 성능, 과적합 제어 기능을 제고아는 트리 기반 앙상블 모델

body dataset 활용

from xgboost import XGBClassifier, XGBRegressor
from sklearn.model_selection import train_test_split
from sklearn.metrics import confusion_matrix, classification_report, mean_squared_error, r2_score
import pandas as pd
import numpy as np

body = pd.read_csv('../data/bodyPerformance.csv')
body.head(3)

# 성별/등급을 수치형 데이터로 변환

body['gender'] = np.where(
    body['gender'] == 'M', 0, 1
)

body['class'] = body['class'].map({'A': 0, 'B': 1, 'C': 2, 'D': 3})

body.head(3)

X = body.drop('class', axis = 1)
y = body['class']

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.3, \
random_state = 42, stratify = y)

# XGBoost 분류 모델을 생성 (다중 분류 모델 → softmax 기반)

clf = XGBClassifier(
    n_estimators = 1000,
    learning_rate = 0.05,
    objective = 'multi:softprob',
    eval_metric = 'mlogloss',
    max_depth = 5,
    min_child_weight = 2,
    subsample = 0.8,
    colsample_bytree = 0.8,
    early_stopping_rounds = 50,
    random_state = 42,
    tree_method = 'hist'
)

clf.fit(X_train, y_train, eval_set = [(X_test, y_test)], verbose = 50)
print("Best Iteration: ", clf.best_iteration)
print("Best Score: ", clf.best_score)

clf_pred = clf.predict(X_test)
print(confusion_matrix(y_test, clf_pred))
print()
print(classification_report(y_test, clf_pred))

hyper parameter들을 조정해주며 성능을 더욱 향상시킬 수 있다.

PCA

차원 축소 기법으로, 고차원 데이터를 상관관계가 없는 새로운 축으로 변환, 이때 데이터의 분산을 최대한 보존하면서 축소한다.

iris dataset 활용

import matplotlib.pyplot as plt
import pandas as pd
import numpy as np
from sklearn.decomposition import PCA
from sklearn.model_selection import train_test_split, GridSearchCV, StratifiedKFold
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.svm import SVC, SVR
from sklearn.metrics import classification_report, r2_score

iris = pd.read_csv('../csv/iris.csv')
iris.head()

X = iris.drop('species', axis = 1)
y = iris['species']

pca = PCA()
X_pca = pca.fit_transform(X, y)

X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size = 0.2, random_state = 42, stratify = y
)

# KFold 생성
cv = StratifiedKFold(
    n_splits = 5, shuffle = True, random_state = 42
)

# Pipeline 생성: Scaler → PCA → SVC
pipe = Pipeline(
    [
        ('scaler', StandardScaler()),
        ('pca', PCA(random_state = 42)),
        ('svc', SVC(random_state = 42, probability = True))
    ]
)

# 최적의 parameter를 찾기 위한 parameter의 조합
params = {
    'pca__n_components' : [None, 2, 3],
    'svc__C' : [0.1, 1, 10],
    'svc__gamma': ['scale', 'auto'],
    'svc__kernel' : ['linear', 'rbf']
}

# GridSearchCV 객체를 생성
grid = GridSearchCV(
    estimator = pipe,
    param_grid = params,
    scoring = 'accuracy',
    cv = cv,
    n_jobs = -1,
    verbose = 1,
    refit = True
)

grid.fit(X_train, y_train)

print('Best estimator: ', grid.best_estimator_)
print('Best Parameter: ', grid.best_params_)
print(classification_report(
    y_test, grid.predict(X_test)
))

K-means

k개의 그룹으로 자동 분류하는 비지도 학습 알고리즘으로,

그룹의 중심점을 반복적으로 계산하여 서로 가까운 데이터끼리 묶어 군집을 형성한다.

iris dataset 활용

import matplotlib.pyplot as plt
import pandas as pd
from sklearn.preprocessing import StandardScaler
from sklearn.decomposition import PCA
from sklearn.cluster import KMeans
from sklearn.metrics import silhouette_score, calinski_harabasz_score, davies_bouldin_score, adjusted_rand_score

iris = pd.read_csv('../csv/iris.csv')

X = iris.drop('species', axis = 1)
y = iris['species']

X_std = StandardScaler().fit_transform(X)

# Kmeans 객체 생성
model = KMeans(
    n_clusters = 3,
    random_state = 42,
    n_init = 10
)

model.fit(X_std)
labels = model.predict(X_std)

# 검증 지표 (군집이 얼마나 잘 되었는가?)
inertia = model.inertia_
silhouette = silhouette_score(X_std, labels)
chs = calinski_harabasz_score(X_std, labels)
dbs = davies_bouldin_score(X_std, labels)

# 실제 라벨과의 계산
ari = adjusted_rand_score(y, labels)

print('inertia: ', round(inertia, 3))
print('silhouette: ', round(silhouette, 3))
print('calinski: ', round(chs, 3))
print('davies: ', round(dbs, 3))
print('ARI: ', round(ari, 3))

inertia:  139.82
silhouette:  0.46
calinski:  241.904
davies:  0.834
ARI:  0.62

이때 inertia_, davies_Bouldin_score은 작을수록 좋고, calinski_Harabasz_score은 높을수록 좋으며,

silhouette_score, adjusted_rand_score은 1에 가까울수록 좋다.

# 군집의 상황을 2차원 그래프로 시각화 → 차원 축소
pca = PCA(n_components=2)

X_pca = pca.fit_transform(X_std)

# pca를 이용해서, 중심점을 2차원으로 축소
center_pca = pca.transform(model.cluster_centers_)

plt.figure(figsize = (12, 8))
plt.scatter(X_pca[:, 0], X_pca[:, 1], c = labels, cmap = 'viridis', s = 40, alpha = 0.7)
plt.scatter(center_pca[:, 0], center_pca[:, 1], c = 'black', s = 100, marker = 'X', label='center')
plt.legend()
plt.show()

t-SNE

비선형 차원 축소 기법으로, 고차원 데이터의 국소 구조를 보존하면서 2차원 또는 3차원 시각화를 하기 위해 사용한다.

고차원 데이터의 경우에는 거리 기반 유사도를 사용하며, 저차원의 경우에는 t-분포를 이용해 확률적으로 비슷하게 재현한다.

digits dataset 활용

digits dataset은 숫자를 나타내는데 필요한 데이터를 담은 dataset이다.

해당 dataset에 포함된 image column을 활용하여 시각화를 하면 다음과 같은 이미지가 도출된다.

각 데이터가 0 ~ 9 중 어디에 속하는지 시각화를 수행하는 작업을 수행할 것이다.

import matplotlib.pyplot as plt
import pandas as pd
from sklearn.datasets import load_digits
from sklearn.preprocessing import StandardScaler
from sklearn.manifold import TSNE

digits = load_digits()
pd.DataFrame(digits.data)

column이 64개다 = 64차원이다.

tsne = TSNE(
    n_components=2,
    perplexity=40,
    random_state=42,
    n_jobs=-1
)

X = StandardScaler().fit_transform(digits['data'])
y = digits['target']

X_tsne = tsne.fit_transform(X)

print(X.shape)			# (1797, 64)
print(X_tsne.shape)		# (1797, 2)

기존 64차원에서 2차원으로 줄어든 모습을 볼 수 있다.

plt.figure(figsize=(16, 10))

sc = plt.scatter(
    X_tsne[:, 0], X_tsne[:, 1], c = y, cmap = 'cool', s = 40
)

plt.legend(*sc.legend_elements(), title='Digits')
plt.show()

각 target 별로 데이터가 뭉쳐져 있는 모습을 확인할 수 있다.

5월 19일 ‍

오늘의 소감: 대학교에서 진행했던 팀플에서 DBSCAN을 사용할 뻔한 적이 있었는데,

그때만 해도 관련 과정을 많이 듣지 않았던 때라 뭔지 몰라서 헤매었던 기억이 있다.

(배운 것 이외의 방법이 나오면 많이 쫄았었지...)

많은 방법을 접하고 있는 지금을 새로이 도전하는 것을 두려워하지 않는 계기로도 발전시켜나갔으면 좋겠다.

DBSCAN

밀도 기반의 클러스터링 알고리즘으로, 데이터의 밀도를 이용하여 군집을 생성한다.

body dataset 활용

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from sklearn.preprocessing import StandardScaler, LabelEncoder
from sklearn.cluster import DBSCAN
from sklearn.neighbors import NearestNeighbors
from sklearn.metrics import silhouette_score, adjusted_rand_score
from sklearn.decomposition import PCA

body = pd.read_csv('../data/bodyPerformance.csv')

늘 그랬듯 범주형 데이터를 수치로 변환하고, 독립/종속으로 분할

obj_cols = body.select_dtypes('object').columns
le = LabelEncoder()

for col in obj_cols:
    body[col] = le.fit_transform(body[col])
    
X = body.drop(['class'], axis = 1)
y1 = body['class']
y2 = body['gender']

X_std = StandardScaler().fit_transform(X)

X 데이터에서 k번째 최근접 이웃의 거리를 계산

각각의 거리 데이터에서 10번째 이웃의 거리만 추출하여 kth_list에 저장

nbrs = NearestNeighbors(n_neighbors=10).fit(X_std)
distances, idxs = nbrs.kneighbors(X_std)
kth_list = np.sort(distances[:, -1])

plt.figure(figsize=(5, 5))
plt.plot(kth_list)
plt.grid(True)
plt.show()

값이 13,000 근처에서 확 꺾이는 것을 볼 수 있는데, 이 꺾인 뒤의 값들은 노이즈라고 생각할 수 있으며,

해당 부분의 y값을 eps로 잡아주면 된다.

diffs = np.diff(kth_list)
eps_ = np.where(diffs>0.05)[0]
print('급변하는 인덱스의 값: ', eps_)
print('대략적인 eps의 최적값: ', kth_list[eps_[0]])

# 급변하는 인덱스의 값:  [13357 13370 13371 13374 13376 13378 13380 13382 13383 13384 13385 13386 13387 13388 13389 13390 13391]
# 대략적인 eps의 최적값:  3.051458810772378

DBSCAN

db = DBSCAN(
    eps = 1.7,
    min_samples = 10,
    n_jobs = -1
)

labels = db.fit_predict(X_std)

set(labels)

db = DBSCAN(
    eps = 1.7,
    min_samples = 10,
    n_jobs = -1
)

labels = db.fit_predict(X_std)

# 검증 지표
# 노이즈 제외하고 검증
flag = labels != -1
sil = silhouette_score(X_std[flag], labels[flag])
ari = adjusted_rand_score(y1, labels)
print(sil)
print(ari)

# 0.3466129480317822
# 0.0049927528548928055

막상 eps를 3으로 지정하니까 군집이 하나만 생성되었기에, eps값을 1.7로 낮추어 분석을 진행하였다.

# PCA를 이용하여 2차원으로 차원 축소하고 그래프 시각화
pca = PCA(n_components=2, random_state=42)
X_pca = pca.fit_transform(X_std)

# 노이즈 / 비노이즈 부분을 다르게 표시
non_noise = labels != -1

# 비노이즈 산점도 그래프 표시
plt.scatter(X_pca[non_noise, 0], X_pca[non_noise, 1], \
            c = labels[non_noise], cmap = 'cool', label = 'Cluster', alpha = 0.5)

# 노이즈 산점도 그래프 표시
plt.scatter(X_pca[~non_noise, 0], X_pca[~non_noise, 1], c = 'black', label = 'Noise', alpha = 0.3)

plt.legend()
plt.show()

5월 21일 ‍

오늘의 소감: 학교에서는 Tensorflow로만 하다가 Torch를 하니까 좀 어색한 느낌이 있다...

코드를 다시 살펴보며 꼼꼼히 복습해야겠다.

Torch - 선형 모델

import torch
import torch.nn as nn
import torch.optim as optim

torch: tensor type으로 parsing하기 위함

nn: 기본 뼈대

optim: 기울기 변화를 주는 기능

독립, 종속변수 tensor로 생성

X = torch.tensor([[1.0], [2.0], [3.0], [4.0]])
y = torch.tensor([[3.0], [5.0], [7.0], [9.0]])

# 순전파 (모델 학습 → 예측)

class LinearReg(nn.Module):
    def __init__(self):
        super(LinearReg, self).__init__()
        self.linear = nn.Linear(1, 1)
    
    def forward(self, x):
        return self.linear(x)

클래스 생성

model = LinearReg()

손실함수, 옵티마이저 설정

criterion = nn.MSELoss()
optimizer = optim.SGD(model.parameters(), lr = 0.01)

모델 학습 (1번)

# 순전파 (생성된 모델을 호출하면 forward() 함수를 호출하도록 nn.Module에서 설정되어있음)
pred = model(X)
# LinearReg 클래스 안의 forward 함수를 호출하여 독립변수(x)를 인자값으로 사용한다.

# 손실 함수
loss = criterion(pred, y)

# 기울기 초기화
optimizer.zero_grad()

# 역전파 (자동 미분) → 데이터가 있는 쪽으로 방향을 제시한다
loss.backward()

# 가중치를 업데이트 (파라미터(모델) 수정)
optimizer.step()

# loss 값을 확인
print(loss)
# tensor(49.5290, grad_fn=<MseLossBackward0>)

모델 평가

# DL 모델은 반복 학습이 기본 설정 → 학습 모드를 평가 모드로 전환
# eval(): 모델을 평가모드로 전환
# train(): 모델을 학습 모드로 전환
model.eval()

# 예측, 평가 (메모리의 사용량을 줄이기 위해서 가중치의 계산을 잠시 비활성화)
with torch.no_grad():
    y_pred = model(X)
    loss = criterion(y_pred, y)
    print(y_pred)
    print(loss)

# 반복 학습을 통해서 가중치와 편향을 변화시킨다.
epochs = 200
model.train()

for epoch in range(epochs):
    # 순전파
    pred = model(X)
    # 손실 함수
    loss = criterion(pred, y)
    # 기울기 초기화
    optimizer.zero_grad()
    # 자동 미분(역전파) → 가중치의 방향을 제시
    loss.backward()
    # 가중치를 업데이트
    optimizer.step()

    if (epoch + 1) % 20 == 0:
        print(f"Epoch: [{epoch+1}, 200], Loss: {round(loss.item(), 6)}")

반복학습 후 모델 평가

model.eval()

with torch.no_grad():
    y_pred = model(X)
    loss = criterion(y_pred, y)
    print(y_pred)
    print(loss)

Torch - 비선형 모델: 회귀

california dataset 활용

from sklearn.datasets import fetch_california_housing
from sklearn.model_selection import train_test_split

data = fetch_california_housing()

X = data['data']
y = data['target']

print(X.shape, y.shape)
# (20640, 8) (20640,)

# 1차원 데이터를 2차원으로 변경
y = y.reshape(-1, 1)

# 학습, 평가 데이터로 분할
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size = 0.2, random_state = 42
)

# Tensor 형태로 변환
X_train_tensor = torch.tensor(X_train, dtype=torch.float32)
X_test_tensor = torch.tensor(X_test, dtype=torch.float32)
y_train_tensor = torch.tensor(y_train, dtype=torch.float32)
y_test_tensor = torch.tensor(y_test, dtype=torch.float32)

# 비선형 모델 생성 (선형 모델 → 활성화 함수 → 선형 모델)

class Reg2(nn.Module):
    def __init__ (self, _dim):
        super(Reg2, self).__init__()
        # 다중 퍼셉트론 안에 선형 모델 → 활성화 함수 → 선형 모델
        self.model = nn.Sequential(
            # 첫번째 레이어
            nn.Linear(_dim, _dim),
            # 비선형 구조 파악용 활성화 함수
            nn.ReLU(),
            nn.Linear(_dim, 1)
        )
    
    def forward(self, x):
        return self.model(x)

model3 = Reg2(n_feature)
criterion3 = nn.MSELoss()
optimizer3 = optim.SGD(model3.parameters(), lr = 0.01)

# 반복 학습
model3.train()

for epoch in range(300):
    n = epoch + 1
    pred3 = model3(X_train_sc)
    loss3 = criterion3(pred3, y_train_tensor)
    optimizer3.zero_grad()
    loss3.backward()
    optimizer3.step()

    if n % 30 == 0:
        print(f"Epoch [{n} / 300], Loss: {round(loss3.item(), 6)}")

model3.eval()
with torch.no_grad():
    pred3 = model3(X_test_sc)
    loss3 = criterion3(pred3, y_test_tensor)

for i in range(10):
    print(f"실제 데이터: {y_test[i]}, 예측 데이터: {pred3[i].item()}")

Torch - 비선형 모델: 분류

iris dataset 활용

import pandas as pd
from sklearn.metrics import accuracy_score, classification_report
from sklearn.preprocessing import LabelEncoder
df = pd.read_csv('../csv/iris.csv')

X = df.drop('species', axis = 1)
y = df['species']

le = LabelEncoder()
y = le.fit_transform(y)
y

X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size = 0.2, random_state = 42, stratify = y
)

# Scaling
scaler = StandardScaler()
X_train_sc = scaler.fit_transform(X_train)
X_test_sc = scaler.transform(X_test)

# Tensor 형태로 변환
X_train_tensor = torch.tensor(X_train_sc, dtype = torch.float32)
X_test_tensor = torch.tensor(X_test_sc, dtype = torch.float32)
y_train_tensor = torch.tensor(y_train, dtype = torch.long)
y_test_tensor = torch.tensor(y_test, dtype = torch.long)
	# 분류의 경우에는 종속변수를 long 타입으로 잡는다.

class clf(nn.Module):
    def __init__(self, _dim):
        super(clf, self).__init__()
        self.model = nn.Linear(_dim, 3)
    
    def forward(self, x):
        return self.model(x)

clf_model = clf(X.shape[1])
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(clf_model.parameters(), lr = 0.01)
pred = clf_model(X_train_tensor)
pred

clf_model.train()

for epoch in range(300):
    pred = clf_model(X_train_tensor)
    loss = criterion(pred, y_train_tensor)
    optimizer.zero_grad()       # 기울기 초기화
    loss.backward()             # 자동 미분
    optimizer.step()            # 기울기 업데이트
    n = epoch + 1
    
    if n % 30 == 0:
        print(f'Epoch: [{n} / 300], Loss: {round(loss.item(), 6)}')

clf_model.eval()

with torch.no_grad():
    pred = clf_model(X_test_tensor)
    _, pred_idx = torch.max(pred, 1)

acc = accuracy_score(y_test, pred_idx)
print('정확도: ', round(acc, 4))
print(classification_report(y_test, pred_idx))

5월 22일 ‍

오늘의 소감: 처음 보는 라이브러리는 역시 어려워

RNN

insurance dataset 활용

라이브러리, 데이터 로드

import math
import numpy as np
import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import DataLoader, Dataset
from sklearn.preprocessing import StandardScaler
import matplotlib.pyplot as plt

데이터 생성, 전처리

np.random.seed(42)
torch.manual_seed(42)

# 노이즈를 포함한 연속성을 가진 sin 곡선 생성
x = torch.arange(3000).float()
y = torch.sin(2 * math.pi * 0.02 * x) + 0.05 * torch.randn(3000)

# train test split
train_size = int(0.8 * len(x))
print(train_size)		# 2400

X_train = y[:train_size]
X_test = y[train_size:]

scaler = StandardScaler()
X_train_sc = scaler.fit_transform(X_train.reshape(-1, 1))
X_test_sc = scaler.transform(X_test.reshape(-1, 1))
	# reshape를 통해 2차원 array의 형태로 변환

X_train_tensor = torch.tensor(X_train_sc, dtype = torch.float32)
X_test_tensor = torch.tensor(X_test_sc, dtype=torch.float32)

X_train_tensor.shape		# torch.Size([2400, 1])


# Tensor Data를 배치가 존재하는 3차원 데이터로 변환
X_train_tensor = X_train_tensor.unsqueeze(0)
X_test_tensor = X_test_tensor.unsqueeze(0)
X_train_tensor.shape		# torch.Size([1, 2400, 1])

DataLoader

Pytorch에서 Dataset들을 batch 단위로 꺼내주는 반복자

반복 학습 루트에 맞는 형태의 데이터셋을 공급해주는 역할

# Custom Dataset 클래스 정의

class WindowDataset(Dataset):
    def __init__(self, _data, _window):
        # _data: 시계열 데이터
        # _window : 구간 설정
        self.data = _data
        self.window = _window
        # 유효 샘플의 개수 계산
        # 입력 데이터: 전체 길이 - window 크기
        self.n = len(self.data) - self.window
    # __len__ 메서드: 데이터셋의 크기를 반환
    # __getitem__ 메서드: 인덱스에 해당하는 샘플을 반환
    # 특수 메서드: DataLoader가 데이터셋에서 데이터를 불러올 때 자동으로 호출
    def __len__(self):
        return self.n

    def __getitem__(self, idx):
        # DataLoader 실제로 입력된 데이터들을 슬라이스해서 가지고 가는 함수
        x = self.data[ idx : idx + self.window ]
        y = self.data[ idx + self.window ]
        return x, y

DataLoader 활용 데이터 분할

window = 10
train_ds = WindowDataset(X_train_tensor.squeeze(0), window)
test_ds = WindowDataset(X_test_tensor.squeeze(0), window)

batch_size = 10
x_list = []
y_list = []

for i in range(len(train_ds)):
    if i == 10:
        break
    x, y = train_ds[i]
    x_list.append(x)
    y_list.append(y)

train_dl = DataLoader(
    train_ds,
    batch_size = 64,
    drop_last=True,
    shuffle=True
)

test_dl = DataLoader(
    test_ds,
    batch_size=64,
    drop_last=True,
    shuffle=False
)

반복 학습

train_loss_list = []
test_loss_list = []

for epoch in range(20):
    model.train()

    running = 0.0
    n_seen = 0

    for x, y in train_dl:
        x = x.float()
        y = y.float()

        # RNN 모델에 입력(x)을 넣어서 예측값(yhat)을 얻는다.
        yhat = model(x)

        loss = criterion(yhat, y)
        optimizer.zero_grad()
        loss.backward()

        # 미분값 폭주 방지
        torch.nn.utils.clip_grad_norm_(model.parameters(), 1.0)

        optimizer.step()

        running += loss.item() * x.size(0)
        n_seen += x.size(0)
    
    train_loss = running / max(1, n_seen)
    train_loss_list.append(train_loss)
    print(f'Epoch {epoch+1}, Train Loss: {round(train_loss, 8)}')

모델 평가

model.eval()
preds = []
trues = []

with torch.no_grad():
    for x, y in test_dl:
        x = x.float()
        y = y.float()
        pred = model(x)
        preds.append(pred)
        trues.append(y)
        
preds = torch.cat(preds, 0).squeeze(-1).numpy()
trues = torch.cat(trues, 0).squeeze(-1).numpy()

시각화

plt.figure(figsize=(20, 13))
plt.plot(preds[:1000], label='Predicted')
plt.plot(trues[:1000], label = 'True')
plt.legend()
plt.grid()
plt.show()

7주차 소감

잘 버텨오다가 DataLoader에서 조금 무너졌다... 그래 여기까지가 내 배경지식이구나...

참고도서를 읽어서 해당 부분 제대로 복습하고 다음 주 부분 들어가야겠다...!

6주차 Note: 머신러닝

가라어퍼 — Sat, 16 May 2026 18:10:46 +0900

️ 6주차: 5월 11일 ~ 5월 15일

멀티캠퍼스 부트캠프 6주차 요약✍️

[ 5/11 ] 머신러닝: LinearRegression, DecisionTree

[ 5/12 ] 머신러닝: 다항 회귀, Ridge, Lasso, ElasticNet

[ 5/13 ] 머신러닝: LogisticRegression, SVM

[ 5/14 ] 머신러닝: Bagging, Boosting

[ 5/15 ] 머신러닝: RandomForest, Pipeline, GridSearchCV

5월 11일 ‍

오늘의 소감: 오후 시간에는 Logistic Regression을 포함한 다양한 분류/회귀 모델의 이론을 학습하였다.

내일이면 해당 부분 코딩을 하게될 것인데, 단순 모델에서 확장된 개념을 실습할 생각하니 기대된다!

LinearRegression

저번 시간 마지막에 짧게 하고 넘어갔던 LinearRegression Review

boston dataset 활용

라이브러리, 데이터 로드

import pandas as pd
from sklearn.preprocessing import StandardScaler
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_squared_error, r2_score

boston = pd.read_csv('../csv/boston.csv')

데이터 분할

X_train, X_test, y_train, y_test = train_test_split(
    boston.drop('Price', axis=1),
    boston['Price'],
    test_size = 0.3,
    random_state = 42
)

스케일링

stdScaler = StandardScaler()
X_train_sc = stdScaler.fit_transform(X_train)
X_test_sc = stdScaler.transform(X_test)

선형 회귀 모델 생성, 학습, 예측

lr = LinearRegression()
lr_inter = LinearRegression(fit_intercept = False)

# 기본형 모델에 스케일링하지 않은 데이터 사용
lr.fit(X_train, y_train)
pred = lr.predict(X_test)
print(r2_score(y_test, pred))		# 0.7112260057484925

# 기본형 모델에 스케일링한 데이터 사용
lr.fit(X_train_sc, y_train)
pred = lr.predict(X_test_sc)
print(r2_score(y_test, pred))		# 0.7112260057484932

# 절편을 사용하지 않는 모델에 스케일링하지 않은 데이터 사용
lr_inter.fit(X_train, y_train)
pred = lr_inter.predict(X_test)
print(r2_score(y_test, pred))		# 0.6662585112262787

# 절편을 사용하지 않는 모델에 스케일링한 데이터 사용
lr_inter.fit(X_train_sc, y_train)
pred = lr_inter.predict(X_test_sc)
print(r2_score(y_test, pred))		# -6.445989223950212

DecisionTree

저번 시간 마지막에 짧게 하고 넘어갔던 DecisionTree Review

iris dataset 활용

라이브러리, 데이터 로드

import matplotlib.pyplot as plt
import pandas as pd
import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.tree import DecisionTreeClassifier, plot_tree
from sklearn.metrics import accuracy_score, recall_score, precision_score, f1_score, confusion_matrix

iris = pd.read_csv('../csv/iris.csv')

데이터 분할

X_train, X_test, y_train, y_test = train_test_split(
    iris.drop('species', axis = 1),
    iris['species'],
    test_size = 0.2,
    random_state = 42,
    stratify = iris['species']
)

연습 문제

1. max_depth 5, 3, 1을 기준으로 3개의 모델을 생성
2. score(X_train, y_train) 함수를 이용하여 학습된 데이터에서 정확도를 확인
3. X_test를 이용하여 예측 → f1_score를 이용하여 모델의 성능 확인

# 1)
tree1 = DecisionTreeClassifier(max_depth=1, random_state=42)
tree3 = DecisionTreeClassifier(max_depth=3, random_state=42)
tree5 = DecisionTreeClassifier(max_depth=5, random_state=42)

tree1.fit(X_train, y_train)
tree3.fit(X_train, y_train)
tree5.fit(X_train, y_train)

# 2)
print(tree1.score(X_train, y_train))	# 0.6666666666666666
print(tree3.score(X_train, y_train))	# 0.9833333333333333
print(tree5.score(X_train, y_train))	# 1.0

# 3)
pred1 = tree1.predict(X_test)
pred3 = tree3.predict(X_test)
pred5 = tree5.predict(X_test)

print(f1_score(y_test, pred1, average='micro'))		# 0.6666666666666666
print(f1_score(y_test, pred3, average='micro'))		# 0.9666666666666667
print(f1_score(y_test, pred5, average='micro'))		# 0.9333333333333333

min_samples_split 매개변수 사용

min_samples_split : 분할 가능한 최소 샘플 개수

clf = DecisionTreeClassifier(max_depth=3, min_samples_split=45, random_state=42)
clf.fit(X_train, y_train)
feature_names = X_train.columns
class_names = y_train.unique()

# 해당 매개변수가 없는 tree와 비교
plt.figure(figsize=(30, 30))
plt.subplot(1, 2, 1)
plot_tree(tree3, feature_names=feature_names, class_names=class_names, filled = True)
plt.title('without min_samples_split')
plt.subplot(1, 2, 2)
plot_tree(clf, feature_names=feature_names, class_names=class_names, filled = True)
plt.title('with min_samples_split')
plt.show()

5월 12일 ‍

오늘의 소감: 이론이 쏟아진다아아아아... 버텨내자아아아...

다항 회귀

cereal dataset 활용

라이브러리, 데이터 로드

import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns

from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_absolute_error, r2_score
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import PolynomialFeatures

cereal = pd.read_csv('../data/cereal.csv')
cereal.info()

데이터 전처리

cereal.describe()

최솟값이 음수인 이상치들이 carbo, sugars, potass 세 column에서 관측되었다.

이상치 제거

flag = (cereal[['carbo', 'sugars', 'potass']] < 0).any(axis = 1)

df = cereal.loc[~flag, ]
df.describe()

다항 회귀선 시각화

1차 회귀선 시각화

sns.regplot(
    data = df, x = 'sugars', y = 'rating'
)

plt.show()

2차 회귀선 시각화

sns.regplot(
    data = df, x = 'sugars', y = 'rating', order = 2
)

plt.show()

단항회귀 vs 다항회귀 결과 비교

# column 하나만 선택하기 위해 상관계수 확인

df.iloc[:, 3:].corr().iloc[-1, ]

단항회귀

x = df[['sugars']]
y = df['rating']

X_train, X_test, y_train, y_test = train_test_split(x, y, test_size = 0.3, random_state = 42)

lr = LinearRegression()
lr.fit(X_train, y_train)

pred = lr.predict(X_test)
print(mean_absolute_error(y_test, pred))
# 7.469662633513549

2차항(다항) 회귀

poly_reg = PolynomialFeatures()

X_train_poly = poly_reg.fit_transform(X_train)
X_test_poly = poly_reg.transform(X_test)

lr.fit(X_train_poly, y_train)
pred_2 = lr.predict(X_test_poly)

print(mean_absolute_error(y_test, pred_2))
# 6.203734788707707

문자열로 이루어진 데이터 컬럼은 모두 제외하고, 단항회귀 vs 다항회귀 MAE 값 비교

# 단항회귀

df1 = df.select_dtypes('number')
X = df1.drop('rating', axis=1)
y = df1['rating']

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.3, random_state = 42)

lr.fit(X_train, y_train)

pred_4 = lr.predict(X_test)

print('MAE:', mean_absolute_error(y_test, pred_4))
print('R2 score:', r2_score(y_test, pred_4))
print()
print('회귀계수:', lr.coef_, ', 절편:', lr.intercept_)

# 다항회귀

X_train_poly = poly_reg.fit_transform(X_train)
X_test_poly = poly_reg.transform(X_test)

lr.fit(X_train_poly, y_train)

pred_5 = lr.predict(X_test_poly)

print('MAE:', mean_absolute_error(y_test, pred_5))
print('R2 score:', r2_score(y_test, pred_5))
print()
print('회귀계수:', lr.coef_, ', 절편:', lr.intercept_)

Ridge

diabetes dataset 활용

import pandas as pd
import numpy as np
from sklearn.datasets import load_diabetes
from sklearn.linear_model import Ridge, LinearRegression
from sklearn.model_selection import train_test_split
from sklearn.metrics import mean_absolute_error, r2_score
import matplotlib.pyplot as plt

diabetes = load_diabetes()
df = pd.DataFrame(diabetes['data'], columns= diabetes['feature_names'])
df.head()

alphas = np.logspace(-3, 1, 5)
alphas			# array([1.e-03, 1.e-02, 1.e-01, 1.e+00, 1.e+01])

data = []

for a in alphas:
    # 모델 생성
    ridge = Ridge(alpha = a)
    ridge.fit(diabetes['data'], diabetes['target'])
    # 학습된 모델의 회귀계수를 data 리스트에 추가
    data.append(
        ridge.coef_
    )

df_ridge = pd.DataFrame(data, index=alphas, columns = df.columns)
df_ridge

plt.figure(figsize=(16, 15))

plt.axhline(y=0, linestyle='--', linewidth=2, color='black')

plt.plot(df_ridge.loc[0.001, :], '^-', color="#ffb8b8")
plt.plot(df_ridge.loc[0.01, :], 'o-', color="#ff9191")
plt.plot(df_ridge.loc[0.1, :], 'v-', color="#ff6060")
plt.plot(df_ridge.loc[1.0, :], '*-', color="#ff3434")
plt.plot(df_ridge.loc[10.0, :], 's-', color="#d40000")

plt.legend(['center', 0.001, 0.01, 0.1, 1, 10], bbox_to_anchor = (1, 1))
plt.show()

X_train, X_test, y_train, y_test = train_test_split(
    diabetes['data'], diabetes['target'], test_size=0.2, random_state=42
    )

lr = LinearRegression()
lr.fit(X_train, y_train)
pred = lr.predict(X_test)
print(round(r2_score(y_test, pred), 4))		# 0.4526

for a in [0.01, 0.1, 1]:
    ridge = Ridge(alpha = a)
    ridge.fit(X_train, y_train)
    pred2 = ridge.predict(X_test)
    print(f'alpha = {a} / MAE = {round(mean_absolute_error(y_test, pred2), 4)} / r² = {round(r2_score(y_test, pred2), 4)}')

# alpha = 0.01 / MAE = 42.8369 / r² = 0.456
# alpha = 0.1 / MAE = 42.9969 / r² = 0.4609
# alpha = 1 / MAE = 46.1389 / r² = 0.4192

미세하지만 Ridge의 성능이 더 좋은 것을 확인할 수 있다.

Lasso

from sklearn.linear_model import Lasso

lasso_1 = Lasso(alpha = 0.01)
lasso_2 = Lasso(alpha = 0.1)
lasso_3 = Lasso(alpha = 1)

# Ridge에서 분할한 데이터 사용
lasso_1.fit(X_train, y_train)
lasso_2.fit(X_train, y_train)
lasso_3.fit(X_train, y_train)

pred1 = lasso_1.predict(X_test)
pred2 = lasso_2.predict(X_test)
pred3 = lasso_3.predict(X_test)

print(mean_absolute_error(y_test, pred1))		# 42.83184707336087
print(mean_absolute_error(y_test, pred2))		# 42.85442771664998
print(mean_absolute_error(y_test, pred3))		# 49.73032753662261

print(r2_score(y_test, pred1))				# 0.4566861194580625
print(r2_score(y_test, pred2))				# 0.4718547867276227
print(r2_score(y_test, pred3))				# 0.3575918767219113

ElasticNet

함수 로드

from sklearn.linear_model import ElasticNet

모델 호출, 학습, 예측, 평가

ela_1 = ElasticNet(alpha=0.01)
ela_2 = ElasticNet(alpha=0.1)
ela_3 = ElasticNet(alpha=1)

ela_1.fit(X_train, y_train)
ela_2.fit(X_train, y_train)
ela_3.fit(X_train, y_train)

pred_1 = ela_1.predict(X_test)
pred_2 = ela_2.predict(X_test)
pred_3 = ela_3.predict(X_test)

print(r2_score(y_test, pred_1))		# 0.37364841571505814
print(r2_score(y_test, pred_2))		# 0.09865421116113748
print(r2_score(y_test, pred_3))		# -0.0024652131111431164

~~처참한 결과값~~

5월 13일 ‍

오늘의 소감: SVM을 ADsP나 빅분기에서는 꽤 깊게 다뤘던 것 같은데, 학교 실습으로는 해본 적 없는 부분이라 의문이 있었다.

오늘 해보니 더욱 잘 알겠다... 결론은 ~~앙상블 쓰자 랜덤 포레스트 최고~~

Logistic Regression

라이브러리, 데이터 로드

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

from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score, confusion_matrix

body = pd.read_csv('../data/bodyPerformance.csv')
body.head()

데이터 전처리: 문자 형태 변환

문자 형태인 gender column을 숫자 형태로 변환

body['gender'].value_counts()

변환하는 5가지 방법

# map 활용 1
body['gender'].map(
    lambda x : 0 if x == 'M' else 1
)

# map 활용 2
body['gender'].map(
    {
        'M': 0,
        'F': 1
    }
)

# replace
body['gender'].replace('M', 0).replace('F', 1)

# numpy
np.where(body['gender'] == 'M', 0, 1)

# get_dummies
df = pd.get_dummies(body, columns = 'gender', drop_first = True)

일부러 데이터 불균형 만들기

class에서 A는 1 그 외의 값들은 0으로 변환

df['class_1'] = np.where( df['class'] == 'A', 1, 0 )
df['class_1'].value_counts()

데이터 분할

# 독립 변수 종속 변수 데이터 분할
X = df.drop(['class', 'class_1'], axis=1)
y = df['class_1']	# 불균형이 있는 컬럼 활용


# train test 데이터 분할
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size = 0.3, random_state = 42, stratify = y
)
	# 데이터가 불균형하므로 stratify 사용

모델 생성, 학습, 예측, 평가

# 모델 생성
logR = LogisticRegression()

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

# 예측
pred = logR.predict(X_test)

# 평가
cm = confusion_matrix(y_test, pred)
acc = accuracy_score(y_test, pred)
prc = precision_score(y_test, pred)
rcll = recall_score(y_test, pred)
f1 = f1_score(y_test, pred)

혼동 행렬 시각화

plt.figure(figsize = (7, 5))

sns.heatmap(
    cm, annot = True, cmap = 'Blues', fmt = 'd',
    xticklabels = ['pred Negative', 'pred Positive'],
    yticklabels = ['actual Negative', 'actual Positive']
)

plt.show()

평가 지표 수치로 확인

print('정확도: ', round(acc, 2))
print('정밀도: ', round(prc, 2))
print('재현율: ', round(rcll, 2))
print('f1 score: ', round(f1, 2))

정확도는 높은 반면, 클래스 데이터의 불균형으로 인해 정밀도, 재현율, f1 score는 낮은 값을 보이는 것을 확인할 수 있다.

클래스별 예측 확률과 decision_function 확인, 시각화

번외로, 0(Not A)과 1(A)를 예측할 확률을 보여주는 함수와, 클래스별 점수를 보여주는 decision_function을 활용

# 예측 확률 데이터 확인
proba = pd.DataFrame(logR.predict_proba(X_train))

# 클래스별 점수 (분류에 대한 확신의 점수)
cs = pd.DataFrame(logR.decision_function(X_train))

# proba, cs 데이터 프레임을 단순 열결합
df2 = pd.concat([proba, cs], axis=1)
df2.columns = ['predict proba of Not A', 'predict proba of A', 'decision_function']
df2

시각화

# 그래프로 만들었을 때 보기 편하도록 정렬
df2.sort_values('decision_function', inplace = True)
df2.reset_index(drop = True, inplace = True)

# 시각화
plt.figure(figsize = (16, 8))
plt.axhline(y = 0.5, linestyle = '--', linewidth = 2, color = 'black', alpha = 0.3)
plt.axvline(x = 0, linestyle = '--', linewidth = 2, color = 'black', alpha = 0.3)
plt.plot(df2['decision_function'], df2['predict proba of Not A'], '--', label = 'Not A', color = "#0400ff")
plt.plot(df2['decision_function'], df2['predict proba of A'], '--', label = 'A', color = "#ff0000")
plt.xlabel('Decision Funtion')
plt.ylabel('Predict Probability')
plt.legend()
plt.show()

데이터 불균형 해결

1. 샘플링 기법을 이용하여 데이터의 균형을 맞춘다.

2. 모델 생성 시 불균형한 데이터들에 가중치를 특별 부여

이 중 2번 방법으로 불균형 해결

logR2 = LogisticRegression(class_weight='balanced')

train, test 분할 시 이미 계층화 작업을 수행했으므로 해당 작업은 다시하지 않는다.

logR2.fit(X_train, y_train)
pred_2 = logR2.predict(X_test)

acc = accuracy_score(y_test, pred_2)
prc = precision_score(y_test, pred_2)
rcll = recall_score(y_test, pred_2)
f1 = f1_score(y_test, pred_2)

print('정확도: ', round(acc, 2))
print('정밀도: ', round(prc, 2))
print('재현율: ', round(rcll, 2))
print('f1 score: ', round(f1, 2))

class_weight 사용 후 평가 지표

class_weight 사용 전 평가 지표

정확도와 정밀도는 감소했지만, 재현율과 f1 score는 증가한 것을 볼 수 있다.

데이터 전처리: 이상치 제거

5월 7일에 만들어놓은 outlier_iqr2 함수를 py 파일을 통해 모듈화 시켜 진행

outlier 모듈 코드

import numpy as np

def outlier_iqr(data, *cols, n = 1.5, drop = False):
    df = data.copy()
    whis_dict = {}

    for col in cols:
        try:
            q_1, q_3 = np.percentile(df[col], [25, 75])
            iqr = q_3 - q_1

            upper_whis = q_3 + (n * iqr)
            lower_whis = q_1 - (n * iqr)

            print(f'''
                지정된 컬럼의 이름: {col},
                상단 경계: {upper_whis},
                하단 경계 {lower_whis}''')

            upper_flag = df[col] > upper_whis
            lower_flag = df[col] < lower_whis
            upper_n = len( df.loc[upper_flag, ] )
            lower_n = len( df.loc[lower_flag, ] )
            print(f'상단 경계를 벗어나는 데이터의 개수: {upper_n}, 하단 경계를 벗어나는 데이터의 개수: {lower_n}')
            whis_df = df.loc[upper_flag|lower_flag, ]
            whis_dict[col] = whis_df

            if drop:
                df = df.loc[ ~(upper_flag | lower_flag), ]
            else:
                df.loc[upper_flag, col] = upper_whis
                df.loc[lower_flag, col] = lower_whis

        except Exception as e:
            print(f'Error: {e}')
    
    return df, whis_dict

함수 로드

from outlier import outlier_iqr

이상치 제거

outlier_drop_df, outlier_dict = outlier_iqr(df, *df.drop('class_1', axis=1).columns, drop = True)
print(len(body), len(outlier_drop_df))		# 13393 12634

분할, 학습, 예측, 평가

X_train, X_test, y_train, y_test = train_test_split(
    outlier_drop_df.drop(['class', 'class_1'], axis=1),
    outlier_drop_df['class_1'],
    test_size = 0.3,
    stratify = outlier_drop_df['class_1']
)

logR2.fit(X_train, y_train)
pred_3 = logR2.predict(X_test)

acc = accuracy_score(y_test, pred_3)
prc = precision_score(y_test, pred_3)
rcll = recall_score(y_test, pred_3)
f1 = f1_score(y_test, pred_3)

print('정확도: ', round(acc, 2))
print('정밀도: ', round(prc, 2))
print('재현율: ', round(rcll, 2))
print('f1 score: ', round(f1, 2))

데이터 전처리: 샘플링

RandomUnderSampler, SMOTE 활용

필요한 부분 import

from imblearn.under_sampling import RandomUnderSampler
from imblearn.over_sampling import SMOTE

분석하기 전에 매번 같은 코드를 작성하므로 해당 부분 함수로 생성

적합~평가 함수 생성

def logR_function(x, y, weight = None):
    X_train, X_test, y_train, y_test = train_test_split(
        x, y, test_size = 0.3, random_state = 42, stratify = y
    )

    model = LogisticRegression(class_weight = weight)

    model.fit(X_train, y_train)

    pred = model.predict(X_test)

    acc = accuracy_score(y_test, pred)
    prc = precision_score(y_test, pred, average = 'macro')
    rcll = recall_score(y_test, pred, average = 'macro')
    f1 = f1_score(y_test, pred, average = 'macro')

    print('정확도: ', round(acc, 2))
    print('정밀도: ', round(prc, 2))
    print('재현율: ', round(rcll, 2))
    print('f1 score: ', round(f1, 2))
    return pred, y_test

RandomUnderSampler 활용

undersample = RandomUnderSampler(sampling_strategy = 1)
    # 소수 클래스와 다수 클래스의 숫자를 똑같이 맞춤: 약 6700개의 데이터를 날림

X = df.drop(['class', 'class_1'], axis = 1)
y = df['class_1']

X_under, y_under = undersample.fit_resample(X, y)

under_pred, y_test = logR_function(X_under, y_under)

SMOTE 활용

smote = SMOTE(sampling_strategy=1)

X_over, y_over = smote.fit_resample(X, y)

over_pred, y_test = logR_function(X_over, y_over)

연습 문제

1. body 데이터에서 성별 column을 0, 1로 변환
2. class 컬럼의 데이터: A는 1, B는 2, C는 3, D는 4로 변경
3. 극단치 데이터를 경계값들로 대체
4. 로지스틱 회귀를 이용하여 혼동행렬, 나머지 성능 지표를 확인

body = pd.read_csv('../data/bodyPerformance.csv')

# 1)
body['gender'] = body['gender'].map(lambda x : 0 if x == 'M' else 1)

# 2)
body['class'] = body['class'].map( {'A': 1, 'B': 2, 'C': 3, 'D': 4} )

# 3)
outlier_replace_df, outlier_dict2 = outlier_iqr(body, *body.drop('class', axis=1).columns)

# 4)
X = outlier_replace_df.drop(['class'], axis = 1)
y = outlier_replace_df['class']

pred, y_test = logR_function(X, y)
print()
print(confusion_matrix(y_test, pred))

혼동 행렬 시각화

plt.figure(figsize=(7,5))

sns.heatmap(cm, annot=True, cmap='Blues', fmt='d', xticklabels=[1,2,3,4], yticklabels=[1,2,3,4])
plt.ylabel('Actual Class')
plt.xlabel('Pred Class')
plt.show()

Support Vector Machine (SVM)

라이브러리, 데이터 로드

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

from sklearn.model_selection import train_test_split
from sklearn.svm import SVC
from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score

df = pd.read_csv('../data/classification.csv')
df.head()

총 297행의 데이터

SVC: SVM으로 분류 작업을 할 때

데이터 클래스의 분포를 그래프로 확인

sns.pairplot(
    data = df,
    hue = 'success'
)

SVC 모델 학습, 예측, 평가

X = df.drop('success', axis = 1)
y = df['success']

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.3, random_state = 42)

svc = SVC()
svc_2 = SVC(C=0.1)

svc.fit(X_train, y_train)
svc_2.fit(X_train, y_train)

pred = svc.predict(X_test)
pred2 = svc_2.predict(X_test)


acc = accuracy_score(y_test, pred)
acc_2 = accuracy_score(y_test, pred2)

prc = precision_score(y_test, pred)
prc_2 = precision_score(y_test, pred2)

rcll = recall_score(y_test, pred)
rcll_2 = recall_score(y_test, pred2)

f1 = f1_score(y_test, pred)
f1_2 = f1_score(y_test, pred2)

print('정확도: ', round(acc, 4), round(acc_2, 4))
print('정밀도: ', round(prc, 4), round(prc_2, 4))
print('재현율: ', round(rcll, 4), round(rcll_2, 4))
print('f1 score: ', round(f1, 4), round(f1_2, 4))

# 정확도:  0.9 0.9
# 정밀도:  0.9821 0.9821
# 재현율:  0.873 0.873
# f1 score:  0.9244 0.9244

뭔가 잘못됐다... 왜 평가지표가 똑같이 나오는 거야

근데 왜 똑같이 나오는 지 모르겠다... 어디서 잘못된거냐...

SVR: SVM으로 회귀 작업을 할 때

추가 라이브러리 로드, 데이터 생성

from sklearn.svm import SVR
from sklearn.metrics import mean_squared_error, r2_score

가지고 있는 데이터로 SVR을 돌리면 시간이 너무 오래 걸려서, 간단한 데이터셋을 만들기로 했다.

x = np.sort(5 * np.random.rand(40, 1), axis = 0)
y = np.sin(x).ravel()
    # ravel: 1차원으로 변경

# 노이즈 추가
y[::5] += 3 * (0.5 - np.random.rand(8))

모델 학습, 예측, 평가

svr_rbf.fit(x, y)
svr_lin.fit(x, y)
svr_poly.fit(x, y)

pred_rbf = svr_rbf.predict(x)
pred_lin = svr_lin.predict(x)
pred_poly = svr_poly.predict(x)

index = ['RBF', 'Linear', 'Poly']
cols = ['MSE', 'R2']

result = pd.DataFrame(index = index, columns = cols)
preds = [pred_rbf, pred_lin, pred_poly]

for pred, idx in zip(preds, index):
    mse = mean_squared_error(y, pred)
    r2 = r2_score(y, pred)

    result.loc[idx, 'MSE'] = round(mse, 2)
    result.loc[idx, 'R2'] = round(r2*100, 2)

result

y가 sin 곡선에서 노이즈를 추가한 것이기에 linear나 다항식의 형태로는 좋은 성과를 거두지 못하고,

RBF(가우시안)의 형태가 가장 성능이 좋은 모습을 보였다.

5월 14일 ‍

오늘의 소감: 곧 모델의 1황 랜덤 포레스트가 온다... 오늘은 그를 위한 기틀을 닦는 날

Ensemble

hotel datasets 활용

라이브러리, 데이터 로드

import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import BaggingClassifier
from sklearn.metrics import f1_score

hotel = pd.read_csv('../data/hotel_bookings.csv')

데이터 전처리

이상치

hotel.info()

hotel.describe()

adr column은 투숙료를 의미하는데, 여기서 0보다 작은 값이 보인다.

flag = hotel['adr'] < 0
hotel.loc[flag,]

행이 하나밖에 없고, 비상식적인 수치이기에 제거한다.

hotel = hotel.loc[~flag,]
hotel.describe()

min 값이 0원이지만 공짜로 투숙하는 경우가 있을 수 있으니 해당 부분은 넘어간다.

결측치

lead_time과 adr column의 결측치들을 평균값으로 대체

hotel['lead_time'] = hotel['lead_time'].fillna( hotel['lead_time'].mean() )
hotel['adr'] = hotel['adr'].fillna( hotel['adr'].mean() )

해당 부분은 결측치를 제외하고 평균 내주는 pandas의 특성 덕에 가능하다.

0과 1로 이루어진 is_repeated_guest column의 결측치들은 최빈값으로 대체

hotel['is_repeated_guest'] = hotel['is_repeated_guest'].fillna(
    hotel['is_repeated_guest'].mode()[0]
)

범주형 변수

범주형 변수인 deposit_type를 dummy 변수로 변환한다.

hotel['deposit_type'].unique()
# ['No Deposit', 'Refundable', 'Non Refund']

hotel['deposit_type'].value_counts()
# deposit_type
# No Deposit    19137
# Non Refund      834
# Refundable       28

df = pd.get_dummies(hotel, columns=['deposit_type'], drop_first = True)
df.info()

class의 불균형 정도 확인

df['is_canceled'].value_counts()

불균형이 심하긴 하지만 우선 해당 비율을 유지한 채로 분석을 시행해보겠다.

데이터 분할, 모델 생성/학습/예측/평가

데이터 분할

# 독립/종속 분할
X = df.drop('is_canceled', axis = 1)
y = df['is_canceled']

# train/test 분할
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size = 0.2, random_state = 42, stratify = y
)

y_train.value_counts()

모델 생성

배깅 모델을 생성할 때는 기본 모델이 필요한데, 이를 위한 DecisionTree를 먼저 생성한다.

이때, class 데이터가 불균형하므로 class_weight parameter를 사용해 해당 부분을 커버해준다.

base_model = DecisionTreeClassifier(class_weight = 'balanced')
model = BaggingClassifier(base_model)

모델 학습, 예측, 평가

model.fit(X_train, y_train)
pred = model.predict(X_test)

print( round( f1_score(y_test, pred), 4 ) )
	# 0.5845

생각보다 성능이 좋지 않아, DecisionTreeClassifier의 max_depth 값을 조정해본다.

모델 생성~평가 - 수정

base_model = DecisionTreeClassifier(class_weight = 'balanced', max_depth=3)
model = BaggingClassifier(base_model)

model.fit(X_train, y_train)
pred = model.predict(X_test)

print( round( f1_score(y_test, pred), 4 ) )
	# 0.5735

오히려 성능이 더 떨어지는 모습을 보여, class의 불균형을 해소하는 방안을 시도해본다.

데이터 전처리: 샘플링

RandomOverSampler나 SMOTE 만을 그냥 사용하는 것이 아닌,

RandomOverSampler를 활용한 후, Bootstrap을 활용하는 방법을 사용해본다.

1. RandomOverSampling / 2:1로 resampling
2. Bagging model의 bootstrap을 0.8로 지정하고 n_estimators를 100으로 설정
- DecisionTree Classifier의 class_weight는 default 값으로, max_depth는 3으로 설정

from imblearn.over_sampling import RandomOverSampler

ros = RandomOverSampler(sampling_strategy=0.5)
over_X, over_y = ros.fit_resample(X, y)

over_y.value_counts()
# is_canceled
# 0    17599
# 1     8799
# Name: count, dtype: int64

base_model = DecisionTreeClassifier(max_depth = 3)
model = BaggingClassifier(max_samples = 0.8, n_estimators = 100)

X_train, X_test, y_train, y_test = train_test_split(
    over_X, over_y, test_size = 0.2, random_state = 42, stratify = over_y
)

model.fit(X_train, y_train)
pred = model.predict(X_test)

print( round( f1_score(y_test, pred), 4 ) )
# 0.9323

성능이 눈에 띄게 좋아진 것을 확인할 수 있다.

근데 여기서 내가 잘못한 부분이 무엇일까?

정답은 바로

base_model = DecisionTreeClassifier(max_depth = 3)
model = BaggingClassifier(max_samples = 0.8, n_estimators = 100)

이 부분

가만 보면 base_model을 사용하지 않았다.

근데 웃긴 게 base_model 사용하면 성능이 더 떨어진다. f1 score 0.54 정도로...

아니고 그냥 얻어걸린 거임

강사님은 max_depth를 사용하지 않아도 n_estimators가 과적합을 방지해주는 것이라 보셨다.

이후로도 max_depth를 사용하지 않은 bagging의 결과가 좋았다.

Boosting

AdaBoost : 분류

라이브러리, 데이터 로드

import numpy as np
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.ensemble import AdaBoostClassifier
from sklearn.metrics import classification_report

body = pd.read_csv('../data/bodyPerformance.csv')
body.head(3)

데이터 전처리

# gender column의 M → 0, F → 1
body['gender'] = body['gender'].map({'M': 0, 'F': 1})

# class 변환
body['class'] = body['class'].map({'A': 1, 'B': 2, 'C': 3, 'D': 4})

데이터 분할

X = body.drop('class', axis=1)
y = body['class']

X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size = 0.2, random_state = 42
)

모델 생성, 학습, 예측, 평가

clf = AdaBoostClassifier()
clf.fit(X_train, y_train)
pred = clf.predict(X_test)
print(classification_report(y_test, pred))

평가가 한 줄로 끝나다니... 신세계였다

파라미터 수정

성능을 더 끌어올려보려는 시도로 파라미터를 조정해본다.

clf2 = AdaBoostClassifier(n_estimators=500, learning_rate=0.1)
clf2.fit(X_train, y_train)
pred2 = clf2.predict(X_test)
print(classification_report(y_test, pred2))

큰 차이가 없다.

estimator-max_depth 수정

Decision Tree가 너무 단순한 형태라 생긴 문제일 수도 있기에, estimator의 값을 조정해보기로 했다.

from sklearn.tree import DecisionTreeClassifier

clf3 = AdaBoostClassifier(
    estimator = DecisionTreeClassifier(max_depth = 4),
    n_estimators = 500,
    learning_rate = 0.1
)

clf3.fit(X_train, y_train)
pred3 = clf3.predict(X_test)
print(classification_report(y_test, pred3))

성능이 많이 좋아졌다!

AdaBoost : 회귀

라이브러리, 데이터 로드

from sklearn.ensemble import AdaBoostRegressor
from sklearn.metrics import mean_absolute_error, r2_score
car = pd.read_csv('../data/CarPrice_Assignment.csv')

데이터 전처리: 숫자 column만 필터링

df = car.select_dtypes('number')
df.drop('car_ID', axis=1, inplace = True)

데이터 분할

X = df.drop('price', axis = 1)
y = df['price']

X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size = 0.3, random_state = 42
)

모델 생성, 학습, 예측, 평가

reg = AdaBoostRegressor()
reg.fit(X_train, y_train)
pred = reg.predict(X_test)
print('MAE: ', round(mean_absolute_error(y_test, pred), 2), '/ R²: ', round(r2_score(y_test, pred)*100, 2))
# MAE:  2007.03 / R²:  90.53

오차 시각화

# 각 단계별 예측값을 이용하여 MAE를 구하고 그래프로 시각화
list(reg.staged_predict(X_test))

mae_list = []
for stage_pred in list(reg.staged_predict(X_test)):
    mae = mean_absolute_error(y_test, stage_pred)
    mae_list.append(mae)

# 시각화
plt.figure(figsize=(30, 10))
plt.plot(mae_list)
plt.xlabel('Count')
plt.ylabel('MAE')
plt.show()

변수 중요도 시각화

importance = reg.feature_importances_
cols = X.columns

importance_df = pd.DataFrame(
    zip(cols, importance),
    columns = ['feature_name', 'importance']
)

importance_df.sort_values('importance', ascending = False, inplace=True)
importance_df.reset_index(drop = True, inplace = True)
importance_df

plt.figure(figsize = (25, 10))
plt.bar(importance_df['feature_name'], importance_df['importance'])
plt.show()

5월 15일 ‍

오늘의 소감: 랜포는 신이다

RandomForest

body dataset 활용

라이브러리, 데이터셋 로드

import pandas as pd
import numpy as np

from sklearn.model_selection import train_test_split
from sklearn.metrics import classification_report, mean_absolute_error, r2_score
from sklearn.ensemble import RandomForestClassifier, RandomForestRegressor

body = pd.read_csv('../data/bodyPerformance.csv')
body.head()

데이터 전처리: LabelEncoder

저번과 마찬가지로 gender column과 class column을 숫자형 데이터로 변환해줄 것인데,

이번엔 LabelEncoder를 사용해보기로 하였다.

# LabelEncoder → 문자형 데이터들을 숫자형으로 변환
from sklearn.preprocessing import LabelEncoder
labelencoder = LabelEncoder()
body['class_1'] = labelencoder.fit_transform(body['class'])
body['gender'] = labelencoder.fit_transform(body['gender'])
body.head()

범주형 데이터를 숫자로 인식하게 되면 범주형 데이터간의 관계를 찾으려할 수 있으므로,

독립적인 범주형 데이터에서는 사용하지 않는 것이 좋다.

sklearn.preprocessing에 속해 있기에 기본 동작은 scaler와 동일하다.

X = body.drop(['class', 'class_1'], axis=1)
y = body['class_1']

X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size = 0.3, random_state = 42, stratify = y

RandomForestClassifier 사용

clf = RandomForestClassifier()
clf.fit(X_train, y_train)
pred = clf.predict(X_test)

print(classification_report(y_test, pred))

parameter 변경

1. 모델의 개수를 증가
2. 각 트리에서 사용되는 샘플을 70%로 제한
3. `min_sample_leaf`를 기본값 1에서 4로 변경

clf2 = RandomForestClassifier(
    n_estimators = 200,
    max_samples = 1.0,
    min_samples_leaf = 1,
    max_features = 6
)

clf2.fit(X_train, y_train)
pred2 = clf2.predict(X_test)

print(classification_report(y_test, pred2))

값이 미세하게 증가했다.

Pipeline

iris dataset 활용

라이브러리, 데이터 로드

import pandas as pd
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler, LabelEncoder
from sklearn.svm import SVC
from sklearn.model_selection import train_test_split
from sklearn.metrics import classification_report

iris = pd.read_csv('../csv/iris.csv')

데이터 전처리, 분할

le = LabelEncoder()
iris['species'] = le.fit_transform(iris['species'])
iris['species'].value_counts()

X = iris.drop('species', axis = 1)
y = iris['species']

X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size = 0.2, random_state = 42, stratify = y
)

파이프 라인

pipe = Pipeline(
    [
        ( 'scaler', StandardScaler() ),     # step 1
        ( 'model', SVC() )                  # step 2

    ], verbose = True
)

pipe.fit(X_train, y_train)
pred = pipe.predict(X_test)
print(classification_report(y_test, pred))

GridSearchCV

그대로 iris dataset 활용

Pipeline이 여러 단계를 연속적으로 실행하는 자동화 도구였다면,

GridSearch는 이 Pipeline을 활용해서 최적의 파라미터를 찾아준다.

라이브러리 로드

from sklearn.model_selection import GridSearchCV

자세한 파라미터 설명은 K-fold를 결합한 부분에서 언급하겠다.

# SVC 모델 생성

svc = SVC()

# svc에서 사용할 매개변수의 목록들을 작성
grid_dict = {
    'C' : [ 0.1, 1, 10 ],
    'kernel' : [ 'linear', 'rbf' ],
    'gamma' : [ 'scale', 'auto' ]
}

grid = GridSearchCV(
    estimator = svc,
    param_grid = grid_dict,
    cv = 5,
    scoring = 'accuracy',
    verbose = 1,
)


grid_dict

grid.fit(X_train, y_train)


print('최적의 파라미터 조합: ', grid.best_params_)
print('최적의 점수: ', grid.best_score_)
print('최적의 모델: ', grid.best_estimator_)

K-Fold

데이터셋을 K개의 동일 크기로 나눠서 K번 반복

이때, 하나의 폴드를 검증용으로 사용, K-1개의 폴드를 학습용으로 사용

라이브러리 로드

import numpy as np
from sklearn.model_selection import KFold, StratifiedKFold

K-Fold logic

X = np.array(
    ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J']
)

# KFold
kfold = KFold(n_splits = 5)

list(kfold.split(X))

for train_idx, test_idx in kfold.split(X):
    print('-' * 60)
    print("학습 데이터의 목록: ", X[train_idx])
    print("검증 데이터의 목록: ", X[test_idx])

k-fold는 해당 로직으로 굴러간다는 것을 볼 수 있다.

Pipeline + GridSearchCV + K-Fold

1. boston 데이터셋 로드
2. 독립변수, 종속변수로 데이터 분할
3. train, test 8:2
4. K-Fold 이용하여 10개의 폴드 생성 (shuffle=True)
5. Pipeline 생성 (StandardScaler(), SVR())
6. 파라미터 조합 생성 (svr 모델에서 C(1, 10, 100), kernel('linear', 'rbf'), epsilon(0.1, 0.2, 0.5))
7. GridSearchCV 베스트 모델 선정의 기준은 neg_mean_squared_error
8. 최고의 조합을 찾은 뒤 R2 score를 이용하여 성능을 확인
9. 최적의 파라미터를 이용하여 새로운 모델을 생성하고 성능 R2 score 확인

# 1)
boston = pd.read_csv('../csv/boston.csv')

# 2)
X = boston.drop('Price', axis = 1)
y = boston['Price']

# 3)
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42
)

# 4)
kfold = KFold(n_splits=10, shuffle=True, random_state=42)

# 5)
pipe = Pipeline(
    [
        ('scaler', StandardScaler()),
        ('reg', SVR())
    ]
)

# 6) ~ # 7)
params = {
    'reg__C' : [1, 10, 100],
    'reg__epsilon' : [0.1, 0.2, 0.5],
    'reg__kernel' : ['linear', 'rbf']
}

grid_reg = GridSearchCV(
    estimator= pipe,               		# 파이프라인으로 생성한 모델을 지정
    param_grid= params,             		# dict 형태로 파라미터의 조합
    scoring = 'neg_mean_squared_error',         # 베스트 모델 선정 기준
    cv = kfold,               		   	# 생성해둔 KFold 지정
    refit = True,               		# 재학습 여부
    n_jobs = -1,                 	 	# 모든 CPU를 사용
    return_train_score= True,    		# 학습 데이터의 성능을 출력
    verbose = 2                    		# 로그 표시를 상세하게
)

# 8)
grid_reg.fit(X_train, y_train)
grid_reg.score(X_test, y_test)		# -12.063990309898506
print(grid_reg.best_estimator_)
	# Pipeline(steps=[('scaler', StandardScaler()), ('reg', SVR(C=100, epsilon=0.5))])

# 9)
pred = grid_reg.predict(X_test)
from sklearn.metrics import r2_score
print(round(r2_score(y_test, pred), 4))		# 0.8355

6주차 소감

모델과 함께 몰아쳤던 6주차

만약 내가 기초 지식이 없었다면 견뎌낼 수 있었을까...?

ADsP 준비할 때의 기억이 새록새록했던 한 주였다. 그 땐 이론만으로도 머리 싸맸었는데...

빅분기 대비가 제대로 된 것 같아 뿌듯하다.

~~이제 더이상 sklearn의 서브 모듈 기억 못해서 로지스틱 못 불러오는 바보같은 짓은 안 하겠지~~

다음 주는 비지도 학습에 대해 배운 뒤 딥러닝으로 넘어갈 시간이다.

사실 딥러닝보다는 자연어 처리가 더 무섭긴 하지만...ㅋㅋㅋ 다음 주도 성실하게 참여하자!

5주차 Note: 머신러닝

가라어퍼 — Fri, 8 May 2026 18:07:36 +0900

5주차: 5월 4일 ~ 5월 8일

멀티캠퍼스 부트캠프 5주차 요약✍️

[ 5/4 ] 휴강

[ 5/5 ] 어린이날 휴강

[ 5/6 ] 시각화: Looker Studio

[ 5/7 ] 머신러닝: Outlier, dummies, 데이터 불균형, 데이터 Split

[ 5/8 ] 머신러닝: 데이터 Scaling, Regression, Classification

5월 6일 ‍

오늘의 소감: Looker는 Tableau와 PowerPoint를 결합한 느낌? UI는 Tableau가 더 예쁘긴 한데, 편의성은 Looker가 조금 더 좋은 듯하다.

둘 모두 시각화 툴이니만큼 크게 차이점이라 할 만한 점은 보이지 않았으니, 두 툴을 함께 공부해도 좋겠다는 생각이 들었다.

수업 시간에 실습한 내용

Tableau는 피벗테이블의 느낌이었다면, Looker는 PPT 만드는 느낌이었달까?

두 툴들의 장점이 명확해서 자유자재로 활용할 수 있다면 정말 나의 분석에 날개를 달아줄 듯한 느낌이 들었다.

5월 7일 ‍

오늘의 소감: 빅분기에서 사용할 수 있는 것들을 많이 배운 날! 시각화가 일찍 끝난 것은 아쉽지만...

학교에서 배웠던 머신러닝을 단단히 다진다 생각하고 열심히 하자!

이상치

wine dataset을 활용한 이상치 처리

라이브러리, 데이터 로드

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import load_wine

wine_data = load_wine()
wine = pd.DataFrame(
    data = wine_data['data'],
    columns = wine_data['feature_names']
)
wine['class'] = wine_data['target']

wine

이상치 데이터를 확인

wine.describe()

boxplot()

plt.boxplot(wine['color_intensity'])
plt.show()

그래프로 보았을 때 이상치가 4개 정도 보인다.

이상치 필터링

이상치만을 골라내기 위하여 사분위수, IQR을 계산한다.

q_1, q_3 = np.percentile(wine['color_intensity'], [25, 75])
print(q_1)		# 3.2199999999999998
print(q_3)		# 6.2

# IQR 계산
iqr = q_3 - q_1

# 상단 경계 계산
iqr_top = q_3 + 1.5*iqr
# 하단 경계 계산
iqr_bottom = q_1 - 1.5*iqr

print(iqr, iqr_top, iqr_bottom)
# 2.9800000000000004 10.670000000000002 -1.2500000000000009


# 위쪽 이상치 필터링
upper_flag = wine['color_intensity'] > iqr_top
# 아래쪽 이상치 필터링
lower_flag = wine['color_intensity'] < iqr_bottom

wine.loc[upper_flag | lower_flag, ]

이상치 제거, 대체

# 극단치 제거
df = wine.copy()
out_idx = df.loc[upper_flag | lower_flag, ].index
df.drop(out_idx, axis=0)

# 극단치 대체
# 상단의 경계에서 벗어난 데이터는 상단의 경계 값으로 채워주고
# 하단의 경계에서 벗어난 데이터는 하단의 경계 값으로 채워준다.
df2 = wine.copy()
df2.loc[upper_flag, 'color_intensity'] = iqr_top

# 검증용 boxplot
plt.boxplot(df2['color_intensity'])
plt.show()

이상치가 제거된 것을 확인할 수 있다.

범주형 데이터의 변환

더미 변수 생성

# class column의 값들을 범주형으로 변경
wine['class'] = wine['class'].map(
    lambda x: wine_data['target_names'][x]
)

# 더미 변수 생성
dummie_df = pd.get_dummies(wine, columns = ['class'])
dummie_df

데이터의 불균형 해소

샘플링: 다수 데이터와 소수 데이터를 특정 비율로 조절해주는 기법

라이브러리 로드

import pandas as pd
from sklearn.datasets import make_classification
from collections import Counter
from imblearn.under_sampling import RandomUnderSampler

make_classification()

make_classification() : 데이터가 불균형한 랜덤 데이터를 생성

x, y = make_classification(
    n_samples= 1000,
    n_features= 5,
    weights= [0.9],
    flip_y= 0
)

# Counter: 숫자 세는 기능
Counter(y)		# Counter({np.int64(0): 901, np.int64(1): 99})

데이터 프레임으로 엮기

df = pd.DataFrame(x)
df['target'] = y

df.head()

언더 샘플링: RandomUnderSampler()

언더 샘플링: 다수의 라벨을 가진 데이터를 샘플링하여 소수의 데이터의 수준으로 감소시키는 방법

# RandomUnderSampler 라는 class를 생성
undersampler = RandomUnderSampler()

under_x, under_y = undersampler.fit_resample(x, y)

Counter(under_y)		# Counter({np.int64(0): 99, np.int64(1): 99})

undersampler에서 데이터의 비율을 변경
sampling_strategy 매개변수 → 소수 데이터의 비율을 의미, 0.5면 2배

undersampler2 = RandomUnderSampler(sampling_strategy = 0.3)
under_x2, under_y2 = undersampler2.fit_resample(x, y)
Counter(under_y2)		# Counter({np.int64(0): 330, np.int64(1): 99})

오버 샘플링: RandomOverSampler()

오버 샘플링: 소수 데이터를 다수 데이터 개수만큼 증가시켜 학습에 사용하기 위한 방법

랜덤 오버 샘플링: 소수의 데이터를 단순 복제하여 다수의 데이터와의 비율을 맞춰주는 과정

from imblearn.over_sampling import RandomOverSampler
oversampler = RandomOverSampler()
over_x, over_y = oversampler.fit_resample(x, y)
Counter(over_y)		# Counter({np.int64(0): 901, np.int64(1): 901})

# 소수의 데이터 비율을 다수의 반 정도로 샘플링

oversampler2 = RandomOverSampler(sampling_strategy=0.5)
over_x2, over_y2 = oversampler2.fit_resample(x, y)
Counter(over_y2)		# Counter({np.int64(0): 901, np.int64(1): 450})

오버 샘플링: SMOTE()

SMOTE: 소수 데이터의 관측값에 대한 K개의 최근접 양수를 이웃으로 찾고, 관측 값과 이웃으로 선택된 값 사이에 임의의 새로운 데이터를 생성하는 방법

from imblearn.over_sampling import SMOTE
smote = SMOTE()
sm_x, sm_y = smote.fit_resample(x, y)
Counter(sm_y)		# Counter({np.int64(0): 901, np.int64(1): 901})

SMOTE 결과 시각화

import matplotlib.pyplot as plt
import seaborn as sns

fig, axes = plt.subplots(2, 2, figsize=(15, 15))

# 4개의 산점도 그래프 생성
sns.scatterplot(
    x = x[:, 2], y = x[:, 3], ax = axes[0][0], hue = y, alpha = 0.4
)

sns.scatterplot(
    x = under_x[:, 2], y = under_x[:, 3], ax = axes[0][1], hue = under_y, alpha = 0.4
)

sns.scatterplot(
    x = over_x[:, 2], y = over_x[:, 3], ax = axes[1][0], hue = over_y, alpha = 0.4
)

sns.scatterplot(
    x = sm_x[:, 2], y = sm_x[:, 3], ax = axes[1][1], hue = sm_y, alpha = 0.4
)

axes[0][0].set_title('Origin Data')
axes[0][1].set_title('Random Under Sample')
axes[0][1].set_xlim(-3.5, 3.5)
axes[0][1].set_ylim(-4.5, 4.5)
axes[1][0].set_title('Random Over Sample')
axes[1][1].set_title('SMOTE')

plt.show()

데이터 분할 (Split)

iris dataset을 활용한 이상치 처리

라이브러리, 데이터셋 로드

import pandas as pd
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
iris_data = load_iris()

데이터셋 전처리: 정리, 이상치 처리

iris = pd.DataFrame(iris_data['data'], columns = iris_data['feature_names'])
iris['class'] = iris_data['target']

# target 데이터들의 이름을 변환
iris['class'] = iris['class'].map(
    lambda x: iris_data['target_names'][x]
)

iris

데이터 Split: train_test_split()

X = iris.drop('class', axis=1)
y = iris['class']

X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size = 0.3, random_state = 42
)

# 데이터의 개수를 확인
print(f'X_train: {X_train.shape}, X_test: {X_test.shape}')
	# X_train: (105, 4), X_test: (45, 4)
print(f'y_train: {y_train.shape}, y_test: {y_test.shape}')
	# y_train: (105,), y_test: (45,)
    
y_train.value_counts()

train_test_split()의 매개변수

test_size: test 데이터의 비율 (0~1)
random_state: 임의의 데이터를 추출하는 과정에서 seed 값을 지정
shuffle: 데이터를 섞을 것인가(시계열 데이터셋인 경우에는 False)
stratify: 특정 변수를 지정하면 해당 변수를 기준으로 계층화. 해당 변수의 비율을 유지하도록 데이터 분할

X_train2, X_test2, y_train2, y_test2 = train_test_split(
    X, y, test_size = 0.3, shuffle=False, random_state = 42
)

y_train2.value_counts()

X_train3, X_test3, y_train3, y_test3 = train_test_split(
    X, y, test_size = 0.3, stratify=y, random_state=42
)

y_train3.value_counts()

5월 8일 ‍

오늘의 소감:

데이터 Scaling

데이터들의 최솟값과 최댓값, 평균, 표준편차를 출력하는 함수 생성

def scaler_print(train, test):
    print(f"""
    Train Data:
        Min : {round(train.min(), 2)}
        Max : {round(train.max(), 2)}
        Mean: {round(train.mean(), 2)}
        Std : {round(train.std(), 2)}
""")

    print(f"""
    Test Data:
        Min : {round(test.min(), 2)}
        Max : {round(test.max(), 2)}
        Mean: {round(test.mean(), 2)}
        Std : {round(test.std(), 2)}
""")

Standard Scaler

평균이 0, 분산이 1인 정규분포로 스케일링

from sklearn.preprocessing import StandardScaler
stdscaler = StandardScaler()

X_train_sc = stdscaler.fit_transform(X_train3)
X_test_sc = stdscaler.transform(X_test3)
scaler_print(X_train_sc, X_test_sc)

Min-Max Scaler

from sklearn.preprocessing import MinMaxScaler

mnscaler = MinMaxScaler()

X_train_sc = mnscaler.fit_transform(X_train3)
X_test_sc = mnscaler.transform(X_test3)

scaler_print(X_train_sc, X_test_sc)

Max Abs Scaler

from sklearn.preprocessing import MaxAbsScaler
mascaler = MaxAbsScaler()

X_train_sc = mascaler.fit_transform(X_train3)
X_test_sc = mascaler.transform(X_test3)

scaler_print(X_train_sc, X_test_sc)

Robust Scaler

Robust Scaler: 평균과 분산을 이용한 Standard 대신에 중앙값과 사분위수를 활용하는 방식
중앙값을 0으로 설정, IQR을 사용하여 이상치의 영향을 최소화
quantile_range 매개변수(기본값 (25.0, 75.0)): 더 넓거나 좁은 범위의 값을 이상치로 판단하게 할 수 있다.

from sklearn.preprocessing import RobustScaler
ruscaler = RobustScaler()
ruscaler2 = RobustScaler(quantile_range=(20, 80))

X_train_sc = ruscaler.fit_transform(X_train3)
X_test_sc = ruscaler.transform(X_test3)
scaler_print(X_train_sc, X_test_sc)

X_train_sc = ruscaler2.fit_transform(X_train3)
X_train_sc = ruscaler2.transform(X_test3)
scaler_print(X_train_sc, X_test_sc)

inverse_transform

inverse_transform: 스케일링된 데이터를 원본 데이터로 복원

X_origin = ruscaler2.inverse_transform(X_train_sc)
pd.DataFrame(X_origin).head()

회귀 분석

boston dataset을 활용한 회귀 분석

라이브러리, 데이터 로드

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

from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression
from sklearn.metrics import r2_score, mean_absolute_error, mean_absolute_percentage_error, \
    mean_squared_error, mean_squared_log_error, root_mean_squared_error
    
boston = pd.read_csv('../csv/boston.csv')
boston.head()

빨간색 박스 부분이 종속 변수이다.

독립변수, 종속변수 분할 후 데이터 분할

X = boston.drop(columns=['CHAS', 'Price'])
y = boston['Price']

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.2, random_state = 42)

모델 생성, 학습, 예측

# 모델 생성
lr = LinearRegression()

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

# 예측
pred = lr.predict(X_test)

모델 평가

성능 평가 지표

MAE: | 실제값 - 예측값 |
MSE: MEAN( ( 실제값-예측값 )² )
RMSE: √ MSE
MSLE: log( MSE )
MAPE: MAE %
R² Score: SSR / SST

mae = mean_absolute_error(y_test, pred)
mse = mean_squared_error(y_test, pred)
rmse = root_mean_squared_error(y_test, pred)
mape = mean_absolute_percentage_error(y_test, pred)
r2 = r2_score(y_test, pred)

print(f"MAE: {round(mae, 2)}")				# 3.24
print(f"MSE: {round(mse, 2)}")				# 24.64
print(f"RMSE: {round(rmse, 2)}")			# 4.96
print(f"MAPE: {round(mape, 2)*100}%")			# 17.0%
print(f"R2 Score: {round(r2, 2)}")			# 0.66

분류 분석

iris dataset을 활용한 분류 분석

라이브러리, 데이터 로드

import matplotlib.pyplot as plt
from sklearn.tree import DecisionTreeClassifier, plot_tree
import pandas as pd

iris = pd.read_csv('../csv/iris.csv')
iris.head()

빨간색 박스 부분이 종속 변수이다.

독립변수, 종속변수 분할

X = iris.drop('species', axis=1)
y = iris['species']

모델 생성, 학습, 예측

# 모델 생성
clf = DecisionTreeClassifier(max_depth=3, random_state=42)

# 모델 학습
clf.fit(X, y)

트리 구조 시각화

feature_names = X.columns

plt.figure(figsize=(15, 15))
plot_tree(clf, feature_names=feature_names, class_names=iris['species'].unique(), fontsize=10, filled=True)
plt.show()

train, test 데이터 분할 후 모델 적합, 예측, 평가

# 라이브러리 로드
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score, confusion_matrix

# 분류 모델이기에 계층화 적용
# split
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42, stratify=y
)

# 모델 적합
clf.fit(X_train, y_train)

# 예측
pred = clf.predict(X_test)

# 평가
accuracy_score(y_test, pred)		# 0.9666666666666667
confusion_matrix(y_test, pred)
# array([[10,  0,  0],
#        [ 0,  9,  1],
#        [ 0,  0, 10]])


# 시각화
plt.figure(figsize=(15, 15))
plot_tree(clf, feature_names=X.columns, class_names=iris['species'].unique(), fontsize=10, filled=True)
plt.show()

5주차 소감

연휴가 있어서 빠르게 지나갔던 5주차!

6주차부터는 본격적인 ML, DL, 자연어 처리를 하게 될 것을 생각하니 새삼 시간이 빠르다.

곧 빅분기 실기 접수도 있으니만큼, 이번에 공부하는 내용들로 sklearn에 대한 지식을 확고히 하자.

~~저번 시험처럼 linear_model 생각 안 나서 모델 못 쓰지 말고~~

너무 자동완성에 의존하지 말고, 강사님 따라서 친다고도 생각하지 말고... 내가 내 코드를 건축하는 느낌으로 내것으로 만들자!

4주차 Note: 데이터 시각화

가라어퍼 — Fri, 1 May 2026 17:27:53 +0900

똥손이슈 반짝눈 대실패

️ 4주차: 4월 27일 - 4월 30일

멀티캠퍼스 부트캠프 4주차 요약✍️

[ 4/27 ] Web: Flask

[ 4/28 ] 웹, 데이터 시각화: PythonAnywhere, matplotlib, drinks 데이터셋 활용

[ 4/29 ] 데이터 시각화: offline, online, aapl 데이터셋 활용

[ 4/30 ] 데이터 시각화: tableau, GA

[ 5/1 ] 근로자의 날 휴강

4월 27일 ‍

오늘의 소감: 코드가 길어지면 어지럽기는 마찬가지... py js html 문법 통일해줬으면 (그럴리가...)

본격적인 시각화 툴을 다루기 전, 시각화 결과를 구현할 수 있는 웹을 구축하는 방법을 배웠다.

오늘 사용한 파일들

▪️app.py (이번 시간에 새로 생성한 웹 구축 모듈)
▪️db.py (4/20일에 만들어둔 sql 연결 모듈)
▪️index.html, main.html (웹 구현 html 코드)

# flask 프레임워크 안에서 특정 기능을 로드
from flask import Flask, render_template, request, redirect, url_for
# render_template → templates 폴더 안에 html 문서를 가져오기 위한 기능
# request → 유저가 보낸 데이터에 접근하기 위한 기능
# redirect → 특정 주소로 이동
# url_for → 특정 주소를 지정하기 위한 기능
    # (상대 경로 지정 → app.py 위치로부터 경로를 설정)
    # html 문서 안에서 사용 (render_template() 함수를 이용해서 app.py에서 실행)

from db import MyDB
from querys import user
import pandas as pd

환경 구축

# Flask class 생성 → 웹 서버를 구축 기능
# class 생성 시 생성자 함수 호출
    # 필수 인자 1개 → 현재 실행이 되는 파일의 이름(app.py)
    # 파일의 이름을 그대로 사용할 시 파일의 이름이 변경될 때 매번 수정 작업 필요
    # __name__ → 현재 파일의 이름
    
app = Flask(__name__)
db = MyDB()
db.sql_query(user.create_query)
db.commit()

# 회원 테이블 생성 쿼리문 하나 작성
create_query = """
    CREATE TABLE IF NOT EXISTS `user` (
        `id` varchar(32) primary key,
        `password` varchar(32) not null,
        `name` varchar(32)
    )
"""

# 로그인 조회 쿼리문 작성
# id, password를 이용하여 데이터가 존재하는가?
login_query = """
    SELECT *
    FROM `user`
    WHERE `id` = %s AND `password` = %s
"""

# 회원 가입 쿼리문
    # 아이디 중복 체크
    # id, password, name 입력하고 회원가입
id_check_query = """
    SELECT *
    FROM `user`
    WHERE `id` = %s
"""

signup_query = """
    INSERT INTO `user` VALUES (%s, %s, %s)
"""

API 생성 1: index()

# 웹 서버의 api 목록들 생성
# 데코레이션(내비게이션 함수) → @함수
    # 특정 주소와 함수를 연결
    # 주소 → base_url(127.0.0.1:5000) + sub_url()
        # 이 주소로 요청이 들어왔을 때 함수를 호출
        
@app.route("/")
def index():
    # HTML로 하이퍼 링크 생성
    # return "<a href='https://www.google.com'>Google</a>"
    return render_template("index.html")
    # templates 폴더 안에 html 문서를 불러와서 되돌려준다.(render_template())
    # render_template에서 {{변수명}}은 python에서의 변수를 담겠다.
    # {%python code} code를 인식하여 조건에 맞는 경우에만 html을 추가
        # 반복문을 이용해서 html을 반복적으로 추가

index.html

<!DOCTYPE html>
<html lang="en">
    <head>
        <meta charset="UTF-8">
        <meta name="viewport" content="width=device-width, initial-scale=1.0">
        <!-- title 태그는 탭에 나타나는 이름 -->
        <title>Document</title>
    </head>
    <body>
        <!-- 실제 화면에 나타나는 부분 -->
         <h1>Hello Flask</h1>
         <p>이 페이지는 메인 페이지입니다.</p>
        <!-- 유저가 입력할 수 있는 공간 생성(input) -->
        <!-- 입력한 데이터를 서버에게 보낸다(form) -->
        <!-- form 태그: action 속성-어디로 데이터를 보낼 것인가?(주소값) -->
        <!-- method 속성-어떤 방식으로 데이터를 보낼 것인가? (get/post) -->
        <!-- 웹 서버의 데이터를 key: value 형태로 보낸다. -->
        <!-- 뒤에 나올 login의 login 과정 -->
        <form action="/login" method="get">
            <!-- 유저의 id 입력하는 공간 -->
            <label>ID</label>
            <input type="text" name='input_id'>
            <br>
            <!-- 유저의 password 입력하는 공간 -->
            <label>PASSWORD</label>
            <input type="password" name="input_pass">
            <br>
            <!-- 데이터를 보낸다 → 제출 버튼이 필요 -->
            <input type="submit">
        </form>
        <h3>post 방식으로 데이터 보내기 </h3>
        <!-- 뒤에 나올 login2의 login 과정 -->
        <!-- post 방식으로 데이터를 보낸다. -->
        <form action="/login2" method = "post">
            <label>ID</label>
            <input type="text" name='input_id'>
            <br>
            <label>PASSWORD</label>
            <input type="password" name="input_pass">
            <br>
            <input type="submit">
        </form>
    </body>
</html>

API 생성 2: login 1

# /login 주소를 생성 (get 방식)

@app.route('/login')
def login():
    # 유저가 보낸 데이터를 받아온다. (flask 프레임워크에서 기능을 불러와서 사용)
    print(request.args)
    print("유저가 입력한 ID: ", request.args['input_id'])
    print("유저가 입력한 password : ", request.args['input_pass'])
    # DataBase server에 해당하는 아이디, 패스워드가 모두 일치하는 데이터가 존재하는가?
    # 조건문을 이용하여 로그인 성공/실패
    if request.args['input_id'] == 'admin' and request.args['input_pass'] == '1234':
        #로그인 성공
        return "로그인 성공"
    else:
        return "ID, PASSWORD를 확인해주세요"

이 방식은 주소창에 ID와 PASSWORD가 노출되므로 이후 과정에서 사용하지 않는다.

API 생성 3: login 2

# /login2 주소를 생성 (post 방식)
# post 방식은 데이터를 숨겨서 보내고,
    # 웹 브라우저에서 주소창에 입력하는 방식으로 확인이 불가능
    
@app.route('/login2', methods=['post'])
def login2():
    print(request.form)
    _id = request.form['input_id']
    _pass = request.form['input_pass']
    sql_result = db.sql_query(user.login_query, _id, _pass)
    db.commit()
    print(sql_result)
    
    if sql_result:
        # 로그인한 계정의 이름을 화면에 표시 
        sql_name = sql_result[0]['name']
        df = pd.read_csv("../csv/AAPL.csv")
        df2 = df.tail(10)
        x_data = df2['Date'].tolist()
            # Series는 html에서 사용 불가능
        y_data = df2['Adj Close'].tolist()
        th_data = df.columns.tolist()
        td_data = df2.to_dict('records')
        return render_template('main.html',
                               name = sql_name,
                               x = x_data,
                               y = y_data,
                               th_data = th_data,
                               td_data = td_data)
    else:
        return redirect('/')

main.html

<!DOCTYPE html>
<html lang="en">
    <head>
        <meta charset="UTF-8">
        <meta name="viewport" content="width=device-width, initial-scale=1.0">
        <title>Document</title>
    </head>
    <body>
        <h1>Main Page</h1>
        <!-- 로그인한 유저의 이름을 대입 -->
        <p>{{name}}님 안녕하세요!</p>

        <!-- 그래프가 그려지는 영역을 먼저 선택 -->
        <div>
            <canvas id="myChart"></canvas>
        </div>

        <!-- 외부의 라이브러리를 호출 -->
        <script src="https://cdn.jsdelivr.net/npm/chart.js"></script>

        <!-- 실제 그래프를 canvas에 그려주는 부분 -->
        <script>
            // id가 myChart인 태그를 선택해서 상수 ctx에 대입
            // 변수는 let이나 var를 이용하여 변수를 생성
          const ctx = document.getElementById('myChart');

        //   Chart class를 생성 → 그래프를 그려주는 부분
        new Chart(
            ctx,
            {
            type: 'line',
            data: {
            labels: {{x | tojson}},
            datasets: [{
                label: '# of Votes',
                data: {{y | tojson}},
                borderWidth: 1
            }]
         }
      });
    </script>

    <!-- 표를 생성 -->
    <!-- table 태그, tr 태그: 행을 표시, th/td 태그: 열을 표시 -->
    <table border = 1>
        <tr>
            <!--
                반복문을 이용해서 작업을 하면 짧고 유동성 있게 사용 가능
                python에서 for문은 들여쓰기를 요함 
             -->
            <!-- 그래서 필요한 반복문의 시작과 -->
            {% for col in th_data%}
                <th>{{col}}</th>
            <!-- 반복문의 끝 -->
            {% endfor %}
        </tr>


        {% for row in td_data %}
        <tr>
            {% for col in th_data %}
                <td>{{row[col]}}</td>
            {% endfor %}
        </tr>
        {% endfor %}
    </table>
</body>
</html>

API 생성 4: html 실행

@app.route('/dashboard')
def dashboard():
    return render_template('dashboard.html')

# 웹 서버를 시작한다. (구동한다.)
app.run(debug=True)
	# debug 매개변수 → 디버그 모드를 사용할 것인가? (기본값 False)
    # True 변경 시 개발 모드로 변경 → 파일이 수정됐을 때 서버가 재시작

4월 28일 ‍

오늘의 소감: 드디어 시각화 시작!! 정신 단단히 차리자 - ̗̀( ˶'ᵕ'˶) ̖́-

html

오전 시간에는 어제 했던 app.py 파일의 html을 업그레이드하는 작업을 수행하였다.

시각화

matplotlib 활용

라이브러리 로드

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt

# 현재 컴퓨터의 os를 확인하기 위한 라이브러리 로드
import platform

라인 그래프 생성

plt.plot
인자를 1개만 입력하면 y축에 데이터 입력, 이때 x축은 0부터 1씩 증가
인자가 2개인 경우 첫번째 인자가 x축, 두번째 인자가 y축의 데이터
- 이 때 두 인자의 길이가 같아야 한다.
ipynb의 경우 plt.show를 사용하지 않아도 그래프가 출력됨

plt.plot( [5,4,3,2,1] )
plt.show()

선의 종류와 색깔 지정

x = [1, 2, 3, 4]
y = [70, 80, 100, 60]

plt.plot(x, y, '.-')
plt.show()
plt.plot(x, y, 'r')
plt.show()

그래프 두 개 동시에 그리기

plt.plot(x, y)
plt.plot(x, [100, 60, 80, 40], 'r--')
plt.show()

제목, x축, y축 이름 지정

matplotlib 기본 폰트는 한글을 지원하지 않음

따라서 폰트 설정을 변경한 후에 제목, 축 이름에 한글을 사용할 수 있다.

이때 platform lib을 사용한다.

if platform.system() == 'Windows':
    plt.rc('font', family='Malgun Gothic')
else:
    plt.rc('font', family='AppleGothic')

plt.plot(x, y)
plt.title('그래프 제목')
plt.xlabel('x축 이름')
plt.ylabel('y축 이름')

plt.show()

마이너스 기호의 깨짐방지

# 둘이 같은 기능
plt.rc('axes', unicode_minus = False)
# plt.rcParams['axes.unicode_minus'] = False

plt.plot(x, [-10, 10, -20, 0])
plt.show()

범례

하나의 영역에서 데이터가 2개 이상인 경우 → 각각의 데이터들이 어떤 데이터인지 의미를 알아야한다.

x = [1,2,3]
y1 = [10, 6, 3]
y2 = [5, 8, 17]

# plt.plot(x, y1, label='A')
# plt.plot(x, y2, label='B')
# plt.legend()

plt.plot(x, y1)
plt.plot(x, y2)
plt.legend(['a', 'b'], loc='upper center')

바 그래프 생성

# 수직
plt.bar(x, y1)
plt.show()

# 수평
plt.barh(x, y1)
plt.show()

막대의 색상과 너비를 지정

plt.bar(x, y1, width=0.4, color=['red', 'yellow', 'green'])
plt.show()

특정 막대의 색상을 변경

bar_graph = plt.bar(x, y1)
bar_graph[1].set_color("#FE6B00")

plt.show()

vscode는 색상 지정이 편하다

산점도 그래프 생성

x = np.random.random(100)
y = np.random.random(100)

plt.scatter(x, y)
plt.show()

drinks 데이터셋을 통한 여러가지 시각화

데이터 로드, 확인

df = pd.read_csv('../csv/drinks.csv')
df.head()

df.info()

결측치 확인, 대체

flag = df['continent'].isna()
df.loc[flag, ]

# 결측치의 모든 데이터를 'OT' 로 대체
df.fillna('OT', inplace=True)

왼: isna(), 오른: fillna('OT')

데이터간 상관계수 확인

# 문자열 데이터 drop
df2 = df.drop(columns=['country', 'continent'])
df2.corr()

산점도 그려보기

x = df['beer_servings']
y = df['total_litres_of_pure_alcohol']
plt.scatter(x, y)
plt.show()

heatmap

import seaborn as sns

corr = df.iloc[:, 1:5].corr()

plt.figure(figsize=(12, 8))
sns.heatmap(data=corr,
            annot=True,
            square=True,
            fmt='0.3f',
            annot_kws={'size': 10},
            cbar = True,
            cmap = 'Blues',
            xticklabels=['맥주', '위스키', '와인', '순수알콜'],
            yticklabels=['맥주', '위스키', '와인', '순수알콜']
            )

# annot: 주석 표시 유무
# square: 히트탭 정사각형 표시 유무
# fmt = 주석의 소수점 자리수를 지정
# annot_kws = 주석의 환경 설정 (size: 글자의 크기를 변경)
# cbar = 사이드바 표시여부

pairplot

sns.pairplot(
    df.loc[:, '맥주소비량':'순수알콜'],
    corner = True,              # 중복이 되는 산점도 그래프 제거
    kind = 'reg',               # 추세선 추가
    plot_kws = {
        'line_kws' : {
            'color' : 'red'     # 추세선의 색상을 변경
        }
    }
)

plt.show()

연습 문제

1. 컬럼의 이름들을 변경
2. 파생변수 → 총 술 소비량: 맥주소비량+위스키소비량+와인소비량
3. 파생변수 → 도수: (순수알콜/총술소비량)*100
4. 대륙별 그룹화하여 도수의 평균을 구한다 → 가장 독한 술을 먹는 대륙은 어디인가?

# 1)
df.columns = ['국가', '맥주소비량', '위스키소비량', '와인소비량', '순수알콜', '대륙']

# 2)
df['총술소비량'] = df['맥주소비량']+df['위스키소비량']+df['와인소비량']

# 3)
df['도수'] = df['순수알콜']/df['총술소비량']*100

#4)
df[df['총술소비량'] == 0]

우리나라의 총 술 소비량은 전세계 몇 위일까?

# 총 술 소비량을 기준으로 내림차순 정렬
df.sort_values('총술소비량', ascending=False, inplace=True)
# 인덱스를 초기화하고 기존의 인덱스를 제거
df.reset_index(drop=True, inplace=True)

# 순위 → 위치 값에 +1
# 국가의 이름이 'South Korea' 인 데이터를 추출해서 인덱스를 확인

flag = df['국가'] == 'South Korea'
korea_index = df.loc[flag,].index[0]
korea_rank = korea_index + 1
korea_value = df.loc[korea_index, '총술소비량']

그래프 생성

x = df.index
y = df['총술소비량']

flag = df['국가'] == 'South Korea'
korea_index = df.loc[flag,].index[0]
korea_rank = korea_index + 1
korea_value = df.loc[korea_index, '총술소비량']

plt.figure(figsize=(20, 8))
bar_graph = plt.bar(x, y, color='gray')

# 한국 위치의 막대를 선택해서 색상 변경
bar_graph[korea_index].set_color('red')

# 그래프에 주석 추가 (화살표로 주석이 가리키는 곳을 표시)
plt.annotate(
    f"South Korea \n rank: {korea_rank} \n 총술소비량: {korea_value}",
    xy = (korea_index, korea_value),
    xytext= (korea_index+10, korea_value+150),
    arrowprops= {
        'facecolor' : 'pink',       # 화살표 안쪽 색상
        'edgecolor' : 'grey',       # 화살표 테두리 색상
        'headwidth' : 20,           # 화살표 머리 너비
        'headlength' : 20,          # 화살표 머리길이
        'width': 10,                # 화살표 꼬리의 너비
        'shrink': 0.1               # 화살표와 xy, xytext 간의 간격 조정
    }
)

# annotate 첫번째 인자: 주석이 들어갈 텍스트 지정
# 두번째 인자: 주석이 어느 부분을 설명하는가? (좌표)
# 세번째 인자: 주석 문구의 위치
# 네번째 인자: 주석과 해당 데이터를 화살표로 연결

plt.show()

4월 29일 ‍

오늘의 소감:

고수님들이 하는 짱멋진 시각화 - 엄청 많은 레이어도 깔끔하게 처리해서 한눈에 확 들어오게 함

내가 하는 시각화 - 색깔놀이 히히히

...센스가 하늘에서 내려올 수 있다면 얼마나 좋을까

offline 데이터 활용 시각화

라이브러리 로드

import pandas as pd
import platform
import matplotlib.pyplot as plt

데이터 로드, 확인

offline = pd.read_csv('../csv/card/오프라인.csv', encoding='cp949')
offline

데이터 전처리

컬럼명 변경

# 항목정의서 엑셀 파일을 로드

col_info = pd.read_excel('../csv/card/항목정의서.xlsx')
col_info

col_info['데이터 컬럼'].to_list()
# ['기준년월', '업종 구분', '성별', '연령대', '이용 건수', '이용 금액']

offline.columns = col_info['데이터 컬럼'].to_list()
offline

결측치 확인

offline.info()

# 항목정의서를 기준으로 성별에서 '-'가 결측치이다.

(offline['성별']=='-').sum()		# np.int64(0)

offline['성별'].value_counts()

결측치가 없는 것으로 파악되었다.

컬럼 타입 변경

from datetime import datetime
offline['기준년월'] = pd.to_datetime(offline['기준년월'], format='%Y%m')

그래프의 한글 깨짐 방지

if platform.system() == 'Windows':
    plt.rc('font', family = 'Malgun Gothic')
else:
    plt.rc('font', family = 'AppleGothic')

데이터 시각화

월별, 성별을 기준으로 이용 금액의 평균을 그래프로 표시

pd.pivot_table(
    offline,
    index = '기준월',
    columns = '성별',
    values = '이용 금액',
    aggfunc = 'mean'
).plot(kind='bar', color=("#ffa9a9", "#b0bfff"))

기준년월별 업종별로 이용 금액의 합계를 그래프로 표시

pd.pivot_table(
    offline,
    index = '기준년월',
    columns = '업종 구분',
    values = '이용 금액',
    aggfunc = 'sum'
).plot(color=("#FFA4A4", "#A1BAFF", "#78E26A", "#FFEC95"))

여러 개의 데이터를 한 캔버스 안에서 따로따로 그릴 때

# subplots() → 영역을 나눠주는 함수 → 영역을 나눈 캔버스를 생성
    # → 앞에서 생성한 캔버스의 크기는 초기화하고 새로 생성
    # 2개의 데이터를 되돌려준다. // 1. 캔버스, 2. 캔버스 영역


fig, axes = plt.subplots(2, 2, figsize=(20,8))
axes[0][0].plot([1,2,3,4], color="#FFB2B2")
axes[0][1].plot([1,2,3,4], color="#C0CBFF")
axes[1][0].plot([1,2,3,4], color="#97D48F")
axes[1][1].plot([1,2,3,4], color="#FFE89E")

한 화면에 연령대 별로 그래프를 따로 생성

group_data2 = pd.pivot_table(
    offline,
    index = '기준년월',
    columns = '연령대',
    values = '이용 금액',
    aggfunc = 'sum'
)

group_data2.plot(figsize=(10,10))

성별, 업종별 총 이용금액의 합계를 라인 그래프로 표시

group_data3 = pd.pivot_table(
    offline,
    index = '업종 구분',
    columns = '성별',
    values = '이용 금액',
    aggfunc = 'sum'
)

group_data3 = offline.groupby(['기준년월', '성별', '업종 구분'])['이용 금액'].sum()
group_data3 = group_data3.unstack().unstack()
group_data3.iloc[:, 0]

plt.figure(figsize=(16, 20))

for i in range(len(group_data3.columns)):
    plt.subplot(4, 2, i+1)
    plt.plot(group_data3.iloc[:, i])
    plt.title(group_data3.columns[i])

plt.show()

offline+online 데이터 활용 시각화

데이터 로드

offline = pd.read_csv('../csv/card/오프라인.csv', encoding='cp949')
online = pd.read_csv('../csv/card/온라인.csv', encoding='cp949')

데이터 프레임 컬럼명 변경

offline.columns = ['기준년월', '업종', '성별', '연령대', '이용건수', '이용금액']
online.columns = ['기준년월', '성별', '연령대', '이용건수', '이용금액']

online dataset에서는 업종 column이 없다.

데이터 결합

df = pd.concat( [offline, online], axis = 0, ignore_index = True )

# df 업종 column의 결측치 대체
df['업종'] = df['업종'].fillna('온라인')

# 기준연월 시계열로 변경
df['기준년월'] = pd.to_datetime(df['기준년월'], format='%Y%m')

모든 업종별로 이용건수 차이를 그래프로 확인

pd.pivot_table(
    df,
    index = '기준년월',
    columns = '업종',
    values = '이용건수',
    aggfunc = 'sum'
).plot(figsize=(16,10), color=("#FFB9B9", "#9ECBFF", "#96E4A3", "#FFE59C", "#CC9EDA"))

AAPL 데이터 활용

애플 주식 데이터
목표: 이동 평균선 도출

import pandas as pd
import matplotlib.pyplot as plt
import platform

if platform.system() == 'Windows':
    plt.rc('font', family = 'Malgun Gothic')

df = pd.read_csv('../csv/AAPL.csv')

# 필요한 column만 불러오고 싶을 때는
df2 = pd.read_csv('../csv/aapl.csv', usecols=['Date', 'Adj Close'])

df2.info()

결측치 처리

결측치가 하나 뿐이라 결측치가 포함된 행은 drop

Date column은 datetime type으로 변경

df2.dropna(inplace=True)

df2['Date'] = pd.to_datetime(df2['Date'])
df2.info()

# Date column을 index로 설정
df2.set_index('Date', inplace=True)

df2.iloc[0:20, 0].mean()

# 이동평균값 컬럼을 먼저 생성 → 데이터는 0.0을 대입
	# (평균을 구할 것이기에 float 타입으로 만들기 위함)
df2['이동평균값'] = 0.0

for i in range(len(df2)-19):
    df2.iloc[i+19, 1] = df2.iloc[i:i+20, 0].mean()
   
# 다른 방법으로 인덱스끼리 묶어서 연산을 해주는 함수가 존재: rolling(n)
df2['center2'] = df2['Adj Close'].rolling(20).mean().fillna(0

df2[['Adj Close', 'center2']].tail(100).plot(figsize=(30, 10))

그래프 꾸미기

plt.figure(figsize=(30, 10))
plt.plot(df2.tail(100)['Adj Close'], color='#000000')
plt.plot(df2.tail(100)['center2'], '--', color="#cf2424")

plt.show()

df2['ub'] = df2['center2'] + (2*df2['Adj Close'].rolling(20).std())
df2['lb'] = df2['center2'] - (2*df2['Adj Close'].rolling(20).std())

# 최근 100일치 데이터에서 상단밴드, 하단밴드, 이평선, 종가 그래프
df2.drop(['이동평균값'], axis=1).tail(100).plot()

이것도 좋지만 조금 더 깔끔하게 보고 싶어져서 따로 찾아본 버전

plt.figure(figsize=(30,10))
plt.plot(df2['ub'].tail(200), color="#52865F", label='ub')
plt.plot(df2['lb'].tail(200), color='#52865F', label='lb')
plt.plot(df2['center2'].tail(200), color="#FF00F2", label='이평선')
plt.plot(df2['Adj Close'].tail(200), marker = 'o', markersize=5, color="#C25555", label='종가')
plt.fill_between(df2.tail(200).index, df2['ub'].tail(200), df2['lb'].tail(200), color = 'green', alpha = 0.05)
plt.legend()
plt.show()

plt.fill_between을 사용하면 색깔이 채워져서 더욱 band 같아보일 것 같았다!

4월 30일 ‍

오늘의 소감: tableau는 코드가 불필요하다. (엑셀 기초 정도의 실력만 있으면 될 듯)

혼자서 tableau를 쓰려고 했을 때 가장 막막한 것은 시작이었다.

새로운 툴에 대한 마음적 장벽도 있지만, 어떤 데이터를 가지고 시작해야할지를 몰랐다고 해야할까...?

matplotlib의 디자인을 보다가 seaborn을 보고 놀랐고, seaborn을 보다가 tableau를 보니 더욱 놀랐다.

특히 지리 데이터를 다루는 것을 꼭 한번 시도해보고 싶었는데 tableau에서 해당 부분 시각화가 가능하다는 생각에 기뻤다.

GA는 웹을 관리하는 입장, 예를 들면 소형 쇼핑몰 등에서 아주 유용하게 사용할 수 있는 툴이었다.

아직 html과 많이 친하지 않아서... 또 tableau를 보다가 GA를 보려니까 훨씬 복잡한 느낌이긴 했다.

해당 부분 진도를 짧게 나간지라 아직 시스템과 친해질 시간이 많이 필요해보인다.

개인적으로는 looker와 GA를 어떻게 같이 사용하는지가 궁금했는데, 시간이 부족한 관계로 이 부분까지는 진도를 나가지 못했다. 추후에 수행할 기회가 왔으면 좋겠다.

Tableau가 워낙 직관적으로 구성이 잘 돼있어서 크게 작성할 것이 없다...! 그래서 신기했던 것 위주로 짤막하게 작성해보려 한다.

서울시의 행정구별 평균 할인율

처음 실행했을 때는 중구와 강서구의 데이터가 나오지 않았다.

다른 지역(ex. 부산광역시)에 중구, 강서구가 있었기 때문에 정확한 지역을 표시할 수 없다고 나온 것이었다.

이 때 세부정보로 Address SD(시도)를 추가하니 문제가 해결되었다.

폭포수 차트

2021년의 경우 적더라도 수익이 꾸준히 난 구조이기에 이게 뭐? 싶을수도 있는 결과가 도출되었다.

그래서 나름 다이나믹했던 2019년부터 2020년까지의 데이터를 보았다.

빨간색에 가까울 수록 이익이 마이너스, 파란색에 가까울 수록 이익이 플러스이다.

각 막대가 y=0에서 시작하는 것이 아닌, 전월의 마지막 시점에서 시작한다.

~~말해놓고 보니 주식 차트였네~~

4주차 소감

생각보다 시각화를 많이 하지 않은 느낌이라 아쉽긴 하지만...

새로운 것을 많이 배워갈 수 있는 시간이었다!

연휴 동안 복습 게을리하지말고, 지금까지 배운 것들을 빅분기 실기랑 내용 대조해가면서 공부도 조금씩 하자!

다음 주차는 머신러닝이다. 빅분기에서 써먹을 일 많을테니 열심히 하자! - ̗̀( ˶'ᵕ'˶) ̖́-

3주차 Note: 데이터 수집

가라어퍼 — Sun, 26 Apr 2026 19:14:30 +0900

️ 3주차 : 4월 20일 - 4월 24일

멀티캠퍼스 부트캠프 3주차 요약✍

[ 4/20 ] 데이터 수집 (AI 활용): python과 db 연결(+모듈 생성), openAPI data((json/xml)를 DataFrame으로 변환
[ 4/21 ] 데이터 수집 (AI 활용): HTML, 크롤링
[ 4/22 ] 데이터 수집 (AI 활용): Selenium
[ 4/23 ] 데이터 수집 (AI 활용): SQL과 Python의 문법 비교
[ 4/24 ] Github 특강: 본문에서는 생략

4월 20일 ‍

오늘의 소감: 오류의 늪 시작...

초심자의 입장에서 주석은 정말 중요하지만 긴 주석과 긴 코드를 보고 있으니 머리가 더욱 어지럽다.

주석과 코드를 같이 쓸 때의 가독성을 확보할 수 있는 방법을 강구해보아야겠다.

python과 db 연결

dotenv

python과 database를 연결할 때 주소, 포트 등 서버의 정보를 입력하게 되는데,

이를 그냥 온라인에 업로드하면 보안상 취약점이 된다.
그러한 부분을 숨기는 기능이 dotenv이다.

!pip install python-dotenv

# 라이브러리 load
from dotenv import load_dotenv
import pymysql
import os
import pandas as pd

# os → python 환경에서 사용하는 변수들에 접근하기 위해 사용
# load_dotenv → .env 파일의 내용을 환경 변수에 임시 등록

dotenv를 사용하기 위해 .env 파일을 생성하고, python에서 load_dotenv 실행

load_dotenv()		# True

# 등록된 환경변수에 접근
os.getenv('port')	# 포트번호가 '문자열'로 출력: 숫자 변환 필요

나의 경우 OperationalError: (2003, "Can't connect to MySQL server on '`서버코드`' ([WinError 10061] 대상 컴퓨터에서 연결을 거부했으므로 연결하지 못했습니다)") 라는 에러가 출력되었는데, 서비스 → MySQL80이 실행되고 있는지 확인해야한다.
백그라운드에서 꺼져있었기에 발생한 문제이고, 실행하고 난 뒤 정상적으로 작동하였다.

Cursor 생성

cursor = _db.cursor(pymysql.cursors.DictCursor)

# DictCursor는 select의 결과값을 Dict 형태로 받아온다.

Table 생성

# DDL: 테이블 생성
# 기존의 테이블이 존재한다면 테이블 생성 X
# 없으면 생성

create_table = """
    CREATE TABLE IF NOT EXISTS
    `user_info`
    (
        `id` VARCHAR(32) PRIMARY KEY,
        `password` VARCHAR(32) NOT NULL,
        `name` VARCHAR(32),
        `age` INT
    )

질의

# cursor를 통해서 sql 쿼리문을 실행할 때는 execute() 함수를 이용
cursor.execute(create_table)		# 0

데이터 대입

signup_query = """
    INSERT INTO
    `user_info`
    VALUES (
        "test", "1234", "kim", 30
    )
"""
cursor.execute(signup_query)	# 1

fetchall()

# 결과값을 불러오는 함수

cursor.fetchall()
# [{'id': 'test', 'password': '1234', 'name': 'kim', 'age': 30}]

그런데 아직까지는 MySQL Workbench에서는 데이터가 등록되지 않은 상태이다.
이는 아직 확인 절차에 있다는 것을 의미한다.

commit

# _db에서 확정 작업(commit()), 결과를 DB와 동기화
_db.commit()

이후 Workbench를 확인해보면 데이터가 등록됨을 볼 수 있다.

여러 데이터 입력

# 들어오는 데이터가 바뀔 때마다 query문을 작성하는 건 불필요

signup_query = """
    INSERT INTO `user_info`
    VALUES (%s, %s, %s, %s)
"""

# %s 는 들어오는 데이터들의 위치를 지정
input_id = input('아이디를 입력하시오')
input_pass = input('비밀번호를 입력하시오')
input_name = input('이름을 입력하시오')
input_age = input('나이를 입력하시오')

# execute(query, [datas]) 함수에 리스트의 각각의 원소들이 %s 위치에 순서대로 대입
cursor.execute(signup_query, [input_id, input_pass, input_name, input_age])		# 1

cursor.execute(user_list_query)		# 2

cursor.fetchall()
# [{'id': 'test', 'password': '1234', 'name': 'kim', 'age': 30},
# {'id': 'test2', 'password': '1111', 'name': 'lee', 'age': 20}]

DB 연동 class 선언, 생성

로직

생성자 함수
- 서버의 정보를 입력한다. (매개변수 필요)
- class가 생성이 될 때마다 다른 DB server에 정보를 담을 수 있다.
- 2개의 객체를 생성하여 다른 DB server와 연동
함수 2개 생성
- 1. query문 실행 함수 (매개변수: query문(필수), *datas)
  - 서버와의 연결
  - cursor 생성
  - CUD (insert, update, delete)
    - query문 작성
    - execute() 함수를 이용하여 cursor에 질의를 보낸다.
      - query문의 시작이 select라면 fetchall() 함수를 사용하여 데이터를 return
- 2. DataBase에 변화를 주는 함수
  - DB server에서 commit()을 이용해서 데이터 확정
  - DB server와의 연결을 종료(close())

코드

class 선언

class MyDB:
    def __init__(self, host, port, user, password, db):
        self.host = host
        self.port = port
        self.user = user
        self.password = password
        self.db = db

    # 데이터베이스에 변화를 주는 함수 
    def commit(self):
        try:
            self.db_server.commit()
            self.db_server.close()
            del self.db_server
        except:
            print( "데이터베이스 서버와의 연결이 되어있지 않습니다. sql_query() 함수를 호출하여 서버와의 연결을 해주세요" )
    
    def sql_query(self, query, *datas):
        try:
            self.db_server
            print('접속된 서버가 존재함')
        except:
            self.db_server = pymysql.connect(
                host = self.host, 
                port = self.port, 
                user = self.user, 
                password = self.password, 
                db = self.db
            )
        # cursor 생성 
        cursor = self.db_server.cursor(pymysql.cursors.DictCursor)

        try:
            cursor.execute(query, datas)
            if query.lstrip().lower().startswith('select'):
                result = cursor.fetchall()
            else:
                result = "Query OK!"
            return result
        except Exception as e:
            print('query문 execute중 에러')
            print(e)

class 생성

db1= MyDB(
    host = os.getenv('host'),
    port = int(os.getenv('port')),
    user = os.getenv('user'),
    password = os.getenv('pwd'),
    db = os.getenv('db_name')
)

db1.sql_query('a')
db1.commit()

생성자 함수에 콤마 넣지 말자, port에 int 제대로 쓰자

~~다 했는데 안 되면 재시작해라 그게 최고다~~

data insert

insert_query = """
    INSERT INTO `user_info`
    VALUES (%s, %s, %s, %s)
"""
select_query = """
    SELECT * FROM `user_info`
"""

data_list = ['test3', '0000', 'lee', 40]
db1.sql_query(insert_query, *data_list)

# 접속된 서버가 존재함
# 'Query OK!'

data 확인

db1.sql_query(select_query)

# [{'id': 'test', 'password': '1234', 'name': 'kim', 'age': 30},
# {'id': 'test3', 'password': '0000', 'name': 'lee', 'age': 40}]

data delete

delete_query = """
    DELETE FROM `user_info`
"""

data_list = ['test']

db1.sql_query(delete_query)

# 접속된 서버가 존재함
# 'Query OK!'

??: 다 했는데 안 되면 재시작해라 그게 최고다
아니? 새로고침 안 좋은데? 초기화 안 좋은데?ㅠㅠ 초기화되면 로딩했던 거 다 사라지는데??

한참동안 고쳐지지 않는 에러가 떠서 강사님 코드도 복붙해보고... 프로그램을 새로 키기를 몇번이나 했고 라이브러리도 죄다 새로 import 해놓았는데

정말 바보도 아니고 라이브러리는 임포트했으면서 load_dotenv() 를 실행하지 않고 계속 작업한 것이다...
그리고 콤마!!!! 자꾸 써야할 곳에 안 쓰고 안 써야할 곳에 쓴다.
언젠가 또 실수할 것이 뻔하므로 기록...

모듈화

py 파일에 import한 라이브러리들과 아까 만들어뒀던 클래스를 붙여넣어 모듈화 진행

# 파일명 db.py

import db
db3 = db.MyDB()
db3.sql_query(select_query)

# [{'id': 'test', 'password': '1234', 'name': 'kim', 'age': 30}]

잘 불러와지는 것을 확인할 수 있다.

Open API

개인적으로 학교에서 알려준 바가 없어서 가장 궁금했던 부분이었던 Open API 활용...
Key를 발행하는 것까지는 해본 적이 있는데 그 이후에 이 Key를 가지고 뭐 어떡하라는 건지 몰라서 마구 찾아보다 그냥 돌아선 적이 있다

data download

https://www.data.go.kr/data/15111004/openapi.do#/API%20%EB%AA%A9%EB%A1%9D/corp%2FgetEsgStatus데이터를 받아와서 python에서 DataFrame으로 변형시켰다.

# 라이브러리 설치/로드
!pip install requests
import requests

# 인증키 변수에 저장

service_key = '내가 발급받은 API key'
page_no = 1
num_of_rows = 100

url = 'https://apis.data.go.kr/B553069/esg/corp/getEsgStatus'

# 파라미터 지정

params = {
    'serviceKey': service_key,
    'pageNo' : page_no,
    'numOfRows': num_of_rows
}

# server에게 요청을 보낸다
# requests 안에 get() 함수를 이용. 대부분 get을 사용
    # get()
        # 첫번째 인자에는 주소
        # params 매개변수: 파라미터 값들을 dict 형태로 대입

res = requests.get(url, params=params)

res # <Response [200]>
type(res.content) # bytes

bytes를 dictionary type으로 변환

import json
res_data = json.loads(res.content)
type(res_data) # dict

# data를 예쁘게 출력해서 보고 싶을 때
from pprint import pprint
pprint(res_data)

dictionary를 DataFrame으로 변환

~~배운지 얼마나 됐다고 아는 내용 나오니 이리 기쁠 수가 없었다~~

df = pd.DataFrame(res_data['response']['body']['items'])

xml, json 파일을 DataFrame으로 변환

또 다른 데이터셋을 download
https://www.data.go.kr/data/15126832/openapi.do#/API%20%EB%AA%A9%EB%A1%9D/pscd
해당 데이터를 다운로드했다.

env 파일을 활용하여 데이터 load

env 파일에 다음과 같이 작성하여 저장

service_key = '내가 발급받은 API key'

xml 데이터 변환

url = 'https://apis.data.go.kr/B010003/kamcoRlctRlst/pscd'

params = {
    'serviceKey': os.getenv('service_key'),
    'pageNo' : 1,
    'numOfRows': 100,
    'resultType': 'xml'
}

res = requests.get(url, params=params)
res # <Response [200]>

# -----------------------------------------------------

!pip install xmltodict
# xml을 dict 형태로 변환하는 라이브러리
from xmltodict import parse

res_data_xml = parse(res.content)
pprint(res_data_xml['response']['body']['items']['item'])

df3 = pd.DataFrame(res_data_xml['response']['body']['items']['item'])

json 데이터 변환

params2 = {
    'serviceKey': os.getenv('service_key'),
    'pageNo' : 1,
    'numOfRows': 100,
    'resultType': 'json'
}

res2 = requests.get(url, params=params2)
# url은 xml 데이터 변환 코드에 작성되어 있음
res # <Response [200]>
pprint(res_data_json['body']['items']['item'])

df2 = pd.DataFrame(res_data_json['body']['items']['item'])

이렇게 하여 open API xml, json 형태의 데이터를 불러와 DataFrame 형식으로 변환할 수 있다.

코드가 길고 불러올 라이브러리들도 많으니 코드의 가독성이 이래서 필요하구나 싶다.

~~앞으로 더 복잡해지겠지~~

이제 더 점점 어려워질테니 마음 단단히 먹고 가자

4월 21일 ‍

오늘의 소감: 아래 이미지로 대체

듀얼 모니터 없이 노트북만으로 HTML, 줌, VS code 병행하려니 죽을 맛이다...

결국 어제 모니터를 구매했다...ㅎㅎ

~~왜 느는 게 실력이 아니라 장비욕심이냐~~

HTML

각종 태그 모음

크롤링

find()

html 문서 안에서 특정 태그의 첫번째 정보를 출력
find(속성명=속성값)
결과값의 type은 TAG

# 라이브러리 설치/로드
!pip install bs4 selenium
import requests
from bs4 import BeautifulSoup as bs

res = requests.get("https://www.naver.com")
res.content     # type: bytes
res.text        # type: str
html_text = res.text

# 문자열에서 특정 문자의 위치를 찾는 함수: find()
html_text.find("네이버") # 378

parsor

문자 형태로 이루어진 html 문서를 BeautifulSoup class를 이용해서 객체 변환
문자 데이터에서는 특정 영역의 content를 추출하기 어렵기에, BeautifulSoup에 내장된 함수를 이용
데이터를 추출하기 위해 class 생성 시 데이터를 대입

soup = bs(html_text, 'html.parser')
type(soup) # bs4.BeautifulSoup

find_all()

html 문서 안에서 특정 태그의 모든 정보를 출력
결과값의 type은 ResultSet (TAG의 list형태)

# versis find

soup.find('a')
# <a href="#topAsideButton"><span>상단영역 바로가기</span></a>


soup.find_all('a')
# [<a href="#topAsideButton"><span>상단영역 바로가기</span></a>,
#  <a href="#shortcutArea"><span>서비스 메뉴 바로가기</span></a>,
#  <a href="#newsstand"><span>새소식 블록 바로가기</span></a>,
#  <a href="#shopping"><span>쇼핑 블록 바로가기</span></a>,
#  <a href="#feed"><span>관심사 블록 바로가기</span></a>,
#  <a href="#account"><span>MY 영역 바로가기</span></a>,
#  <a href="#widgetboard"><span>위젯 보드 바로가기</span></a>,
#  <a href="#viewSetting"><span>보기 설정 바로가기</span></a>]

+) find, find_all 함수는 TAG type에서는 사용 가능하지만, ResultSet type에서는 사용 불가능하다.

네이버 증권 사이트 크롤링

미리 말하자면, 아래 코드는 `pd.read_html()` 한 줄로 대체되는 항목이다.

import requests
from bs4 import BeautifulSoup as bs
import pandas as pd

result = requests.get('https://finance.naver.com')
soup = bs(result.text, 'html.parser')

div_data = soup.find('div', attrs = {'class': 'section_sise_top'})

tables = div_data.find_all('table', attrs = {'class': 'tbl_home'})

# ------------------------------------------------------------------

# 실행 때마다 변수명이 다른 df 생성

vari_num = 1

for table_data in tables:
    # thead 추출: columns
    head_data = table_data.find('thead')
    cols = [th.string for th in th_list]

    # tbody 추출: values
    body_data = table_data.find('tbody')
    tr_list = body_data.find_all('tr')

    values = []

    for tr in tr_list:
        row_list = tr.find_all(['th', 'td'])
        value_data = [data.get_text().strip() for data in row_list]
        values.append(value_data)

    globals()[f"df{vari_num}"] = pd.DataFrame(values, columns=cols)
    vari_num += 1

pd.read_html()

하지만 위 코드는 pd.read_html() 한 줄로 정리될 수 있다.
이때, pd.read_html() 은 테이블 형태에만 적용할 수 있다.

pd.read_html(str(div_data))

# os 에러가 나는 경우
from io import StringIO
pd.read_html(StringIO(str(div_data)), encoding='cp949')

4월 22일 ‍

오늘의 소감: 하루 했다고 html에 적응했나보다... 재밌다

크롤링 Review

https://www.google.com/robots.txt 과 같이 robots.txt를 붙이면 크롤링 규칙이 나온다. (Allow/Disallow)

get_text()를 이용하는 걸 자꾸 까먹는데, 데이터 type에 대해 추가적인 공부가 필요할 듯 하다.
(어떤 type이 get_text() 사용이 가능한지, 어떤 함수를 쓰면 어떤 type이 되는지)
학교에서 파이썬 배울 때는 for문 나올 때마다 머리를 감싸쥐고 절규했었는데,
이 과정에서는 마치 구세주라도 찾는 것인 양 for문을 마구 찾아 쓰고 있었다... (왜 반복문이 만능인지 제대로 체감 중 )

크롤링-Selenium 활용

너무너무 신기했던 Selenium!!! 다들 이렇게 매크로 만드는구나...

~~다음 방켓팅 때 활용을~~

라이브러리 설치, 로드

!pip install selenium
import requests
from bs4 import BeautifulSoup as bs
import pandas as pd
from selenium import webdriver
from seleniuhttp://m.webdriver.common.by import By
from seleniuhttp://m.webdriver.common.keys import Keys
import re

네이버 쇼핑 사이트 크롤링

네이버를 열고, 검색창에 검색하고, enter를 누르는 것까지 모두 입력할 수 있다.

# 웹 브라우저를 제어하기 위해 변수에 저장
driver = webdriver.Chrome()
driver.get("http://naver.com")

# 네이버 메인 화면에서 검색어를 입력하는 input Tag는 id가 query이다.
search_element = driver.find_element(By.ID, 'query')

# search_element → 검색어 입력창을 의미
search_element.send_keys('아이폰')

# 검색어의 입력이 끝났으면 ENTER 키를 눌러서 검색을 시작
search_element.send_keys(Keys.ENTER)

이러면 갑자기 네이버에 접속해서 검색창에 아이폰이 입력되고 검색을 하는데 신세계였다... 이걸 내가 했다니 말도 안돼

~~(팩트: 내가 한 게 아니다)~~

# 하이퍼링크의 콘텐츠 데이터가 '쇼핑'인 태그를 선택
len(driver.find_elements(By.LINK_TEXT, '쇼핑'))

shopping_button = driver.find_element(By.LINK_TEXT, '쇼핑')
# 쇼핑 버튼을 클릭한다.
shopping_button.click()

머릿속에서 계속 이게 생각났다... ~~셀레니움아 자... 이게 클릭이야~~

원하는 화면이 나왔다면 python에 불러온다.

html_data = driver.page_source
soup = bs(html_data, 'html.parser')


# 상품의 정보가 모두 들어있는 영역인 div 태그 중 id가 content인 태그를 추출
items_div = soup.find(
    'div',
    attrs = {
        'id': 'content'
    }
)

item_list = items_div.find_all(
    'div',
    attrs= {
        'class': re.compile('product_item')
    }
)

# 반복문을 이용하여 item_list의 상품명, 가격, 배송비 2차원 데이터로 생성

values = []

for item in item_list:
    
    # 상품명 추출
    item_name = item.find(
        'div',
        attrs = {
            'class': re.compile('product_title')
        }
    ).get_text()

    # 가격을 추출
    item_price = item.find(
        'span',
        attrs= {
            'class': 'price'
        }
    ).get_text()

    # 배송비 추출
    item_fee = item.find(
        'div',
        attrs= {
            'class' : re.compile('price_delivery_fee')
        }
    ).get_text()

    # 상품의 링크 주소를 추출
        # (상품명 추출해서 그 안에서 a 태그 찾고 href 속성 값 추출)
    name_tag = item.find(
        'div',
        attrs= {
            'class' : re.compile('product_title')
        }
    )
    item_url = name_tag.find('a')['href']

    # 상품명과 가격 배송비를 딕셔너리 형태로 생성하여 values에 추가
    values.append(
        {
            '상품명': item_name,
            '가격': item_price,
            '배송비': item_fee,
            'url': item_url
        }
    )

df = pd.DataFrame(values)

데이터프레임 형태로 만들 수 있다.

수집한 데이터를 mysql db server에 저장

to_sql()

from sqlalchemy import create_engine
engine = create_engine(
    "서버 주소"
)

df.to_sql(name='naver', con=engine, index=False)

4월 23일 ‍

오늘의 소감: 오랜만에 SQL 다루니까 얘가 정말 직관적이구나 싶다...

python 문법은 아직도 가끔 까먹을 때가 있는데 SQL 문법은 까먹지를 않는다.

Python과 SQL 문법 비교

데이터 로드

emp라는 csv 파일 load
20일에 만들어뒀던 db.py 파일을 이용하였다.
※ pandas로 슬라이싱하는 경우 인덱스 번호가 유지되고, query문을 작성하면 인덱스가 새롭게 들어간다.

import pandas as pd
from db import MyDB
db = MyDB()


query_1 = """
    SELECT * FROM `emp`
"""

emp_df = pd.DataFrame(db.sql_query(query_1))
emp_df

pd.read_csv('../csv/emp.csv') 도 가능하다.

데이터 필터링

SAL 컬럼의 데이터가 1500 이상인 사원의 모든 정보를 확인

# 1
emp_df[emp_df['SAL'] >= 1500]

# 2
emp_df.loc[emp_df['SAL'] >= 1500, ]

이때만 해도 1번 방식이 편했는데, col 조건식이 붙으니까 2번이 더 편했다.

# 위 조건식을 Query로 만든다면

query_3 = """
    SELECT *
    FROM `emp`
    WHERE SAL >= 1500
"""

emp_filter = db.sql_query(query_3)
pd.DataFrame(emp_filter)

SAL이 1500 이상이고, JOB이 MANAGER인 사원의 사원번호와 이름을 출력

# pandas
flag_1 = emp_df['SAL'] >= 1500
flag_2 = emp_df['JOB'] == 'MANAGER'
col_flag = ['EMPNO', 'ENAME']

emp_df.loc[ flag_1 & flag_2, col_flag]


# sql query
query_4 = """
    SELECT EMPNO, ENAME
    FROM `emp`
    WHERE SAL >= 1500 AND JOB = 'MANAGER'
"""

pd.DataFrame(db.sql_query(query_4))

SAL 1500 이상 2500 이하인 사원의 모든 정보 확인

# pandas 1
flag_3 = emp_df['SAL'] >= 1500
flag_4 = emp_df['SAL'] <= 2500
emp_df.loc[flag_3 & flag_4, ]

# pandas 2
emp_df.loc[
    emp_df['SAL'].isin(range(1500,2501)),
]

# pandas 3
emp_df.loc[
    emp_df['SAL'].between(1500, 2500)
]


# sql query
query_5 = """
    SELECT *
    FROM `emp`
    WHERE SAL BETWEEN 1500 AND 2500
"""

pd.DataFrame(db.sql_query(query_5))

모두 동일한 결과값이 추출된다.

JOB이 MANAGER 이거나 SALESMAN인 모든 사원 정보를 확인

# pandas 1
flag_5 = emp_df['JOB'] == 'MANAGER'
flag_6 = emp_df['JOB'] == 'SALESMAN'
emp_df.loc[flag_5 | flag_6, ]

# pandas 2
flag_7 = emp_df['JOB'].isin(['MANAGER', 'SALESMAN'])
emp_df.loc[flag_7,]

# sql query
query_6 = """
    SELECT *
    FROM `emp`
    WHERE JOB in ('MANAGER', 'SALESMAN')
"""
pd.DataFrame(db.sql_query(query_6))

역시 동일한 결과가 추출된다.

계속 pd.DataFrame 쓰기 귀찮아서 함수를 만들었다.

def sql(query):
    result = pd.DataFrame(
        db.sql_query(query)
    )

    return result

사원의 이름이 S로 시작하는 사람, S가 포함된 사람 추출

# pandas 1: for문

# s로 시작하는 사람
word = 's'
flag_list = []
for name in emp_df['ENAME']:
    flag_list.append(
        name.lower().startswith(word.lower())
    )
emp_df.loc[flag_list,]

# S로 끝나는 경우
        # name.lower().endswith(word.lower())
        
        # S를 포함하는 경우
        # word.lower() in name.lower()

# -----------------------------------------------------

# pandas 2: for문 없이

# s로 시작하는 사람
word = 's'
flag_8 = emp_df['ENAME'].str.lower().str.startswith(word.lower())
emp_df.loc[flag_8,]
# s로 끝나는 경우
                                        # .endswith
# s를 포함하는 경우
                                        # .contains


# -----------------------------------------------------

# sql query
# pandas에서 %는 특수기호이기에 %만 사용해서는 작동하지 않는다

# s로 시작하는 사람
query_7 = """
    SELECT *
    FROM `multicam`.`emp`
    WHERE ENAME LIKE "s%%"
"""
# S가 포함되는 경우
    # WHERE ENAME LIKE "%%s%%"

sql(query_7)

s로 시작하는 경우

s를 포함하는 경우

python, sql 모두 동일한 결과가 추출된다.

데이터 결합

join 결합

emp table과 dept table을 DEPTNO라는 column을 통해 결합

# pandas
pd.merge(emp_df, dept_df, on='DEPTNO', how='left')

# SQL

query_8 = """
    SELECT *
    FROM emp
        LEFT JOIN dept
            ON emp.DEPTNO = dept.DEPTNO
"""

sql(query_8)

pandas에서 column이 다를 때 join

dept_df2 = dept_df.copy()
dept_df2.rename(
    columns={
        'DEPTNO' : 'DEPTNUM'
    }, inplace=True
)

이후 아까 한 것과 같이 pd.merge(emp_df, dept_df2, on='DEPTNO', how='left') 를 하게 되면 ERROR가 발생한다.
이 경우 결합하고자 하는 데이터프레임의 key를 모두 써주면 결합에 성공한다.

pd.merge(
    emp_df, dept_df2, left_on='DEPTNO', right_on='DEPTNUM', how='left'
)

union

tran_1과 tran_2 table을 union 결합

# sql
query_9 = """
    SELECT * FROM `tran_1`
    UNION
    SELECT * FROM `tran_2`
"""
sql(query_9)


# pandas
tran_1 = pd.read_csv('../csv/tran_1.csv')
tran_2 = pd.read_csv('../csv/tran_2.csv')
tran_d1 = pd.read_csv('../csv/tran_d_1.csv')
tran_d2 = pd.read_csv('../csv/tran_d_2.csv')

pd.concat([tran_1, tran_2], axis=0, ignore_index=True)

ignore_index = True 때문에 index가 동일한 모습으로 나타난다.

join: 중복된 키 select

잠시 다시 join으로 돌아와서, join을 수행한 key를 select하는 과정에 대해 풀이한다.
transaction_id를 동일한 key로 가지는 tran_1과 tran_d_1 테이블을 조인 결합한다.

query_11 = """
    SELECT
        transaction_id,
        price,
        payment_date,
        quantity
    FROM
    `tran_1` `t1`
    LEFT JOIN
    `tran_d_1` `td1`
    ON
    t1.transaction_id = td1.transaction_id
"""

sql(query_11)

해당 문제를 해결하려면 select문에 있는 transaction_id를 어느 테이블에서 가져올 것인지를 명시해야한다.

# tran_1과 tran_d_1 테이블을 조인 결합

query_11 = """
    SELECT
        t1.transaction_id,
        price,
        payment_date,
        quantity
    FROM
    `tran_1` `t1`
    LEFT JOIN
    `tran_d_1` `td1`
    ON
    t1.transaction_id = td1.transaction_id
"""

sql(query_11)

그나저나 as 없이도 이름 변경 가능한 거 충격이다... 적응하면 편할 것 같긴 한데 매번 as 써왔던 입장에서는 어색하달까...

데이터 정렬

ENAME을 기준으로 내림차순 정렬

# sql
query_12 = """
    SELECT * FROM
    `emp` ORDER BY ENAME DESC
"""
sql(query_12)


# pandas
emp_df.sort_values('ENAME', ascending=False)

그룹화

JOB으로 그룹화하여 SAL의 통계량 추출

# sql
# pandas와 다르게 SELECT 문에 그룹화 연산을 적어주어야 함.

query_13 = """
    SELECT
        JOB,
        AVG(SAL) AS SAL_AVG,
        SUM(SAL) AS SAL_SUM
    FROM `emp`
    GROUP BY JOB
"""
sql(query_13)

# pandas
emp_df[ ['JOB', 'SAL'] ].groupby('JOB').agg(['mean', 'sum', 'count'])

형태는 조금 다르지만 값은 동일하게 나오는 것을 볼 수 있다.
값들의 정렬도 조금 다른데, 이는 SQL 쿼리문에서 HAVING을 통해 동일하게 만들 수 있다.

서브쿼리

부서의 지역이 NEW YORK, CHICAGO인 부서의 번호를 받아서 사원의 정보를 확인

# sql
query_16 = """
    SELECT *
    FROM `emp`
    WHERE DEPTNO IN
    (
        SELECT DEPTNO
        FROM `dept`
        WHERE LOC IN ('NEW YORK', 'CHICAGO')
    )
"""
sql(query_16)


# pandas
flag_9 = dept_df.loc[
    dept_df['LOC'].isin( ['NEW YORK', "CHICAGO"] ), 'DEPTNO'
]
emp_df.loc[emp_df['DEPTNO'].isin(flag_9), ]

둘 다 두 번의 작업을 거친다는 것에서 공통점이 있다.
pandas의 경우, flag_9에 담긴 코드를 두번째 코드의 flag_9 자리에 그대로 써놓으면 sql과 비슷하게 서브쿼리 느낌의 코드가 될 것이다.

HAVING

직종에서 ANALYST를 제외하고 직종별로 그룹화를 하여
SAL의 평균이 2500 이상인 데이터에서 평균 SAL이 높은 순서대로 출력

# sql

query_17 = """
    SELECT
        JOB,
        AVG(SAL) SAL_AVG
    FROM `emp`
    WHERE JOB != 'ANALYST'
    GROUP BY JOB
    HAVING SAL_AVG >= 2500
    ORDER BY SAL_AVG DESC
    
"""
sql(query_17)

# pandas

df = emp_df.loc[
    emp_df['JOB'] != 'ANALYST'
]
group_df = df[ ['JOB', 'SAL'] ].groupby('JOB').mean()
group_df = group_df.loc[
    group_df['SAL'] >= 2500
]
group_df.sort_values('SAL', ascending=False).reset_index()

3주차 소감

오랜만에 SQL을 다루니까 반가웠고, 궁금했던 크롤링에 대해 알 수 있어 시간 가는 줄 몰랐던 주차였다.
역시 익숙한 것은 쉽고, 새로운 것은 어렵다. 하지만 새로운 것을 마주하는 것에 익숙해져야겠지.

다음 주는 시각화다. 맷플롯립, 구글 애널리틱스부터 태블로까지!!
정말 필요로 했던 부분이자 나의 취약점이다. 완전히 내 것으로 만든다는 생각으로 열심히 하자!