Recording Study Log

[251027] 66일차

junecho — Mon, 27 Oct 2025 20:03:33 +0900

코드카타 2문제 풀고 100번에 진입함

쉬운 문제였어서 코드는 안 올림

실은 이거 올리고 싶어서 글씀

우하핫 PPT 처음 보여드릴 때도 엄청 칭찬하셨었는데, 서면 피드백에서도 또 칭찬 받았다^ㅡ^v

전처리 메인으로 2차 플젝 때 처음 해본건데 정말… 전처리란 섬세하고 민감한 사람만이 잘 할 수 있는것 같음

나같이 응대충햐~ 하는 사람이 하기에는 너무나도 센시티브한 녀석임

태블로랑 크롤링 세션은 …어떻게 글로 정리해야 할 지 감이 안와서 정리를 못하겠음

~대충 감으로 익히는중~

아 크롤링 과제하다가 엄청 헤맸던 거 올려놔야겠다

disabled OPEN_MAP_AND_LOCAL service

API 요청 실패: 401 - {"errorType":"AccessDeniedError","message":"KA Header is required but neither os nor origin field is given”

계속 뜨던 에러들……………………칷

DOG같은 카카오 API 인증 이것 때문에 1시간 넘게 허비했음

https://developers.kakao.com/console/app

→ 앱 → 앱 설정 → 앱 → 추가 기능 신청 → 카카오맵 → 신청 → 상태 ON

[251024] QCC

junecho — Fri, 24 Oct 2025 16:06:45 +0900

CODEKATA

정말 간만의 TIL 이라고 쓰고 그냥 QCC 기록용

와…SQL 한동안 안했더니 기억이 잘 안났음 어떡하냐

코드카타 할 시간은 없는데 팀프로젝트는 해야되고 자격증 시험 공부도 해야되고 아~~~

바쁘다 바빠 현대인의 삶

현대인 말고 원시인하면 안될까요

팀장이 되어버렸음……………………………………

OMG.

내가 팀장하면 독재자 된다고 했는데 때론 그것도 필요하대 ㅠㅠㅠ

일정 관리 못한다니까 일정 관리 서포터 해준다고 팀장하래 ~~~~

ㅠㅠ

근데 다른 사람들은 내가 팀장 됐다고 하니까 다 좋아한다 나쁜 사람들

SELECT COUNT(gnp - gnpold) AS country_count
FROM country
WHERE 
  gnpold IS NOT NULL AND gnpold != 0 AND
  population >= 10000000 AND (gnp - gnpold) < 0

SELECT district, ROUND(AVG(population)) AS average_population
FROM city
GROUP BY district
HAVING COUNT(name) >= 3
ORDER BY ROUND(AVG(population)) DESC

⇒

2번 문제 ORDER BY 해도 뭔가 정렬이 이상하게 보였음 왜지

처음엔 ORDER BY average_population 이렇게 했다가 정렬 이상해서

보험으로 ROUND(AVG(population)) 라곤 했는데 보이는 결과는 똑같았음...

ROUND가 아니라 다른걸 썼어야 했나.....?

WITH cond AS (
  SELECT cr.continent AS continent, MAX(ct.population) AS max_population
  FROM country cr LEFT JOIN city ct on cr.code = ct.countrycode
  WHERE ct.name IS NOT NULL
  GROUP BY cr.continent
)

SELECT ct.name AS city_name, cr.name AS country_name, cr.continent, cd.max_population AS population
FROM 
  country cr JOIN city ct ON cr.code = ct.countrycode 
  JOIN cond cd ON cr.continent = cd.continent 
  AND ct.population = cd.max_population
ORDER BY population DESC

⇒

처음엔 WITH 없이 그냥 MAX로 뽑았다가 MAX population이랑 city랑 맞지 않는걸 보고

WITH로 MAX population해서 city찾고 본문에서는 JOIN 시켜버림

튜터님 코드

SELECT CityName AS city_name, CountryName AS country_name, Continent AS continent_name, Population AS population
FROM (
    SELECT
        c.Name AS CityName, co.Name AS CountryName, co.Continent, c.Population,
        ROW_NUMBER() OVER (PARTITION BY co.Continent ORDER BY c.Population DESC) AS PopulationRank
    FROM qcc.country co
    JOIN qcc.city c ON c.CountryCode = co.Code
) ranked_cities
WHERE PopulationRank = 1
ORDER BY Population DESC

[251002] 통계검정 실습 01 - t-test

junecho — Thu, 2 Oct 2025 23:38:55 +0900

✅ t-test

두 그룹 간 평균의 차이가 통계적으로 유의미한지를 검정하는 방법

실제로 차이가 있는지, 우연인지 판단

이론

수행 단계

1️⃣ 표본 크기에 따른 정규성 확인

n < 30 : Shapiro-Wilk test 필수 ⇒ p > 0.05 일시 t-test
30 ≤ n < 100 : 왜도/첨도 확인 ⇒ 왜도<1, 첨도<2 일시 t-test
n ≥ 100 : 중심극한정리 적용 ⇒ 왜도 < 2 일시 t-test

2️⃣ 정규성 검정 stats.shapiro()

p > 0.05 : 정규분포 ⇒ t-test
p ≤ 0.05 : 비정규분포 ⇒ 비모수검정

3️⃣ 등분산성 검정 (독립표본만) stats.levene

Levene's test p > 0.05 ⇒ equal_var=True (Student’s t-test)
Levene's test p ≤ 0.05 ⇒ equal_var=False (Welch's t-test)

4️⃣ 결과해석

p-value < 0.05 ⇒ 유의한 차이 있음
Cohen's d로 효과 크기 확인 (0.2: 작음, 0.5: 중간, 0.8: 큼)

종류

종류	사용처	함수	예시
독립표본 t-test	두 독립 그룹 비교	ttest_ind()	와인 종류별 알코올 도수
대응표본 t-test	같은 대상의 전후 비교	ttest_rel()	치료 전후 혈당 수치
단일표본 t-test	한 그룹과 기준값 비교	ttest_1samp()	평균 알코올 도수 13도인지?

정규성 확인을 위한 Q-Q Plot 이해와 해석

Quantile-Quantile Plot : 데이터가 정규분포를 따르는지 시각적으로 확인하는 도구

X축 : 이론적 정규분포 분위수 (정규분포 기준)
Y축 : 실제 데이터 분위수
핵심 : 데이터가 정규분포를 따르면 점들이 직선에 가깝게 배열
왜도 (Skewness)
- : 데이터 분포의 비대칭 정도를 나타내는 통계량
- 0에 가까울 수록 분포가 대칭적(정규분포)
- ∩ 모양 → Left-skew 왼쪽 긴 꼬리
- ∪ 모양 → Right-skew 오른쪽 긴 꼬리
첨도 (Kurtosis)
- : 데이터 분포의 꼬리 두께와 중심부의 뾰족함 정도를 나타내는 통계량
- 정규 분포의 첨도 : 일반적으로 3.
- 양 끝 ↓ → Light Tailed (극단값 ↓)
- 양 끝 ↑ → Heavy Tailed (극단값 ↑)

패턴명	Q-Q Plot 모양	의미	대응방법
Normal	직선	정규분포	t-test
Light Tail 가벼운 꼬리	S자	극단값 ↓	큰 문제 ❌
Heavy Tail 무거운 꼬리	역S자	극단값 ↑	비모수 검정 고려
Left-skew	∩ 모양	음의 왜도	제곱 변환 고려
Right-skew	∪ 모양	양의 왜도	로그 변환 고려
Bimodal	계단 모양	이산형 데이터	비모수 검정 권장

https://jtr13.github.io/EDAVold/qqplot.html

p-value Cohen’s d

구분	p-value (통계적 유의성)	Cohen’s d (실질적 유의성)
핵심 질문	“이 결과가 우연인가?”	“이 차이가 실무적으로 중요한가?”
특징	표본 크기에 민감	표본 크기와 무관한 표준화 지표
장단점	차이의 크기를 알 수 ❌	실제 영향력의 크기를 보여줌

비모수 검정 대안

종류	사용처	함수
독립표본 t-test	Mann-Whitney U test	mannwhitneyu()
대응표본 t-test	Wilcoxon signed-rank test	wilcoxon()
단일표본 t-test	One-sample Wilcoxon test	wilcoxon(data-기준값)

실무 팁

1️⃣ 시각화 우선 : 데이터 분포를 먼저 확인 (박스플롯, 히스토그램, Q-Q Plot)

2️⃣ Q-Q Plot + Shapiro-Wilk 조합

: 정량적 검정과 시각적 확인을 함께함. stats.shapiro()
불확실하면 Welch’s t-test : stats.ttest_ind(equal_var=False) 가 더 안전

3️⃣ p-value + 효과 크기 : 통계적 유의성과 실제적 중요성을 함께 평가

4️⃣ 애매하면 비모수 : 정규성이 의심스러우면 비모수 검정이 안전

코드

# 필수 라이브러리 Import
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
from scipy import stats
from scipy.stats import shapiro, levene, ttest_ind, ttest_rel, ttest_1samp
from scipy.stats import mannwhitneyu, wilcoxon
from sklearn.datasets import load_wine, load_iris, load_diabetes
import warnings
import platform

warnings.filterwarnings('ignore')

# 운영체제별 한글 폰트 설정
if platform.system() == 'Windows':
    plt.rcParams['font.family'] = 'Malgun Gothic'
elif platform.system() == 'Darwin':  # macOS
    plt.rcParams['font.family'] = 'AppleGothic'
else:  # Linux
    plt.rcParams['font.family'] = 'NanumGothic'

# 마이너스 기호 깨짐 방지
plt.rcParams['axes.unicode_minus'] = False

# 시각화 기본 설정
plt.rcParams['figure.figsize'] = (12, 4)

# 전역 시드 설정 (재현성을 위해)
np.random.seed(42)

print("="*50)
print("라이브러리 로드 완료!")
print("한글 폰트 설정 완료!")
print("="*50)

정규성 판단 도우미 함수

# 정규성 판단 도우미 함수
def check_normality_simple(data, name="데이터"):
    # NaN 체크
    if pd.isna(data).any():
        print(f"⚠️ 경고: {name}에 NaN 값이 {pd.isna(data).sum()}개 포함됨")
        data = data.dropna()
        print(f"   → NaN 제거 후 n={len(data)}")
    
    n = len(data)
    
    print(f"\\n[{name} 정규성 검정] n={n}")
    print("-"*40)
    
    # 왜도와 첨도
    skew = stats.skew(data)
    kurt = stats.kurtosis(data, fisher=True)
    print(f"왜도(Skewness): {skew:.3f}")
    print(f"첨도(Kurtosis): {kurt:.3f}")
    
    # 표본 크기에 따른 판단
    if n < 30:
        stat, p = shapiro(data)
        print(f"Shapiro-Wilk p-value: {p:.4f}")
        is_normal = p > 0.05
        reason = f"Shapiro p={'>' if is_normal else '≤'}0.05"
    elif n < 100:
        if abs(skew) < 1 and abs(kurt) < 2:
            is_normal = True
            reason = "|왜도|<1, |첨도|<2"
        else:
            stat, p = shapiro(data)
            print(f"추가 Shapiro-Wilk p-value: {p:.4f}")
            is_normal = p > 0.05
            reason = f"Shapiro p={'>' if is_normal else '≤'}0.05"
    else:
        is_normal = abs(skew) < 2
        reason = f"|왜도|{'<' if is_normal else '≥'}2 (중심극한정리)"
    
    print(f"결과: {'✅ 정규분포 가정 충족' if is_normal else '❌ 정규분포 가정 위반'} ({reason})")
    return is_normal

Parameters
- data : 정규성을 검정할 데이터 (Null 자동 제거)
- name : 출력 시 표시될 데이터 이름. str, default=”데이터”
bool
- True : 정규분포 가정 가능 (모수 검정)
- False : 정규분포 가정 위반 (비모수 검정)
검정 기준
- n < 30 : Shapiro-Wilk 검정 (p > 0.05)
- 30 ≤ n < 100 : 왜도/첨도 우선, 필요시 Shapiro-Wilk
- n ≥ 100 : 왜도 기준 ( ㅣ왜도ㅣ< 2, 중심극한정리)

실습 01 : Wine 데이터로 독립표본 t-test

❓ 클래스 0과 클래스1 와인의 알코올 도수에 차이 있는가 ❓

print("\\n" + "="*60)
print("실습 1: Wine 데이터 - 독립표본 t-test")
print("="*60)

# Wine 데이터 로드
wine = load_wine()
wine_df = pd.DataFrame(wine.data, columns=wine.feature_names)
wine_df['class'] = wine.target

print(f"\\n데이터 크기: {wine_df.shape}")
print(f"클래스: {wine.target_names.tolist()}")
print("\\n특징 변수 (처음 5개):")
for i, feature in enumerate(wine.feature_names[:5]):
    print(f"  {i+1}. {feature}")

# 클래스 0과 1의 알코올 도수 비교
class0_alcohol = wine_df[wine_df['class'] == 0]['alcohol']
class1_alcohol = wine_df[wine_df['class'] == 1]['alcohol']

# 기초 통계량 테이블
stats_table = pd.DataFrame({
    '구분': ['Class 0', 'Class 1'],
    '샘플수': [len(class0_alcohol), len(class1_alcohol)],
    '평균': [class0_alcohol.mean(), class1_alcohol.mean()],
    '표준편차': [class0_alcohol.std(), class1_alcohol.std()],
    '최소값': [class0_alcohol.min(), class1_alcohol.min()],
    '최대값': [class0_alcohol.max(), class1_alcohol.max()]
})

print("\\n[알코올 도수 기초 통계량]")
display(stats_table.round(2))

# 시각화
fig, axes = plt.subplots(1, 3, figsize=(14, 5))

# 박스플롯
bp = axes[0].boxplot([class0_alcohol, class1_alcohol], 
                      labels=['Class 0', 'Class 1'],
                      patch_artist=True)
bp['boxes'][0].set_facecolor("#aed6df")
bp['boxes'][1].set_facecolor("#fea188")
axes[0].set_ylabel('알코올 도수')
axes[0].set_title('알코올 도수 분포')
axes[0].grid(True, alpha=0.3)

# 히스토그램
axes[1].hist(class0_alcohol, bins=10, alpha=0.6, label='Class 0', 
             color="#0063b2", density=True, edgecolor='black')
axes[1].hist(class1_alcohol, bins=10, alpha=0.6, label='Class 1', 
             color="#e94b3c", density=True, edgecolor='black')
axes[1].set_xlabel('알코올 도수')
axes[1].set_ylabel('밀도')
axes[1].set_title('알코올 도수 분포 비교')
axes[1].legend()
axes[1].grid(True, alpha=0.3)

# Q-Q plot (Class 0)
stats.probplot(class0_alcohol, dist="norm", plot=axes[2])
axes[2].set_title('Q-Q Plot (Class 0)')
axes[2].grid(True, alpha=0.3)

# stats.probplot() 함수는 직접적으로 색상 변경 옵션 제공X. SO, 반환된 결과를 사용해 수정해야함
(osm, osr), (slope, intercept, r) = stats.probplot(class0_alcohol, dist="norm", fit=True)
line = axes[2].get_lines()[0]  # 기존 라인 가져오기
axes[2].clear()  # 기존 플롯 지우기

# 새로운 색상으로 마커와 라인 그리기
axes[2].scatter(osm, osr, color='#0063b2', marker='o', alpha=0.7)  # 마커 색상 변경
axes[2].plot(osm, slope * osm + intercept, color='#e94b3c', linewidth=2)  # 선 색상 변경

axes[2].set_title('Q-Q Plot (Class 0)')
axes[2].grid(True, alpha=0.3)
plt.show()

1️⃣ 표본 크기에 따른 정규성 확인

2️⃣ 정규성 검정

print("\\n" + "="*50)
print("가설검정 프로세스")
print("="*50)

# Step 1: 정규성 검정
is_normal_0 = check_normality_simple(class0_alcohol, "Class 0 알코올")
is_normal_1 = check_normality_simple(class1_alcohol, "Class 1 알코올")

3️⃣ 등분산성 검정 (독립표본만) stats.levene

# Step 2: 등분산성 검정
print("\\n[등분산성 검정]")
print("-"*40)
stat, p_levene = levene(class0_alcohol, class1_alcohol)
print(f"Levene's test p-value: {p_levene:.4f}")
equal_var = p_levene > 0.05
print(f"결과: {'✅ 등분산 가정 충족' if equal_var else '❌ 이분산 → Welch t-test 사용'}")

4️⃣ 가설검정 ttest_ind(equal_var=equal_var)

5️⃣ 결론 도출

# =============================================================================
# Step 3: 가설검정
# =============================================================================
print("\\n[가설검정]")
print("-"*40)

# 가설 설정
print("H₀: μ₀ = μ₁ (두 클래스의 알코올 도수가 같다)")
print("H₁: μ₀ ≠ μ₁ (두 클래스의 알코올 도수가 다르다)")
print("유의수준: α = 0.05")

# -----------------------------------------------------------------------------
# 3-1. 검정 방법 선택 및 실행
# -----------------------------------------------------------------------------
# 정규성 검정 결과에 따라 모수/비모수 검정 선택
if is_normal_0 and is_normal_1:
    # 모수 검정: 독립표본 t-검정 (두 그룹 모두 정규분포)
    t_stat, p_value = ttest_ind(class0_alcohol, class1_alcohol, equal_var=equal_var)
    test_name = "Student's t-test" if equal_var else "Welch's t-test"
    print(f"\\n{test_name} 결과:")
    print(f"t = {t_stat:.4f}, p = {p_value:.4f}")
    
    # Cohen's d 효과 크기 계산 (표준화된 평균 차이)
    # d = (평균1 - 평균2) / 합동표준편차
    pooled_std = np.sqrt((class0_alcohol.var() + class1_alcohol.var()) / 2)
    cohens_d = (class0_alcohol.mean() - class1_alcohol.mean()) / pooled_std
    abs_d = abs(cohens_d)
    
    # Cohen's d 해석 기준
    if abs_d < 0.2:
        effect = "매우 작은 효과"
    elif abs_d < 0.5:
        effect = "작은 효과"
    elif abs_d < 0.8:
        effect = "중간 효과"
    else:
        effect = "큰 효과"
    
    print(f"Cohen's d = {cohens_d:.3f} ({effect})")

else:
    # 비모수 검정: Mann-Whitney U 검정 (정규성 가정 위반)
    # 중앙값 차이를 검정 (순위 기반)
    u_stat, p_value = mannwhitneyu(class0_alcohol, class1_alcohol, alternative='two-sided')
    print(f"\\nMann-Whitney U test 결과:")
    print(f"U = {u_stat:.4f}, p = {p_value:.4f}")

# -----------------------------------------------------------------------------
# 3-2. 통계적 결론 도출
# -----------------------------------------------------------------------------
print(f"\\n[결론]")

# p-value를 유의수준(α=0.05)과 비교하여 가설 채택/기각 결정
if p_value < 0.05:
    print(f"✅ p-value({p_value:.4f}) < 0.05 → 귀무가설 기각")
    print(f"   두 클래스의 알코올 도수에 유의한 차이가 있음")
    print(f"   (통계적으로 의미있는 차이 존재)")
else:
    print(f"❌ p-value({p_value:.4f}) ≥ 0.05 → 귀무가설 채택")
    print(f"   두 클래스의 알코올 도수에 유의한 차이가 없음")
    print(f"   (관측된 차이는 우연에 의한 것일 수 있음)")

실습 02 : Diabetes 데이터로 대응표본 t-test

❓ 치료 전후 혈당 수치 변화 있는가 ❓

print("\\n" + "="*60)
print("실습 2: Diabetes 데이터 - 대응표본 t-test")
print("="*60)

# Diabetes 데이터 로드 및 가상의 전후 데이터 생성
diabetes = load_diabetes()

# 30명 환자의 치료 전 혈당 (표준화된 값)
n_patients = 30
before_glucose = diabetes.target[:n_patients]

# 치료 후 혈당 (평균적으로 감소하는 가상의 데이터 생성)
treatment_effect = np.random.normal(-15, 5, n_patients)  # 평균 15 감소
after_glucose = before_glucose + treatment_effect

# DataFrame 생성
treatment_df = pd.DataFrame({
    '환자ID': [f'P{i:03d}' for i in range(1, n_patients+1)],
    '치료전': before_glucose,
    '치료후': after_glucose,
    '변화량': after_glucose - before_glucose
})

print("\\n[데이터 샘플 (처음 5명)]")
display(treatment_df.head())

print("\\n[기초 통계량]")
stats_summary = pd.DataFrame({
    '구분': ['치료 전', '치료 후', '변화량'],
    '평균': [treatment_df['치료전'].mean(), 
            treatment_df['치료후'].mean(),
            treatment_df['변화량'].mean()],
    '표준편차': [treatment_df['치료전'].std(),
                treatment_df['치료후'].std(),
                treatment_df['변화량'].std()]
})
display(stats_summary.round(2))

# 시각화
fig, axes = plt.subplots(1, 3, figsize=(14, 5))

# Before-After 연결선 그래프
for i in range(len(treatment_df)):
    axes[0].plot([0, 1], [treatment_df.iloc[i]['치료전'], treatment_df.iloc[i]['치료후']], 
                'gray', alpha=0.4, linewidth=0.8)
axes[0].plot([0, 1], [treatment_df['치료전'].mean(), treatment_df['치료후'].mean()], 
            'red', linewidth=3, marker='o', markersize=8, label='평균')
axes[0].set_xticks([0, 1])
axes[0].set_xticklabels(['치료 전', '치료 후'])
axes[0].set_ylabel('혈당 수치')
axes[0].set_title('개인별 변화')
axes[0].legend()
axes[0].grid(True, alpha=0.3)

# 박스플롯
bp = axes[1].boxplot([treatment_df['치료전'], treatment_df['치료후']], 
                     labels=['치료 전', '치료 후'],
                     patch_artist=True)
bp['boxes'][0].set_facecolor("#ead98b")
bp['boxes'][1].set_facecolor("#7dd0b6")
axes[1].set_ylabel('혈당 수치')
axes[1].set_title('혈당 분포')
axes[1].grid(True, alpha=0.3)

# 변화량 히스토그램
axes[2].hist(treatment_df['변화량'], bins=10, edgecolor='black', alpha=0.7, color="#93c763")
axes[2].axvline(0, color='red', linestyle='--', linewidth=2, label='변화 없음')
axes[2].axvline(treatment_df['변화량'].mean(), color='blue', linestyle='--', 
               linewidth=2, label=f'평균: {treatment_df["변화량"].mean():.1f}')
axes[2].set_xlabel('혈당 변화량')
axes[2].set_ylabel('빈도')
axes[2].set_title('변화량 분포')
axes[2].legend()
axes[2].grid(True, alpha=0.3)

plt.tight_layout()
plt.show()

1️⃣ 표본 크기에 따른 정규성 확인

2️⃣ 정규성 검정

print("\\n" + "="*50)
print("가설검정 프로세스")
print("="*50)

# Step 1: 변화량의 정규성 검정
is_normal_diff = check_normality_simple(treatment_df['변화량'], "변화량")

3️⃣ 가설검정 ttest_rel()

4️⃣ 결론 도출

# =============================================================================
# Step 2: 가설검정
# =============================================================================
print("\\n[가설검정]")
print("-"*40)

# 가설 설정 (대응표본 검정)
print("H₀: μ_before = μ_after (치료 효과 없음)")
print("H₁: μ_before ≠ μ_after (치료 효과 있음)")
print("유의수준: α = 0.05")

# -----------------------------------------------------------------------------
# 2-1. 검정 방법 선택 및 실행
# -----------------------------------------------------------------------------
# 차이값의 정규성에 따라 모수/비모수 검정 선택
if is_normal_diff:
    # 모수 검정: 대응표본 t-검정 (차이값이 정규분포)
    # 동일 대상의 전후 비교이므로 paired t-test 사용
    t_stat, p_value = ttest_rel(treatment_df['치료전'], treatment_df['치료후'])
    print(f"\\nPaired t-test 결과:")
    print(f"t = {t_stat:.4f}, p = {p_value:.4f}")
    
    # -------------------------------------------------------------------------
    # 2-2. 효과 크기 계산 (Cohen's d for paired samples)
    # -------------------------------------------------------------------------
    # 대응표본의 Cohen's d = 평균 변화량 / 변화량의 표준편차
    cohens_d = treatment_df['변화량'].mean() / treatment_df['변화량'].std()
    abs_d = abs(cohens_d)
    
    # Cohen's d 해석 기준 (대응표본)
    if abs_d < 0.2:
        effect = "매우 작은 효과"
    elif abs_d < 0.5:
        effect = "작은 효과"  
    elif abs_d < 0.8:
        effect = "중간 효과"
    else:
        effect = "큰 효과"
    
    print(f"Cohen's d = {cohens_d:.3f} ({effect})")
    
    # -------------------------------------------------------------------------
    # 2-3. 신뢰구간 계산
    # -------------------------------------------------------------------------
    # 평균 변화량의 95% 신뢰구간 추정
    # CI = 평균 ± t(α/2, df) × SE
    confidence = 0.95  # 신뢰수준
    n = len(treatment_df)  # 표본 크기
    mean_diff = treatment_df['변화량'].mean()  # 평균 변화량
    se_diff = stats.sem(treatment_df['변화량'])  # 표준오차
    
    # t-분포 기반 신뢰구간 (자유도 = n-1)
    ci = stats.t.interval(confidence, n-1, loc=mean_diff, scale=se_diff)
    print(f"평균 변화의 95% CI: [{ci[0]:.2f}, {ci[1]:.2f}]")
    
else:
    # 비모수 검정: Wilcoxon 부호순위 검정 (정규성 가정 위반)
    # 중앙값 차이를 검정 (순위와 부호 기반)
    w_stat, p_value = wilcoxon(treatment_df['치료전'], treatment_df['치료후'])
    print(f"\\nWilcoxon signed-rank test 결과:")
    print(f"W = {w_stat:.4f}, p = {p_value:.4f}")

# -----------------------------------------------------------------------------
# 2-4. 통계적 결론 도출
# -----------------------------------------------------------------------------
print(f"\\n[결론]")

# p-value를 유의수준(α=0.05)과 비교하여 가설 채택/기각 결정
if p_value < 0.05:
    print(f"✅ p-value({p_value:.4f}) < 0.05 → 귀무가설 기각")
    print(f"   치료가 효과가 있음 (평균 {abs(treatment_df['변화량'].mean()):.1f} 감소)")
    print(f"   (통계적으로 유의한 개선 효과)")
else:
    print(f"❌ p-value({p_value:.4f}) ≥ 0.05 → 귀무가설 채택")
    print(f"   치료 효과가 유의하지 않음")
    print(f"   (관측된 변화는 우연에 의한 것일 수 있음)")

실습 03 : Iris 데이터로 단일표본 t-test

❓ Setosa 종의 평균 꽃받침 길이가 5.0cm인가 검정 ❓

print("\\n" + "="*60)
print("실습 3: Iris 데이터 - 단일표본 t-test")
print("="*60)

# Iris 데이터 로드
iris = load_iris()
iris_df = pd.DataFrame(iris.data, columns=iris.feature_names)
iris_df['species'] = iris.target

# Setosa 종의 꽃받침 길이
setosa_sepal = iris_df[iris_df['species'] == 0]['sepal length (cm)']
target_value = 5.0  # 검정할 기준값

print(f"[Setosa 꽃받침 길이 정보]")
print(f"샘플 수: {len(setosa_sepal)}")
print(f"평균: {setosa_sepal.mean():.3f}cm")
print(f"표준편차: {setosa_sepal.std():.3f}cm")
print(f"중앙값: {setosa_sepal.median():.3f}cm")
print(f"검정 기준값: {target_value}cm")

# 시각화
fig, axes = plt.subplots(1, 3, figsize=(14, 5))

# 히스토그램
axes[0].hist(setosa_sepal, bins=12, edgecolor='black', alpha=0.7, color="#aed6df")
axes[0].axvline(target_value, color='red', linestyle='--', linewidth=2, label=f'기준값: {target_value}cm')
axes[0].axvline(setosa_sepal.mean(), color='green', linestyle='--', linewidth=2, 
                label=f'평균: {setosa_sepal.mean():.2f}cm')
axes[0].set_xlabel('꽃받침 길이 (cm)')
axes[0].set_ylabel('빈도')
axes[0].set_title('Setosa 꽃받침 길이 분포')
axes[0].legend()
axes[0].grid(True, alpha=0.3)

# 박스플롯
bp = axes[1].boxplot(setosa_sepal, patch_artist=True)
bp['boxes'][0].set_facecolor("#aed6df")
axes[1].axhline(target_value, color='red', linestyle='--', linewidth=2)
axes[1].set_ylabel('꽃받침 길이 (cm)')
axes[1].set_title('박스플롯')
axes[1].text(1.1, target_value+0.05, f'기준값: {target_value}', color='red')
axes[1].grid(True, alpha=0.3)

# Q-Q plot
stats.probplot(setosa_sepal, dist="norm", plot=axes[2])
axes[2].set_title('Q-Q Plot')
axes[2].grid(True, alpha=0.3)

plt.tight_layout()
plt.show()

1️⃣ 표본 크기에 따른 정규성 확인

2️⃣ 정규성 검정

print("\\n" + "="*50)
print("가설검정 프로세스")
print("="*50)

# Step 1: 정규성 검정
is_normal = check_normality_simple(setosa_sepal, "Setosa 꽃받침 길이")

3️⃣ 가설검정 ttest_1smap

4️⃣ 결론 도출

# =============================================================================
# Step 2: 가설검정
# =============================================================================
print("\\n[가설검정]")
print("-"*40)

# 가설 설정 (단일표본 검정)
# 표본 평균이 특정 값(target_value)과 같은지 검정
print(f"H₀: μ = {target_value}cm (평균이 {target_value}cm)")
print(f"H₁: μ ≠ {target_value}cm (평균이 {target_value}cm가 아님)")
print("유의수준: α = 0.05")

# -----------------------------------------------------------------------------
# 2-1. 검정 방법 선택 및 실행
# -----------------------------------------------------------------------------
# 정규성 검정 결과에 따라 모수/비모수 검정 선택
if is_normal:
    # 모수 검정: 단일표본 t-검정 (데이터가 정규분포)
    # 표본 평균과 모집단 평균(target_value)을 비교
    t_stat, p_value = ttest_1samp(setosa_sepal, target_value)
    print(f"\\nOne-sample t-test 결과:")
    print(f"t = {t_stat:.4f}, p = {p_value:.4f}")
    
    # -------------------------------------------------------------------------
    # 2-2. 신뢰구간 계산 및 해석
    # -------------------------------------------------------------------------
    # 모평균의 95% 신뢰구간 추정
    # CI = 표본평균 ± t(α/2, df) × SE
    confidence = 0.95  # 신뢰수준
    n = len(setosa_sepal)  # 표본 크기
    mean = setosa_sepal.mean()  # 표본 평균
    se = stats.sem(setosa_sepal)  # 표준오차 (SE = s/√n)
    
    # t-분포 기반 신뢰구간 (자유도 = n-1)
    ci = stats.t.interval(confidence, n-1, loc=mean, scale=se)
    print(f"평균의 95% CI: [{ci[0]:.3f}, {ci[1]:.3f}]cm")
    
    # 신뢰구간과 목표값 비교
    # 목표값이 신뢰구간 내에 있으면 H₀를 기각할 수 없음
    if ci[0] <= target_value <= ci[1]:
        print(f"→ {target_value}cm가 신뢰구간 내에 있음")
    else:
        print(f"→ {target_value}cm가 신뢰구간 밖에 있음")
        
else:
    # 비모수 검정: Wilcoxon 부호순위 검정 (정규성 가정 위반)
    # 중앙값이 목표값과 같은지 검정 (순위와 부호 기반)
    
    # 각 관측값과 목표값의 차이 계산
    differences = setosa_sepal - target_value
    
    # Wilcoxon 부호순위 검정 실행
    # 차이의 절댓값에 순위를 매기고, 부호를 고려하여 검정
    w_stat, p_value = wilcoxon(differences)
    print(f"\\nWilcoxon signed-rank test 결과:")
    print(f"W = {w_stat:.4f}, p = {p_value:.4f}")

# -----------------------------------------------------------------------------
# 2-3. 통계적 결론 도출
# -----------------------------------------------------------------------------
print(f"\\n[결론]")

# p-value를 유의수준(α=0.05)과 비교하여 가설 채택/기각 결정
if p_value < 0.05:
    print(f"✅ p-value({p_value:.4f}) < 0.05 → 귀무가설 기각")
    
    # 차이의 방향 확인 (평균이 목표값보다 높은지 낮은지)
    diff = setosa_sepal.mean() - target_value
    if diff > 0:
        print(f"   평균({setosa_sepal.mean():.3f}cm)이 {target_value}cm보다 유의하게 높음")
    else:
        print(f"   평균({setosa_sepal.mean():.3f}cm)이 {target_value}cm보다 유의하게 낮음")
    print(f"   (통계적으로 의미있는 차이 존재)")
    
else:
    print(f"❌ p-value({p_value:.4f}) ≥ 0.05 → 귀무가설 채택")
    print(f"   평균이 {target_value}cm와 유의한 차이가 없음")
    print(f"   (관측된 차이는 우연에 의한 것일 수 있음)")

실습 04 : Wine 데이터 다중 비교

# =============================================================================
# 추가 실습: Wine 데이터에서 여러 특징 비교
# =============================================================================
print("\\n" + "="*60)
print("추가 실습: Wine 데이터에서 여러 특징 비교")
print("="*60)

# -----------------------------------------------------------------------------
# 1. 비교할 특징 설정 및 반복 검정
# -----------------------------------------------------------------------------
# Class 0과 Class 1 간 여러 특징을 한 번에 비교
features_to_compare = ['malic_acid', 'ash', 'total_phenols', 'flavanoids']

# 결과를 저장할 리스트
results = []

# 각 특징에 대해 독립표본 t-검정 수행
for feature in features_to_compare:
    # -------------------------------------------------------------------------
    # 1-1. 데이터 추출
    # -------------------------------------------------------------------------
    class0_data = wine_df[wine_df['class'] == 0][feature]
    class1_data = wine_df[wine_df['class'] == 1][feature]
    
    # -------------------------------------------------------------------------
    # 1-2. 등분산 검정 (Levene's test)
    # -------------------------------------------------------------------------
    # 두 그룹의 분산이 같은지 검정하여 적절한 t-test 선택
    _, p_levene = levene(class0_data, class1_data)
    equal_var = p_levene > 0.05  # p > 0.05면 등분산 가정
    
    # -------------------------------------------------------------------------
    # 1-3. 독립표본 t-검정 수행
    # -------------------------------------------------------------------------
    # equal_var에 따라 Student's t-test 또는 Welch's t-test 실행
    t_stat, p_value = ttest_ind(class0_data, class1_data, equal_var=equal_var)
    
    # -------------------------------------------------------------------------
    # 1-4. 효과 크기 계산 (Cohen's d)
    # -------------------------------------------------------------------------
    # 표준화된 평균 차이 = (평균1 - 평균2) / 합동표준편차
    pooled_std = np.sqrt((class0_data.var() + class1_data.var()) / 2)
    cohens_d = (class0_data.mean() - class1_data.mean()) / pooled_std
    
    # Cohen's d 해석 기준
    abs_d = abs(cohens_d)
    if abs_d < 0.2:
        effect = "매우 작음"
    elif abs_d < 0.5:
        effect = "작음"
    elif abs_d < 0.8:
        effect = "중간"
    else:
        effect = "큼"
    
    # -------------------------------------------------------------------------
    # 1-5. 결과 저장
    # -------------------------------------------------------------------------
    results.append({
        '특징': feature,
        'Class0 평균': class0_data.mean(),
        'Class1 평균': class1_data.mean(),
        '차이': class0_data.mean() - class1_data.mean(),
        't값': t_stat,
        'p-value': p_value,
        "Cohen's d": cohens_d,
        '효과크기': effect,
        '유의성': '유의함' if p_value < 0.05 else '유의하지 않음'
    })

# -----------------------------------------------------------------------------
# 2. 결과 정리 및 출력
# -----------------------------------------------------------------------------
# 결과를 DataFrame으로 변환하여 가독성 향상
results_df = pd.DataFrame(results)
results_df = results_df.round(4)  # 소수점 4자리로 반올림

print("\\n[Class 0 vs Class 1 비교 결과]")
# 핵심 정보만 선택하여 표시
display(results_df[['특징', '차이', 'p-value', "Cohen's d", '효과크기', '유의성']])

# -----------------------------------------------------------------------------
# 3. 시각화: p-value 및 효과 크기 비교
# -----------------------------------------------------------------------------
fig, ax = plt.subplots(figsize=(10, 6))

# -------------------------------------------------------------------------
# 3-1. p-value 막대 그래프
# -------------------------------------------------------------------------
# 유의한 결과(p<0.05)는 빨간색, 그렇지 않으면 회색으로 표시
colors = ['red' if p < 0.05 else 'gray' for p in results_df['p-value']]
bars = ax.bar(range(len(results_df)), results_df['p-value'], color=colors)

# 유의수준 기준선 (α = 0.05)
ax.axhline(0.05, color='black', linestyle='--', label='p=0.05')

# x축 레이블 설정
ax.set_xticks(range(len(results_df)))
ax.set_xticklabels(results_df['특징'], rotation=45)
ax.set_ylabel('p-value')
ax.set_title('각 특징별 유의성 검정 결과')
ax.legend()

# -------------------------------------------------------------------------
# 3-2. 막대 위에 Cohen's d 값 표시
# -------------------------------------------------------------------------
# 각 막대 위에 효과 크기를 텍스트로 추가
for i, (bar, d) in enumerate(zip(bars, results_df["Cohen's d"])):
    ax.text(bar.get_x() + bar.get_width()/2, bar.get_height() + 0.01,
            f'd={d:.2f}', ha='center', va='bottom')

plt.tight_layout()
plt.show()

self 실습

self 실습 01 : 레스토랑 매출 비교

❓ 주말(토,일)과 평일(월~금)의 일일 평균 매출에 차이가 있는가? ❓

⇒ 두 독립 그룹의 비교니까 ttest_ind() 사용하기?

# 가상의 레스토랑 매출 데이터 생성
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
from scipy import stats
from scipy.stats import shapiro, levene, ttest_ind

np.random.seed(42)

# 4주간의 데이터 (28일)
days = ['월', '화', '수', '목', '금', '토', '일'] * 4
dates = pd.date_range('2024-01-01', periods=28)

# 평일은 평균 100만원, 주말은 평균 130만원 매출 (단위: 만원)
daily_sales = []
for day in days:
    if day in ['토', '일']:
        # 주말: 평균 130, 표준편차 20
        sale = np.random.normal(130, 20)
    else:
        # 평일: 평균 100, 표준편차 15
        sale = np.random.normal(100, 15)
    daily_sales.append(sale)

# DataFrame 생성
sales_df = pd.DataFrame({
    '날짜': dates,
    '요일': days,
    '매출액': daily_sales,
    '주말여부': ['주말' if d in ['토', '일'] else '평일' for d in days]
})

# 주말과 평일 데이터 분리
weekend_sales = sales_df[sales_df['주말여부'] == '주말']['매출액']
weekday_sales = sales_df[sales_df['주말여부'] == '평일']['매출액']

print("="*60)
print("실습 문제 1: 레스토랑 매출 비교")
print("="*60)
print(f"\\n데이터 기간: 4주 (28일)")
print(f"평일(월~금) 데이터: n={len(weekday_sales)}")
print(f"주말(토,일) 데이터: n={len(weekend_sales)}")
print("\\n[데이터 미리보기]")
display(sales_df.head(7))  # 첫 주 데이터

dd = sales_df.groupby(["주말여부"])["매출액"].describe()
dd

cond0 = sales_df[sales_df["주말여부"] == "평일"]["매출액"]
cond1 = sales_df[sales_df["주말여부"] == "주말"]["매출액"]

cond1

# 시각화
fig, axes = plt.subplots(1, 4, figsize=(20, 6))

# 박스플롯
bp = axes[0].boxplot([cond0, cond1], labels=["평일", "주말"], patch_artist=True)
bp["boxes"][0].set_facecolor("#0063b2")
bp["boxes"][1].set_facecolor("#e94b3c")
axes[0].set_title("주말 여부 매출액 차이")
axes[0].grid(axis="y", alpha=0.5)

# 히스토그램
axes[1].hist(cond0, bins=5, alpha=0.6, label="평일", color="#0063b2",
             edgecolor="black", density=True)
axes[1].hist(cond1, bins=5, alpha=0.6, label="평일", color="#e94b3c",
             edgecolor="black", density=True)
axes[1].set_xlabel("매출액")
axes[1].set_title("주말 여부 매출액 차이")
axes[1].grid(axis="y", alpha=0.5)

# Q-Q Plot
stats.probplot(cond0, dist="norm", plot=axes[2])
axes[2].set_title('Q-Q Plot (Class 0)')
axes[2].grid(True, alpha=0.3)

stats.probplot(cond1, dist="norm", plot=axes[3])
axes[3].set_title('Q-Q Plot (Class 0)')
axes[3].grid(True, alpha=0.3)

1️⃣ 표본 크기에 따른 정규성 확인

2️⃣ 정규성 검정

print("\\n" + "="*50)
print("가설검정 프로세스")
print("="*50)

# Step 1: 정규성 검정
is_normal_0 = check_normality_simple(cond0, "평일 매출")
is_normal_1 = check_normality_simple(cond1, "주말 매출")

3️⃣ 등분산성 검정 (독립표본만) stats.levene

# Step 2: 등분산성 검정
print("\\n[등분산성 검정]")
print("-"*40)
stat, p_levene = levene(cond0, cond1)
print(f"Levene's test p-value: {p_levene:.4f}")
equal_var = p_levene > 0.05
print(f"결과: {'✅ 등분산 가정 충족' if equal_var else '❌ 이분산 → Welch t-test 사용'}")

4️⃣ Welch t-test ttest_ind(equal_var=False)

# Step 3: Welch t-test 사용
print("\\n[Welch t-test]")
print("-"*40)
tstat, pval = stats.ttest_ind(cond0, cond1, equal_var=False)
print("평일 vs 주말")
print(f"주말-평일 매출액 : {tstat:.4f}", f"\\np-value : {pval:.4f}")
print("-"*40)

if pval < 0.05:
    print(f"✅ p-value({pval:.4f}) < 0.05 → 귀무가설 기각")
    print(f"    평일 매출액과 주말 매출액은 유의한 차이가 있음")
    print(f"    (통계적으로 의미있는 차이 존재)")
else:
    print(f"❌ p-value({pval:.4f}) ≥ 0.05 → 귀무가설 채택")
    print(f"    평일 매출액과 주말 매출액은 유의한 차이가 없음")
    print(f"    (관측된 차이는 우연에 의한 것일 수 있음)")

5️⃣ 가설검정

6️⃣ 결론 도출

# =============================================================================
# Step 4: 가설검정
# =============================================================================
print("\\n[가설검정]")
print("-"*40)

# 가설 설정
print("H₀: μ₀ = μ₁ (평일 매출액과 주말 매출액은 유의한 차이가 없다)")
print("H₁: μ₀ ≠ μ₁ (평일 매출액과 주말 매출액은 유의한 차이가 있다)")
print("유의수준: α = 0.05")

# -----------------------------------------------------------------------------
# 4-1. 검정 방법 선택 및 실행
# -----------------------------------------------------------------------------
# 정규성 검정 결과에 따라 모수/비모수 검정 선택
if is_normal_0 and is_normal_1:
    # 모수 검정: 독립표본 t-검정 (두 그룹 모두 정규분포)
    t_stat, p_value = ttest_ind(cond0, cond1, equal_var=equal_var)
    test_name = "Student's t-test" if equal_var else "Welch's t-test"
    print(f"\\n{test_name} 결과:")
    print(f"t = {t_stat:.4f}, p = {p_value:.4f}")
    
    # Cohen's d 효과 크기 계산 (표준화된 평균 차이)
    # d = (평균1 - 평균2) / 합동표준편차
    pooled_std = np.sqrt((cond0.var() + cond1.var()) / 2)
    cohens_d = (cond0.mean() - cond1.mean()) / pooled_std
    abs_d = abs(cohens_d)
    
    # Cohen's d 해석 기준
    if abs_d < 0.2:
        effect = "매우 작은 효과"
    elif abs_d < 0.5:
        effect = "작은 효과"
    elif abs_d < 0.8:
        effect = "중간 효과"
    else:
        effect = "큰 효과"
    
    print(f"Cohen's d = {cohens_d:.3f} ({effect})")

else:
    # 비모수 검정: Mann-Whitney U 검정 (정규성 가정 위반)
    # 중앙값 차이를 검정 (순위 기반)
    u_stat, p_value = mannwhitneyu(cond0, cond1, alternative='two-sided')
    print(f"\\nMann-Whitney U test 결과:")
    print(f"U = {u_stat:.4f}, p = {p_value:.4f}")

# -----------------------------------------------------------------------------
# 4-2. 통계적 결론 도출
# -----------------------------------------------------------------------------
print(f"\\n[결론]")

# p-value를 유의수준(α=0.05)과 비교하여 가설 채택/기각 결정
if p_value < 0.05:
    print(f"✅ p-value({p_value:.4f}) < 0.05 → 귀무가설 기각")
    print(f"   두 클래스의 알코올 도수에 유의한 차이가 있음")
    print(f"   (통계적으로 의미있는 차이 존재)")
else:
    print(f"❌ p-value({p_value:.4f}) ≥ 0.05 → 귀무가설 채택")
    print(f"   두 클래스의 알코올 도수에 유의한 차이가 없음")
    print(f"   (관측된 차이는 우연에 의한 것일 수 있음)")

self 실습 02 : 운동 프로그램 효과 평가

❓ 8주 운동 프로그램이 체지방률 감소에 효과가 있는가❓

⇒ 같은 대상의 전후 비교니까 ttest_rel() 사용하기?

# 가상의 데이터 생성 (25명 참가자)
np.random.seed(123)
n_participants = 25

# 프로그램 전 체지방률 (%)
before_fat = np.random.normal(28, 5, n_participants)
before_fat = np.clip(before_fat, 15, 40)  # 현실적인 범위로 제한

# 프로그램 후 체지방률 (평균적으로 2% 감소, 개인차 존재)
reduction = np.random.gamma(2, 1, n_participants)  # 감소량은 양수
after_fat = before_fat - reduction
after_fat = np.clip(after_fat, 10, 39)  # 현실적인 범위로 제한

# DataFrame 생성
fitness_df = pd.DataFrame({
    '참가자ID': [f'ID{i:03d}' for i in range(1, n_participants+1)],
    '운동전_체지방률': before_fat,
    '운동후_체지방률': after_fat,
    '체지방_감소량': before_fat - after_fat
})

print("="*60)
print("실습 문제 2: 운동 프로그램 효과 평가")
print("="*60)
print(f"\\n참가자 수: {n_participants}명")
print("\\n[데이터 샘플]")
display(fitness_df.head())

# 시각화
fig, axes = plt.subplots(1, 3, figsize=(14, 5))

# Before-After 연결선 그래프
for i in range(len(fitness_df)):
    axes[0].plot([0, 1], [fitness_df.iloc[i]["운동전_체지방률"], fitness_df.iloc[i]["운동후_체지방률"]], 
                'gray', alpha=0.4, linewidth=0.8)
axes[0].plot([0, 1], [fitness_df["운동전_체지방률"].mean(), fitness_df["운동후_체지방률"].mean()], 
            'red', linewidth=3, marker='o', markersize=8, label='평균')
axes[0].set_xticks([0, 1])
axes[0].set_xticklabels(["운동 전", "운동 후"])
axes[0].set_ylabel("체지방률")
axes[0].set_title('개인별 변화')
axes[0].legend()
axes[0].grid(True, alpha=0.3)

# 박스플롯
bp = axes[1].boxplot([fitness_df["운동전_체지방률"], fitness_df["운동후_체지방률"]], 
                     labels=["운동 전", "운동 후"], patch_artist=True)
bp['boxes'][0].set_facecolor("#ead98b")
bp['boxes'][1].set_facecolor("#7dd0b6")
axes[1].set_ylabel("체지방률")
axes[1].set_title("체지방률 변화")
axes[1].grid(True, alpha=0.3)

# 변화량 히스토그램
axes[2].hist(fitness_df["체지방_감소량"], bins=10, edgecolor='black', alpha=0.7, color="#93c763")
axes[2].axvline(0, color='red', linestyle='--', linewidth=2, label='변화 없음')
axes[2].axvline(fitness_df["체지방_감소량"].mean(), color='blue', linestyle='--', 
               linewidth=2, label=f'평균: {fitness_df["체지방_감소량"].mean():.1f}')
axes[2].set_xlabel("체지방 감소량")
axes[2].set_ylabel("빈도")
axes[2].set_title("체지방 감소량 분포")
axes[2].legend()
axes[2].grid(True, alpha=0.3)

plt.tight_layout()
plt.show()

1️⃣ 표본 크기에 따른 정규성 확인

2️⃣ 정규성 검정

print("\\n" + "="*50)
print("가설검정 프로세스")
print("="*50)

# Step 1: 변화량의 정규성 검정
is_normal_diff = check_normality_simple(fitness_df["체지방_감소량"], "체지방_감소량")

⇒ 비모수검정 - 윌콕슨 사용해야 함

3️⃣ 가설검정

4️⃣ 윌콕슨

5️⃣ 결론 도출

# =============================================================================
# Step 2: 가설검정
# =============================================================================
print("\\n[가설검정]")
print("-"*40)

# 가설 설정 (대응표본 검정)
print("H₀: μ_before = μ_after (운동 효과 없음)")
print("H₁: μ_before ≠ μ_after (운동 효과 있음)")
print("유의수준: α = 0.05")
alpha = 0.05
# -----------------------------------------------------------------------------
# 2-1. 검정 방법 선택 및 실행
# -----------------------------------------------------------------------------
# 차이값의 정규성에 따라 모수/비모수 검정 선택
if is_normal_diff:
    # 모수 검정: 대응표본 t-검정 (차이값이 정규분포)
    # 동일 대상의 전후 비교이므로 paired t-test 사용
    t_stat, p_value = ttest_rel(fitness_df["운동전_체지방률"], fitness_df["운동후_체지방률"])
    print(f"\\nPaired t-test 결과:")
    print(f"t = {t_stat:.4f}, p = {p_value:.4f}")
    
    # -------------------------------------------------------------------------
    # 2-2. 효과 크기 계산 (Cohen's d for paired samples)
    # -------------------------------------------------------------------------
    # 대응표본의 Cohen's d = 평균 변화량 / 변화량의 표준편차
    cohens_d = fitness_df["체지방_감소량"].mean() / fitness_df["체지방_감소량"].std()
    abs_d = abs(cohens_d)
    
    # Cohen's d 해석 기준 (대응표본)
    if abs_d < 0.2:
        effect = "매우 작은 효과"
    elif abs_d < 0.5:
        effect = "작은 효과"  
    elif abs_d < 0.8:
        effect = "중간 효과"
    else:
        effect = "큰 효과"
    
    print(f"Cohen's d = {cohens_d:.3f} ({effect})")
    
    # -------------------------------------------------------------------------
    # 2-3. 신뢰구간 계산
    # -------------------------------------------------------------------------
    # 평균 변화량의 95% 신뢰구간 추정
    # CI = 평균 ± t(α/2, df) × SE
    confidence = 0.95  # 신뢰수준
    n = len(treatment_df)  # 표본 크기
    mean_diff = fitness_df["체지방_감소량"].mean()  # 평균 변화량
    se_diff = stats.sem(fitness_df["체지방_감소량"])  # 표준오차
    
    # t-분포 기반 신뢰구간 (자유도 = n-1)
    ci = stats.t.interval(confidence, n-1, loc=mean_diff, scale=se_diff)
    print(f"평균 변화의 95% CI: [{ci[0]:.2f}, {ci[1]:.2f}]")
    
else:
# Step 2: 비모수검정 - 윌콕슨 (정규성 가정 위반)
    # 중앙값 차이를 검정 (순위와 부호 기반)
    w_stat, p_value = wilcoxon(fitness_df["운동전_체지방률"], fitness_df["운동후_체지방률"])
    print(f"\\nWilcoxon signed-rank test 결과 :")
    print(f"W = {w_stat:.7f}, p = {p_value:.7f}")

# -----------------------------------------------------------------------------
# 2-4. 통계적 결론 도출
# -----------------------------------------------------------------------------
print(f"\\n[결론]")

# p-value를 유의수준(α=0.05)과 비교하여 가설 채택/기각 결정
if p_value < alpha:
    print(f"✅ p-value({p_value:.4f}) < 0.05 → 귀무가설 기각")
    print(f"   운동 효과가 있음 (평균 {abs(fitness_df['체지방_감소량'].mean()):.1f} 감소)")
    print(f"   (통계적으로 유의한 개선 효과)")
else:
    print(f"❌ p-value({p_value:.4f}) ≥ 0.05 → 귀무가설 채택")
    print(f"   운동 유의하지 않음")
    print(f"   (관측된 변화는 우연에 의한 것일 수 있음)")

self 실습 03 : 제품 품질 검사

❓ 생산된 음료의 실제 용량이 표기 용량(500ml)과 일치하는가❓

⇒ 한 그룹과 기준값의 비교니까 ttest_1samp() 사용하기 ?

# 가상의 데이터 생성 (40개 샘플)
np.random.seed(456)
n_samples = 40

# 실제 용량 (평균 498ml, 표준편차 3ml로 약간 부족한 상황 시뮬레이션)
actual_volume = np.random.normal(498, 3, n_samples)

# DataFrame 생성
quality_df = pd.DataFrame({
    '샘플번호': [f'S{i:03d}' for i in range(1, n_samples+1)],
    '실제용량': actual_volume,
    '표기용량과의_차이': actual_volume - 500
})

print("="*60)
print("실습 문제 3: 제품 품질 검사")
print("="*60)
print(f"\\n샘플 수: {n_samples}개")
print(f"표기 용량: 500ml")
print("\\n[데이터 정보]")
print(f"실제 용량 평균: {actual_volume.mean():.2f}ml")
print(f"실제 용량 표준편차: {actual_volume.std():.2f}ml")

quality_df

# 시각화
fig, axes = plt.subplots(1, 3, figsize=(14, 5))
target_value = 500

# 히스토그램
axes[0].hist(quality_df["실제용량"], bins=12, edgecolor='black', alpha=0.7, color="#aed6df")
axes[0].axvline(target_value, color='red', linestyle='--', linewidth=2, label=f'기준값: {target_value}cm')
axes[0].axvline(quality_df["실제용량"].mean(), color='green', linestyle='--', linewidth=2, 
                label=f'평균: {quality_df["실제용량"].mean():.2f}cm')
axes[0].set_xlabel('음료 실제 용량 (ml)')
axes[0].set_ylabel('빈도')
axes[0].set_title('음료 실제 용량')
axes[0].legend()
axes[0].grid(True, alpha=0.3)

# 박스플롯
bp = axes[1].boxplot(quality_df["실제용량"], patch_artist=True)
bp['boxes'][0].set_facecolor("#aed6df")
axes[1].axhline(target_value, color='red', linestyle='--', linewidth=2)
axes[1].set_ylabel('음료 실제 용량 (ml)')
axes[1].set_title('박스플롯')
axes[1].text(1.1, target_value+0.05, f'기준값: {target_value}', color='red')
axes[1].grid(True, alpha=0.3)

# Q-Q plot
stats.probplot(quality_df["실제용량"], dist="norm", plot=axes[2])
axes[2].set_title('Q-Q Plot')
axes[2].grid(True, alpha=0.3)

plt.tight_layout()
plt.show()

1️⃣ 표본 크기에 따른 정규성 확인

2️⃣ 정규성 검정

print("\\n" + "="*50)
print("가설검정 프로세스")
print("="*50)

# Step 1: 정규성 검정
is_normal = check_normality_simple(quality_df["실제용량"], "음료 실제 용량")

3️⃣ 가설검정

4️⃣ 결론 도출

# =============================================================================
# Step 2: 가설검정
# =============================================================================
print("\\n[가설검정]")
print("-"*40)

# 가설 설정 (단일표본 검정)
# 표본 평균이 특정 값(target_value)과 같은지 검정
print(f"H₀: μ = {target_value}ml (평균이 {target_value}ml)")
print(f"H₁: μ ≠ {target_value}ml (평균이 {target_value}ml가 아님)")
print("유의수준: α = 0.05")

# -----------------------------------------------------------------------------
# 2-1. 검정 방법 선택 및 실행
# -----------------------------------------------------------------------------
# 정규성 검정 결과에 따라 모수/비모수 검정 선택
if is_normal:
    # 모수 검정: 단일표본 t-검정 (데이터가 정규분포)
    # 표본 평균과 모집단 평균(target_value)을 비교
    t_stat, p_value = ttest_1samp(quality_df["실제용량"], target_value)
    print(f"\\nOne-sample t-test 결과:")
    print(f"t = {t_stat:.4f}, p = {p_value:.4f}")
    
    # -------------------------------------------------------------------------
    # 2-2. 신뢰구간 계산 및 해석
    # -------------------------------------------------------------------------
    # 모평균의 95% 신뢰구간 추정
    # CI = 표본평균 ± t(α/2, df) × SE
    confidence = 0.95  # 신뢰수준
    n = len(quality_df["실제용량"])  # 표본 크기
    mean = quality_df["실제용량"].mean()  # 표본 평균
    se = stats.sem(quality_df["실제용량"])  # 표준오차 (SE = s/√n)
    
    # t-분포 기반 신뢰구간 (자유도 = n-1)
    ci = stats.t.interval(confidence, n-1, loc=mean, scale=se)
    print(f"평균의 95% CI: [{ci[0]:.3f}, {ci[1]:.3f}]cm")
    
    # 신뢰구간과 목표값 비교
    # 목표값이 신뢰구간 내에 있으면 H₀를 기각할 수 없음
    if ci[0] <= target_value <= ci[1]:
        print(f"→ {target_value}ml가 신뢰구간 내에 있음")
    else:
        print(f"→ {target_value}ml가 신뢰구간 밖에 있음")
        
else:
    # 비모수 검정: Wilcoxon 부호순위 검정 (정규성 가정 위반)
    # 중앙값이 목표값과 같은지 검정 (순위와 부호 기반)
    
    # 각 관측값과 목표값의 차이 계산
    differences = quality_df["실제용량"] - target_value
    
    # Wilcoxon 부호순위 검정 실행
    # 차이의 절댓값에 순위를 매기고, 부호를 고려하여 검정
    w_stat, p_value = wilcoxon(differences)
    print(f"\\nWilcoxon signed-rank test 결과:")
    print(f"W = {w_stat:.4f}, p = {p_value:.4f}")

# -----------------------------------------------------------------------------
# 2-3. 통계적 결론 도출
# -----------------------------------------------------------------------------
print(f"\\n[결론]")

# p-value를 유의수준(α=0.05)과 비교하여 가설 채택/기각 결정
if p_value < 0.05:
    print(f"✅ p-value({p_value:.4f}) < 0.05 → 귀무가설 기각")
    
    # 차이의 방향 확인 (평균이 목표값보다 높은지 낮은지)
    diff = quality_df["실제용량"].mean() - target_value
    if diff > 0:
        print(f"   평균({quality_df['실제용량'].mean():.3f}cm)이 {target_value}cm보다 유의하게 높음")
    else:
        print(f"   평균({quality_df['실제용량'].mean():.3f}cm)이 {target_value}cm보다 유의하게 낮음")
    print(f"   (통계적으로 의미있는 차이 존재)")
    
else:
    print(f"❌ p-value({p_value:.4f}) ≥ 0.05 → 귀무가설 채택")
    print(f"   평균이 {target_value}cm와 유의한 차이가 없음")
    print(f"   (관측된 차이는 우연에 의한 것일 수 있음)")

[251001] 머신러닝 04 - 분류

junecho — Wed, 1 Oct 2025 23:46:12 +0900

✅ 분류 (Classification)

데이터가 어느 범주(클래스)에 속하는지 예측

ex) 스팸 메일 분류(스팸/정상), 질병 여부(양성/음성), 제조 공정 품질(불량/정상) 등…

분류 모델 사용 이유 : 이진 분류(양성/음성, 합격/불합격/ 정상/불량 등)는 직관적

❓ 지도학습

입력 데이터(Feature 특징)와 정답(Label)이 주어졌을 때, 모델이 정답을 예측하도록 학습하는 방식
회귀 - 연속값 예측
분류 - 범주 예측

로지스틱 회귀 (Logistic Regression)

선형 회귀처럼 입력값의 선형 결합을 취하지만, 결과를 0~1 사이의 확률로 변환하기 위해 로지스틱 함수(시그모이드 함수)를 사용
장점
- 계산이 빠르고 구현이 간단
- 결과 해석이 용이 (회귀 계수로 각 변수의 영향도 해석 가능)
단점
- 복잡한 비선형 패턴을 학습하기엔 한계가 있음

로지스틱 회귀 코드

LogisticRegression()

from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import accuracy_score, classification_report

# 1. 데이터 로드
iris = load_iris()
X = iris.data       # 특징(feature) 데이터
y = iris.target     # 타깃(target) 데이터

# 2. 데이터 분할 (train : test = 8 : 2)
# stratify=y : 클래스 비율을 train, test가 유사하게끔 맞춤
X_train, X_test, y_train, y_test = train_test_split(X, y,
                                                    test_size=0.2,
                                                    random_state=42,
                                                    stratify=y)

# 3. Logistic Regression
logistic_model = LogisticRegression(max_iter=200)  
logistic_model.fit(X_train, y_train)

# 4. 예측
y_pred_logistic = logistic_model.predict(X_test)

# 5. 성능 평가

print("=== Logistic Regression ===")
print("Accuracy:", accuracy_score(y_test, y_pred_logistic))
print(classification_report(y_test, y_pred_logistic, target_names=iris.target_names))

LogisticRegression()
- 학습 데이터(X_train, y_train)를 이용해 로지스틱 회귀 모델을 학습
- max_iter(최대 반복 횟수)를 기본값(100)에서 조금 늘려 200으로 설정
accuracy_score로 정확도(Accuracy) 계산
classification_report로 클래스별 정밀도(precision), 재현율(recall), F1 점수, 지원된 샘플 수(support) 등을 확인
target_names=iris.target_names를 통해 각 클래스의 이름(‘setosa’, ‘versicolor’, ‘virginica’)으로 보고서를 보기 쉽게 표시

SVM (Support Vector Machine)

데이터를 가장 잘(안전 여유공간을 크게) 구분하는 경계를 찾는 알고리즘

ex) 두 부류(ex: 고양이 vs 개)를 잘 구분해주는 경계를 찾는데, 두 부류가 최대한 멀리 떨어지도록(안전 여유공간이 넓도록) 찾는 방식

장점
- 차원이 높은 데이터에서도 좋은 성능을 보일 수 있음
- 결정 경계를 명확하게 찾는 경우, 예측 성능이 우수함
  - 결정경계란? → SVM이 찾은 최적의 분류선(또는 초평면)
  - ex) 한쪽 편을 '고양이'로, 다른 한편을 '개'로 구분해주는 기준선
단점
- 파라미터(C, 커널 종류 등)를 적절히 찾아야 하므로 튜닝 비용이 큼
- 대규모 데이터 세트에 대해서는 학습 속도가 느릴 수 있음

SVM 코드

SVC()

from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.svm import SVC
from sklearn.metrics import accuracy_score, classification_report

# 1. 데이터 로드
iris = load_iris()
X = iris.data       # 특징(feature) 데이터
y = iris.target     # 타깃(target) 데이터
print(X.shape)
print(y.shape)

# 2. 데이터 분할 (train : test = 8 : 2)
X_train, X_test, y_train, y_test = train_test_split(X, y,
                                                    test_size=0.2,
                                                    random_state=42,
                                                    stratify=y)

# 3. SVM(Support Vector Machine)
# C, gamma 등의 하이퍼파라미터를 설정해서 더 최적화할 수도 있습니다.
svm_model = SVC()
svm_model.fit(X_train, y_train)

# 4. 예측
y_pred_svm = svm_model.predict(X_test)

# 5. 성능 평가
# Accuracy(정확도)와 정밀 평가(classification_report)를 이용해 비교해봅니다.

print("=== SVM ===")
print("Accuracy:", accuracy_score(y_test, y_pred_svm))
print(classification_report(y_test, y_pred_svm, target_names=iris.target_names))

SVM
- SVC()는 기본적으로 커널(kernel)을 ‘rbf’로 사용
- 다른 하이퍼파라미터(C, gamma 등)를 조정해서 성능 개선을 시도할 수 있음
accuracy_score로 정확도(Accuracy) 계산
classification_report로 클래스별 정밀도(precision), 재현율(recall), F1 점수, 지원된 샘플 수(support) 등을 확인
target_names=iris.target_names를 통해 각 클래스의 이름(‘setosa’, ‘versicolor’, ‘virginica’)으로 보고서를 보기 쉽게 표시

[250930] 머신러닝 03 - 회귀

junecho — Tue, 30 Sep 2025 21:12:24 +0900

✅ 회귀 분석

종속변수(Y)와 하나 이상의 독립변수(X) 간의 관계를 추정하여, 연속형 종속변수를 예측하는 통계/머신러닝 기법

ex) “공부한 시간(X)에 따라 시험 점수(Y)가 어떻게 변하는가?” 를 예측

개요

지도학습에서의 분류와 회귀의 차이
- 분류 (Classification) : 결과값이 이산형(클래스 라벨)
- 회귀 (Regression) : 결과값이 연속형(숫자 값)
- 사람의 지능적인 작업을 기계가 수행하도록 만드는 광범위한 개념
회귀 모델을 사용하는 이유
- 1️⃣ 미래 값 예측 : 실수값 예측에 사용 ex) 매량, 주가, 온도 등…
- 2️⃣ 인과 관계 해석 (통계 관점) : 특정 독립변수가 종속변수에 미치는 영향력을 해석하기 위해
- 3️⃣ 데이터 기반 의사결정 : 추세 파악, 자원 배분 등

회귀 모델 대표적 활용 사례
- 경제 - 주식 가격 예측, 판매량 예측
- 건강 - 혈압, 콜레스테롤 수치 예측
- 제조업 - 불량률, 생산량 예측

선형 회귀 (Linear Regression)

독립변수(X)와 종속변수(Y)가 선형적(일차 방정식 형태)으로 관계를 맺고 있다고 가정

❓ 선형적 관계

: 변수가 증가하면, 다른 변수도 일정한 비율로 증가/감소 하는 관계

ex) 키가 커지면 몸무게도 증가하는 경향 / 공부 시간을 늘리면 시험 점수가 오르는 경향

장점 : 해석 간단, 구현 쉬움
단점 : 데이터가 선형성이 아닐 경우 예측력이 떨어짐
독립변수 한 개인 상황에서는 직선이 나오는데, 독립변수가 많으면 평면이 나오게 됨

회귀식

β0 : 절편(intercept) = 편향
βi : 각 독립변수의 회귀계수(coefficient) = x의 계수 = 가중치 = 파라미터 = 베타

⇒ 독립변수가 많아질수록 항이 늘어난다

선형 회귀 모델 학습 과정

1️⃣ 가중치 (회귀계수) 초기화 ⇒ 베타값을 처음엔 모르니까 아무 값이나 해서 정해둠

2️⃣ 손실함수(Loss Function) 설정 : 주로 MSE(Mean Squared Error) 사용

❓ 손실함수 : 얼마나 오차가 나는지, 손실이 나는지 평가 해주는 지표

⇒ 좋은 베타값은 오차가 적게 나오는 베타값

3️⃣ 최적화 : 수학적인 방법(최소자승법), 경사하강법(Gradient Descent) 등을 통해 가중치 업데이트

4️⃣ 학습 완료 후 : β0, β1, …를 얻어서 새로운 입력 값에 대한 예측 수행

예시
- 데이터
  - X = 공부 시간, Y = 시험 점수
  - (1시간, 40점), (2시간, 50점), (3시간, 60점), (4시간, 70점) …
- 모델

1시간 공부 → 40점, 2시간 공부 → 50점 …

선형회귀 코드

import numpy as np
import pandas as pd
from sklearn.datasets import load_diabetes
from sklearn.linear_model import LinearRegression, SGDRegressor
from sklearn.model_selection import train_test_split
from sklearn.metrics import mean_squared_error, r2_score

# 1. 데이터 로드
diabetes = load_diabetes()
X = diabetes.data       # X : 특성(독립변수)
y = diabetes.target     # y : 타겟(종속변수)

print(X.shape)
print(y.shape

train_test_split()

# 2. 학습/테스트 데이터 분리
# 80% 학습용, 20% 테스트용으로 데이터 분할 (재현성을 위한 random_state=42)
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42)

print(X_train.shape)
print(y_train.shape)
print(X_test.shape)
print(y_test.shape)

: 전체 데이터셋을 학습용 세트와 테스트용 세트로 분할하는 데 사용

LinearRegression()

# 3. 선형회귀 (LinearRegression) 모델
lin_reg = LinearRegression()
lin_reg.fit(X_train, y_train)

: 종속 변수(대상)와 하나 이상의 독립 변수(특징) 간의 선형 관계를 구하는 것을 목표로 함
fit() : 모델을 학습하기 위해 객체에 호출되는 메서드

predict()

# 예측
y_pred_lin = lin_reg.predict(X_test)

# 성능 측정
mse_lin = mean_squared_error(y_test, y_pred_lin)
r2_lin = r2_score(y_test, y_pred_lin)

# 평균 비율 오차 - 실제값 대비 예측값이 몇 % 오차가 났는지
def MPE(y_true, y_pred):
    return np.mean((y_true - y_pred) / y_true) * 100

print("[LinearRegression 결과]")
print("가중치(coefficient):", lin_reg.coef_)
print("절편(intercept):", lin_reg.intercept_)
print("MSE:", mse_lin)
print("R2 점수:", r2_lin)
print("평균 비율 오차 : ", MPE(y_test, y_pred_lin))

predict() : 테스트 세트에 대한 예측 수행
mean_squared_error(x, y) : MSE 오차를 계산하는 어떤 지표. x, y 두 개의 값의 오차 계산
r2_score(x, y) : 얼마나 예측이 잘 되어져 있는지 점수로 나타내는 값

⇒

10열이 있었기 때문에 가중치는 10개가 나옴.

절편은 베타값을 처음에는 모르니까 임의로 지정해주는 상수값

SGDRegressor()

# 4. SGDRegressor 모델
sgd_reg = SGDRegressor(max_iter=6000, tol=1e-3, random_state=42)
sgd_reg.fit(X_train, y_train)

: 확률적 경사하강법

# 예측
y_pred_sgd = sgd_reg.predict(X_test)

# 성능 측정
mse_sgd = mean_squared_error(y_test, y_pred_sgd)
r2_sgd = r2_score(y_test, y_pred_sgd)

# 평균 비율 오차
def MPE(y_true, y_pred):
    return np.mean((y_true - y_pred) / y_true) * 100

print("[SGDRegressor 결과]")
print("가중치(coefficient):", sgd_reg.coef_)
print("절편(intercept):", sgd_reg.intercept_)
print("MSE:", mse_sgd)
print("R2 점수:", r2_sgd)
print("평균 비율 오차 : ", MPE(y_test, y_pred_sgd))

예측 후, MSE와 R2 점수를 통해 모델 성능 확인

다항 회귀 (Polynomial Regression)

비선형적인 관계를 다항식(polynomial) 형태로 모델링

ex) 2차 다항식
선형 회귀와 다른 점 : 단순 선형항(X) 뿐만 아니라 $X^2, X^3$,... 같은 고차항을 추가해 비선형 패턴을 학습할 수 있다
적용 예시
- 제조 공정에서 온도와 반응률 관계가 곡선 형태인 경우
- 건강 데이터에서 나이와 특정 지표(근육량 등)가 단순 선형보다 곡선 형태로 나타나는 경우
주의점
- 고차항을 무작정 늘리면 훈련 데이터에는 과도하게 맞춰져 과적합(overfitting) 문제가 발생
- 모델 복잡도와 일반화 성능 간의 균형을 맞춰야 함

다항회귀 코드

import numpy as np
import pandas as pd
from sklearn.datasets import make_friedman1
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import PolynomialFeatures
from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_squared_error, r2_score
from sklearn.pipeline import Pipeline

# 1) 비선형 데이터 생성 (make_friedman1)
# n_samples: 샘플 개수, n_features: 특성 개수, noise: 잡음 크기
X, y = make_friedman1(n_samples=1000, n_features=5, noise=1.0, random_state=42)
print(X.shape)
print(y.shape)

# 2) 학습/테스트 분리
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.3, random_state=42
)

print(X_train.shape)
print(y_train.shape)
print(X_test.shape)
print(y_test.shape)

LinearRegression()

# 3) 단순 선형회귀 모델 (비교용)
lin_reg = LinearRegression()
lin_reg.fit(X_train, y_train)
y_pred_lin = lin_reg.predict(X_test)

mse_lin = mean_squared_error(y_test, y_pred_lin)
r2_lin = r2_score(y_test, y_pred_lin)

# 평균 비율 오차
def MPE(y_true, y_pred):
    return np.mean((y_true - y_pred) / y_true) * 100

print("[단순 선형회귀 결과]")
print("MSE:", mse_lin)
print("R2:", r2_lin)
print("평균 비율 오차 : ", MPE(y_test, y_pred_lin))
print()

⇒ 비선형을 고려하지 않고, LinearRegression만 적용했을 때의 성능을 MSE, R^2, MPE로 측정

PolynomialFeatures()

# 4) Polynomial Regression (2차 예시)
poly_model = Pipeline([
    ("poly", PolynomialFeatures(degree=2, include_bias=False)),
    ("lin_reg", LinearRegression())
])
poly_model.fit(X_train, y_train)
y_pred_poly = poly_model.predict(X_test)

mse_poly = mean_squared_error(y_test, y_pred_poly)
r2_poly = r2_score(y_test, y_pred_poly)

# 평균 비율 오차
def MPE(y_true, y_pred):
    return np.mean((y_true - y_pred) / y_true) * 100

print("[다항회귀(2차) 결과]")
print("MSE:", mse_poly)
print("R2:", r2_poly)
print("평균 비율 오차 : ", MPE(y_test, y_pred_poly))

PolynomialFeatures(degree=2)로 2차 항까지 고려하도록 변한 후, 다시 선형회귀를 적용하는 파이프라인을 구성
비선형 패턴을 어느 정도 학습할 수 있으므로, 단순 선형회귀보다 더 좋은 성능이 기대됨 (물론 과적합 위험도 존재
결과 비교
- MSE, R^2 등을 비교하여 단순 선형회귀 대비 다항회귀가 Friedman1 데이터셋에서 어떤 차이를 보이는지 확인 가능
- 만약 더 높은 차수(예: 3차, 4차)를 적용하거나, 다른 비선형 모델(예: 랜덤 포레스트, SVM 회귀 등)을 사용하면 성능이 달라질 수 있음

회귀 모델 평가 방법

MSE (Mean Squared Error)

예측값과 실제값의 차이를 제곱하여 평균
오차가 클수록 제곱에 의해 더 큰 벌점이 매겨지므로, 큰 오차에 특히 민감
평균 제곱 오차라고도 하며, 회귀 모델 평가에서 매우 자주 사용됨

MAE (Mean Absolute Error)

예측값과 실제값의 차이를 절댓값으로 측정한 후 평균
예측이 평균적으로 실제값에서 얼마나 벗어났는지 직관적으로 표현

RMSE (Root Mean Squared Error)

MAE와 달리 제곱을 통해 큰 오차에 가중치를 더 주는 특징
오차가 클수록 패널티가 커지므로, 큰 오차가 중요한 문제에서 자주 사용

R² (결정 계수)

yˉ: 종속변수의 평균
값의 범위
- 0 ~ 1 (음수가 될 수도 있음)
해석
- 1에 가까울수록 학습된 모델이 데이터를 잘 설명한다고 볼 수 있음
- 0이라면 모델이 종속변수를 전혀 설명하지 못한다는 의미

고급 회귀 기법 - Ridge & Lasso Regression

선형 회귀에 규제(Regularization) 항을 추가하여 과적합을 방지

Ridge(릿지) 회귀

가중치 제곱합(L2 Norm)을 패널티로 추가
효과 : 가중치가 너무 커지지 않도록 방지 (가중치 값을 부드럽게 줄임)

Lasso(라쏘) 회귀

가중치 절댓값합(L1 Norm)을 패널티로 추가
효과 : 가중치를 0으로 만들어 변수 선택(Feature Selection) 효과

릿지회귀 & 라쏘회귀 코드

import numpy as np
import pandas as pd
from sklearn.datasets import fetch_california_housing
from sklearn.model_selection import train_test_split
from sklearn.linear_model import Ridge, Lasso
from sklearn.metrics import mean_squared_error, r2_score

# 1. 데이터 로드
housing = fetch_california_housing()
X = housing.data
y = housing.target

print(X.shape)
print(y.shape)

# 2. 학습/테스트 데이터 분리
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42
)

print(X_train.shape)
print(y_train.shape)
print(X_test.shape)
print(y_test.shape)

Ridge()

# 3. Ridge 회귀
# alpha=1.0 (규제 세기) 는 필요에 따라 조정 가능
ridge_reg = Ridge(alpha=1.0, random_state=42)
ridge_reg.fit(X_train, y_train)

L2 규제항을 포함하는 Ridge 모델
alpha가 클수록 규제 강도가 세어져, 모델 가중치(계수)들의 크기를 더욱 제약
학습 후, 예측 결과에 대해 MSE와 R^2 점수를 계산

# 예측
y_pred_ridge = ridge_reg.predict(X_test)

# 성능 평가
mse_ridge = mean_squared_error(y_test, y_pred_ridge)
r2_ridge = r2_score(y_test, y_pred_ridge)

# 평균 비율 오차
def MPE(y_true, y_pred):
    return np.mean((y_true - y_pred) / y_true) * 100

print("[Ridge 회귀 결과]")
print("  가중치(coefficient):", ridge_reg.coef_)
print("  절편(intercept):", ridge_reg.intercept_)
print("  MSE:", mse_ridge)
print("  R^2 점수:", r2_ridge)
print("평균 비율 오차 : ", MPE(y_test, y_pred_ridge))
print()

Lasso()

# 4. Lasso 회귀
# alpha=0.1 정도로 조금 낮춰 볼 수도 있음 (기본값 1.0)
# alpha가 너무 크면 가중치가 0이 되어 과소적합 위험이 있습니다.
lasso_reg = Lasso(alpha=0.1, random_state=42, max_iter=10000)
lasso_reg.fit(X_train, y_train)

L1 규제항을 사용하는 Lasso 모델
alpha가 클수록 일부 가중치가 정확히 0으로 수렴(특성 선택 효과)
마찬가지로 MSE, R^2를 통해 성능을 평가

# 예측
y_pred_lasso = lasso_reg.predict(X_test)

# 성능 평가
mse_lasso = mean_squared_error(y_test, y_pred_lasso)
r2_lasso = r2_score(y_test, y_pred_lasso)

# 평균 비율 오차
def MPE(y_true, y_pred):
    return np.mean((y_true - y_pred) / y_true) * 100

print("[Lasso 회귀 결과]")
print("  가중치(coefficient):", lasso_reg.coef_)
print("  절편(intercept):", lasso_reg.intercept_)
print("  MSE:", mse_lasso)
print("  R^2 점수:", r2_lasso)
print("평균 비율 오차 : ", MPE(y_test, y_pred_lasso))

정리 / Q&A

정리

회귀 모델은 연속형 결과 변수를 예측하는 데 사용
선형 회귀는 가장 기본적인 형태지만, 데이터의 패턴이 비선형일 경우 다항 회귀 등을 고려
규제(Regularization) 기법을 활용한 모델(Lasso, Ridge)은 가중치를 규제하여 과적합을 방지
앙상블 기법(Gradient Boosting, XGBoost 등)을 사용하는 경우 복잡한 비선형 패턴을 더 잘 포착할 수 있다 (추후 배울 내용)
모델의 성능 평가는 MAE, RMSE, R² 등 다양한 지표를 통해 진행

Q&A

Q1: 선형 회귀와 다항 회귀 중 어느 것을 선택해야 하나요?

A1: 데이터의 분포와 잔차(오차) 패턴을 확인하여, 단순 선형 모델로 설명이 어렵다면 다항 회귀를 고려합니다. 먼저, 선형회귀와 다항회귀 모두를 진행해보고 나서 판단해보는 방법도 있습니다.

Q2: Lasso와 Ridge 중 어느 규제 기법을 써야 하나요?

A2: Lasso는 변수 선택(가중치를 0으로 만들어 불필요한 변수 제거)에 유리하며, Ridge는 모든 가중치를 부드럽게 줄여 모델 안정성을 높이는 데 유리합니다. 분석 목적과 데이터 특성에 따라 선택하거나, Elastic Net처럼 두 기법을 혼합하는 방법도 있습니다.

Q3: 앙상블 기법은 항상 선형 회귀보다 좋은가요?

A3: 대부분의 경우 앙상블 기법이 예측 성능이 높지만, 데이터의 규모나 특징, 문제의 복잡도에 따라 다릅니다. 또한 하이퍼파라미터 튜닝이 까다롭고 계산 비용이 큰 단점도 있으므로 상황에 맞춰 선택합니다.

Q4: 회귀 모델에서 독립변수가 많아질수록 항상 성능이 좋아지나요?

A4: 독립변수가 많아지면 모델이 복잡해져 과적합될 가능성이 커집니다. 변수 선택 기법(Feature Selection)이나 규제(Regularization)를 통해 불필요한 변수를 제거하고, 교차검증으로 모델 일반화 성능을 평가해야 합니다.

Q5: 회귀 모델을 만들 때 어떤 지표(R², MAE, RMSE)를 우선적으로 봐야 하나요?

A5: 문제의 특성에 따라 달라집니다. 예측 오차의 크기가 중요하면 RMSE나 MAE, 모델이 데이터를 얼마나 잘 설명하는지 보려면 R²를 사용합니다. 여러 지표를 종합적으로 살펴보는 것이 바람직합니다.

[250929] 머신러닝 02

junecho — Mon, 29 Sep 2025 20:50:19 +0900

✅ 데이터 전처리

원시(raw) 데이터에서 불필요하거나 손실(노이즈)이 있는 부분을 처리하고, 분석 목적에 맞는 형태로 만드는 과정

ex) 스팸 메일 필터링, 이미지 분류, 음성 인식 등

결측치 처리

삭제 (Removal)
- : 결측치가 있는 행(row) 또는 열(column)을 제거
- 간단하지만 데이터 손실이 발생
- 결측치가 전체 데이터에서 매우 소수일 때 적합
대체 (Imputation)
- 평균or중앙값으로 대체 → 수치형 데이터에서 많이 사용, 데이터 분포 왜곡이 비교적 적음
- 최빈값으로 대체 → 범주형 데이터에서 사용
- 예측 모델로 대체 → 회귀/분류 모델을 이용해 결측값을 예측

결측치 처리 코드

import numpy as np
import pandas as pd

# 1) 가상 데이터 생성
#   - 일부 값들을 np.nan으로 지정해 결측값을 만듭니다.
data = {
    'A': [1, 2, np.nan, 4, 5, np.nan, 7],
    'B': [5, 4, 2, np.nan, np.nan, 3, 1],
    'C': [2, np.nan, np.nan, 6, 7, 8, 9]
}
df = pd.DataFrame(data)
df

.dropna() : 결측이 하나라도 있으면 해당 행 제거

# 2) 결측치 제거 (결측이 하나라도 있으면 해당 행을 제거)
df_drop = df.dropna()
df_drop

.fillna() : NULL값을 지정된 값으로 바꿈

numeric_only=True : 숫자형 데이터에만 계산을 해주고 싶을 때 사용

# 3) 평균값으로 대치
df_mean = df.copy()
df_mean = df_mean.fillna(df_mean.mean(numeric_only=True))
df_mean

# 4) 중앙값으로 대치
df_median = df.copy()
df_median = df_median.fillna(df_median.median(numeric_only=True))
df_median

# 5) 최빈값으로 대치
#   - DataFrame의 mode()는 각 열별로 최빈값을 반환합니다.
#   - mode() 결과가 여러 개(동률)일 경우 첫 번째 행의 값을 취합니다.
df_mode = df.copy()
print(df_mode.mode()) # 확인용
mode_values = df_mode.mode().iloc[0]  # 첫 번째 행(가장 상위 mode)만 취함
df_mode = df_mode.fillna(mode_values)
df_mode

이상치 탐지 & 제거

이상치 (Outlier) : 정상 범주에서 크게 벗어난 값

이상치 탐지

1️⃣ 통계적 기법 (3σ Rule)

: 데이터가 정규분포를 따른다고 가정, 평균에서 ±3σ(표준편차) 범위를 벗어나는 값을
이상치로 간주
직관적이고 간단하나 정규성 가정이 틀릴 수 있음

2️⃣ 박스플롯(Boxplot) 기준

: 사분위수 (IQR = Q3 - Q1) 를 이용해 (Q1 - 1.5 * IQR) + (Q3 + 1.5 * IQR) 벗어나는 데이터를 이상치로 간주
분포 특성에 영향을 적게 받는 장점

3️⃣ 머신러닝 기반

: 이상치 탐지 알고리즘 (Isolation Forest, DBSCAN 등)
복합적 패턴을 고려할 수 있음

이상치 제거 코드

import pandas as pd
import numpy as np

# 예시 데이터프레임 생성
np.random.seed(42)  # 재현성을 위해 시드 설정
normal_values = np.random.normal(loc=50, scale=5, size=30)   # 평균 50, 표준편차 5인 정규분포에서 30개 값 생성
outliers = [150, 180, 200, 300]  # 눈으로 봐도 이상치로 판단될 수 있는 큰 값들

# normal_values와 outliers를 합쳐서 하나의 리스트로 구성
all_values = np.concatenate([normal_values, outliers])
# 예시로 0~39 범위의 임의 날짜/시간 데이터를 간단히 만들기
dates = pd.date_range('2021-01-01', periods=len(all_values), freq='D')

df = pd.DataFrame({
    'date': dates,
    'sensor_value': all_values
})
df

# 이상치 제거 (간단하게 박스플롯 기준 적용 예시)
Q1 = df['sensor_value'].quantile(0.25)
Q3 = df['sensor_value'].quantile(0.75)
IQR = Q3 - Q1
lower_bound = Q1 - 1.5 * IQR
upper_bound = Q3 + 1.5 * IQR
df = df[(df['sensor_value'] >= lower_bound) & (df['sensor_value'] <= upper_bound)]
df

정규화/표준화 = 스케일링

❓ WHY 필요

모델(특히 거리 기반 알고리즘, 딥러닝 등)에 따라 특정 변수의 스케일이 크게 영향을 미칠 수 ⭕
ex) 센서 A는 값 범위가 0~1000, 센서 B는 값 범위가 0~1이라면, A가 모델에 더 큰 영향을 줌

정규화 (MinMaxScaler)

: 모든 값을 0과 1 사이로 매핑
값의 스케일이 달라도 공통 범위로 맞출 수 있음
딥러닝(신경망), 이미지 처리 등에서 입력값을 0~1로 제한해야 하거나, 각 특성이 동일한 범위 내 있어야 하는 경우 자주 사용
거리 기반 알고리즘(유클리디안 거리 사용)이나, 각 특성의 범위를 동일하게 맞춤으로써 계산 안정성을 높이고 싶을 때
최소값·최대값이 극단값(Outlier)에 민감. 만약 극단치가 있으면 대부분의 데이터가 [0, 1] 구간 내부 한쪽에 치우침
새로운 데이터가 기존 최대값보다 커지거나, 최소값보다 작아지는 경우, 스케일링 범위를 벗어날 수 있어 재학습하거나 다른 처리가 필요

표준화 (StandardScaler)

: 평균을 0, 표준편차를 1로 만듦
분포가 정규분포에 가깝게 변형됨
평균이 0, 표준편차가 1로 맞춰지므로, 정규분포 가정을 사용하는 알고리즘 (선형회귀, 로지스틱회귀, SVM 등)에 자주 쓰임
변환된 값들이 이론적으로 -∞ ~ +∞ 범위를 가질 수 있음
데이터가 특정 구간([0, 1] 등)에 고정되지 않음
데이터 분포가 심하게 치우쳐 있으면, 평균과 표준편차만으로는 충분한 스케일링이 되지 않을 수 있음 (로그 변환, RobustScaler 등 추가 고려)

정규화/표준화 코드

import pandas as pd
import numpy as np

# 난수를 재현하기 위해 시드 설정
np.random.seed(42)

# 예시 마케팅 지표 데이터 생성
data_size = 10
df = pd.DataFrame({
    'impressions': np.random.randint(1000, 10000, size=data_size), # 광고 노출 횟수
    'clicks': np.random.randint(0, 300, size=data_size), # 광고 클릭 횟수
    'conversions': np.random.randint(0, 50, size=data_size), # 광고를 통해 구매한 횟수
    'cost': np.random.randint(100, 5000, size=data_size), # 광고비 지출액
    'revenue': np.random.randint(100, 10000, size=data_size) # 광고를 통해 발생한 매출
})
df

MinMaxScaler() : 정규화. 일반적으로 0과 1 사이의 지정된 범위로 특성을 조정하는데 사용

from sklearn.preprocessing import MinMaxScaler

# 스케일링을 적용할 컬럼만 선정
cols_to_scale = ['impressions', 'clicks', 'conversions', 'cost', 'revenue']

# MinMaxScaler 객체 생성(기본 스케일: [0,1])
minmax_scaler = MinMaxScaler()

# fit_transform을 통해 스케일링된 결과를 데이터프레임으로 변환
df_minmax_scaled = pd.DataFrame(minmax_scaler.fit_transform(df[cols_to_scale]), 
                                columns=cols_to_scale)                            
print(df_minmax_scaled.max())
print(df_minmax_scaled.min())
                     
df_minmax_scaled

MinMaxScaler() 에서의 fit_transform()
- : 밑의 두 단계를 한 번에 호출
- fit : 열을 살펴 최솟값과 최댓값을 찾음
- transform : 찾은 최솟값/최댓값으로 각 데이터를 0~1 범위로 바꿈

StandardScaler() : 표준화. 평균을 제거하고 단위 분산으로 스케일링하여 특성을 표준화.

from sklearn.preprocessing import StandardScaler

# StandardScaler 객체 생성
standard_scaler = StandardScaler()

# fit_transform을 통해 스케일링된 결과를 데이터프레임으로 변환
df_standard_scaled = pd.DataFrame(standard_scaler.fit_transform(df[cols_to_scale]), 
                                  columns=cols_to_scale)

print(df_standard_scaled.mean())
print(df_standard_scaled.std())
df_standard_scaled

StandardScaler() 에서의 fit_transform()
- : 밑의 두 단계를 한 번에 호출
- fit : 열의 평균과 표준편차를 구함
- transform : 각 값을 “(x - 평균) / 표준편차” 로 변환하여 평균 0, 표준편차 1인 분포를 만듦

불균형 데이터 처리

정상 99%, 불량 1%처럼 한 클래스가 극도로 적은 경우

문제점 : 모델이 극도로 적은 클래스를 거의 예측하지 못할 가능성이 큼 (편향 발생)

해결 기법

1️⃣ Oversampling

Random Oversampling
- : 소수 클래스의 데이터를 단순 복제하여 개수를 늘림
SMOTE(Synthetic Minority Over-sampling Technique)
- : 소수 클래스를 "무작정 복사"만 하는 게 아니라, “비슷한” 데이터들을 서로 섞어서(Interpolation) 새로운 데이터 생성
- 즉, 소수 클래스(ex: 스팸) 안에서 가까운 데이터 둘(혹은 몇 개)을 고르고, 그 사이에 새 데이터 포인트를 만들어내어, 소수 클래스의 다양한 예시를 가상으로 늘리는 기법
- ex) “모양이나 맛이 비슷한 `두 오렌지를 고른 다음, 그 중간 정도 되는 새로운 오렌지를 상상해서 만들어낸다” 같은 느낌

2️⃣ Undersampling

: 다수의 클래스 데이터를 줄이는 방식
데이터 손실 위험이 있지만, 전체 데이터 균형을 맞출 수 있음

3️⃣ 혼합 기법

: SMOTE와 언더샘플링을 적절히 섞어서 사용

불균형 데이터 처리 코드

import numpy as np
import pandas as pd

# 난수 고정 (재현성)
np.random.seed(42)

# 불균형 데이터 크기 설정
# 예: 총 100개 중 defect=1(불량)인 샘플 10개, defect=0(정상)인 샘플 90개
size_1 = 10
size_0 = 90

# 정상 클래스 (defect=0) 데이터 생성
feature1_0 = np.random.normal(loc=10, scale=2, size=size_0)
feature2_0 = np.random.normal(loc=5, scale=1, size=size_0)

# 불량 클래스 (defect=1) 데이터 생성
feature1_1 = np.random.normal(loc=20, scale=5, size=size_1)
feature2_1 = np.random.normal(loc=10, scale=2, size=size_1)

# 배열 병합
feature1 = np.concatenate([feature1_0, feature1_1])
feature2 = np.concatenate([feature2_0, feature2_1])
defect = np.array([0]*size_0 + [1]*size_1)

# 데이터프레임 생성
df = pd.DataFrame({
    'feature1': feature1,
    'feature2': feature2,
    'defect': defect
})

df

SMOTE()

from imblearn.over_sampling import SMOTE
# 불균형 데이터 처리 (SMOTE)
X = df.drop('defect', axis=1)   # 결측치 처리, 이상치 제거, 인코딩 등 사전 처리 후
y = df['defect']
smote = SMOTE(random_state=42)
X_res, y_res = smote.fit_resample(X, y)

fit_resample
- : SMOTE 알고리즘이 x, y를 바탕으로 소수 클래스 데이터를 자동 생성
- 오버샘플링된 X_res, y_res에는 클래스 불균형이 개선된(1:1에 가깝거나 원하는 비율이 된) 상태가 됨

X_res

y_res

y_res.hist()

범주형 데이터 변환

import pandas as pd
import numpy as np

# 예시 데이터프레임 생성
data_size = 10
np.random.seed(42)

labels = ['apple', 'banana', 'cherry']
random_labels = np.random.choice(labels, data_size)

df = pd.DataFrame({
    'id': range(1, data_size + 1),
    'label': random_labels,
    'value': np.random.randint(1, 100, data_size),
    'another_feature': np.random.choice(['A', 'B'], data_size)  # 또 다른 범주형 변수
})

df

원-핫 인코딩 (One-Hot Encoding)

범주형 변수를 각각의 범주별로 새로운 열로 표현, 해당 범주에 해당하면 1, 아니면 0
ex) 색상(‘Red’, ‘Blue’, ‘Green’) → ‘Red=1,Blue=0,Green=0’ / ‘Red=0,Blue=1,Green=0’ / …
장점 : 범주 간 서열 관계가 없을 때 사용하기 좋음
단점 : 범주가 매우 많으면 차원이 커짐

pd.get_dummies()

# 범주형 변수 변환 (원-핫 인코딩 예시)
df = pd.get_dummies(df, columns=['label'])

pd.get_dummies(df, columns=["칼럼이름"]) : 열의 범주들을 각각 별도 열로 만들어, 해당하는 행에는 1, 그렇지 않은 행에는 0 매핑

레이블 인코딩 (Label Encoding)

범주를 숫자로 직접 맵핑(‘M’=0, ‘L’=1, ‘XL’=2 등)
단순하지만, 모델이 숫자의 크기를 서열 정보로 잘못 해석할 수 있음

LabelEncoder()

# 범주형 변수 변환 (레이블 인코딩 예시)
from sklearn.preprocessing import LabelEncoder
encoder = LabelEncoder()
df["label"] = encoder.fit_transform(df["label"])
df

피처 엔지니어링

모델 성능 향상을 위해 기존 데이터를 변형, 조합해 새로운 특성(피처)를 만드는 작업

복잡한 데이터 구조 안에 존재하는 패턴을 효과적으로 추출해 모델이 쉽게 학습하게 함

실습 예시

1️⃣ 파생 변수 생성

날짜 파생 변수
- ex) 측정 시간이 ‘2025-02-24 10:35:00’이라면, ‘월(2)’, ‘요일(월=1)’, ‘시(10)’, ‘주말여부(0/1)’ 등으로 분해
수치형 변수 조합
- ex) ‘온도’와 ‘습도’가 있을 때, 새로운 피처 ‘온도×습도(TEMP×HUMID)’를 추가 → 두 변수의 상호작용이 불량 발생에 영향을 줄 수 있음
로그 변환, 제곱근 변환 등
- : 분포가 매우 치우친 변수(오른쪽 꼬리가 긴 경우)에 로그 변환을 적용하여 정규성에 가까워지도록 조정

2️⃣ 파생 변수 생성 코드 예시

import pandas as pd
import numpy as np

np.random.seed(42)  # 재현성을 위한 시드 고정

# 10개 데이터 샘플 생성
data_size = 10

# 날짜/시간 컬럼(예시)
dates = pd.date_range(start="2023-01-01", periods=data_size, freq='D')

# 온도(°C) : 15 ~ 35 사이 정수
temperature = np.random.randint(15, 36, size=data_size)

# 습도(%) : 30 ~ 90 사이 정수
humidity = np.random.randint(30, 91, size=data_size)

df = pd.DataFrame({
    'date': dates,
    'temperature': temperature,
    'humidity': humidity
})

df

# 피처 엔지니어링 (온도와 습도 간 상호작용)
df['temp_humid_interaction'] = df['temperature'] * df['humidity']
df

3️⃣ 변수 선택 (Feature Selection)

상관관계
- 두 변수 간 상관도가 높은 상황인 경우 다중공선성 의심.
- 중복 정보가 클 수 있으므로, 하나만 남기거나 둘 다 제거 고려
VIF
- : 어떤 변수 하나가, 다른 변수들과 얼마나 겹치는지(상관이 큰지) 수치로 보여주는 지표
- 회귀분석에서 다중공선성 문제를 파악할 때 사용
- VIF가 일정 기준(예: 10 이상)을 넘으면 해당 변수를 제거하거나 비슷한 변수들을 합치는(변환) 등의 방법으로 문제를 해결
모델 기반 중요도 (Feature Importance)
- 트리 기반 모델(랜덤 포레스트, XGBoost 등)을 훈련 후 중요도가 낮은 변수를 제거

4️⃣ 변수 간 상호작용 추가

다항식 / 교차항 생성
- ex) 2차 다항식(Quadratic Features)
- 제조 공정에서 온도, 압력, 속도 등이 곱해져야 비로소 의미가 생기는 경우가 많음

❓ 다중공선성(multicollinearity)

회귀분석(집값 예측, 매출 예측 등)을 할 때, 여러 설명 변수(독립 변수)를 사용
그런데 이 변수들이 서로 너무 비슷한 정보를 담고 있어 (즉, 서로 강하게 상관이 있어) 모델이 헷갈리는 문제가 생김
이런 다중공선성 문제는 회귀계수(모델 파라미터)의 의미 해석과 모델 안정성을 해침
- ex) 집 크기(㎡)와 방 개수가 거의 정비례한다면, 둘 다 넣었을 때 겹치는 정보가 많아짐
- "방 개수"와 "평수(㎡)"라는 두 변수가 존재
- 방이 5개면 평수도 대체로 넓고, 1개면 대체로 좁을거임 (둘은 서로 높은 상관 관계).
- 둘 다 회귀분석에 넣으면 모델 입장에서 "비슷한 정보가 두 번 들어온 셈"이라, 어떤 변수가 집값에 얼마나 영향을 주는지(독립적 기여도)를 구분하기 어려워짐
- 이런 경우, VIF가 높게 나타난다.

[250929] 머신러닝 01

junecho — Mon, 29 Sep 2025 20:33:12 +0900

✅ 머신러닝 ?

컴퓨터가 인간의 개입 없이(또는 최소한으로) 데이터를 학습하여 패턴을 찾아내고, 새로운 데이터에 대해 예측이나 분류를 수행하는 기술

ex) 스팸 메일 필터링, 이미지 분류, 음성 인식 등

머신러닝의 3대 요소

데이터 (Data)
- : 데이터가 참고하는 정보의 모음
알고리즘 (Algorithm)
- : 문제를 해결하기 위해 순서대로 처리하는 방법이나 규칙
- =모델
컴퓨팅 파워 (Computing Power)
- : 컴퓨터가 얼마나 빠르고 많이 일(연산)을 할 수 있는지를 나타내는 능력치
- 딥러닝에서 중요

머신러닝, AI, 딥러닝

인공지능(AI)
- 사람의 지능적인 작업을 기계가 수행하도록 만드는 광범위한 개념
머신러닝
- AI를 실현하기 위한 방법 중 하나로, 데이터로부터 특징이나 규칙을 찾아내서 학습 하는 것
- ex) 스팸 메일에는 특정 단어나 형태가 자주 등장하는 공통점(패턴)이 있을 수 있는데 이를 자동으로 스팸으로 분류
딥러닝(Deep Learning)
- 머신러닝의 하위 분야로, 사람의 뇌신경을 본 떠 만든 인공신경망으로 이루어져 있음
- 인공신경망을 여러 겹 쌓아서 복잡한 정보를 학습할 수 있음
- ex) 오늘날 많이 유명한 모델들이 여기에 속함 : ChatGPT, 알파고, 알파스타, DALL-E

대량의 데이터 처리와 분석

현대 사회는 매순간 엄청난 양의 데이터를 생성
- 대규모 데이터를 빠르고 정확하게 분석하여, 복잡한 상관관계를 발견하고 예측
기존 방식으로는 처리하기 어려웠던 빅데이터 활용 가능
- ex) SNS에 쏟아지는 게시글, 대형 쇼핑몰의 상품 거래 기록 등
❓ 빅데이터 → 일반적인 방법으로는 저장·분석하기 힘들 만큼 방대한 양의 데이터

머신러닝 vs 기존 통계 분석

통계 분석
- 가설 검증, 추론 (ex. "이 변수와 저 변수 사이에 유의한 관계가 있는가?")
- 주로 "왜?"라는 질문에 집중
머신러닝
- 예측 (얼마나 정확하게 미래나 미지의 데이터를 예측할 수 있는가)
- "얼마나 잘?"에 집중 (정확도, 재현율 등)

✅ 머신러닝 종류

지도학습 (Supervised Learning)

우리가 맞다고 알고 있는 결과값을 정답값(레이블)이 있는 데이터를 학습하는 방식

ex) 고양이 사진에는 '고양이'라는 정답(레이블)을 붙여서, 컴퓨터가 어떤 이미지가 고양이인지 학습 가능

분류 (Classification)
- : 어느 그룹에 속하는지를 결정
- ex) 이메일이 스팸인지 아닌지, 은행 대출 상환 가능 여부
회귀 (Regression)
- : 숫자로 된 결과를 예측
- ex) 주택 가격 예측, 주가 예측

비지도학습 (Unsupervised Learning)

레이블(정답값) 없이 데이터 패턴을 스스로 찾음

군집화 (Clustering)
- : 성향이 비슷한 사람이나 사물을 자동으로 묶어내는 기법
- ex) 고객 군집 분석, 문서 토픽 분석
차원 축소 (Dimensionality Reduction)
- : 데이터의 특징(변수)이 너무 많아서 복잡한 데이터를**, 핵심 정보만 남기고 압축**하는 기법
- ex) 수백 가지 지표가 있는 데이터를 2~3개의 핵심 지표로 요약
- ↔ 변수선택 : 변수를 일부만 택하는 것

강화학습(Reinforcement Learning)

에이전트가 환경과 상호작용하며 보상(Reward)을 최대화하도록 학습

❓ 에이전트 : 학습을 수행하는 주인공, 게임으로 치면 플레이어, 로봇으로 치면 로봇 자체가 에이전트

❓ 환경 : 에이전트가 움직이고 상호작용하는 무대

❓ 보상 : 에이전트가 잘했을 때 얻는 점수(칭찬)나, 잘못했을 때 받는 벌점 같은 개념

ex) 알파고(바둑), 로보틱스, 게임 AI
시뮬레이션 환경에서 시도-오류를 반복하며 **가장 높은 보상을 보장해주는 행동 규칙(전략)**을 학습
참고로 알고있기

✅ 머신러닝 모델링 프로세스

❗ 머신러닝 프로젝트는 단순히 모델만 잘 만든다고 끝나지 않음

데이터 수집부터 배포까지 전체 흐름을 이해하는 것이 매우 중요

1. 데이터 수집

웹 크롤링, 센서 측정, 설문조사, DB 추출 등 다양한 방법
양질의 데이터 확보가 프로젝트의 성패를 좌우
ex) 제조업에서는 공정 라인에 설치된 IoT 센서에서 데이터 지속 수집

2. 전처리 (Preprocessing)

1️⃣ 결측치 처리

: 결측치란 데이터 표에서 일부 셀이 비어 있는 상태
빈 칸을 평균이나 가장 빈도가 높은 값으로 대신 채우거나, 필요하면 빼고(삭제) 분석

2️⃣ 이상치 처리

: 대부분의 데이터 범위에서 심하게 벗어난 값을 해결
ex) 사람 몸무게 데이터가 대개 50~100kg인데, 500kg으로 기록된 경우는 오타 등으로 생긴 이상치일 가능성이 높음

3️⃣ 스케일링

: 각각 다른 단위를 쓰는 데이터(ex : 키는 cm, 몸무게는 kg)를 비슷한 수준으로 맞춰주는 작업
ex) 키는 150~180의 범위를 가지고 있고 몸무게는 50~100의 범위를 가지고 있어서 값의 크기가 다른데, 몸무게와 키 모두 0~1 범위로 바꾸면, 머신러닝 알고리즘이 두 값을 더 공평하게 다룰 수 있음

4️⃣ 범주형 변환

: 글자로 된 정보를 숫자로 바꿔주는 과정
ex) 원-핫 인코딩, 레이블 인코딩 등

❓ 원-핫 인코딩 이란? → 해당 범주에 속하면 1, 아니면 0을 넣는 방식

‘빨강·초록·파랑’이라는 세 범주가 있으면
빨강 = (1,0,0), 초록 = (0,1,0), 파랑 = (0,0,1)

❓ 레이블 인코딩 예시 → 순서대로 숫자를 부여

M=0, L=1, XL=2 …
다만, 숫자에 순위 의미가 생겨버릴 수 있어서 주의가 필요

3. 모델링 (Modeling)

지도학습의 경우 분류/회귀 알고리즘 선택 (ex: 로지스틱 회귀, 랜덤 포레스트, XGBoost 등)
비지도학습의 경우 클러스터링/차원 축소 알고리즘 선택 (ex: K-Means, PCA 등)

4. 성능 평가 (Evaluation)

분류
- Accuracy, Precision, Recall, F1-score, ROC-AUC 등
회귀
- MAE, RMSE, R² 등
비지도(군집)
- 실루엣 계수 등

정리

머신러닝 : 데이터에서 패턴 학습 → 예측/분류 수행
머신러닝, 딥러닝, AI : AI라는 큰 개념 안에 머신러닝, 그 안에 딥러닝
머신러닝 vs 통계 : 예측 성능 vs 가설 검정
머신러닝 학습 종류 : 지도학습, 비지도학습, 강화학습
모델링 프로세스 : 데이터 수집 → 전처리 → 모델링 → 평가 → 최적화 → 배포

[250926] 스파르타코딩 본캠프 39일차

junecho — Fri, 26 Sep 2025 15:51:48 +0900

CODEKATA

어제부터 코드카타 목록에 없는 프로그래머스 SQL 문제 격파중

~ SQL 4페이지 까지 모든 문제 ✔ 완료

어제는 너무 쉬운 문제들밖에 없어서 코드카타 따로 올릴게 없었음

오늘도 그렇긴 한데 함정 문제가 있어서 올려봄

오늘의 총 후기 : 문제를 꼼꼼히 잘 읽자...... (개억울함)

00) 년, 월, 성별 별 상품 구매 회원 수 구하기

SELECT 
    YEAR(s.sales_date) AS year, MONTH(s.sales_date) AS month, 
    i.gender, COUNT(DISTINCT s.user_id) AS users
FROM online_sale s LEFT JOIN user_info i ON s.user_id = i.user_id
WHERE i.gender = 0 OR i.gender = 1
GROUP BY YEAR(s.sales_date), MONTH(s.sales_date), i.gender
ORDER BY year, month, gender

⇒ ⭕

이 문제의 어이없는 점.

GENDER 컬럼은 비어있거나 0 또는 1의 값을 가지며 0인 경우 남자를, 1인 경우는 여자를 나타냅니다.

라고 했으면서, 답안은

이때, 성별 정보가 없는 경우 결과에서 제외해주세요. <<<

저거 못보고 계속 아 왜 결과가 틀렸다고 하지 하고 다시 읽어보니까 결과에서 제외하래 ㅠ 그럼 NULL값이 남자라고 알려주지 말던가~~~~ 개낚임

QCC

1번

SELECT COUNT(business_entity_id) AS customer_count
FROM person
WHERE email_promotion = 1 OR email_promotion = 2

아 문제 대충 안읽어서 틀림 ㄹㅈㄷㅋㅋ
개인(소매) << 고객의 수 였구나 미친 ~~~개웃김 ㅠ
WHERE person_type = "IN" 넣게 해주세요 젠장ㅋㅋ

문제 대충 읽어서 2번 맞고 1번틀린 바보 저에요

2번

-- 2011-10 동안 / 취소 안된 거래 / 총 주문 수량
WITH cnt AS (
  SELECT sh.customer_id, SUM(sd.order_qty) AS cnt
  FROM sales_order_header sh LEFT JOIN sales_order_detail sd ON sh.sales_order_id = sd.sales_order_id
  WHERE sh.order_date LIKE "2011-10%" AND sh.status != 6
  GROUP BY sh.customer_id
),
-- 총 주문수량 70이상 & 고객 이름 찾기 위한 join 
sum70 AS (
  SELECT cnt.customer_id, cnt.cnt, cus.person_id
  FROM cnt cnt LEFT JOIN sales_customer cus ON cnt.customer_id = cus.customer_id
  WHERE cnt >= 70
)
  
SELECT s.customer_id, p.first_name, p.last_name, s.cnt AS total_quantity
FROM sum70 s LEFT JOIN person p ON s.person_id = p.business_entity_id
ORDER BY s.customer_id

와 2번 제출하고 자리 와가지고 다시 코드 보는데, 총 수량 컬럼 total_quantity 으로 이름 안바꿔놔서 개 식겁함 ㄷㄷㄷㄷ

그래서 수정하고 다시 제출했더니 재제출 돼서 다행이었순 휴~~~

[250925] 스파르타코딩 본캠프 38일차

junecho — Thu, 25 Sep 2025 22:08:39 +0900

✅ 통계 라이브 세션 정리

https://www.notion.so/250917-32-i_hate_statistics-01-271c9c8dda7e806c877ac817bda5375a?source=copy_link

[250917] 32일차 - i_hate_statistics 01 | Notion

✅ 통계학 2가지 유형

www.notion.so

https://www.notion.so/250918-33-i_hate_statistics-02-273c9c8dda7e802a83d0c1fdbe363df9?source=copy_link

[250918] 33일차 - i_hate_statistics 02 | Notion

✅ 대표값

www.notion.so

https://www.notion.so/250919-34-i_hate_statistics-03-273c9c8dda7e8030b316dcea1b23f3c2?source=copy_link

[250919] 34일차 - i_hate_statistics 03 | Notion

✅ 확률

www.notion.so

https://www.notion.so/250922-35-i_hate_statistics-04-276c9c8dda7e80259b4fcf233e374146?source=copy_link

[250922] 35일차 - i_hate_statistics 04 | Notion

모집단 전체를 다보는 건 불가능 → 표본만 관찰

www.notion.so

https://www.notion.so/250924-37-i_hate_statistics-05-278c9c8dda7e808fb21bcbe95f8d5efa?source=copy_link

[250924] 37일차 - i_hate_statistics 05 | Notion

✅ 상관

www.notion.so

[250924] 스파르타코딩 본캠프 37일차

junecho — Wed, 24 Sep 2025 16:06:06 +0900

CODEKATA

~ 105문제

101) Product Sales Analysis III

# 1차 코드
WITH first AS (
    SELECT product_id, MIN(year) AS first_year
    FROM sales
    GROUP BY product_id
)
SELECT f.product_id, f.first_year, s.quantity, s.price
FROM first f JOIN sales s ON f.product_id = s.product_id AND f.first_year = s.year

⇒ ⭕

어제 풀었던 문제랑 비슷한 양상인데 WITH 안쓰고 어떻게 해보려다가 기억이 안나서 그냥 WITH씀

효율 좋은건 역시나 WITH 안쓰는 쿼리였다

WITH 안쓰면서 다시 짜보자

어제 풀은 문제의 효율 1등 코드를 참고해서 짰음

# 2차 코드
SELECT a.product_id, a.first_year, s.quantity, s.price
FROM (
    SELECT product_id, MIN(year) AS first_year
    FROM sales
    GROUP BY product_id
) a LEFT JOIN sales s ON a.product_id = s.product_id AND a.first_year = s.year

⇒ ⭕

굿

FROM 절에다가 또 서브쿼리 쓸바에 WITH로 항상 뺐기 때문에 FROM에다가 박기는 좀 낯설음

FROM 절에다가 서브쿼리 박는게 효율이 쥐똥만큼 더 좋긴 한데,

솔직히 가독성 좋은건 WITH지 않나 ㅎ? (WITH교 신도의 의견)

105) Customers Who Bought All Products

SELECT c.customer_id
FROM customer c LEFT JOIN product p ON c.product_key = p.product_key
GROUP BY c.customer_id
HAVING COUNT(DISTINCT c.product_key) = (SELECT COUNT(DISTINCT product_key) FROM product)

⇒ ⭕

오 딱 HAVING에 서브쿼리만 쓸 수 있으면 바로 풀리는데…! 하면서 검색해봤더니 ㄹㅇ 쓸 수 있었음

처음에 c.product_key에도 DISTINCT 안먹이고 했다가 서버 테스트에서 틀렸다고 하길래,

테스트케이스로 가져와서 하나하나 출력해보니까 product_key를 같은 걸 여러번 사는 경우도 있었음!

그래서 DISTINCT 먹이고 해결 완료