이런게 실전 협업인가...

협업 시 어떻게 대화를 해야할지 의견을 구할 지인이 내 주변엔 없다^^;

일 재미있게 하고싶은데 효율적으로 일하고싶은데 어렵다

대화스킬이 필요하다.

그동안 배울때 Git Bash로만 진행을 해왔기 때문에 툴이라는 생각을 못하고

원본 저장소(repository)를 통째로 복사해서 내 계정에 새로운 저장소를 만드는 것

이라고 알고 있었다.

* fork 설치 방법

https://git-fork.com/ 로 접속 후 환경에 맞게 다운로드

* fork 실행

• clone

  File - Clone - Repository Url 설정 - Parent Folder 설정 - Name 설정 - Clone 아이콘 클릭

  
  
  

* Git Flow

Repository - Git Flow - Initialize Git Flow... 

Branch명 설정 - Feature Prefix : feature/기능구현이름 설정 - Initialize Git Flow

Local Changes - 로컬에서 변경된 사항
All Commits -  현재까지 모든 commit사항
Open in - IDE 사용 가능

* commit 방법

작업 후 로컬에서 변동사항이 생기면

Local Changes(숫자)로 변함 -> Unstaged 에서 파일 눌러서 변동사항 확인 후 그대로 진행하려면 Stage 클릭 

Unstaged -> Staged로 넘어감  // 잘 못 넘겼을 시 Unstage누르면 다시 되돌아감.

coommit 내용을 입력 한 후  Commit Files 버튼 클릭.

* push 방법

Push 클릭 - Branch 설정 - Remote 설정(우선 협업시에는 로컬에서  원격origin을 우선적으로 / upstream은 원본 저장소) - push

* PR보내기(pull request)

내 원격 저장소에서 pull request 클릭 -  협업시 base를 내 브랜치로 설정 - compare는 작업한 브랜치 설정 - Create pull request 클릭 - 다시 확인 후 진짜 괜찮으면 Create pull request 클릭

회사나 사용하려는 서버에 ID와 PW 그리고 공개키가 등록이 되어있어야 가능함!

1. 공식 사이트에서 PuTTY 설치 설치하면 같이 깔리는 PuTTYgen 도 필요(키 변환용)

2. 키 변환 (필수)

PuTTY는 OpenSSH 키(id_ed25519)를 바로 못씀. PuTTY 전용 PPK 파일로 변환

- PuTTYgen 실행
- 메뉴에서 Conversions → Import key 선택
- C:\Users\user\.ssh\id_ed25519 선택 (개인키 파일)
- "Save private key" 버튼 → 예를 누르고 저장 (예: id_ed25519.ppk)

3. PuTTY 설정

   Session 탭
   Host Name: IP주소
   Port: 포트번호
   Connection type: SSH
   

Connection → Data Auto-login username: 본인 ID

Connection → SSH → Tunnels Source port: 11434 Destination: 127.0.0.1:11434 선택: Local , Auto Add 클릭 → L11434 127.0.0.1:11434가 목록에 생겨야 함

Connection → SSH → Auth → Credentials "Private key file for authentication" → 아까 만든 id_ed25519.ppk 선택

다시 Session 탭에서 "Saved Sessions"에 이름 입력 (예: my_server) "Save" 클릭

4. 접속하기

Saved Sessions에서 my_server 선택 → "Open" → 바로 로그인 ```

~/.ssh/

이 폴더 안에 id_rsa.pub, id_ecdsa.pub, id_ed25519.pub 같은 파일이 있으면 그게 공개키

키가 없을 때

* Ed25519 방식

• 알고리즘: 타원곡선 기반(Elliptic Curve), 최신 암호화 방식.
• 키 길이: 별도 지정 불필요 (항상 256비트, RSA 3072~4096비트와 비슷하거나 더 안전).
• 장점: 생성 속도와 인증 속도가 빠름. 키 길이가 짧아서 관리하기 편리. 현대적인 보안 표준에 맞음.
• 단점: 극히 오래된 서버/시스템에서는 지원 안 될 수 있음 (하지만 요즘은 거의 다 지원).

ssh-keygen -t ed25519 -C "이메일주소"

→ id_ed25519(개인키), id_ed25519.pub(공개키)가 생김

* RSA 방식

• 알고리즘: RSA (전통적인 공개키 암호 방식).
• 키 길이 지정 가능: -b 4096 → 키 길이를 4096비트로 생성 (보안 강도 ↑).
• 장점: 아주 오래된 서버/시스템까지 대부분 지원.
• 단점: 키 길이가 길어질수록 연산 속도가 느려지고, 저장 공간도 더 차지함.

  ssh-keygen -t rsa -b 4096 -C "이메일주소"

  → id_rsa(개인키), id_rsa.pub(공개키)가 생성.

정리

RSA 4096: 호환성 최고, 보안도 충분히 강함. (구형 서버까지 다 대응하고 싶으면 선택)

Ed25519: 최신 권장 방식, 빠르고 짧고 안전함. (특별히 구형 시스템 쓸 게 아니라면 이걸 추천)

6개월간 진행한 포트폴리오를 정리하고,이력서를 작성하고, 자기소개서고 작성했다. 그 후 수정에 수정에 수정을 거치고, 여기저기서 첨삭과 컨설팅도 받고, 또또또 수정에 수정.

틈틈히 평일과 주말마다 사이즈 프로젝트와 개인학습까지 하다보니 어느새 3주가 흘렀다. 어쩌다 보니 첫 면접을 보았고 느낀 것이 많아 이제부터는 종종 중요한 일들을 회고로 남겨보기로 마음먹었다.

2월달의 나의 목표는 수료 후 한달안에 취업하는 것이였는데, 하나같이 비전공자에 전문학사, 무경력, 어학점수X 이런 스펙으로는 이력서를 기본 400~500개는 넣어야 그나마 취업을 할 수 있다고한다. 또한, 신입부터 연봉협상을 잘하고 들어가야한다는 이야기까지..

전문직에 있어서인지 개인적인 생각으론 내가 열심히하면 내 능력만큼 자연스럽게 오르는게 연봉이다.라고 생각하는 입장이라 초봉은 그렇게 중요하다고 생각을 해본적이없다. 그런데 이쪽 직종은 그게 아닌가? 이런저런 이야기를 들으니 더 더욱 취업 준비가 어려웠다. 하지만, 20대때 내가 그랬듯이 난 여전히 초봉은 크게 관여치않기로했다.

드디어 모든 서류의 수정을 마쳤다. 나에게로 이력서를 넣는 날이 오는구나! 이력서를 넣으면서 알게된 사실은 좀 충격적이였다 누가 IT는 학력을 안본다고 했나 안그런 회사도 있겠지만, 전문학사는 이력서를 넣어도 서류확인 안한다는 소식을 들었다. 그 소식은 날 더 자극하였고 그날에만 약 20개의 회사에 이력서를 넣었다. 지원하는데 돈드는 것도 아니고 보던말던 난 넣을거야!! 심보였던 것 같다.

그렇게 약 30개 정도의 회사에 이력서를 넣고 정말 오랜만에 전 직장 동료들을 만나 점심을 먹고있는데 나에게도 면접제의가 왔다. 아니, 200~300개는 넣어야 면접 볼까말까라며...? 난 서류만 끝냈고 면접은 준비가 안됐는데 걱정이 되면서도 기분좋은 떨림이 돌았다.

스타트업, 소규모회사, 복지 이것저것 따지지않고 상관없이 나의 경력을 터줄 곳을 찾은게 신의 한수였나보다.

내 인생에 이런 스타일의 면접을 보게되는 날이 오다니! 전공이 피부미용인지라 인생 첫 취업은 교수님 직장으로 면접같은거 없이 조기취업으로 들어갔었고, 그 뒤로는 경력이 있으니 이력서를 내면 짧게 인사형식 35분 그 후 바로 실전 데모를 1020분정도 하는게 내 삶의 면접방식이였는데 드라마에서만 보던 여러면접관들앞에 앉아서 구두로 보는 면접을 내가 하게되었다.

부트캠프를 진행하면서도 면접에대한 많은 이야기를 들었던터라 걱정을 많이했다. 질문에 한마디도 대답을 못하면 어떻게하지?

실은 근 10년간 1:1으로 고객과 단둘이 근육,피부에 대한 얘기만하다보니 여러사람과 이야기하는 것, 많은 사람들앞에서 내 의견을 말하는것, 목소리를 크게 내는 것, 피부 쪽이 아닌 다른 주제로 내 생각을 잘 전달하거나 표현하는 법이 엄청나게 퇴화 된 걸 스스로도 느꼈기에 더 걱정을 했다.

그래 자기소개조차 버벅거리면 얼마나 멍청해보일까 그거라도 안떨고 말할 수 있게 연습하자! 생각했고, 거짓말 안하고 100번 이상 연습했다.

• 다른말은 잘 못해도 자기소개는 하고 나올 수 있겠지.
• 그래 30개 넣는게 면접들어온게 어디야 경험이다 생각하고 여유롭게 마음 먹자
• 처음하는 경험이지만 프로젝트와 포트폴리오작성도 그랬듯이 하다보면 결과는 나오겠지

계속 마인드 컨트롤을하면서 첫 면접을 갔다.

첫 면접 회고 (+ 취업)

2025년 9월 18일 성수동 스타트업 회사 11시

• 간단한 자기소개 없이 시작
• 40분 기술문제풀이세션
• 문제풀이방식 설명
• 기술면접 + 인성면접

이렇게 진행되었다. 결과는 처참..... 그래도 배운건 정말 많았다.

• 기술문제 풀이 설명시 타인에게 전달방식 미숙

• -> 방향성은 맞는데 설명이 많이 부실하다는 평을 받음.

• 기본적인 에러펑션에 대한 무지

• -> 기본적인 지식조차 숙지가 안된 느낌.

• AI부트캠프를 듣게된 과정 전달미스

• -> 흥미를 쉽게 느끼고 쉽게 식는다는 느낌을 줌. 끝맺음을 안하는 사람이 되어버림.

• 전문용어 무지

• -> 질문의도 잘못파악 + 엉뚱한대답

• 학점은행제를 선택한 이유와 진행방식의 부조화

• -> 더 공부하려고 시작했는데 왜 자격증취득으로 학점대체를 했는지 부가설명 부족 바로 면접관이 의문을 품고 역 질문하게 됨.

• '아!네! 아닙니다!' 의 남발

• -> 면접과 질문에 네라고 대답을 한건지 아니라고 대답을 한건지 불분명.

• 너무 떨어서 말의 끝맺음이나 확실한 의사표현을 못함

• -> 어리숙한 모습으로 보여짐.

• 성격 묻는 질문에 업무역량이랑 관련없는 말을 함

• -> 낮을 많이 가리는 편이지만 친해지면 정이많다.

• 추가 공부

• -> Node.js / LangGraph / Typescript

-> 성격 답변은 다시 생각해도 수치풀...🤦‍♀️

더 많은 부분에서 이 부분이 문제구나! 집에가서 회고써야겠다! 했는데.. 기억이 저것뿐이다.. 더 많았던것같았는데

인생 첫 면접다운 면접이였는데 내가 너무 이상하게 면접을 본건지 중간에 면접관 중 한분이 '그 전 면접보셨을거잖아요?' 라고 하셨고, 나는 염소 목소리로 '아? 아니요 첫 면접입니다!' 라고했다...하하하하 그래서일까?

뉴비네 뉴비야 허허허, 
열심히도 삐약삐약 하는구나 허허허,
질문 의도를 좀 더 자세히 설명을 해줘야겠다. 

이런 느낌을 받았다. 감사합니다! 덕분에 면접이 조금 덜 무서워습니다!!!

우선 오늘 회고한 부분은 내일있는 면접때 설명을 보완해야겠다. 300~400개 넣으면 30곳은 볼수있을까? 30곳을 보게되면 면접이 쉬워지기는할까?? 아무튼 다음면접부터는 사진도 찍어와야징

+ 추가 의문

• 집에와서 자고일어나니 의문이 들었다 기술문제풀이에 llm을 쓰라고 했기에 그 안에서만 생각을 했고 어쩌피 llm쓰는거 수량과 가격도 받오면 되겠다 생각했는데 다시 생각해보니 쓸 필요가 없을 것 같다.

• PDF에서 이미지 텍스트를 추출한 후,

• 이미지의 픽셀을 이용해서 색을 추출하고,

• 사람이 읽을수 있는 색 이름으로 변환하고,

• 텍스트에서 수량과 가격을 추출하고 그렇게되면 llm을 굳이? 구현만 해놓으면 비용을 아끼는 방법이 되지않을까?

두번째 면접 회고

2025년 9월 19일 안암동 소규모 회사 10시

• 간단한 자기소개 시작
• 1시간 기술면접 + 인성면접

드디어 예상하고 준비한 간단한 자기소개로 시작하는 면접을 봤다. 어제처럼 염소되지않으려고 최대한 천천히 말을 하려고 노력했고, 문장의 끝맺음을 확실히하려고 했다. 어제보다는 조금은 수월하게 대답했고, 30분 ~ 1시간정도 본다했던 면접은 1시간을 조금 넘겨 끝이났다!!! (그마저도 면접관 중 한 분께서 1 시간을 꽉 채웠네요. 하면서 정리를 하셨다. 일정이 후에 또 있으신가?)

• 재귀함수의 단점

• -> 서버과부화가 아닌 메모리부족

• -> 기초중에 기초인데 공부 더 해야겠다.

• 정확하고 디테일한 정보 부족

• -> 어제와 마찬가지로 트랜스포머가 뭔가요? 하는 식의 질문에 디테일하고 명확한 설명이 부족했다.

• 개발자 F12모드가 막힌 이유에대해 생각해봤는지

• -> 사이드 프로젝트를 진행중인데 신한은행 대출상품 크롤링 시 개발자 모드가 안켜져서 다른 크롤링방식을 찾고있다 말했는데, 그 이유가 뭔지 질문하셨다. 금융쪽이라 보안때문인가했는데 원하는 답이 아닌 것 같았다. 전혀 생각해본적없는 뱡향이라 당황했고 목표는 크롤링이라 크롤링을 할 수 있는 방향성에 대해서만 생각을 해봤지 왜 막혔는지 생각해본적은 없다고 답했다. (신한은행 api 이용)

• 어학점수의 부재

• -> 이 부분은 스스로도 많이 느끼고 있는 부분이라 취업하고 회사에 적응이되면 공부해서 취득해 보려고한다.

• fhir 추가 공부

• -> 의료 시스템 간 데이터 상호운용성을 보장하기 위해 만들어진 국제 표준

어제와 다른 면접분위기에 또 면접 경력이 쌓였구나!!! 가볍게 생각하면서도 한편으론 기대를 하며 회사를 나왔다. 나와서 생각해보니 급여도 안물어본거면, 가망이없는거였나?

아ㅜㅜ 내가 하고싶던 헬스케어 분야였고, 코드리뷰도 매번 다 봐주신다고했고, 여직원도 둘이나 있고!!!!! -> 제일 좋았다 점심 천천히 먹을 수 있겠지...? 두분 다 인상도 좋으셨고 편안한 마음이 들었다. 건물이 노후되서 겨울에 추울것 같은 것과 엘레베이터가 없는 것 화장실이 외부 건물 공용이라는거 빼면 다 좋았다!

합격 전화

근처에 사는 친구와 오랜만에 밥을 먹으려고 약속을 잡아둔터라 면접이 끝났고 고대에서 출발하니까 10분정도면 도착한다고 전화를 한 후 핸드폰을 보니 10시 15분쯤 부재중이 와있었다.

어제 면접 본곳..? 문자도 없었다.

너무 처참하게 망했던터라 그저 '오늘 면접 볼 사람이 늦어서 전화한다는걸 착오로 나한테 한건가?'라는 생각이 제일 먼저 들었다. 문자로 부재중전화를 확인했다고 남겼고 바로 전화가왔다. 핸드폰 넘어로 내가 합격했다고 말하는 소리가 들렸다....

엥? 왜지? 나를??

생각이 들었지만 그저 좋았다. 6개월을 또 취업준비해야하나 싶었는데.. 감사한 마음으로 가야지! 나도 이제 직장인이다!!!!! 경력을 야무지게 쌓아야지!!! 어디가서 나도 이제 개발자라는 말을 할 수 있게되다니 감격이다!!!

너무 심장이 콰쾅거려서 손이 덜덜덜 팟타이를 코로 먹은건지 입으로 먹은건지. 암튼좋다! 추가로 월급이 백이상 줄었으니...씀씀이를 줄여야겠다ㅠㅠ 맛있는 음식들 안녕.....

1. FastAPI 기본 실행 작성코드

# main.py
from fastapi import FastAPI

app = FastAPI()

@app.get("/")
def read_root():
    return{"Hello":"world"}

get은 조회 용도

2. 엔드포인트(API) 기능 코드 작성

# main.py 
from fastapi import FastAPI

app = FastAPI()

@app.get("/")
def read_root():
    return{"Hello":"World"}

@app.get("/item/{item_id}")
def read_item(item_id:int, q:str = None):
    return {"item_id":item_id, "q":q}

3. 엔드포인트(API) 기능 코드 분리

router폴더를 만들고 그 안에 _init_.py 폴더와 엔드포인트.py 파일 생성 후 엔드포인트.py에 코드 분리시키기 main.py에 작성해둔 items 기능 코드를 items.py로 이동시킴

# router/items.py

from fastapi import APIRouter

router = APIRouter()

@router.get("/items/{item_id}")
def read_item(item_id: int, q: str = None):
    return {"item_id": item_id, "q": q}

그 후 main.py에 router/items.py 로 옮겨준 코드를 연결시킴 이때, prefix와 tags 그리고 description 지정할 수 있음

# main.py

from fastapi import FastAPI
from routers import items

app = FastAPI()

@app.get("/'")
def read_root():
    return {"Hello":"World"}

app.include_router(items.router, prefix="/items" tags = ["items"])

연결시켜줄 때 prefix를 지정하면 router/items.py에서

@router.get("/items/{item_id}")를 
@router("/{item_id}")로 바꿔줘야함.

* prefix="/items" 란?

이 라우터(items.router) 안에 있는 모든 경로(path) 앞에 자동으로 /items를 붙여줌

* tags = ["items"] 란?

Swagger UI(/docs)에서 이 라우터에 속한 API들을 "items"라는 그룹으로 묶어줌.

* description 이란?

Swagger UI(자동 문서)에서 API 설명을 보여주고 싶을 때 쓰는 옵션

# 엔드포인트(라우트) 전체 설명 

# router/items.py
from fastapi import APIRouter

router = APIRouter()

@router.get(
    "/{item_id}",
    description="아이템 ID로 특정 아이템을 조회합니다. "
                "q 파라미터를 넣으면 검색 조건이 추가됩니다."
)
def read_item(item_id: int, q: str = None):
    return {"item_id": item_id, "q": q}

• 엔드포인트(라우트) 전체 설명

# 개별 파라미터 설명

# router/items.py

from fastapi import APIRouter, Path, Query

router = APIRouter()

@router.get("/items/{item_id}")
def read_item(
    item_id: int = Path(..., description="조회할 아이템의 고유 ID"),
    q: str | None = Query(None, description="검색 필터에 사용할 문자열")
):
    return {"item_id": item_id, "q": q}

• 개별 파라미터 설명

- FastAPI 주요 파라미터 타입 정리

• Field와 Body의 차이

Rust로 개발한 초고속 파이썬 패키지 & 프로젝트 매니저

UV의 역할

UV는 파이썬 개발에 필요한 여러 도구를 하나로 합친 것

• pip 대체 : uv pip install fastapi → pip보다 10~100배 빠른 설치
• pip-tools 대체 : uv pip compile → requirements 락파일 생성
• virtualenv/venv 대체 : 프로젝트마다 자동 가상환경 관리 (uv run, uv add)
• pipx 대체 : uvx ruff check . → 설치 없이 툴 실행
• pyenv 대체 일부 : uv python install 3.12 → 파이썬 버전 설치/관리

즉, 파이썬 환경 세팅 + 패키지 관리 + 툴 실행 + 파이썬 버전 설치를 올인원으로 해결하는 툴

UV의 특징

속도

Rust로 구현돼서 pip 대비 훨씬 빠름 캐싱/병렬 설치 최적화 → 수십~수백 배 성능 향상 가능

호환성

uv pip … 인터페이스는 pip와 거의 동일해서 기존 습관 그대로 사용 가능. requirements.txt 워크플로도 지원.

통합성

한 도구로 가상환경, 패키지, 툴, 파이썬 버전까지 관리 가능. 별도 pip, pipx, pyenv, poetry를 오가며 쓸 필요가 줄어듦.

자동 관리

uv run … 실행 시 자동으로 프로젝트 전용 venv 생성/사용. 사용자는 activate/deactivate 같은 걸 직접 안 해도 됨.

+ uv 와 uvicorn

uv = 패키지/환경/런타임 관리 도구 uvicorn = ASGI 서버 (FastAPI 실행할 때 쓰는 서버, 이름만 비슷)

설치

• macOS / Linux

curl -LsSf https://astral.sh/uv/install.sh | sh

• PowerShell(Windows)

powershell -ExecutionPolicy ByPass -c "irm https://astral.sh/uv/install.ps1 | iex"

• CMD(Windows)_스탠드얼론 설치

powershell -ExecutionPolicy Bypass -Command "iwr https://astral.sh/uv/install.ps1 -UseBasicParsing | iex"

• 추후 업그레이드 시

  uv self update

또는

• CMD(Windows)_pipx 설치

python -m pip install --user pipx
python -m pipx ensurepath
pipx install uv

• 추후 업그레이드 시

  pipx upgrade uv

설치 확인

uv --version

중요) pip install uv 로 설치하게 되면 설치되는 위치가 현재 실행 중인 파이썬 환경에 따라 달라짐

이 경우:

-다른 프로젝트에서 패키지 버전이 충돌할 수 있고, -PATH 설정이 꼬이면 uv 명령이 안 잡히거나, 특정 가상환경 안에서 인식이 안 될 수도 있음

그래서 공식 문서도 pip install uv보다는 curl로 스탠드얼론 설치하거나 pipx install uv로 격리 설치를 추천 이렇게 하면 시스템 파이썬에 섞이지 않고, 항상 깨끗한 uv 실행 파일을 전역에서 쓸 수 있음.

프로젝트 초기화

uv init --app

현재 디렉토리에 pyproject.toml이 생김

fastapi 설치

uv add fastapi[standard]

+ uv add fastapi 와 uv pip install fastapi 의 차이

둘 다 패키지를 설치하지만, 쓰임새와 관리 방식이 다름.

* uv pip … (pip 대체 모드)

기존 pip를 빠르게 대체하는 모드 requirements.txt나 수동 패키지 설치에 익숙한 경우 그대로 사용 가능 가상환경 : 원하면 직접 python -m venv .venv 같은 걸 만들어야 함 => 기존 pip 워크플로우와 100% 유사하게 쓰고 싶을 때

 uv pip install fastapi
uv pip list
uv pip uninstall fastapi

* uv add … (프로젝트 모드)

pyproject.toml + uv.lock 기반의 프로젝트 단위 패키지 관리 pyproject.toml 파일을 수정하고, uv.lock을 자동 생성 프로젝트 의존성을 기록하고 재현성 보장 가상환경 : 프로젝트마다 자동으로 venv를 생성하고 관리함 => 팀 단위 협업, CI/CD, 재현 가능한 환경을 원할 때

uv init --app             # 프로젝트 초기화 (pyproject.toml 생성)
uv add fastapi[standard]  # fastapi 추가 → toml/lock 자동 업데이트
uv run fastapi dev        # 프로젝트 실행 (자동 가상환경)

+ fastapi와 fastapi[standard] 차이점

-uv add fastapi 만 하면 필수 의존성만 설치 (uvicorn은 빠져있음) -uv add fastapi[standard] 를 하면 uvicorn, python-dotenv 등 개발용에 필요한 라이브러리까지 같이 설치

main.py 실행

uv run fastapi dev main.py          # 배포 시 부적합

또는

uv run uvicorn main:app --reload    # 배포 시 사용 가능

+ uv run fastapi dev main.py 과 uv run uvicorn main:app --reload 차이

명령어	내부 동작	편의 기능	적합한 상황
uv run fastapi dev main.py	Uvicorn 실행 (자동 감지)	.env 로드, 파일 자동 검색, 개발용 기본 설정	개발 환경 (학습/실험)
uv run uvicorn main:app --reload	직접 Uvicorn 실행	없음 (옵션 직접 지정 필요)	개발/운영 모두 (더 명시적)

입력 데이터의 흐름이 앞으로만 전달되는 신경망
이전 장에서 배웠던 완전 연결 신경망과 합성곱 신경망이 모두 피드포워드 신경망에 속함

순환 신경망(RNN)

RNN은 일반적인 완전 연결 신경망과 거의 비슷
뉴런의 출력이 다시 자기 자신으로 전달
어떤 샘플을 처리할 때 바로 이전에 사용했던 데이터를 재사용(이전 샘플의 정보를 가지고있음)

- 타임스텝 : 샘플을 처리하는 한 단계를 의미(한 샘플의 시퀀스의 길이)
- 셀 : 순환신경망에서의 층을 의미
- 은닉상태 : 셀의 출력을 의미

tanh 함수

은닉층의 활성화 함수로 하이퍼볼릭 탄젠트 함수사용
tanh 함수는 s자 모양을 띄어 시그모이드 함수라고도 불리지만, 시그모이드 함수와 달리 -1 ~ 1 사이의 범위를 가짐
순환신경망의 활성화함수로 많이 사용

순환 신경망의 가중치 크기(모델 파라미터 수)

완전연결망가중치(은닉층X뉴런) + 순환망가중치(뉴런^2) + 각 뉴런 절편

순환층의 입력과 출력

샘플마다 2개의 차원을 가짐.
보통 하나의 샘플을 하나의 시퀀스라고 말함.
시퀀스 안에는 여러 개의 아이템들이 있고 이 길이를 타임스텝이라고 함.

by. 정민님

순환 신경망(RNN, Recurrent Neural Network)

순차 데이터

텍스트나 시계열 데이터(일정한 시간 간격으로 기록된 데이터)와 같이 순서에 의미가 있는 데이터를 뜻한다

ex) “I am a boy” 는 이해되지만 “boy am a I”는 말이 되지 않는다

 순환 신경망에서는 마지막 셀의 출력이 1차원이기 때문에 Flatten 클래스로 펼칠 필요가 없다. 셀의 출력을 그대로 밀집층에 사용할 수 있다.

SimpleRNN

RNN은 이전 시점의 출력을 다음 시점의 입력으로 넘겨서, 시간 순서대로 한 스텝씩 도장 찍듯이 처리하는 신경망이다.

즉, 파란 네모(정답)을 예측하기 위해 노란 네모(같은 행의 값)를 주는 것이 아니라, 빨간 네모(4개행의 각 데이터/하나의 윈도우)를 제공하는 방식이다.

뉴런의 출력이 다시 자기 자신으로 전달된다

= 어떤 샘플을 처리할 때, 바로 이전에 사용했던 데이터를 재사용한다

즉, 이전 타임스텝의 샘플을 기억하지만 오래될수록 순환되는 정보는 희미해진다.

OA는 A를 처리 후 출력된 결과이다. OA는 다시 뉴런으로 들어가, B를 처리할 때 같이 사용된다. = OB는 A에 대한 정보가 어느정도 포함되어 있다. OC에는 OB를 사용하므로, A와 B에 대한 정보가 어느정도 들어있다. 이때, 상대적으로 B에 대한 정보가 더 많이 들어있을 것이다.

셀(cell) : 순환 신경망에서 층을 부르는 말

은닉상태(hidden state) : 셀의 출력

RNN 코드

1. 데이터셋 생성

   30일치 과거 데이터를 기반으로 다음날을 예측하기 위한 구조

    from torch.utils.data import Dataset, DataLoader
    import pandas as pd
    import numpy as np
    class NetflixDataset(Dataset):
      def __init__(self,csv_path):
        df = pd.read_csv(csv_path)
        self.data = df.iloc[:,1:4].to_numpy()
        # 0과 1 사이로 정규화
        self.data = self.data / np.max(self.data)
        # 정답(종가)
        self.label = df.iloc[:,-1].to_numpy()
        self.label = self.label / np.max(self.label)
      def __len__(self):
        return len(self.data) - 30 #시작일로부터 30일치 데이터이므로 (시계열 데이터이기때문에 가능)
      def __getitem__(self,idx):
        data = self.data[idx: idx+30]
        label = self.label[idx+30]
        return data, label

2. 데이터 분류

   시계열 데이터는 shuffle 금지!!!

    netflix_dataset = NetflixDataset('/content/train.csv')
    data, label = next(iter(netflix_dataset))
    netflix_dataloader = DataLoader(netflix_dataset, batch_size=32)
    data, label = next(iter(netflix_dataloader))
    data.shape, label.shape

3. 모델 정의

    import torch
    import torch.nn as nn
    class NetflixRnn(nn.Module):
      def __init__(self):
        super().__init__()
        #RNN 계층: 입력 feature의 수 / batch_first: 입력의 모양을 배치우선으로 (B, Seq_len, input_size) 로 만든다는 뜻
        self.rnn = nn.RNN(input_size=3, hidden_size = 10,num_layers=5,batch_first=True)
        # RNN 출력 (batch_size, seq_size,hidden_size) (32,30,10)
   
        # RNN 출력 전체를 flatten 후 Linear 통과
        self.linear1 = nn.Linear(in_features=30*10, out_features=100)
        self.linear2 = nn.Linear(in_features=100, out_features=1) #값을 예측하고 있으니까 출력은 1개
   
        self.relu = nn.ReLU()
   
      def forward(self,x,h0): #h0는 초기 은닉 상태
          # RNN 통과: x -> 모든 시점의 hidden output, hn -> 마지막 hidden state들
        x, hn = self.rnn(x,h0) # x shape: (batch_size, 30, 10)
   
        x = torch.flatten(x,start_dim=1) # x shape: (batch_size, 300)
   
        # 분류기 부분 통과
        x = self.relu(self.linear1(x))
        x = self.linear2(x)
        return x

4. 모델 생성 및 학습

    from tqdm import tqdm
   
    #모델 생성
    netflix = NetflixRnn()
    device = "cuda" if torch.cuda.is_available() else 'cpu'
   
    # 손실 함수: 평균 제곱 오차(회귀 문제이므로)
    loss_fn = nn.MSELoss()
    # 학습률, 에포크 설정 
    lr = 1e-4
    epocs = 200
    # 옵티마이저: Adam 사용
    optim = torch.optim.Adam(netflix.parameters(),lr=lr)
    # 모델을 디바이스에 할당
    netflix = netflix.to(device)
   
    # 모델 학습 루프 
    for epoch in range(epocs):
      iterator = tqdm(netflix_dataloader)
      epoch_loss = 0.0
      for data, label in iterator:
        # 텐서의 학습은 기본인 torch.float32 타입, 형태: (batch_size, 1)
        label = label.reshape(-1,1).to(torch.float32).to(device)
        # 입력 데이터도 float32 
        data = data.clone().detach().to(torch.float32).to(device)  # float -> 32bit
        # 초기 은닉 상태 0으로 초기화
        h0 = torch.zeros(5,data.shape[0],10).to(device)  # num_layers, batch_size, hidden_size
        # 예측
        pred = netflix(data,h0)
        # 손실 계산 및 역전파
        loss = loss_fn(pred,label)
        loss.backward()
        # 가중치 업데이트
        optim.step()
        optim.zero_grad()
   
        epoch_loss += loss.item()
        iterator.set_description(f"loss : {loss.item()}")
      # 에포크별 평균 손실 출력
      print(f'epoch : {epoch + 1}  loss : {epoch_loss / len(netflix_dataloader)}')
    # 학습된 모델 저장
    torch.save(netflix.state_dict(), "netflix.pth")

5. 평가

    # 저장된 모델 불러오기
    loaded_model = NetflixRnn()
    loaded_model.load_state_dict(torch.load('netflix.pth', map_location=device))
    loaded_model.eval()
   
    pred_lists = []
    total_loss = 0.0
    # 평가 시 batch_size=1로 설정
    loader = DataLoader(netflix_dataset,batch_size=1)
   
    # 평가 루프 
    with torch.no_grad():
      for data ,label in loader:
        h0 = torch.zeros(5,data.shape[0],10).to(device)
        # 예측 수행
        predict = loaded_model(data,h0)
        # 예측 결과 저장
        pred_lists.extend([p.item() for p in predict])
        # 손실 누적
        loss = loss_fn(predict,label)
        total_loss += loss.item()
    # 전체 평균 손실 출력
    print(f"loss : {total_loss / len(loader.dataset)}")

6. 시각화

    import matplotlib.pyplot as plt
    # 전체 데이터 비교
    plt.figure(figsize=(15,5))
    plt.subplot(1,2,1)
    plt.plot(pred_lists,label="prediction")
    plt.plot(netflix_dataset.label[30:], label='real')
    plt.legend()
   
    # 일부 영역 확대
    plt.subplot(1,2,2)
    plt.plot(pred_lists,label="prediction")
    plt.plot(netflix_dataset.label[30:], label='real')
    plt.xlim(200,400)
    plt.legend()
    plt.show()

   

LSTM(Long Short-Term Memory)

단기 기억을 오래 보존하기 위해(RNN의 단점 보완) 고안되었다.

Input gate(입력 게이트): 얼마나 새 정보를 셀 상태에 반영할지 Forget gate(망각 게이트): 얼마나 기존 셀 상태를 유지할지 결정 Output gate(출력 게이트): 어떤 정보를 은닉 상태로 보낼지

 차이점

• 은닉 상태에 활성화 함수를 통과시켜 다음 은닉 상태로 만들 때, sigmoid 함수를 사용한다. 또, tanh 함수를 통과한 어떤 값과 곱해져서 은닉 상태를 만든다

• LSTM은 순환되는 상태가 2가지: 은닉 상태(h), 셀 상태(c)

  • 셀 상태: 은닉층과 달리 다음 층으로 전달되지 않고 LSTM 셀에서 순환만 하는 값

  • 두 값에 곱해지는 가중치 처리 방식이 다르다(셀 상태는 별도의 가중치 행렬을 통해 선형변환되지 않고, 게이트 값과 단순 곱셉으로만 업데이트된다)

    항목	은닉 상태 (h)	셀 상태 (c)
    가중치 곱?	U_f, U_i, U_o, U_c 등 가중치 있음	가중치 없음, 단순 곱(f_t ⊙ c_{t-1})
    정보 흐름	출력을 위한 정보	장기 기억 유지용 정보
    업데이트 방식	게이트 출력과 tanh, σ 등 다양한 연산	forget/input 게이트와 원소곱으로 조절

from tensorflow import keras
model = keras.Sequential()
model.add(keras.layers.Embedding(500,16,input_shape=(100,)))
model.add(keras.layers.LSTM(8))
model.add(keras.layers.Dense(1,activation='sigmoid'))

→ 파라미터 수: SimpleRNN의 4배(LSTM안에 작은 셀 4개 있어서)

•  LSTM → LSTM 넘어갈 때는 첫 번째 층이 return_sequences=True, 마지막 층은 False 여야 함 !

  from 문영님

  2개의 층을 연결하기

  • 케라스의 순환층에서 모든 타임스텝의 은닉 상태를 출력하려면 마지막을 제외한 다른 모든 순환층에서 return_sequences 매개변수를 True로 지정하면 됨

    model3 = keras.Sequential()
    model3.add(keras.layers.Embedding(500, 16, input_shape=(100,)))
    model3.add(keras.layers.LSTM(8, dropout=0.3, return_sequences=True))
    model3.add(keras.layers.LSTM(8, dropout=0.3))
    model3.add(keras.layers.Dense(1, activation='sigmoid'))
    
    model3.summary()

    

- 첫 번째 LSTM 층은 모든 타임스텝(100개)의 은닉 상태를 출력하기 때문에 출력 크기가 (None, 100, 8)로 표시됨. 그러나 두 번째 LSTM 층의 출력 크기는 마지막 타임스텝의 은닉 상태만 출력하기 때문에 (None, 8)으로 표시됨.
- 첫 번째 LSTM : 시퀀스 전체 정보 유지
두 번째 LSTM : 그 시퀀스를 종합해서 최종 정보 하나로 요약
LSTM → LSTM 넘어갈 때는 첫 번째 층이 return_sequences=True, 마지막 층은 False 여야 함 !

GRU

LSTM을 간소화한 버전으로, 성능은 비슷한데 구조는 더 단순하다.

• 은닉 상태와 입력에 가중치를 곱하고 절편을 더하는 작은 셀 3개(2개는 sigmoid , 1개는 tanh )

Update gate Reset gate Candidate hidden state

from tensorflow import keras
model = keras.Sequential()
model.add(keras.layers.Embedding(500,16,input_shape=(100,)))
model.add(keras.layers.GRU(8))
model.add(keras.layers.Dense(1,activation='sigmoid'))

→ 파라미터 수: 624개

• 하나의 게이트를 계산할 때 필요한 파라미터 : 200개
  • 입력에 곱하는 가중치 16 x 8 = 128개
  • 은닉 상태에 곱하는 가중치 8 x 8 = 64개
  • 절편은 뉴런마다 하나씩이므로 8개
• 이러한 작은 셀(게이트)가 3개이므로 200 x 3 = 600개
• keras 내부 동작으로 bias가 추가되어서 + 24개 !

GAN(캡챠)

CNN + RNN 의 구조로, 이미지나 시계열에서 공간적 특징과 순차적 흐름을 함께 처리하는 모델이다. 캡차 인식처럼, 이미지로 된 문자가 들어오면 CNN으로 문자 특징을 추출한 다음 RNN으로 문자의 순서를 해석해서 예측하는 것이다.

class CRNN(nn.Module):
  def __init__(self,output_size):
    super().__init__()
    # batch_size 모르니까 None으로
    # CNN 계층: (None, 3, 50, 200)
    self.block = nn.Sequential(
        BasicBlock(3,64), # (None, 64, 24, 196)
        BasicBlock(64,64), # (None, 64, 11, 192)
        BasicBlock(64,64), # (None, 64, 5, 188)
        BasicBlock(64,64), # (None, 64, 2, 184)
        #세로 방향의 정보를 한줄(1픽셀)로 압축 -> 가로축만 남아서 시퀀스로 사용 가능
        nn.Conv2d(64,64,kernel_size=(2,5)) #(None, 64, 1, 180)
        # kernel_size 에서 w:5 는 단어 또는 문자 패턴 뽑기 위함이다(약 5개 안에 하나의 단어가 들어올거다 라고 가정하고)
    )

    # GRU 정의
    self.gru = nn.GRU(64,64, batch_first=False) 
    # 입력: (seq_len=180, batch, input_size=64) 
    # (H,B,input_size)

    #분류 MLP
    self.fc = nn.Sequential(
        nn.Linear(64,128),
        nn.ReLU(),
        nn.Linear(128,output_size) # 각 시점마다 문자 예측 
    )

  def forward(self,x):
      x = self.block(x) # CNN 통과: (1, 3, 50, 200) -> (1, 64, 1, 180) 
      # (B, C, H, W) -> 1,64,180(B,C,W)(0,1,2) 하려면 permute(2,0,1) 필요
      x = x.squeeze(2) # 세로(H) 제거 : (1, 64, 180)
      x = x.permute(2,0,1) # (180, 1, 64) GRU 입력 형태로 변환

      #초기 은닉층(num_layers, batch_size, hidden_size)
      h0 = torch.zeros(1,x.size(1), 64)
      # GRU 처리
      x, _ = self.gru(x,h0)
      # 각 시점마다 문자 분류
      x = self.fc(x)
      #CTC 손실계산
      x = F.log_softmax(x, dim=-1)
      return x

• chatgpt: 왜 reshape이 필요한가

  아주 좋은 질문이에요! 👏

  "차원을 맞추기 위해 flatten() 하는 것"과 "GRU 입력 형태로 맞추기 위해 세로길이를 squeeze() 하는 것"은 비슷한 맥락도 있고, 중요한 차이점도 있어요.

  아래에서 둘을 비교해서 설명드릴게요:

  ---

  공통점:

  둘 다 모델에 맞는 입력 차원으로 데이터를 reshape(재구성) 하기 위한 작업입니다.

  목적	차원 조정
  모델이 원하는 입력 형태에 맞추기 위해	차원을 줄이거나, 바꾸거나, 펼치는 작업

  ---

  차이점:

  항목	flatten()	squeeze() (or permute, reshape for RNN)
  목적	완전히 1D 벡터로 만들어 MLP(선형 계층)에 넣기 위함	시퀀스 데이터로 바꾸기 위해 차원을 재배열
  사용 위치	CNN → MLP 연결 전에 주로 사용	CNN → RNN 연결 전에 사용
  결과	(B, C×H×W) 형태의 벡터	(Seq_len, B, Feature) 또는 (B, Seq_len, Feature)

  ---

  예시 비교

  ① flatten():

    x = x.view(batch_size, -1)  # or torch.flatten(x, start_dim=1)
  

  • 예: (B, 64, 7, 7) → (B, 3136)

  • 목적: MLP (nn.Linear)에 넣기 위해 1차원 벡터로 펼침

    ② squeeze() + permute() (for RNN like GRU):

    x = x.squeeze(2)         # (B, 64, 1, 180) → (B, 64, 180)
    x = x.permute(2, 0, 1)   # → (180, B, 64)
    

  • 목적: 가로 방향 픽셀을 시간 축으로 보고 GRU에 넣기 위한 변형

  • 여기서는 flatten 하지 않고 "시퀀스 처리"에 적합한 구조로만 바꿈

  ---

  핵심 요약

  개념	flatten	squeeze & permute
  쓰는 위치	CNN → MLP	CNN → RNN
  결과 형태	(B, Feature)	(Seq_len, B, Feature)
  목적	벡터로 펼쳐서 선형계층에 넣기	시퀀스 구조로 변환해서 RNN에 넣기
  데이터 의미 유지 여부	공간 구조 무시	시퀀스 의미 유지 (예: 가로 방향 문자 순서)

  ---

  비유로 설명하면:

  • flatten()은 이미지를 일렬로 쫙 펼치는 것 (의미 상실 가능)
  • squeeze() + permute()는 시퀀스 구조를 유지한 채로 배치하는 것 (의미 보존)

  ---

  필요하다면 flatten, view, reshape, permute 등의 차이도 더 정리해드릴 수 있어요!

  좋은 질문이에요!

  • *"가로 방향 픽셀을 시간축으로 본다"는 말을 이해하려면 먼저 GRU 같은 순환 신경망이 **입력을 어떻게 처리하는지를 이해해야 해요.

  ---

  GRU의 입력 형태

  GRU는 입력을 보통 다음과 같은 형태로 받습니다:

    (seq_len, batch_size, input_size)
  

  즉, 하나의 시퀀스 = 여러 개의 시점(time step) 으로 구성되어 있고,

  각 시점마다 하나의 벡터 (input_size) 를 입력받습니다.

  ---

  CNN의 출력 (예: 문자 이미지)

  CNN을 통과한 뒤의 출력 텐서:

    (B, C, H, W) = (batch_size, channel, height, width)
  

  이제 이걸 RNN에 연결해야 하니까, 어느 방향을 시퀀스로 볼지 정해야 해요.

  ---

  왜 "가로(W)를 시간축"으로 보는가?

  문자나 문장의 이미지를 보면 보통 글자들이 가로 방향으로 나열되어 있죠?

    예시: "CRNN" -> 이미지에서 왼쪽부터 C → R → N → N
  

  • 그래서 가로 방향(W) 을 시간 순서로 보고,
  • 세로 방향(H) 은 글자의 세부적인 시각적 정보 (높이, 세로 모양 등)라고 보면 됩니다.

  ---

  그럼 왜 세로(H)를 삭제(squeeze)하나?

  CNN을 거친 후에는 보통 다음처럼 나옵니다:

    (B, 64, 1, 180)
  

  여기서:

  • 64: 채널 (특징 맵의 개수)

  • 1: 세로 방향 (높이)

  • 180: 가로 방향 (폭, 시퀀스 길이)

    즉, CNN을 통해 세로 방향 정보는 이미 모두 요약되었고,

    H = 1 이 되어 더 이상 시퀀스 정보로서 쓸모가 없습니다.

    그래서 이걸 squeeze(2) 해서 차원을 없애주면:

    (B, 64, 180)
    

    이제 이걸 GRU에 넣기 위해 permute 하면:

    (180, B, 64)  # → 시퀀스 길이 180, 배치 B, 특성 64
    

    이렇게 되면 각 가로 픽셀 위치가 하나의 시점(time step) 이 되고,

    그 시점마다의 정보가 64차원의 벡터로 표현되는 거예요.

  ---

  정리

  항목	의미
  왜 가로(W)가 시간축인가?	문자가 가로로 나열되니까 시간 순서로 볼 수 있음
  세로(H)는 왜 1인가?	CNN에서 세로 방향을 다 통합했기 때문
  그래서 squeeze(H)?	쓸모 없는 차원이니까 없애서 RNN에 넣기 좋게 만듦

  ---

tensorflow - keras 라이브러리와 fashion_mnist 데이터 불러오기

from tensorflow import keras
(train_input, train_target), (test_input, test_target) = keras.datasets.fashion_mnist.load_data()
# 애초에 4덩이로 구분되어있어서 train_input, train_target, test_input, test_target 변수로 받을 수 있음

train 데이터와 test 데이터 구조확인

print(train_input.shape, train_target.shape)
#(60000, 28, 28) (60000,)

print(test_input.shape, test_target.shape)
#(10000, 28, 28) (10000,)

각 변수에 들어있는 데이터 구조를 확인.
train_input 은 (60000, 28, 28)인데 이건 28*28 이미지 데이터가 60000개 있는것.
  (전체 이미지 개수(1차원), 이미지의 세로 픽셀 수(2차원), 이미지의 가로 픽셀 수(3차원))


train_target 은 (60000, )인데 타겟 데이터는 60000개의 라벨

fashion_mnist 데이터 시각화 확인하기

import matplotlib.pyplot as plt
fig, axs = plt.subplots(1, 10, figsize=(10,10))
for i in range(10):
  axs[i].imshow(train_input[i], cmap='gray_r')
  axs[i].axis('off')
plt.show()

fig, axs = plt.subplots(1, 10, figsize=(10,10))
1행 10열의 서브플롯을 생성


fig => 서브플롯(axes)을 포함하는 가장 바깥의 컨테이너. 캔버스(도화지)라고 보면 됨.
axes => 캔버스(도화지)안의 작은 네모칸 하나를 의미
axs => 서브플롯(axes)에 들어갈 데이터
subplot() => 도화지를 나누는 방식
  1행 10열의 서브플롯을 생성
fig = Figure(1000 * 1000)
figsize=(10, 10) -> 10인치, 10인치
  픽셀로 바꾸면 10인치 X 100dpi = 1000픽셀, 10인치 X 100dpi = 1000픽셀

import numpy as np
print(np.unique(train_target, return_counts=True))

#(array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9], dtype=uint8), array([6000, 6000, 6000, 6000, 6000, 6000, 6000, 6000, 6000, 6000]))

np.unique(train_target, return_counts=True)

return_counts = True 는
train_target의 unique한 값을 count해서 돌려줌.
-> 각 요소마다 몇 번 나오는지 알 수 있음

이 데이터에서는
10개의 카테고리가있고
각 카테고리별로 6000개씩 train데이터가 들어있음

train데이터 정규화

train_scaled = train_input / 255.0
train_scaled = train_scaled.reshape(-1, 28*28)

픽셀은 0~255까지 있는데
SGDClassifier에서는 특성마다 범위가 많이 다르면 적용시키기 애매함.
0~1 사이로 정해주는것이 좋음
이런 이유로 0~1사이로 만들어주기위해 255로 나눠줌


또한
SGDClassifier는 2차원 배열은 다룰 수 없으므로
2차원 배열인 각 샘플(28, 28)을 1차원 배열로 맞춰줘야함
reshape()를 이용

reshape(-1, 28*28)
-1 : 알아서 맞춤
28*28 : 샘플데이터의 2,3차원을 1차원으로 합침
   -> 그러면 1차원의 샘플개수는 변화없이 60000개!!!

모델만들기

from sklearn.model_selection import cross_validate
from sklearn.linear_model import SGDClassifier
sc = SGDClassifier(loss = 'log_loss', max_iter = 5, random_state = 42)
scores = cross_validate(sc, train_scaled, train_target, n_jobs = -1)
print(np.mean(scores['test_score']))
#0.8194166666666666

확률적 경사 하강법(SGD)를 이용
  (loss = 'log_loss', max_iter = 5, random_state = 42)
    loss = 'log_loss' : 로지스틱 회귀를 의미
    max_iter = 5 : 한번 학습할때 최대5번만 데이터 반복


교차 검증(Cross Validation)
  -> 데이터를 여러 조각으로 나눠서 여러번 학습/검증하여 평균 성능을 계산

  작동흐름(기본 5-fold)
    데이터를 5등분
    4개는 훈련, 1개는 검증
    이걸 총 5번 바꿔가며 훈련/검증
    각각의 test_score 저장

      혹시 fold설정하고싶으면
        from sklearn.model_selection import KFold

        cv=KFold(n_splits=7, shuffle=True, random_state=42)  
          -> 7등분 + 섞기
        scores = cross_validate(model, X, y, cv=cv)  으로 사용 가능

  (sc, train_scaled, train_target, n_jobs = -1)
    sc : 사용할 모델
    train_scaled : 입력데이터 (X)
    train_target : 정답데이터 (y)
    n_jobs = -1 : CPU병렬처리(모든코어사용)

  scores = cross_validate(...)
    결과는 딕셔너리 형식으로 반환
    ex)
      scores.keys()
      # dict_keys(['fit_time', 'score_time', 'test_score'])

      scores['test_score']->5개의 검증 정확도 리스트가 들어있음

  print(np.mean(scores['test_score']))
    다섯 번 검증한 결과의 평균 정확도 출력


전체 흐름 정리
  - train_scaled, train_target으로
  - SGDClassifier 모델을 5번 훈련 + 검증하면서
  - test_score에 성능 저장
  - 평균 정확도를 print로 출력

덴서플로의 케라스 사용하며 인공신경망 모델 만들기

모델 구조정의

# (케라스의 Dense클래스를 사용해 밀집층만들기)
from tensorflow import keras
dense = keras.layers.Dense(10, activation = 'softmax', input_shape = (784,))

# (케라스의 Dense클래스를 사용해 밀집층만들기)

Dense(10, activation = 'softmax', input_shape = (784,))
  (출력층의 개수, 출력에 적용할 함수, 입력의 크기)
  -> 입력의 크기는 784, 출력에 적용할 함수는 softmax, 출력층의 갯수는 10개


********Dense는 무조건 2차원으로 입력을 받아야함. 고로 3차원인 데이터는 평탄화 필요

# 신경망 모델을 Sequential클래스로 만들기
# Sequential 클래스는 밀집층인 danse를 받음.

model = keras.Sequential([dense])

# 신경망 모델을 Sequential클래스로 만들기
# Sequential 클래스는 밀집층인 danse를 받음.




Sequential 모델은 언제 사용???
  입력 → 은닉층 → 출력층
  레이어가 순서대로만 흘러가는 구조일 때
  복잡한 연결(분기, 병합 등)이 없을 때 적합



model = keras.Sequential(dense)  # 에러 발생 / 책이 잘못나옴

* 이유
여기서 dense는 레이어 하나인데,
Sequential()은 내부적으로 레이어들을 반복(iterate) 해서 쌓기 때문에,
리스트 형태로 넣어줘야 함.

최신 권장 방식

from tensorflow import keras
inputs = keras.Input(shape=(784,))  # 입력 정의 (명시적인 Input)
outputs = keras.layers.Dense(10, activation='softmax')(inputs)  # Dense는 입력을 받아서 연결
model = keras.Model(inputs=inputs, outputs=outputs)

또는,

model = keras.Sequential([
    keras.Input(shape=(784,)),                      # 명시적 입력
    keras.layers.Dense(10, activation='softmax')    # Dense는 입력만 받음
])

모델 학습설정

model.compile(loss = 'sparse_categorical_crossentropy', metrics = ['accuracy'])

keras에서 모델 학습설정은
model.compile() 사용


model.compile(loss = 'sparse_categorical_crossentropy', metrics = ['accuracy'])
  loss = 손실함수
    손실함수
      이진 분류 -> binary_crossentropy
      다중 분류 ->
        원핫인코딩 후 사용
          categorical_crossentropy
        원핫인코딩 안된 데이터에 사용
          sparse_categorical_crossentropy

  metrics = ['accuracy']
    Keras는 metrics에 여러 개의 평가 지표를 넣을 수 있게 설계!!
    ********항상 리스트 형태로 받음



나와있지않지만 강사님이 많이 쓰신 파라(07-2에서 나옴)
optimizer = 'adam'
  optimizer :
    - 모델이 오답을 줄이기 위해 가중치를 조금씩 조정하는 방법
    - 딥러닝 모델이 **손실(loss)**을 줄이기 위해 가중치를 어떻게 바꿀지 결정하는 알고리즘,
    즉 **최적화 함수(Optimizer)**

  adam :
    - Adaptive Moment Estimation의 줄임말
    - 많이 쓰이는 최적화 알고리즘 중 하나
    - 학습 속도도 빠르고 성능도 좋아서 대부분의 모델에서 기본값처럼 자주 사용

• Adam 특징

실제 모델 학습

model.fit(train_scaled, train_target, epochs = 5)

.fit() : 케라스에서 모델의 학습을 하는 메서드
sklearn과 비슷하나 epochs가 차이남.
  model.fit(입력데이터, 정답데이터, epochs = 반복할 횟수)

모델 검증

model.evaluate(val_scaled, val_target)

evaluate() : 케라스에서 모델의 성능을 평가하는 메서드
  model.evaluate(입력데이터, 정답데이터)

정리

사이킷런 모델

모델 -> sc = SGDClassifier(loss='log_loss(손실함수)', max_iter = 5(반복횟수))
훈련 -> sc.fit(train_scaled, train_target)
평가 -> sc.score(val_scaled, val_target)

케라스 모델

층생성 -> dense = keras.layers.Dense(10(출력층 개수), activation='softmax'(함수설정), input_shape=(784,)(입력 개수))
모델 -> model = keras.Sequential(dense)
        model.compile(loss = 'sparse_categorical_crossentropy', metrics = ['accuracy'])
훈련 -> model.fit(train_scaled, train_target, epochs = 5(반복횟수))
평가 -> model.evaludte(val_sacled, val_target)

활성화 함수

소프트맥스 함수

• 여러 클래스 중 하나를 선택할 수 있도록 출력을 확률처럼 정규화
• 출력값들이 모두 0~1 사이이며, 총합이 1이 되는 확률 벡터 (softmax([2.0, 1.0, 0.1]) -> [0.659, 0.242, 0.099] -> 전체 합이 1 )
• 각 클래스에 대해 예측된 확률을 명확히 해석 가능
• 다중 분류 문제의 출력층
• 예측 결과를 확률로 해석할 수 있어 직관적이고 분석이 쉬움

시그모이드 함수

• 초창기 인공신경망에 많이 사용된 활성화 함수

• 입력 값을 0~1 사이의 확률처럼 변환

• 출력이 항상 부드럽고 연속적

• 입력이 매우 크거나 작으면 기울기 소실(Vanishing Gradient) 발생 올바른 출력을 만드는데 신속한 대응이 안됨.

• 층이 많을수록 그래디언트가 누적되며 학습이 잘 안 됨

• 은닉층 또는 이진분류의 출력층에 사용 (과거에는 은닉층에서 사용, 현재는 이진 분류의 출력층에서만 주로 사용)

  렐루함수

• 입력이 양수일 경우 마치 활성화함수가 없는 것처럼 입력을 통과시키고, 입력이 음수일 경우 0으로 만듦

• 계산 빠름, 기울기 소실이 없음 (그래디언트 유지됨)

• 심층 신경망에서 빠른 학습, 효과적인 수렴

• 이미지 처리, CNN, DNN에 기본 활성화 함수처럼 사용됨

• 은닉층에서 매우 널리 사용

심층신경망(DNN)

심층 신경망(DNN)

  입력층(Input layer)과 출력층(Output layer) 사이에
  은닉층(Hidden layers)이 2개 이상 존재하는 인공 신경망



[예시 구조]

[입력층]
   ↓
[은닉층1]  ← Dense
   ↓
[은닉층2]  ← Dense
   ↓
[출력층]   ← Softmax

• 얕은 신경망 vs 심층 신경망 비교표

신경망(분류)

• 출력층의 활성화 함수

  - 이진분류 : 시그모이드 함수
  - 다중분류 : 소프트맥스 함수

• 은닉층의 활성화 함수

  - 시그모이드 함수
  - 렐루 함수

신경망(회귀)

• 활성화 함수가 필요없음

  -> 회귀는 Dense층의 activation 매개변수에 아무런 값을 지정하지 않음.

모델에 층 추가하는 방법

방법 1

dense1 = keras.layers.Dense(100, activation = 'sigmoid', input_shape = (784, ))
dense2 = keras.layers.Dense(10, activation = 'sigmoid')

두 번째 층부터는 Keras가 자동으로 입력 shape를 추론
즉, dense1의 출력이 dense2의 입력이 되기 때문에 input_shape가 필요 없음.

model = keras.Sequential([dense1, dense2])
model.summary()

• model.summary()

  케라스는 모델의 summary() 메서드를 호출하면 층에 대한 정보를 얻을 수 있음

• Dense 층의 파라미터 수 공식

  파라미터 수 = (입력 노드 수 × 출력 노드 수) + 출력 노드 수

• name을 매개변수로 지정할 수 있음

  from tensorflow import keras
  dense1 = keras.layers.Dense(100, activation='relu', input_shape=(784,), name='hidden_layer_1')
  dense2 = keras.layers.Dense(10, activation='softmax', name='output_layer')
  model = keras.Sequential([dense1, dense2])

• 출력 크기가 None인 이유

  - (None, 100) = (배치 크기, 뉴런 수)
  None → 입력 데이터가 한 번에 몇 개 들어올지는 아직 모른다
     (fit() 할 때 batch_size = .. 로 설정 가능)
  - 100 → 이 레이어에서 나가는 출력 뉴런 수

• batch_size

  케라스에서 기본 미니 batch_size = 32
  모델이 다양한 크기의 입력을 받을 수 있도록(유연하게 사용하기 위해) None으로 남겨 둠.
  fit()할때 사용
  1개만 넣어도 되고 (배치=1), 64개 넣어도 되고 (배치=64), 전부 넣어도 됨

방법 2

model = keras.Sequential([
    keras.layers.Dense(100, activation='sigmoid', input_shape=(784, ), name = 'hidden'),
    keras.layers.Dense(10, activation='softmax', name = 'output')
], name = '패션 MNIST 모델')
model.summary()

방법 3

model = keras.Sequential()
model.add(keras.layers.Dense(100, activation='sigmoid', input_shape=(784,), name = 'hidden'))
model.add(keras.layers.Dense(10, activation='softmax', name = 'output'))
model.summary()

방법 3은
- Dense 클래스의 객체를 따로 변수에 담지않고 바로 add()메서드로 전달할 수 있음.
- 추가되는 층을 한눈에 볼 수 있음
- 실행시 동적으로 층을 선택하여 추가할 수 있음.

Flatten 층

• Flatten 클래스는 배치차원을 제외하고 나머지 입력 차원을 모두 일렬로 펼치는 역할
• Flatten클래스를 층처럼 입력층과 은닉층 사이에 추가하기 때문에 층이라고 부름.
• 위 코드처럼 입력층 바로 뒤에 추가
• Flatten을 사용하면 입력값의 차원을 짐작하기 쉬움.

  model = keras.Sequential([
    keras.Input(shape=(28, 28)),               # ← 입력층 명시
    keras.layers.Flatten(),                    # ← Flatten은 평탄화만 함
                                               # 앞에서 데이터 전처리시 reshape() 필요없음
    keras.layers.Dense(100, activation='relu'),
    keras.layers.Dense(10, activation='softmax')
  ])
  model.summary()

  

모델 설정 & 훈련 & 검증

from tensorflow import keras
(train_input, train_target), (test_input, test_tergat) = keras.datasets.fashion_mnist.load_data()
train_scaled = train_input / 255.0
train_scaled, val_scaled, train_target, val_target = train_test_split(
    train_scaled, train_target, test_size = 0.2, random_state = 42
)

model.compile(loss = 'sparse_categorical_crossentropy', metrics = ['accuracy'])
model.fit(train_scaled, train_target, epochs = 5)

model.evaluate(val_scaled, val_target)

하이퍼파라미터

• 모델이 학습하지않아 사람이 직접 지정해줘야하는 파라미터 (은닉층의 수, 은닉층의 뉴런의 수, 활성화함수, 층의 종류, 배치 사이즈의 크기, 에포크의 수, 옵티마이저 등..)

옵티마이저 ( Adam 중요 )

• 손실 함수의 값을 최소화(minimize)하기 위해 가중치를 어떻게 업데이트할지 결정하는 알고리즘

• 대표 옵티마이저

SGD (Stochastic Gradient Descent)

• 가장 기본적인 옵티마이저, 간단하고 직관적
• 단순하지만,기울기 방향만 보고 이동하기 때문에 손실이 들쭉날쭉하게 줄어들고 진동이 심할 수 있음
• 매 반복마다 일부 데이터(batch)로 손실을 계산해 가중치 갱신

  optimizer = keras.optimizers.SGD(learning_rate=0.1)
  model.compile(optimizer = optimizer, loss = 'sparse_categorical_crossentropy', metrics = ['accuracy'])

Momentum

• 관성 개념을 사용해 이전 방향으로 더 강하게 이동
• 진동 감소 + 수렴 속도 증가

  optimizer = keras.optimizers.SGD(momentum=0.9, nesterov = True)
  model.compile(optimizer = optimizer, loss = 'sparse_categorical_crossentropy', metrics = ['accuracy'])

Nesterov (Nesterov Accelerated Gradient, NAG)

• 모멘텀을 적용하기 전에 미리 한 걸음 앞서서 기울기를 계산하는 방식
• 더 정확한 방향 제어
• 수렴이 더 안정적이고 빠를 수 있음

  optimizer = keras.optimizers.SGD(learning_rate=0.01, momentum=0.9, nesterov=True)

RMSprop

• Adagrad의 단점(학습률 소멸)을 해결
• 최근 기울기에 지수적으로 가중치를 줘서 더 안정적 (지수평균)
• RNN, LSTM에 매우 적합
• 빠른 수렴

  optimizer = keras.optimizers.RMSprop(learning_rate=0.001)
  model.compile(optimizer = optimizer, loss = 'sparse_categorical_crossentropy', metrics = ['accuracy'])

Adagrad

• 각 파라미터마다 학습률을 자동 조절
• 자주 바뀌는 가중치는 더 천천히 학습 → 희소 데이터에 효과적(ex. 텍스트)
• 단점: 학습률이 너무 작아져서 금방 멈춰버릴 수 있음

  optimizer = keras.optimizers.Adagrad(learning_rate=0.01)
  model.compile(optimizer = optimizer, loss = 'sparse_categorical_crossentropy', metrics = ['accuracy'])

Nadam (Nesterov + Adam)

• Adam에 Nesterov 모멘텀을 추가한 방식
• 최신 최적화 기법 중 하나
• 이론적으로 Adam보다 빠르게 수렴할 수도 있음 (실험적으로 사용됨)

  optimizer = keras.optimizers.Nadam(learning_rate=0.001)
  model.compile(optimizer = optimizer, loss = 'sparse_categorical_crossentropy', metrics = ['accuracy'])

Adam (Adaptive Moment Estimation) 중요

• Momentum + RMSprop 결합
• Momentum (기울기의 평균)
• RMSprop (기울기의 제곱 평균)
• 가장 널리 쓰임, 대부분의 문제에서 잘 동작

  optimizer = keras.optimizers.Adam(learning_rate=0.001)
  model.compile(optimizer = optimizer, loss = 'sparse_categorical_crossentropy', metrics = ['accuracy'])

정리

model.fit(train_scaled, train_target, epochs = 5)

![](https://velog.velcdn.com/images/c_haha_e/post/70567af1-3e77-4608-8ee6-01868c51b9a9/image.png)

model.evaluate(val_scaled, val_target)00

![](https://velog.velcdn.com/images/c_haha_e/post/378ca539-a8e3-423d-8914-dd1cab96b4e9/image.png)

어간 추출이란?

단어에서 변하지 않는 뿌리(어간)만 남기고 접사(변형, 굴절, 어미 등)는 기계적으로 잘라내는 작업

WHY? (왜 해야 할까?)

• 의미는 거의 같은데, 단어 형태만 달라서
  • 데이터 분석/검색/분류할 때 비슷한 단어를 한 덩어리로 보고 싶으니까!

예시:

• “study”, “studies”, “studying”, “studied” → 전부 “studi”로 자름

실전 예시와 코드(영어)

(1) NLTK의 PorterStemmer 사용

from nltk.stem import PorterStemmer

stemmer = PorterStemmer()
words = ["study", "studies", "studying", "studied", "studious"]
for w in words:
    print(w, "->", stemmer.stem(w))

결과:

study     -> study
studies   -> studi
studying  -> studi
studied   -> studi
studious  -> stud

해설:

• 어간(stem)은 “study”에서 “y”까지,
• 다른 단어는 접미사(ies, ing, ed, ious)만 자르고
• 남은 부분 “studi”만 똑같이 반환

(2) 영어의 어간 추출 단점

• 너무 기계적으로 자름! → 뜻이 다르거나 어색한 줄기까지 뽑히기도 함
• 예: “studious”(공부하는, 근면한)도 “studi”로 잘림 → 실제론 ‘study’와 다르지만 같은 그룹 취급

한글에서의 어간 추출

• 한글은 “동사/형용사 어간”이 활용(변형)될 때

  형태소 분석기(예: Okt, Kkma 등)가 ‘어간(동사 기본형)’을 자동 추출함

예시)

from konlpy.tag import Okt
okt = Okt()
print(okt.morphs("먹었다"))  # ['먹', '었다']
print(okt.morphs("가는 중이다"))  # ['가', '는', '중', '이다']

• “먹었다” → [‘먹’, ‘었다’] (먹: 어간, 었다: 어미)
• “가는 중이다” → [‘가’, ‘는’, ‘중’, ‘이다’] (가: 어간)

2. 표제어 추출(Lemmatization)이란?

표제어 추출이란?

단어를 사전에 등록된 정확한 기본형(표제어)로 바꿔주는 작업 → 즉, 단어를 진짜 원래 단어로 맞춰주는 것!

WHY? (왜 표제어?)

• 단어의 정확한 본래 의미를 영어 사전/국어사전 기준으로 통일
• 검색, 분류, 의미 비교, 번역 등에서 가장 ‘정확한 단어’만 남기고 싶을 때 사용

실전 예시와 코드(영어)

(1) NLTK의 WordNetLemmatizer 사용

from nltk.stem import WordNetLemmatizer

lemmatizer = WordNetLemmatizer()
words = ["study", "studies", "studying", "studied", "studious", "went", "going"]
for w in words:
    print(w, "->", lemmatizer.lemmatize(w, pos='v'))

결과:

study     -> study
studies   -> study
studying  -> study
studied   -> study
studious  -> studious
went      -> go
going     -> go

해설:

• “study” 계열 → 전부 “study”(기본형)
• “went” “going” → “go”(동사 원형)
• “studious”는 형용사(근면한)라 “study”로 안 바뀜

(2) 어간 추출 vs 표제어 추출 차이점

한글에서의 표제어 추출

• 한글 형태소 분석기는

  ‘동사/형용사’의 기본형(표제어)을

  자동으로 태깅해줌

예시)

from konlpy.tag import Okt
print(okt.pos("아름다웠던 순간을 잊지 못해요."))
# [('아름답', 'Adjective'), ('었던', 'Eomi'), ...]

• “아름다웠던” → ‘아름답’(표제어), ‘었던’(어미)

3. 실제 실무/실전에서의 활용

• 어간 추출:

  • 속도가 매우 중요하고,

    ‘비슷하면 한 그룹’만 필요할 때 (검색, 대용량 데이터)

• 표제어 추출:

  • 의미, 정확성이 더 중요한 작업 (번역, 감정분석, 요약 등)

4. 실습 결과 해설

(1) 어간 추출의 단점

• 엉뚱한 줄기(studi, go, runn 등)만 남아

  진짜 뜻이 사라지기도 함!

• “meeting” → “meet” (OK)

  “better” → “better” (표제어는 “good”)

(2) 표제어 추출의 단점

• 속도가 느림
• 사전 없는 단어는 안 바뀜(신조어, 오타 등)

5. 입문자용 체크 퀴즈

1. 어간 추출이랑 표제어 추출의 큰 차이는?
2. “studied”를 어간/표제어 추출하면 각각 뭐가 되나?
3. 한글 문장(“먹었다”)에서 어간/표제어는 각각?
4. 실제 뉴스 기사/리뷰 분석에서는 어떤 방식을 더 쓸까? 그 이유는?

** 한줄정리**

어간 추출은 단어에서 “뿌리”만 남기는 ‘가지치기’, 표제어 추출은 사전 기준 “진짜 본래 단어”만 남기는 ‘본명 맞추기’! 정확성 중요하면 표제어, 속도/단순 그룹이면 어간 추출!

1. 정제(Cleansing) – 개념

정제란?

• “텍스트에서 불필요하거나 방해되는 내용(노이즈)를 깨끗하게 지워내는 작업”

• 갖고 있는 코퍼스로부터 노이즈 데이터를 제거

• 예시:

  • “ㅋㅋㅋ”, “ㅎㅎ”, “^_^”, “~”, “특수문자” 등
  • 광고/스팸성 멘트, 욕설, HTML 태그, 이메일, 링크, 숫자 등

• WHY(왜 필요?)

  → 방해되는 불순물이 많으면 진짜 뜻, 핵심 단어, 감정을 제대로 분석할 수 없음

정제 실습(코드 예시)

import re
text = "안녕하세요^^ 오늘 날씨 짱좋음ㅋㅋㅋ #해시태그 http://link.com"
# 1. 특수문자 제거
text = re.sub(r'[^가-힣0-9\s]', '', text)
# 2. 한글/숫자/띄어쓰기만 남기기
print(text)
# 결과: 안녕하세요 오늘 날씨 짱좋음 해시태그 linkcom

• 필요에 따라 이메일/링크/광고만 따로 지울 수도 있음

2. 정규화(Normalization) – 개념

정규화란?

• “비슷한 뜻인데 여러 가지로 적힌 표현들을 하나의 표준(기본) 형태로 통일시키는 작업”

• 정규화(normalization) : 표현 방법이 다른 단어들을 통합시켜서 같은 단어로 만듦

• 예시:

  • “짜증나”, “짜증난다”, “짜증남” → “짜증나다”
  • “핵꿀잼”, “꿀잼”, “재밌다”, “아주 재미있다” → “재미있다”
  • “굿굿”, “good”, “좋아요” → “좋다”

• WHY(왜 필요?)

  → 똑같은 의미가 여러 형태로 있으면

    “진짜 중요 단어” 개수가 필요 이상으로 늘어나고 분석 결과가 흐려짐

정규화 실습(코드 예시)

import re

text = "굿굿! 오늘 핵꿀잼ㅋㅋㅋ 날씨 짱좋음 ㅎㅎㅎ"
# 1. 반복 문자(ㅋㅋㅋ, ㅎㅎㅎ 등) 제거
text = re.sub(r'[ㅋㅎ]+', '', text)
# 2. 은어/신조어/약어 통일
text = text.replace('굿굿', '좋다')
text = text.replace('핵꿀잼', '재미있다')
text = text.replace('짱좋음', '아주 좋음')
print(text)
# 결과: 좋다! 오늘 재미있다 날씨 아주 좋음

실제 실무 적용 포인트

• 정제:

  • 데이터 품질 ↑
  • 스팸, 광고, 욕설, 쓸데없는 특수문자 ↓
  • 모델이 진짜 필요한 정보만 배울 수 있음

• 정규화:

  • 단어 종류 ↓
  • 진짜 ‘중요 키워드’만 정확히 잡힘
  • 한글 SNS 신조어, 채팅방, 커뮤니티 텍스트에 꼭 필요!

• 실무에서는:

  • 반복문, 사전(Dictionary) 만들어서 여러 신조어/은어/줄임말 한꺼번에 통일 가능!

  • 데이터 양이 많을수록

    정제·정규화가 모델 성능에 “지분율 50%”

  • 실전에서는 “욕설, 광고, 신조어 사전” 등

    따로 관리하는 경우 많음

** 한줄정리**

정제(Cleansing)는 ‘필요 없는 것들’을 지우고, 정규화(Normalization)는 ‘비슷한 의미’를 한 가지 표준 형태로 맞추는 것!

정제와 정규화에 사용되는 대표 라이브러리

1. 정제(Cleansing)에 자주 쓰는 라이브러리

① Python 내장 re(정규표현식)

• 특징:

  • 텍스트에서 불필요한 문자, 패턴(특수문자, 숫자, URL, 이메일, 광고 등)

    자동으로 찾아서 삭제/치환

  • 한글/영어 모두 가능

• 예시:

  
    import re
    text = "굿굿! 오늘 핵꿀잼ㅋㅋㅋ #해시태그 http://link.com"
    # 특수문자, URL 등 제거
    clean = re.sub(r'[^가-힣0-9\s]', '', text)
    print(clean)
    # 결과: 굿굿 오늘 핵꿀잼 해시태그 http://linkcom
  

② BeautifulSoup (HTML 정제)

• 특징:

  • 웹 페이지에서 HTML 태그, 스크립트 등 삭제
  • 크롤링/뉴스 기사/블로그 등에서 주로 사용

• 예시:

  
    from bs4 import BeautifulSoup
    html = "<html><body>안녕하세요! <b>반갑습니다.</b></body></html>"
    soup = BeautifulSoup(html, 'html.parser')
    print(soup.get_text())
    # 결과: 안녕하세요! 반갑습니다.
  

③ kss, soynlp, KoNLPy (한국어용)

• 특징:

  • 한국어에서 문장 분리, 맞춤법/중복 문자 등 정제에 활용

• 예시:

  
    import kss
    text = "안녕하세요.오늘은 날씨가 참 좋아요ㅋㅋㅋ"
    print(list(kss.split_sentences(text)))
    # 결과: ['안녕하세요.', '오늘은 날씨가 참 좋아요ㅋㅋㅋ']
  

2. 정규화(Normalization)에 자주 쓰는 라이브러리

① soynlp

• 특징:

  • 한글 신조어, 반복 문자(ㅋㅋㅋ, ㅎㅎㅎ), 띄어쓰기 정규화
  • 오타 교정 등 자동화 기능

• 예시:

  
    from soynlp.normalizer import repeat_normalize
    text = "우와아아아아 짱재밌엉ㅋㅋㅋㅋ"
    print(repeat_normalize(text, num_repeats=2))
    # 결과: 우와아 짱재밌엉ㅋㅋ
  

② Python 내장 re + 사용자 정의 사전

• 특징:

  • 신조어, 약어, 줄임말, 은어 등

    직접 만든 “정규화 사전”과 함께 사용

• 예시:

    text = "굿굿! 오늘 핵꿀잼 짱좋음"
    replace_dict = {'굿굿':'좋다', '핵꿀잼':'재미있다', '짱좋음':'아주 좋음'}
    for k, v in replace_dict.items():
        text = text.replace(k, v)
    print(text)
    # 결과: 좋다! 오늘 재미있다 아주 좋음
  

③ Ekphrasis (영어 정규화 특화)

• 특징:

  • 영어 약어, 이모티콘, 채팅체 등을 표준 영어로 정규화
  • 영어 SNS, 트위터 등에서 많이 씀

• 예시:

  
    # 설치: pip install ekphrasis
    from ekphrasis.classes.preprocessor import TextPreProcessor
  
    text_processor = TextPreProcessor(
        normalize=['url', 'email', 'percent', 'money', 'phone', 'user'],
        annotate={'hashtag', 'allcaps', 'elongated', 'repeated'},
        fix_html=True, segmenter="twitter", corrector="twitter"
    )
    print(" ".join(text_processor.pre_process_doc("I looooveee Python!!! #awesome @user http://site.com")))
    # (URL, 이모티콘, 반복 문자, 태그 등 표준화)
  

3. 기타 실무 보조 라이브러리

• pyspellchecker : 영어 맞춤법 교정
• hanspell : 한글 맞춤법 교정 (pip로 설치 필요)
• ftfy : 인코딩 깨짐/이상한 문자 복원 (영어 등)
• pandas : 데이터프레임 내 결측값, 중복값 등 정제

정리

1. 개념

토큰화란?

글(문장, 댓글, 기사 등)을 “뜻이 있는 가장 작은 덩어리(보통 ‘단어’나 ‘형태소’라고 부름)”로 잘게 쪼개는 작업

• 영어는 띄어쓰기 기준으로 “apple is good” → [‘apple’, ‘is’, ‘good’]
• 한글은 조사(을/는/이/가 등), 어미(했다/하다 등) 때문에 조금 더 세밀하게 쪼개야 함

2. WHY?

• 컴퓨터는 글자 그대로 “사람의 뜻”을 이해 못 함
• 그래서, “글을 의미 있는 단위로 쪼개서” 숫자나 규칙으로 바꿔야 함
• 이게 “자연어 처리의 첫 단계”, 이게 잘 돼야 “빈도 세기, 감정 분석, 요약, 번역 등”이 가능해짐!

3. 필요 라이브러리

from nltk.tokenize import word_tokenize
from nltk.tag import pos_tag
from konlpy.tag import Okt
from konlpy.tag import Kkma
from nltk.tokenize import sent_tokenize
from nltk.tokenize import word_tokenize
from nltk.tokenize import WordPunctTokenizer
from nltk.tokenize import TreebankWordTokenizer
from tensorflow.keras.preprocessing.text import text_to_word_sequence

!pip install kss
import kss

1. nltk.tokenize.word_tokenize

• 영어 문장용
• 기능: 문장을 ‘단어’ 단위로 쪼갬
• 특징: 영어 띄어쓰기, 구두점(마침표, 콤마 등)까지 잘 분리

2. nltk.tag.pos_tag

• 영어 문장용
• 기능: 각 단어의 품사(명사, 동사 등) 태깅
• 특징: 영어 품사 태그를 붙임

3. konlpy.tag.Okt

• 한글 전용 형태소 분석기
• 기능: 한글 문장 → ‘형태소’ 단위로 분리 & 품사 태깅
• 특징:
  • 띄어쓰기, 조사, 어미 등 잘 분리
  • '명사', '동사', '형용사' 등 품사정보 제공

4. konlpy.tag.Kkma

• 한글 전용, 더 정교한 형태소 분석기
• 기능: 한글 문장 → 더 세밀한 형태소 분리 & 품사 태깅
• 특징:
  • 긴 복합문장도 잘게 쪼갬
  • 품사 태그 종류가 더 세분화됨
  • (Okt보다 느리지만, 더 복잡한 문장에 강함)

5. nltk.tokenize.sent_tokenize

• 영어 ‘문장 단위’로 쪼개기
• 기능: 여러 문장이 있는 텍스트 → 문장별 리스트
• 특징: 마침표 등 기준으로 문장 나눔

6. nltk.tokenize.word_tokenize

• 영어 문장(글, 텍스트)을 ‘단어’ 단위로 쪼개서 단어(및 구두점)를 ‘리스트’형태로 반환
• 기능: 여러문장이 있는 텍스트 → 문장별 리스트
• 특징: 단어와 구두점이 분리

7. nltk.tokenize.WordPunctTokenizer

• 영어, 구두점 기준으로 더 세게 쪼갬
• 기능: 단어 + 구두점 따로따로 분리
• 특징: “won't” → [‘won’, “'”, ‘t’] 등 아주 세밀하게 쪼갬

8. nltk.tokenize.TreebankWordTokenizer

• 영어, 미국 Treebank 코퍼스 표준 규칙 사용
• 기능: 영어 문장 쪼개기, 어포스트로피, 하이픈 등도 신경 써서 분리

9. tensorflow.keras.preprocessing.text.text_to_word_sequence

• 영어, Keras에서 자주 씀(딥러닝용 전처리)
• 기능: 소문자 변환, 구두점 자동 제거 후 단어만 남김
• 특징: 신경망에 바로 넣기 적합

10. kss (Korean Sentence Splitter)

• 한글 문장 분리 특화
• 설치: !pip install kss
• 기능: 긴 한글 글을 “문장 단위”로 정확하게 쪼갬
• 특징: 뉴스, 블로그, 카톡 등 실생활 한글 문장에 강함

언어에 따른 사용

1. 한글 문장용 라이브러리

(1) KoNLPy 패키지

• 종류: Okt, Kkma, Mecab, Hannanum, Komoran

• 특징:

  • 한국어 형태소(어근, 조사, 어미) 분석 가능
  • 품사 정보까지 태깅 가능
  • 긴 문장도 띄어쓰기/조사/어미 구분 잘함

• 사용법 예시 (Okt)

  
    from konlpy.tag import Okt
    okt = Okt()
    text = "나는 오늘 집에서 공부를 했다."
    print(okt.morphs(text))   # ['나', '는', '오늘', '집', '에서', '공부', '를', '했다', '.']
    print(okt.pos(text))      # [('나', 'Noun'), ('는', 'Josa'), ...]
  

(2) KSS (문장 분리)

• 특징:

  • 한글 긴 텍스트를 문장 단위로 분리
  • 실생활 대화/뉴스 등에서 문장 끝 추정 정확

• 사용법 예시

  
    import kss
    text = "안녕하세요. 오늘도 공부합시다! 네, 알겠어요."
    print(list(kss.split_sentences(text)))
    # ['안녕하세요.', '오늘도 공부합시다!', '네, 알겠어요.']
  

(3)KoNLPy 형태소 분석기 사용

from konlpy.tag import Okt

text = "나는 학교에 갔다."
okt = Okt()
tokens = okt.morphs(text)
print(tokens)
# 결과: ['나', '는', '학교', '에', '갔다', '.']

2. 영어 문장용 라이브러리

(1) NLTK

• 종류:

  • word_tokenize: 단어 토큰화
  • sent_tokenize: 문장 토큰화
  • pos_tag: 품사 태깅

• 특징:

  • 영어 띄어쓰기 기준 분리, 구두점·약어 등도 구별
  • 영어 품사 정보 태깅 가능

• 사용법 예시

  
    from nltk.tokenize import word_tokenize, sent_tokenize
    from nltk.tag import pos_tag
  
    text = "Hello, I'm ChatGPT! Are you learning Python?"
    print(sent_tokenize(text))     # ['Hello, I'm ChatGPT!', 'Are you learning Python?']
    print(word_tokenize(text))     # ['Hello', ',', 'I', "'m", 'ChatGPT', '!', ...]
    print(pos_tag(word_tokenize(text)))
    # [('Hello', 'NNP'), (',', ','), ...]
  

(2) Keras

• 특징:

  • text_to_word_sequence: 구두점 자동 제거, 소문자 변환, 영어 딥러닝용

• 사용법 예시

  
    from tensorflow.keras.preprocessing.text import text_to_word_sequence
    text = "Hello, Deep Learning! Let's tokenize this."
    print(text_to_word_sequence(text))
    # ['hello', 'deep', 'learning', 'lets', 'tokenize', 'this']
  

(3) 영어 토큰화 (띄어쓰기 기준)

sentence = "I am happy."
tokens = sentence.split()
print(tokens)
# 결과: ['I', 'am', 'happy.']

3. 한글+영어 혼합 문장용 라이브러리

(1) KoNLPy (특히 Okt, Mecab)

• 특징:

  • 한글/영어/숫자 혼합 문장에서

    한글 형태소, 영어 단어, 숫자까지 분리

• 사용법 예시

    python
    복사편집
    from konlpy.tag import Okt
    okt = Okt()
    text = "ChatGPT는 인공지능 AI입니다. 파이썬으로 코딩해요!"
    print(okt.morphs(text))
    # ['ChatGPT', '는', '인공지능', 'AI', '입니다', '.', '파이썬', '으로', '코딩', '해요', '!']
  

(2) KSS

• 특징:

  • 한글/영어 섞인 텍스트에서 문장 단위 분리 가능

• 예시

    python
    복사편집
    import kss
    text = "오늘은 AI 세미나! Let's study together. 네, 좋아요."
    print(list(kss.split_sentences(text)))
    # ['오늘은 AI 세미나!', "Let's study together.", '네, 좋아요.']
  

(3) NLTK의 word_tokenize + 한글 라이브러리 병행

• 특징:

  • 영어는 nltk로, 한글은 konlpy로 따로 분리해서 조합

• 예시

    python
    복사편집
    from nltk.tokenize import word_tokenize
    from konlpy.tag import Okt
  
    text_ko = "파이썬과 ChatGPT를 공부해요."
    text_en = "Let's learn Python and ChatGPT."
  
    okt = Okt()
    print(okt.morphs(text_ko))        # ['파이썬', '과', 'ChatGPT', '를', '공부', '해요', '.']
    print(word_tokenize(text_en))     # ['Let', "'s", 'learn', 'Python', 'and', 'ChatGPT', '.']
  

정리

토크나이저와의 차이

1) 정규 표현식 문법

2) 역슬래쉬()를 이용한 문자 규칙

3) 정규표현식 모듈 함수

• r prefix : 문자열 앞에 붙이는 r 은 raw string 의 의미를 가지며 역슬래쉬 \ 을 탈출 문자로 보지 않고, 아무 역할도 하지 않는 평범한 문자열로 간주한다. \s 는 탈출문자에 해당하지 않기 때문에 추가적인 pattern에 넣어줘야함

예시 )

print("Hello World!\n")
print(r"Hello World!\n")

>> Hello World!
>> 
>> Hello World!\n

연습용 사이트(정규식표현) —> https://regexr.com/5mhou

-필수 패키지 설치

pip install nltk konlpy pandas numpy matplotlib seaborn scikit-learn torch 
pip install JPype1-0.6.3-cp36-cp36m-win_amd64.whl # 설치 주소 https://github.com/jpype-project/jpype/releases * 디렉토리에 파일이 있어야 설치 가능 

2. 어디서, 언제, 어떻게 쓰나?

3. 딥러닝 회귀/분류/시계열 모델 직접 설계

• 회귀: 마지막 출력층에 활성화함수 없이 Dense(1)
• 분류: 마지막 출력층에 소프트맥스/시그모이드 등 사용
• 이미지, 자연어, 시계열: Conv2D, LSTM 등 다양한 레이어 자유롭게 조합

4. 주요 사용법(간단 예시)

(1) PyTorch

import torch
import torch.nn as nn

class Net(nn.Module):
    def __init__(self):
        super().__init__()
        self.fc1 = nn.Linear(10, 64)
        self.fc2 = nn.Linear(64, 1)  # 회귀: 1, 분류: 클래스 수
    def forward(self, x):
        x = torch.relu(self.fc1(x))
        x = self.fc2(x)
        return x

model = Net()
# optimizer, loss 함수 등 자유롭게 정의

(2) TensorFlow / Keras

from tensorflow import keras

model = keras.Sequential([
    keras.layers.Dense(64, activation='relu', input_shape=(10,)),
    keras.layers.Dense(1)  # 회귀: 1, 분류: 클래스 수+softmax
])
model.compile(optimizer='adam', loss='mse')

5. 주요 파라미터/설정

• layers.Dense/nn.Linear: 신경망 레이어(입력, 은닉, 출력 등)
• activation: relu, sigmoid, softmax 등
• optimizer: adam, sgd, rmsprop 등
• loss: mse(회귀), crossentropy(분류) 등
• epochs, batch_size: 학습 반복 수, 배치 크기 등
• callbacks, regularization: 얼리스탑, 드롭아웃 등 추가 설정도 가능

6. 비교 요약 표

7. 결론/실전 TIP

• 딥러닝/신경망 모델을 직접 설계하고 싶을 때

  → PyTorch, TensorFlow, Keras 중 자유롭게 선택

• 실무/생산/최고성능

  → TensorFlow, PyTorch

• 입문, 실습, 빠른 개발

  → Keras(tf.keras)

가장 기본적인 인공 신경망으로, 그 형태는 확률적 경사하강법을 사용하는 로지스틱 회귀와 매우 유사하다. 인공신경망은 보다 높은 성능을 가진 새로운 종류의 머신러닝 알고리즘일 뿐, 정말 우리 뇌에 있는 뉴런과 같지 않다는 것을 항상 인지해야한다.

입력층: x값, 픽셀값 그 자체이고 특별한 계산수행 없이 원시 데이터를 받아 전달만 한다.

은닉층: 입력층과 출력층 사이에 있는 모든 층으로, 입력값에 가중치를 곱하고 비선형 함수(활성화 함수)를 적용해 특징을 추출한다.

출력층: z값을 계산하고 이를 바탕으로 클래스 예측하여 신경망의 최종 결과를 만든다.

cf) 밀집층(Dense Layer): 모든 뉴런이 앞층의 뉴런과 연결된 구조

ANN은 단일 신경망으로, Dense가 하나로 구성되어있으며, 다층 신경망은 Dense가 여러 개인 신경망이다.

keras의 클래스

• Dense: 신경망의 밀집층(fully connected layer)을 만드는 클래스로, 각 뉴런이 이전 층의 모든 뉴런과 연결되며,activation 매개변수로 활성화 함수를 지정할 수 있다.
• Sequential(): 순차적으로 층을 쌓는 모델. 신경망 모델을 만드는 클래스로, 객체 생성 시 신경망 모델에 추가할 층을 지정할 수 있다. 1개 이상일 경우, 리스트의 형태 [] 로 전달한다.
• dropout: 모델이 과대적합되지 않도록 일부 뉴런을 랜덤하게 끄는(출력=0) 정규화 기법이다.
• Early Stopping: 모델 훈련 중에 자동으로 특정 동작을 수행하게 해주는 도구인 call back 의 클래스 중 하나로, 검증 성능이 더 이상 좋아지지 않으면 훈련을 중단하여 과대적합을 줄여준다.

옵티마이저(optimizer)

손실함수를 최소화하기 위해 모델의 가중치를 조정하는 알고리즘

2. 활성화 함수(Activation function)

뉴런의 선형 방정식 결과에 적용되는 함수로, 선형을 비선형으로 바꿔서 신경망이 곡선적인 분리/예측을 가능케 하고 더 복잡한 문제를 해결할 수 있도록 도와준다. 용도에 맞게 골라 써야한다.

어떻게 복잡한 문제를 해결하느냐?

→ ReLU : 입력이 양수일 경우, 활성화 함수가 없는 것처럼 그냥 입력을 통과시키고 음수일 경우 0으로 만든다

→ sigmoid : 입력값을 0과 1 사이로 변환해서 확률처럼 해석이 가능하다(양수는 1에 가깝고, 음수는 0에 가깝다)

→ softmax : 여러 출력값들을 확률분포처럼 바꿔서 전체 합이 1이 되도록 조정한다

3. 손실곡선

두 그래프가 비슷하게 낮게 유지되면(=두 그래프가 같을 때), 모델의 일반화 능력(=성능)이 좋다고 할 수 있다.

두 그래프의 간격이 과적합을 의미해서 차이가 적을수록 과적합이 없다

⇒ 간격이 좁고, 그래프가 낮다

4. 합성곱 신경망(CNN)

도장 찍어내듯이 출력(특징)이 하나씩 생겨나는 신경망 구조로 도장의 크기, 즉 커널(kernel)의 크기는 하이퍼 파라미터로서 우리가 지정해줘야한다. 입력의 배열 차원과 커널의 차원이 동일해야한다.

여러 가중치들로 계산된 필터(커널)들이 있고, 각 필터별로 나온 출력값들을 모은 것이다. 이 하나의 출력 행렬을 특징맵(feature maps)이라고 한다.

CNN은 여러 개의 필터를 사용하므로, 여러 개의 출력 행렬이 생기는 것이다. 그 여러 feature map을 쌓은 것이 합성곱 층의 출력이다.

feature map 만드는 과정

노란색이 필터 = 도장 / 빨간 x1,x0 글씨는 가중치(w)

전 은닉층의 뉴런 개수 x 출력층의 뉴런 개수 만큼 가중치의 개수가 생긴다. 인공신경망의 개념

합성: 출력층의 개수가 정해지면 그 전 은닉층에서의 가중치 개수가 정해짐

Conv2D(합성곱 층) / MaxPool2D(최대 풀링)

[입력 이미지]
↓ Conv2D
[특징맵]  ← 가장자리, 윤곽선, 패턴 등
↓ MaxPool2D
[축소된 특징맵] ← 정보는 유지하되 크기는 절반

항상 Conv → MaxPool 순서여야하는가?

No. 일반적인 패턴이긴 하지만 항상 붙여다녀야하는 건 아니다.

https://colab.research.google.com/drive/1P9NCB3MQX5QrCf93VHYfPGa0R1V4qD1y?usp=sharing

01 - https://colab.research.google.com/drive/1P9NCB3MQX5QrCf93VHYfPGa0R1V4qD1y?usp=drive_link

02 - https://colab.research.google.com/drive/1Mu5kBwfkfCIRRQ3nvOF4a3wMaz5Cmebz?usp=drive_link

03 - https://colab.research.google.com/drive/1gpLfy1YFGLyHNLdaA1zVnFN4iPCC4kuo?usp=sharing

(1) scikit-learn (사이킷런)

• LinearRegression (선형회귀)
• Ridge, Lasso, ElasticNet (정규화 회귀)
• SVR (Support Vector Regression)
• RandomForestRegressor, GradientBoostingRegressor
• DecisionTreeRegressor

from sklearn.linear_model import LinearRegression, Ridge, Lasso, ElasticNet
from sklearn.ensemble import RandomForestRegressor, GradientBoostingRegressor
from sklearn.svm import SVR
from sklearn.tree import DecisionTreeRegressor

(2) statsmodels

• 통계적 회귀 분석에 특화 (해석이 필요할 때)

import statsmodels.api as sm

(3) XGBoost, LightGBM, CatBoost

• 고성능 트리 기반 회귀 (분류도 가능)

from xgboost import XGBRegressor
from lightgbm import LGBMRegressor

pip install catboost
from catboost import CatBoostRegressor

(4) PyTorch, TensorFlow, Keras

• 딥러닝 기반 회귀 (신경망)

import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import DataLoader, Dataset

import tensorflow as tf
from tensorflow import keras

from tensorflow import keras
from keras.models import Sequential
from keras.layers import Dense

회귀 라이브러리별 사용 상황 정리 표

2. 분류에 사용하는 라이브러리

(1) scikit-learn

• LogisticRegression (로지스틱 분류)
• SVC (Support Vector Classifier)
• RandomForestClassifier, GradientBoostingClassifier
• DecisionTreeClassifier
• KNeighborsClassifier

from sklearn.linear_model import LogisticRegression
from sklearn.ensemble import RandomForestClassifier, GradientBoostingClassifier
from sklearn.svm import SVC
from sklearn.tree import DecisionTreeClassifier
from sklearn.neighbors import KNeighborsClassifier

(2) XGBoost, LightGBM, CatBoost

• 강력한 분류기 (회귀도 지원)

from xgboost import XGBClassifier
from lightgbm import LGBMClassifier

pip install catboost
from catboost import CatBoostClassifier

(3) PyTorch, TensorFlow, Keras

• 딥러닝 기반 분류 (분류용 출력층, 예: Softmax)

import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import DataLoader, Dataset

import tensorflow as tf
from tensorflow import keras
from tensorflow.keras import layers

from keras.models import Sequential
from keras.layers import Dense

분류 라이브러리별 사용 상황 정리 표

요약 표

실전 팁

• 빠른 실험/기본 분류: scikit-learn
• 고성능/비선형/대용량: XGBoost, LightGBM, CatBoost
• 딥러닝, 이미지/텍스트: PyTorch, TensorFlow, Keras

세부 모델별 추천 상황

[예측]회귀(sklearn) - 선형회귀(Linear Regression)

[예측]회귀(sklearn) - Ridge, Lasso, ElasticNet (정규화 회귀)

[예측]회귀(sklearn) - SVR(Support Vector Regression)

[예측]회귀(sklearn) -DecisionTreeRegressor(의사결정 트리)

[예측]회귀(sklearn) - RandomForestRegressor, GradientBoostingRegressor

[예측]분류(sklearn) - Logistic Regression

[예측]분류(sklearn) - SVC (Support Vector Classifier)

[예측]분류(sklearn) - RandomForestClassifier, GradientBoostingClassifier

[예측]분류(sklearn) - DecisionTreeClassifier (의사결정나무 분류기)

[예측]회귀&분류 - XGBoost, LightGBM, CatBoost

[해석]회귀(statsmodels)

1. 개념(쉬운 정의)

• 전체 데이터를 여러 조각(폴드, fold)으로 나눠서

  여러 번 반복해서 모델 성능을 평가하는 방법이야.

2. 왜 필요할까?

• 모델의 정확하게 평가하려고!
• 한 번만 테스트하면 우연히 쉬운/어려운 데이터가 걸릴 수 있어서 검증이 불안정할 수 있음.
• 여러 번 데이터 섞어가며 평가하면 평균 성능이 훨씬 믿을만해짐.

3. 실전에서 가장 많이 쓰는 방식: K-Fold 교차검증

• K-Fold(대표적으로 5-Fold, 10-Fold):

  ① 데이터를 K개(예: 5개)로 똑같이 나눔

  ② 한 번은 4조각으로 학습, 1조각으로 평가

  ③ 이걸 조각마다 테스트 조각을 바꿔가며 K번 반복

  ④ K번 평가한 점수의 평균이 진짜 성능!

4. 코드 예시

from sklearn.model_selection import cross_val_score
from sklearn.linear_model import LogisticRegression
from sklearn.datasets import load_iris

X, y = load_iris(return_X_y=True)
model = LogisticRegression(max_iter=200)
scores = cross_val_score(model, X, y, cv=5)  # 5-Fold
print(scores)        # [0.96, 0.98, 0.94, 0.96, 1.0]  (폴드별 점수)
print(scores.mean()) # 평균 성능

cross_val_score 파라미터

대표 예시

from sklearn.model_selection import cross_val_score
from sklearn.linear_model import LogisticRegression

model = LogisticRegression()
X = [[1,2],[2,3],[3,4],[4,5]]
y = [0,0,1,1]

scores = cross_val_score(
    estimator=model,  # 사용할 모델
    X=X,              # 입력 데이터(피처)
    y=y,              # 정답 데이터(라벨)
    cv=3,             # 3-Fold 교차검증
    scoring='accuracy'# 평가 방식(정확도)
)
print(scores)

결론 요약

• 필수:
  • 모델(estimator)
  • 입력 데이터(X)
  • 정답/라벨(y)
• 옵션:
  • cv(폴드 수, 기본 5)
  • scoring(평가방식, 기본은 정확도)

6. 실무에서의 역할

• 진짜 성능 일반화 성능 과적합 방지에 꼭 필요
• 모델/파라미터/데이터 튜닝 전 성능 비교에도 표준

한줄 정리

cross-validation은 데이터를 여러 번 섞어서 훈련/평가를 반복하고, 그 평균 성능을 모델의 실력으로 삼는 방법! 실험/공모전/논문/실무에서 모델 비교, 파라미터 튜닝의 표준!

예제 1: PolynomialFeatures

from sklearn.preprocessing import PolynomialFeatures

X = [[2, 3]]

poly = PolynomialFeatures(degree=2)
X_poly = poly.fit_transform(X)

• fit()은 어떤 조합 항들을 만들어야 할지 규칙(차수, 변수 수 등)을 파악
• transform()은 그 규칙에 따라 실제 값을 계산
• 그래서 fit_transform()으로 한 번에 처리 가능 (→ 전처리에서는 주로 많이 씀)

예제 2: 모델 학습 (예: LinearRegression)

from sklearn.linear_model import LinearRegression

model = LinearRegression()
model.fit(X_train, y_train)      # 학습
pred = model.predict(X_test)     # 예측

• fit()은 모델이 가중치 학습하는 과정
• transform()은 없음 (회귀 모델은 변환하는 게 아니라 예측만 함)
• 따라서 이 경우엔 fit()만 사용하고, 나중에 *predict()를 씁니다

전처리기 vs 모델 비교 요약

자주 쓰는 전처리기 정리

이 전처리기들은 fit → transform이 필요하기 때문에,

fit_transform()을 자주 사용합니다.

정리 요약

제외되는 것 (머신러닝 X)

회귀 (Regression) 모델

회귀

Ridge Regression

개념

• 선형 회귀 + L2 정규화
• 계수를 작게 만들어 과적합 방지

특징

• 다중공선성(피처 간 상관)이 있을 때 효과적
• 계수 전체를 줄이되 제거는 하지 않음

언제 사용하나?

• 피처가 많고, 과적합이 우려될 때
• 변수 제거보다 안정적인 예측이 중요할 때

사용 코드

from sklearn.linear_model import Ridge
model = Ridge(alpha=1.0)
model.fit(X_train, y_train)
y_pred = model.predict(X_test)

결과

[1.53, 2.15, 2.88, 3.02, 2.61]

Lasso Regression

개념

• 선형 회귀 + L1 정규화
• 일부 계수를 0으로 만들어 변수 선택 기능

특징

• 중요한 피처만 남기는 데 유용
• 과적합 + 차원 축소 효과

언제 사용하나?

• 고차원 데이터
• 중요 피처만 뽑아내고 싶을 때

사용 코드

from sklearn.linear_model import Lasso
model = Lasso(alpha=0.1)
model.fit(X_train, y_train)
y_pred = model.predict(X_test)

결과

[1.47, 2.12, 2.76, 3.00, 2.54]

ElasticNet

개념

• L1 + L2 혼합한 정규화 회귀
• Lasso와 Ridge의 중간 모델

특징

• Lasso처럼 변수 선택
• Ridge처럼 안정성 확보

언제 사용하나?

• 피처가 많고 일부는 중요할 때
• Lasso와 Ridge 사이에서 절충점을 찾고 싶을 때

사용 코드

from sklearn.linear_model import ElasticNet
model = ElasticNet(alpha=0.1, l1_ratio=0.5)
model.fit(X_train, y_train)
y_pred = model.predict(X_test)

결과

[1.50, 2.10, 2.80, 2.95, 2.57]

SVR (Support Vector Regressor)

개념

• SVM의 회귀 버전
• 마진 내 오차는 무시, 마진 바깥 오차만 패널티(모든 데이터를 정확히 맞추는 것보다, ε (엡실론) 오차 내에 들어오면 그걸 무시하고, 최대한 평탄한(일반화된) 모델을 만드는 것)

특징

• 안정성 있음
• 커널로 비선형 회귀 가능
• 학습 느릴 수 있음

언제 사용하나?

• 고차원 소규모 데이터셋에 적합

• 마진 기반 예측이 필요할 때

• 비선형 회귀가 필요한 경우 → 커널 트릭(kernel trick) 사용 가능

• 이상치가 일부 있는 회귀 문제에서 사용 (ε 튜브로 무시 가능)

• 일반적으로 성능은 좋지만 느릴 수 있음 (큰 데이터에 비효율적)

• 자세히

  예시로 이해하기

  원래 데이터 (저차원, 비선형)

    X = [[-2], [-1], [0], [1], [2]]
    y = [4, 1, 0, 1, 4]  # 즉, y = x² 형태

  이 데이터를 선형 회귀로는 맞출 수 없음

  하지만 SVR(kernel='rbf') 을 사용하면 내부적으로 고차원 공간으로 옮겨서 다음처럼 동작

  • X는 그대로지만, 내부적으로 $x \rightarrow x^2$ 변환한 후 선형 SVR 수행

    결과적으로 비선형 회귀처럼 작동

    SVR의 주요 커널 종류

    커널 이름	설명	사용 예
    'linear'	선형 회귀 (직선)	단순한 관계
    'poly'	다항 회귀 (곡선)	곡선 형태 데이터
    'rbf'	가우시안 커널 (비선형 대응 가장 강력)	대부분 비선형 상황에서 기본 선택
    'sigmoid'	신경망 유사 커널	실험적 사용

    RBF 커널 사용한 비선형 회귀

    import numpy as np
    import matplotlib.pyplot as plt
    from sklearn.svm import SVR
    
    # 비선형 데이터
    X = np.linspace(-5, 5, 100).reshape(-1, 1)
    y = np.sin(X).ravel()
    
    # SVR with RBF kernel
    svr_rbf = SVR(kernel='rbf', C=100, epsilon=0.1)
    svr_rbf.fit(X, y)
    y_pred = svr_rbf.predict(X)
    
    # 시각화
    plt.plot(X, y, label='True Function (sin)', color='gray')
    plt.plot(X, y_pred, label='SVR with RBF Kernel', color='red')
    plt.legend()
    plt.title("비선형 회귀 with 커널 트릭")
    plt.show()
    

    C 파라미터의 뜻

    C는 오차에 대한 패널티의 크기(엄격함)를 결정하는 값

  • C 값이 클수록:

    → ε 범위를 벗어난 오차를 엄하게 처벌함

    → 오차를 줄이려는 경향이 강함 → 훈련 데이터에 더 민감함 → 과적합(overfitting) 위험 증가

  • C 값이 작을수록:

    → ε 범위를 벗어난 오차를 관대하게 허용함

    → 일반화 성능이 좋아짐 (훈련 데이터에 덜 민감함) → 과소적합(underfitting) 가능성

## `epsilon`: **오차 무시 범위 (ε-튜브의 폭)**

> 예측값이 실제값과 ε 이내로 차이가 나면, 그 오차는 벌점 없이 무시
> 

즉, SVR은 모든 오차를 줄이는 게 아니라, "ε만큼은 무시하고 넘어가자"는 방식

---

### 예시

```python
SVR(epsilon=0.1)  # 0.1 만큼의 오차는 그냥 무시
```

- ε=0.1 → 실제값과 예측값이 0.1보다 작게 차이 나면 "잘 맞춘 거"로 간주
- ε가 작을수록 → 더 민감하게 맞추려 함
- ε가 클수록 → 더 많은 오차를 무시 → 더 부드러운 모델

---

### 시각적 설명

| epsilon 값 | 설명 | 예측 결과 |
| --- | --- | --- |
| ε = 0.01 | 거의 모든 데이터 포인트를 감싸려 함 | 복잡하고 민감한 회귀선 |
| ε = 0.5 | 많은 오차를 무시하고, 부드럽고 단순한 회귀선 | 일반화 ↑ |

## `gamma`: **RBF 커널에서 거리의 영향력**

> 커널 함수(RBF 등)에서 하나의 데이터 포인트가 영향을 미치는 범위를 결정
> 

**RBF 커널 함수 정의**:

$K(x_i, x_j) = \exp(-\gamma \|x_i - x_j\|^2)$

→ `gamma`는 **데이터 간의 거리 차이를 얼마나 민감하게 볼 것인가**를 결정

---

### gamma 해석

| gamma 값 | 설명 | 결과 |
| --- | --- | --- |
| **작은 값 (e.g. 0.01)** | 넓은 범위의 데이터를 참고함 | 더 부드럽고 단순 |
| **큰 값 (e.g. 10)** | 가까운 데이터에만 반응 | 복잡하고 민감 (과적합 가능) |

---

### 실습 예

```python
from sklearn.svm import SVR

SVR(kernel='rbf', gamma=0.1)  # RBF 커널의 반응 범위 설정
```

- `gamma=0.1` → 곡선이 부드럽고 천천히 변화
- `gamma=100` → 아주 민감하게 휘어짐, 노이즈에 민감 → 과적합 가능

## 요약

| 하이퍼파라미터 | 역할 | 영향 |
| --- | --- | --- |
| **C** | ε를 벗어난 오차에 대한 패널티 강도 | ↑: 과적합 가능 / ↓: 과소적합 가능 |
| **epsilon** | 오차를 무시할 수 있는 범위 (ε-튜브 폭) | ↑: 더 많은 오차 무시 / ↓: 더 민감 |
| **gamma** | RBF 커널에서 영향 범위 (곡선의 유연성) | ↑: 복잡, 민감 / ↓: 단순, 부드러움 |

GradientBoostingRegressor

개념

• 약한 트리 모델을 순차적으로 학습시켜 오차 보정
• 부스팅 기법

특징

• 고성능 예측
• 과적합에 강함
• 느리지만 성능 우수

언제 사용하나?

• 고정밀 회귀
• 트리 기반이 유리한 데이터셋

사용 코드

from sklearn.ensemble import GradientBoostingRegressor
model = GradientBoostingRegressor(n_estimators=100)
model.fit(X_train, y_train)
y_pred = model.predict(X_test)

결과 예시

[1.55, 2.18, 2.89, 3.01, 2.65]

• n_estimators

  n_estimators란?

  “모델 안에 몇 개의 결정 트리(decision tree)를 만들 건지”를 뜻

  즉, n_estimators는 앙상블을 구성하는 기본 모델(보통 트리)의 개수를 의미

  트리 개수가 많을수록?

  n_estimators 값	의미	장단점
  작은 값 (e.g. 10~50)	빠름, 계산 적음	예측 불안정, 성능 낮을 수 있음
  기본값 (100)	적절한 타협	성능/속도 균형
  큰 값 (500~1000)	더 안정적, 과적합 방지 가능	속도 느림, 메모리 사용 ↑

  주의: 너무 많이 늘려도 성능은 크게 좋아지지 않고 시간만 오래 걸릴 수 있음

  n_estimators가 쓰이는 대표 앙상블 모델들

  모델명	라이브러리	모델 종류	n_estimators 의미
  RandomForestClassifier / Regressor	sklearn.ensemble	배깅 (Bagging)	생성할 결정 트리 수
  BaggingClassifier / Regressor	sklearn.ensemble	배깅	Base 모델 복사 수
  ExtraTreesClassifier / Regressor	sklearn.ensemble	배깅 + 완전 랜덤 분할	매우 빠른 랜덤 포레스트
  GradientBoostingClassifier / Regressor	sklearn.ensemble	부스팅	순차적 학습 단계 수
  AdaBoostClassifier / Regressor	sklearn.ensemble	부스팅	약한 학습기의 수
  XGBClassifier / XGBRegressor	xgboost	부스팅	트리 개수
  LGBMClassifier / LGBMRegressor	lightgbm	부스팅	트리 개수
  CatBoostClassifier / Regressor	catboost	부스팅	트리 개수
  HistGradientBoostingClassifier / Regressor	sklearn.ensemble	고속 히스토그램 기반 부스팅	트리 개수

XGBoostRegressor

개념

• Gradient Boosting 개선 버전
• 속도 + 성능 모두 우수

특징

• 정형 데이터 대회에서 자주 사용
• 과적합 제어 기능 탁월

언제 사용하나?

• 대규모 데이터
• 대회용/실무용 예측 모델

사용 코드

from xgboost import XGBRegressor
model = XGBRegressor(n_estimators=100)
model.fit(X_train, y_train)
y_pred = model.predict(X_test)

결과 예시

[1.57, 2.21, 2.91, 3.03, 2.66]

LightGBMRegressor

개념

• XGBoost보다 더 빠르고 메모리 효율적인 부스팅 모델

특징

• 고속 학습
• 대규모/고차원 데이터 처리에 탁월

언제 사용하나?

• XGBoost보다 더 빠른 학습이 필요할 때
• 실시간 예측 환경

사용 코드

from lightgbm import LGBMRegressor
model = LGBMRegressor(n_estimators=100)
model.fit(X_train, y_train)
y_pred = model.predict(X_test)

결과

[1.56, 2.20, 2.88, 3.02, 2.64]

KNeighborsRegressor

개념

• KNN의 회귀 버전
• 주변 K개의 평균값으로 예측

특징

• 단순하고 직관적
• 정규화 필요
• 느릴 수 있음 (lazy learner)

언제 사용하나?

• 소규모, 복잡한 형태의 데이터
• 선형 관계가 없을 때

사용 코드

from sklearn.neighbors import KNeighborsRegressor
model = KNeighborsRegressor(n_neighbors=5)
model.fit(X_train, y_train)
y_pred = model.predict(X_test)

결과

[1.49, 2.16, 2.77, 2.95, 2.60]

• 지도학습 + 앙상블

  • Random Forest

    Random Forest

    Random Forest는 여러 개의 결정 트리를 만들고 그 결과를 앙상블하여 예측하는 지도학습 모델

    Bagging 기반 앙상블 기법이며, 과적합을 줄이고 예측 성능을 높이는 데 매우 강력.

    ---

    용어	의미
    Tree	결정 트리 (Decision Tree) 하나
    Forest	여러 트리를 모은 숲 → 여러 모델의 앙상블
    Random	트리를 만들 때 데이터와 피처를 랜덤하게 샘플링해서 다양성을 확보

    ---

    작동 원리

    핵심: Bagging (Bootstrap Aggregating)

    1. 원본 데이터에서 중복 허용 샘플링 (bootstrap)

    2. 각 샘플로 결정 트리 학습

    3. 예측 시:

       • 분류: 트리들의 다수결
       • 회귀: 트리들의 평균값

       ➕ 추가로 Random Forest는…

    • 각 노드 분할 시 사용할 피처도 랜덤하게 선택 → 트리 간 상관성↓, 분산↓
    • 이것이 "Random" Forest의 핵심 차별점

    ---

    분류 vs 회귀에서의 작동

    항목	분류 (RandomForestClassifier)	회귀 (RandomForestRegressor)
    예측값	클래스 (0, 1, 2...)	연속적인 수치 (실수)
    결합 방식	다수결 (majority vote)	평균 (mean)
    출력 함수	predict_proba(), predict()	predict()

    ---

    장단점

    장점	단점
    과적합에 강함 (트리 평균 덕분)	모델 크기 큼 (트리 많음)
    특성 중요도 파악 가능	예측 해석 어려움 (블랙박스)
    높은 정확도	느릴 수 있음 (트리 많으면)
    결측치·스케일링 영향 적음	고차원 데이터선 느림

    ---

    수식/구조 요약

    예측 함수

    • 회귀일 때:

      $\hat{y} = \frac{1}{n} \sum_{i=1}^{n} T_i(x)$

    • 분류일 때:

      $\hat{y} = \mathrm{mode} { T_1(x), T_2(x), \dots, T_n(x) }$

      여기서 Ti(x)T_i(x)Ti(x)는 i번째 결정 트리의 예측 결과

    ---

    파라미터 설명

    파라미터	설명
    n_estimators	트리의 개수 (많을수록 성능↑, 속도↓)
    max_depth	각 트리의 최대 깊이
    max_features	노드 분할 시 고려할 최대 피처 수
    bootstrap	부트스트랩 샘플링 여부 (True 권장)
    random_state	랜덤 시드 고정
    n_jobs	병렬 처리 사용 개수 (-1이면 모든 코어 사용)

    ---

    예시

    (1) 분류: RandomForestClassifier

    
      from sklearn.ensemble import RandomForestClassifier
      from sklearn.datasets import load_iris
      from sklearn.model_selection import train_test_split
    
      X, y = load_iris(return_X_y=True)
      X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3)
    
      model = RandomForestClassifier(n_estimators=100, random_state=42)
      model.fit(X_train, y_train)
    
      print("예측 결과:", model.predict(X_test))
      print("정확도:", model.score(X_test, y_test))
    

    ---

    (2) 회귀: RandomForestRegressor

    
      from sklearn.ensemble import RandomForestRegressor
      from sklearn.datasets import make_regression
    
      X, y = make_regression(n_samples=1000, n_features=10, noise=10)
      X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)
    
      model = RandomForestRegressor(n_estimators=100, random_state=42)
      model.fit(X_train, y_train)
    
      from sklearn.metrics import r2_score
      y_pred = model.predict(X_test)
      print("R2 Score:", r2_score(y_test, y_pred))
    

    ---

    특성 중요도(Feature Importance)

    
      import matplotlib.pyplot as plt
    
      importances = model.feature_importances_
      plt.bar(range(len(importances)), importances)
      plt.title("Feature Importances")
      plt.show()
    

    → 어떤 피처가 예측에 영향을 많이 줬는지 시각적으로 파악 가능

    ---

    언제 쓰면 좋을까?

    상황	이유
    과적합 위험이 있는 트리 모델	여러 트리 평균으로 완화
    해석보단 성능이 중요한 경우	앙상블이 정확도 높음
    피처 수 많거나 이상치 있음	트리는 자동 처리에 강함
    기본 베이스라인 모델로	튜닝 없이도 잘 동작함

    ---

    정리 요약

    항목	내용
    분류	RandomForestClassifier
    회귀	RandomForestRegressor
    핵심 기법	Bagging + Random Subspace
    결합 방식	다수결 or 평균
    트리 수	n_estimators로 설정
    장점	과적합 방지, 성능 높음, 중요도 출력
    단점	느림, 블랙박스 해석 어려움

  • Gradient Boosting

    Gradient Boosting (그래디언트 부스팅)

    Gradient Boosting은 약한 모델(보통 얕은 트리)을 순차적으로 학습시켜 오차를 줄여가는 방식의 앙상블 학습법

    • Boosting: 모델을 순차적으로 쌓으며 보완
    • Gradient: 오차(loss)의 기울기(gradient)를 따라 보완 방향을 결정

    ---

    분류 기준	포함 여부	설명
    지도학습	✅	X → y 예측
    앙상블 학습	✅	여러 모델을 결합
    Boosting 방식	✅	순차적으로 모델을 학습시킴

    ---

    핵심 개념 (Boosting)

    • 여러 약한 모델(weak learner)을 순차적으로 학습
    • 각 모델은 이전 모델의 오차를 보완
    • 최종 예측은 모든 모델의 예측을 가중 합

    ---

    작동 순서

    예시: 회귀 문제 기준

    1. 처음에는 단순한 예측 (예: 평균값)
    2. 오차(잔차 residual)를 계산
    3. 그 오차를 잘 예측하는 결정 트리 모델을 하나 학습
    4. 새 예측 = 기존 예측 + 학습된 트리의 출력
    5. 다시 오차 계산 → 또 트리 학습 → 반복…

    ---

    수식적으로 설명

    최종 예측 함수(Final Prediction Function)

    $\hat{y} = F_M(x) = \sum_{m=1}^{M} \gamma_m h_m(x)$

    • $h_m(x)$: m번째 약한 모델 (보통 결정 트리)

    • $γm$: 학습률(learning rate)

    • $F_M(x)$: M번째 단계까지 누적된 최종 예측값

      각 단계에서 학습 목표 (잔차 = 기울기)

      $r_i^{(m)} = -\left[ \frac{\partial L(y_i, F(x_i))}{\partial F(x_i)} \right]{F(x)=F{m-1}(x)}$

    • $r_i^{(m)}$ : i번째 데이터 샘플에 대한 손실 함수의 기울기 (잔차)

    • ${L(y_i, F(x_i))}$ : 손실 함수 (예: MSE, 로그손실 등)

    • ${F_{m-1}(x)}$ : 이전 단계까지의 누적 예측

      → 이 잔차를 예측하도록 $hm(x)$ (새로운 트리) 를 학습

      → 그래서 이름이 Gradient Boosting (기울기를 따라가며 개선)

    ---

    장점과 단점

    장점	단점
    높은 예측 성능	학습 시간 오래 걸림
    다양한 손실 함수 사용 가능	과적합 가능성 있음 (너무 깊거나 많으면)
    특성 중요도 파악 가능	직관적 해석 어려움
    회귀, 분류 모두 가능	하이퍼파라미터 튜닝 필요

    ---

    주요 하이퍼파라미터

    파라미터	설명
    n_estimators	학습할 트리 개수
    learning_rate	학습률 (각 트리 기여 정도)
    max_depth	트리의 최대 깊이
    loss	손실 함수 (회귀: MSE, 분류: log-loss 등)
    subsample	샘플 일부만 학습 (과적합 방지용)

    ---

    예시 (GradientBoostingRegressor)

    
      from sklearn.ensemble import GradientBoostingRegressor
      from sklearn.datasets import make_regression
      from sklearn.model_selection import train_test_split
      from sklearn.metrics import r2_score
    
      # 데이터 생성
      X, y = make_regression(n_samples=1000, n_features=10, noise=15)
      X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)
    
      # 모델 학습
      model = GradientBoostingRegressor(n_estimators=100, learning_rate=0.1, max_depth=3)
      model.fit(X_train, y_train)
    
      # 예측 및 평가
      y_pred = model.predict(X_test)
      print("R2 Score:", r2_score(y_test, y_pred))

    ---

    다른 Boosting 계열과의 비교

    모델	특징	라이브러리
    Gradient Boosting (GBM)	기본적인 부스팅 모델	sklearn
    XGBoost	속도 향상 + 정규화 추가	xgboost
    LightGBM	대용량 데이터에 특화, 속도 매우 빠름	lightgbm
    CatBoost	범주형 자동 처리	catboost

    ---

    실전 사용 시 팁

    상황	추천 설정
    과적합 우려	learning_rate ↓, n_estimators ↑
    훈련 속도 느릴 때	subsample < 1.0, max_depth ↓
    변수 중요도 분석	feature_importances_ 사용
    파라미터 튜닝	GridSearchCV or RandomizedSearchCV

    ---

    요약

    항목	설명
    학습 방식	지도학습 + Boosting 앙상블
    구성 모델	결정 트리(보통 작은 트리)
    결합 방식	잔차 보완식 순차 학습
    최종 예측	모든 트리의 출력값 가중합
    대표 구현	GradientBoostingRegressor, GradientBoostingClassifier
    대표 라이브러리	sklearn, xgboost, lightgbm, catboost

  • XGBoost

    XGBoost (eXtreme Gradient Boosting)

    XGBoost는 여러 약한 결정 트리를 순차적으로 학습하고, 잔차를 줄이도록 가중 합산하는

    Boosting 기반의 고성능 앙상블 모델

    Gradient Boosting에 정규화 + 병렬화 + 가지치기 + 결측처리를 더해 성능을 극대화한 형태

    ---

    왜 "XGBoost"?

    용어	의미
    Boost	이전 모델이 틀린 걸 고쳐나가는 방식 (잔차 보정)
    Gradient	손실 함수의 기울기를 이용해 최적화
    eXtreme	속도/성능 모두 향상 (병렬화 + 최적화)
    Tree	약한 학습기로 CART 트리 사용

    ---

    작동 원리

    Gradient Boosting + 정규화 + 병렬 분할

    잔차(residual)를 예측하도록 다음 트리를 학습

    • 각 트리는 이전까지의 예측값을 보정함

    • 트리마다 분할 기준은 손실 감소 + 복잡도 규제를 같이 고려

    • 학습은 다음과 같은 방식으로 이뤄짐:

      $\hat{y}_i^{(t)} = \hat{y}_i^{(t-1)} + \eta \cdot f_t(x_i)$

    ---

    분류 vs 회귀에서의 작동

    항목	분류 (XGBClassifier)	회귀 (XGBRegressor)
    예측값	클래스	연속 수치
    손실 함수	logloss / softmax	MSE / MAE
    결합 방식	클래스 확률 평균 후 최빈값	예측값 평균
    출력 함수	predict_proba() / predict()	predict()

    ---

    장단점

    장점	단점
    높은 정확도	구조 복잡함
    과적합 방지 정규화 내장	해석 어려움
    결측치 자동 처리	학습 시간 긴 경우 있음
    다양한 손실 함수 지원	파라미터 많아 튜닝 필요
    빠른 학습 (C++ 백엔드)	기울기/헤시안 계산 필요

    ---

    언제 쓰면 좋은가?

    사용 조건	이유
    예측 정확도가 매우 중요	캐글 1위 모델 다수
    과적합 걱정되는 복잡한 데이터	정규화 + 가지치기 내장
    대용량 데이터	병렬 처리, GPU 지원
    결측값 존재	자동 처리 지원
    분류, 회귀, 랭킹 문제	전용 손실 함수 지원

    ---

    내부 동작 구조 요약

    • 기본 구조는 Gradient Boosting과 동일:

      → 오차를 줄이도록 새로운 트리를 순차적으로 추가

    • 하지만 XGBoost는 다음을 추가함:

      • 정규화 (L1/L2)
      • 가지치기 (Pruning)
      • 병렬 최적화
      • 2차 테일러 근사

    ---

    주요 파라미터

    파라미터	의미	설명
    n_estimators	트리 수	많을수록 복잡도 ↑
    learning_rate	학습률	작을수록 안정적
    max_depth	트리 깊이	깊을수록 복잡
    subsample	샘플 비율	과적합 방지
    colsample_bytree	피처 비율	다양성 증가
    gamma	최소 분할 손실	가지치기 기준
    reg_alpha, reg_lambda	L1/L2 정규화	과적합 방지

    ---

    예시

    (1) 회귀용 XGBRegressor

      python
      복사편집
      from xgboost import XGBRegressor
      from sklearn.datasets import make_regression
      from sklearn.model_selection import train_test_split
      from sklearn.metrics import r2_score
    
      X, y = make_regression(n_samples=1000, n_features=10, noise=15)
      X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)
    
      model = XGBRegressor(
          n_estimators=100,
          learning_rate=0.1,
          max_depth=4,
          random_state=42
      )
      model.fit(X_train, y_train)
      y_pred = model.predict(X_test)
      print("R2 Score:", r2_score(y_test, y_pred))
    

    ---

    (2) 분류용 XGBClassifier

      python
      복사편집
      from xgboost import XGBClassifier
      from sklearn.datasets import load_breast_cancer
      from sklearn.model_selection import train_test_split
      from sklearn.metrics import accuracy_score
    
      X, y = load_breast_cancer(return_X_y=True)
      X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)
    
      clf = XGBClassifier(
          n_estimators=100,
          max_depth=3,
          learning_rate=0.1,
          use_label_encoder=False,
          eval_metric='logloss'
      )
      clf.fit(X_train, y_train)
      y_pred = clf.predict(X_test)
      print("Accuracy:", accuracy_score(y_test, y_pred))
    

    특성 중요도 시각화

    
      from xgboost import plot_importance
      import matplotlib.pyplot as plt
    
      plot_importance(model)
      plt.title("Feature Importance")
      plt.show()
    

    변수 중요도 확인

    
      from xgboost import plot_importance
      plot_importance(model)
      plt.show()
    

    ---

    결과값 해석

    모델	주요 평가 지표	의미
    XGBRegressor	R² Score	1에 가까울수록 예측 정확
    XGBClassifier	Accuracy, F1 Score	높을수록 분류 잘함

    ---

    회귀 vs 분류 요약 비교

    항목	회귀	분류
    클래스	XGBRegressor	XGBClassifier
    손실 함수	MSE, MAE 등	logloss, softmax
    출력	실수 값	클래스 확률 또는 라벨
    예측 함수	predict()	predict(), predict_proba()
    평가지표	R², RMSE	Accuracy, F1, AUC

    ---

    마무리 요약

    항목	설명
    핵심 모델	XGBRegressor, XGBClassifier
    구조	Gradient Boosting + 정규화 + 최적화
    특징	정확도 높음, 과적합 억제, 속도 빠름
    입력	X, y → 지도학습 기반
    핵심 수식	기울기 + 헤시안 기반 손실 최소화
    활용	분류/회귀/랭킹 전반에서 성능 최강

  • LightGBM

    개념

    LightGBM은 Gradient Boosting 계열의 트리 기반 머신러닝 알고리즘으로,

    여러 개의 약한 모델(결정 트리)을 순차적으로 학습시켜 예측 정확도를 높이는 앙상블 기법

    특히 학습 속도와 메모리 효율성을 극대화를 위한 최적화된 구조

    "Light" = 빠르고 가볍다

    "GBM" = Gradient Boosting Machine

    주요 특징

    • Leaf-wise 성장 방식: 가장 손실이 큰 리프 노드만 분기 → 더 정확
    • Histogram 기반 학습: 연산량 줄이기 → 더 빠름
    • GOSS: 중요한 데이터 위주로 학습
    • EFB: 희소 feature들을 묶어 처리

    ---

    언제 사용?

    조건	설명
    대규모 데이터셋	수십~수백만 행 이상의 테이블
    고차원 데이터	수천 개 이상의 컬럼
    희소 데이터	원-핫 인코딩된 데이터, 결측치가 많은 데이터
    속도가 중요한 경우	실시간 추천 시스템, 대용량 서비스 등
    - 이진 분류: 예) 스팸 이메일 분류, 암/정상 진단
    - 다중 분류: 예) 손글씨 숫자 분류
    - 회귀: 예) 집값 예측, 수요 예측
    - 랭킹: 예) 검색 결과 정렬, 추천 시스템
    - 이상치 탐지

    ---

    내부 동작 방식

    🔸 3.1 Leaf-wise 성장 방식

    LightGBM은 트리를 키울 때 전체 트리의 depth를 일정하게 늘리는 것이 아니라,

    가장 손실(loss)을 많이 줄일 수 있는 리프 노드 하나만 골라 분기합니다.

    이 방식의 장점은 더 정밀한 학습이 가능하다는 것이고,

    단점은 트리가 불균형하게 커져서 과적합 가능성이 높아진다는 것입니다.

    ---

    🔸 3.2 Histogram 기반 학습

    LightGBM은 feature 값을 일정 구간(bin)으로 나눠서 히스토그램을 만들고,

    이 히스토그램을 기반으로 분할 기준을 정합니다.

    예를 들어, 연속적인 수치형 feature를 256개 구간으로 나누면,

    원래 값들이 정수든 실수든 구간(bin) 번호로 대체하여 처리하므로 훨씬 빠릅니다.

    ---

    🔸 3.3 GOSS (Gradient-based One-Side Sampling)

    Gradient 값이 큰 샘플은 모델이 틀린 예측을 한 것이므로 중요도가 높습니다.

    LightGBM은 Gradient 값이 큰 샘플은 모두 포함하고, 작은 값의 샘플은 일부만 샘플링해서 학습에 사용합니다.

    즉, 중요한 정보는 유지하면서 학습 속도를 크게 줄이는 전략입니다.

    ---

    🔸 3.4 EFB (Exclusive Feature Bundling)

    많은 feature들이 희소한 경우, 예를 들어 one-hot encoding된 경우,

    같은 row에서 둘 다 1이 될 일이 없는 feature들끼리 묶어서 하나처럼 처리합니다.

    예) [0, 1, 0], [0, 0, 1] 같은 feature들 → 하나의 컬럼으로 압축

    ---

    주요 하이퍼파라미터

    파라미터	설명	예시
    num_leaves	하나의 트리에서 사용할 최대 리프 노드 수	과적합 방지: 보통 31~100
    max_depth	트리의 최대 깊이	너무 깊으면 과적합
    learning_rate	학습률	작게 잡을수록 더 정밀
    n_estimators	트리의 개수	많을수록 성능↑ (시간↑)
    min_data_in_leaf	리프 노드가 가져야 할 최소 데이터 수	과적합 방지
    feature_fraction	학습에 사용할 feature 비율	0.8이면 무작위 80% 사용
    bagging_fraction	학습에 사용할 샘플 비율	랜덤샘플링 효과
    boosting_type	부스팅 알고리즘 종류	기본값: ‘gbdt’
    lambda_l1, lambda_l2	정규화 계수 (L1/L2)	과적합 방지용

    ---

    사용 라이브러리 및 설치

      pip install lightgbm

      import lightgbm as lgb

    또는 GPU 지원 버전:

      pip install lightgbm --install-option=--gpu

    ---

    예시 (이진 분류)

      import lightgbm as lgb
      from sklearn.datasets import load_breast_cancer
      from sklearn.model_selection import train_test_split
      from sklearn.metrics import accuracy_score
    
      # 데이터 로드
      X, y = load_breast_cancer(return_X_y=True)
      X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)
    
      # 모델 정의
      model = lgb.LGBMClassifier(
          n_estimators=100,
          num_leaves=31,
          learning_rate=0.1,
          max_depth=-1
      )
    
      # 학습
      model.fit(X_train, y_train)
    
      # 예측
      y_pred = model.predict(X_test)
    
      # 평가
      print("정확도:", accuracy_score(y_test, y_pred))

    ---

    결과 예시

      정확도: 0.9649122807017544

  • CatBoost

  • StackingRegressor

    StackingRegressor

    StackingRegressor는 여러 개의 다른 회귀 모델(base learners)을 조합하고,

    그 결과를 다시 최종 메타 회귀 모델(meta regressor)이 학습하여 더 정확한 예측을 만드는 앙상블 회귀 기법

    → 각 회귀 모델의 예측값을 새로운 입력 특성(feature)으로 간주하고,

    → 그것들을 바탕으로 최종 모델이 다시 예측하는 방식

    ---

    전체 구조

         원본 입력 (X)
               ↓
       ┌─────────────┐
       │  Base 모델 1 │──▶ 예측값1 ─┐
       ├─────────────┤             │
       │  Base 모델 2 │──▶ 예측값2 ─┼─▶  [예측값1, 예측값2, ...] → 메타 모델 → 최종 예측값
       ├─────────────┤             │
       │  Base 모델 3 │──▶ 예측값3 ─┘
       └─────────────┘
    

    • Base 모델: 서로 다른 종류의 회귀 모델 (예: 결정 트리, KNN, SVR 등)

    • Meta 모델: Base 모델들의 예측값을 받아 다시 예측하는 회귀 모델 (보통 선형 모델이 좋음)

      문제 유형	메타 모델 (보통 쓰는 것)
      분류 문제 (classification)	✅ 로지스틱 회귀 (LogisticRegression)
      회귀 문제 (regression)	✅ 릿지 회귀 / 선형 회귀 (RidgeCV / LinearRegression)

    ---

    언제 사용?

    상황	설명
    다양한 회귀 모델의 예측을 조합하고 싶을 때	서로 다른 특성을 가진 모델이 잘 보완해줌
    하나의 모델이 완벽하지 않을 때	서로 다른 편향을 가진 모델을 합치면 시너지 가능
    캐글(Kaggle) 등 대회에서 성능 극대화	실제 우승 솔루션에서 자주 등장

    ---

    예제 (scikit-learn 기반)

      from sklearn.ensemble import StackingRegressor
      from sklearn.linear_model import RidgeCV
      from sklearn.tree import DecisionTreeRegressor
      from sklearn.neighbors import KNeighborsRegressor
      from sklearn.datasets import make_regression
      from sklearn.model_selection import train_test_split
    
      # 1. 데이터 생성
      X, y = make_regression(n_samples=1000, n_features=20, noise=0.1, random_state=42)
      X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)
    
      # 2. Base 모델 정의
      base_models = [
          ('tree', DecisionTreeRegressor(max_depth=5)),
          ('knn', KNeighborsRegressor(n_neighbors=10))
      ]
    
      # 3. 메타 모델 정의 (보통 선형 회귀나 릿지 회귀 사용)
      meta_model = RidgeCV()
    
      # 4. StackingRegressor 정의
      stacking = StackingRegressor(
          estimators=base_models,
          final_estimator=meta_model,
          cv=5  # base 모델 훈련 시 교차검증용
      )
    
      # 5. 학습 및 예측
      stacking.fit(X_train, y_train)
      y_pred = stacking.predict(X_test)
    
      # 6. 결과 확인
      from sklearn.metrics import r2_score
      print("R2 Score:", r2_score(y_test, y_pred))

    ---

    주요 파라미터 설명

    파라미터	설명
    estimators	리스트 형태로 base 모델들을 정의 ((이름, 모델) 튜플)
    final_estimator	메타 모델 (보통 간단한 회귀 모델 사용)
    cv	base 모델 학습 시 내부에서 사용할 교차검증 폴드 수
    n_jobs	병렬 처리용 (CPU 코어 병렬 실행)
    passthrough=True	메타 모델에게 원본 X도 함께 전달 (성능 향상 가능)

    주의사항 / 팁

    주의사항	설명
    Meta 모델은 너무 복잡하지 않게!	보통 LinearRegression, RidgeCV 등 추천
    Base 모델은 서로 다른 성격의 모델로 구성	서로 다른 성능, 편향을 가진 모델을 조합해야 효과적
    cv는 꼭 지정할 것	메타 모델이 과적합되지 않게 하기 위해 중요
    원본 X도 함께 주고 싶다면 passthrough=True 사용	예측 성능이 더 좋아질 수 있음

    확장 가능

    • StackingRegressor 안에 넣는 base 모델은 반드시 회귀 모델이어야 함.

    • 최종 meta 모델도 회귀여야 함.

      예시:

      from sklearn.linear_model import Lasso
      from sklearn.svm import SVR
      from sklearn.ensemble import GradientBoostingRegressor
      
      base = [
        ('lasso', Lasso(alpha=0.01)),
        ('svr', SVR(C=10))
      ]
      meta = GradientBoostingRegressor(n_estimators=100)
      
      model = StackingRegressor(estimators=base, final_estimator=meta, cv=5)

    ---

    정리 요약

    항목	내용
    정의	여러 회귀 모델의 예측을 조합해 최종 회귀 예측을 수행하는 앙상블 모델
    사용 라이브러리	sklearn.ensemble.StackingRegressor
    장점	다양한 모델의 장점을 종합해 성능 극대화
    구성 요소	Base 모델들 + 메타 회귀 모델
    추천 구조	서로 다른 성격의 base 모델 + 간단한 메타 모델
    적합한 문제	일반적인 회귀, 캐글 대회, 성능이 중요한 프로젝트

  • BaggingRegressor

    BaggingRegressor

    Bagging = Bootstrap Aggregating

    → 여러 개의 회귀 모델을 무작위로 다르게 학습시키고,

    그 결과를 평균해서 더 안정적이고 일반화된 예측을 만드는 앙상블 회귀 모델

    개념

    • 훈련 데이터를 중복 허용 샘플링 (bootstrap) 으로 여러 개 생성
    • 각 샘플에 별도의 회귀 모델 학습
    • 예측값은 → 평균(회귀) 으로 결합

    ---

    언제 사용?

    사용 시점	이유
    단일 회귀 모델이 과적합되는 경우	Bagging은 분산을 줄여 과적합을 완화함
    예측값의 안정성이 중요한 경우	평균값을 사용해 노이즈에 덜 민감
    비선형적이거나 복잡한 관계가 있는 데이터	결정 트리 기반 회귀 모델이 잘 작동함
    모델 간 병렬 처리가 가능해야 할 때	Base 모델이 독립적이므로 병렬화 쉬움

    ---

    전체 구조

      훈련 데이터 X
       ├─ bootstrap 샘플링 → 모델1 학습 → 예측1
       ├─ bootstrap 샘플링 → 모델2 학습 → 예측2
       ├─ bootstrap 샘플링 → 모델3 학습 → 예측3
       ...
       └─ 예측 결과 평균 → 최종 예측값

    ---

    예시

    기본 예제: DecisionTreeRegressor + BaggingRegressor

      from sklearn.ensemble import BaggingRegressor
      from sklearn.tree import DecisionTreeRegressor
      from sklearn.datasets import make_regression
      from sklearn.model_selection import train_test_split
      from sklearn.metrics import r2_score
    
      # 1. 데이터 생성
      X, y = make_regression(n_samples=1000, n_features=10, noise=20, random_state=42)
      X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)
    
      # 2. 모델 정의
      base_model = DecisionTreeRegressor()
      bagging = BaggingRegressor(
          base_estimator=base_model,
          n_estimators=100,        # 몇 개의 모델을 만들 것인지
          bootstrap=True,          # bootstrap 샘플링 여부
          max_samples=1.0,         # 각 모델에 사용할 샘플 비율
          max_features=1.0,        # 각 모델에 사용할 특성 비율
          random_state=42,
          n_jobs=-1                # 병렬 처리
      )
    
      # 3. 학습 및 평가
      bagging.fit(X_train, y_train)
      y_pred = bagging.predict(X_test)
    
      print("R² Score:", r2_score(y_test, y_pred))

    ---

    주요 파라미터 정리

    파라미터	설명	기본값
    base_estimator	사용할 회귀 모델 (예: DecisionTreeRegressor)	None → DecisionTree
    n_estimators	앙상블할 모델 수	10
    bootstrap	샘플링 시 중복 허용 여부	True
    max_samples	각 base 모델에 줄 샘플 수 (비율 또는 정수)	1.0
    max_features	각 모델에 사용할 특성 수	1.0
    oob_score	OOB 평가 여부 (훈련에 쓰이지 않은 샘플로 검증)	False
    n_jobs	병렬 처리할 코어 수 (-1: 전부 사용)	None
    random_state	재현 가능성 위한 시드	None

    ---

    Bagging vs 단일 모델

    항목	단일 모델	BaggingRegressor
    예측 성능	불안정하거나 과적합 가능	더 안정적, 분산 감소
    과적합	발생 가능	완화됨
    노이즈에 민감	높음	낮음
    병렬 처리	❌	가능
    속도	빠름	느릴 수 있음 (n_estimators ↑)

    ---

    다양한 base_estimator 사용가능

      from sklearn.svm import SVR
      from sklearn.linear_model import Ridge
      from sklearn.neighbors import KNeighborsRegressor
    
      BaggingRegressor(base_estimator=SVR())
      BaggingRegressor(base_estimator=Ridge())
      BaggingRegressor(base_estimator=KNeighborsRegressor())

    단, 각 base 모델은 회귀 모델이어야 함!

    ---

    OOB (Out-of-Bag) 평가

      bagging = BaggingRegressor(oob_score=True)
      bagging.fit(X_train, y_train)
      print("OOB R² Score:", bagging.oob_score_)

    • Bootstrap에서 빠진 샘플로 내부 검증
    • 추가적인 검증 세트 없이도 성능을 간접 평가 가능

    ---

    성능 비교 실험 (선택)

    모델	R² Score
    DecisionTreeRegressor	0.74
    BaggingRegressor	0.86 (훨씬 향상)

    ---

    정리

    항목	설명
    정의	여러 회귀 모델을 샘플링된 데이터로 학습시켜 평균하는 앙상블
    대표 클래스	sklearn.ensemble.BaggingRegressor
    기본 모델	DecisionTreeRegressor (기본값)
    장점	과적합 완화, 일반화 성능 ↑, 병렬화 가능
    사용 시점	단일 모델이 불안정하거나, 고차원 / 복잡한 데이터

  • VotingRegressor

    VotingRegressor

    여러 개의 서로 다른 회귀 모델들의 예측값을 평균해서

    최종 예측값을 계산하는 앙상블 모델

    • 분류에서는 VotingClassifier가 다수결(Majority voting)을 사용
    • 회귀에서는 VotingRegressor가 예측값의 평균(Averaging) 을 사용

    ---

    구조

            X 입력
              ↓
       ┌──────────────┐
       │  모델1 예측   │ → 예측값1
       │  모델2 예측   │ → 예측값2
       │  모델3 예측   │ → 예측값3
       └──────────────┘
              ↓
        최종 예측 = (예측1 + 예측2 + 예측3) / 3

    ---

    언제 사용하나?

    사용 조건	이유
    다양한 회귀 모델을 조합하고 싶을 때	서로 다른 모델 특성이 시너지를 낼 수 있음
    단순하면서 안정적인 앙상블을 원할 때	평균만 사용하므로 과적합 위험 낮음
    Boosting처럼 순차 학습이 필요 없는 구조	병렬화 가능하고 빠름

    ---

    실습 예제

      from sklearn.ensemble import VotingRegressor
      from sklearn.linear_model import Ridge
      from sklearn.tree import DecisionTreeRegressor
      from sklearn.svm import SVR
      from sklearn.datasets import make_regression
      from sklearn.model_selection import train_test_split
    
      # 데이터 생성
      X, y = make_regression(n_samples=1000, n_features=20, noise=15, random_state=42)
      X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)
    
      # 모델 정의
      model1 = Ridge(alpha=1.0)
      model2 = DecisionTreeRegressor(max_depth=5)
      model3 = SVR()
    
      # VotingRegressor 정의
      voting_model = VotingRegressor(estimators=[
          ('ridge', model1),
          ('tree', model2),
          ('svr', model3)
      ])
    
      # 학습 및 예측
      voting_model.fit(X_train, y_train)
      y_pred = voting_model.predict(X_test)
    

    ---

    주요 파라미터

    파라미터	설명
    estimators	사용할 회귀 모델 리스트 (이름, 모델) 튜플
    n_jobs	병렬 처리 (기본: None, 전체 CPU: -1)
    weights	각 모델의 가중치 지정 가능

    ---

    가중치 지정 예시

      VotingRegressor(
          estimators=[('ridge', model1), ('tree', model2), ('svr', model3)],
          weights=[1, 2, 1]  # tree 모델에 더 높은 비중
      )

    • 비중 조정해서 더 신뢰하는 모델에 가중치 부여 가능

    ---

    VotingRegressor vs 다른 앙상블

    항목	VotingRegressor	BaggingRegressor	StackingRegressor
    예측 방식	평균	각 모델 독립 학습 후 평균	메타 모델이 다시 예측
    모델 다양성	높음 (여러 모델 가능)	보통 같은 모델	가장 다양함
    학습 방식	병렬, 단순	병렬, 부트스트랩	병렬 + 메타 학습
    해석력	높음	중간	낮음
    성능	보통	안정적	가장 높을 수 있음

    ---

    정리

    항목	내용
    용도	여러 회귀 모델의 예측 평균값을 사용해 안정적 예측
    구조	병렬 예측 + 단순 평균
    라이브러리	sklearn.ensemble.VotingRegressor
    추천 사용 상황	단순하고 빠른 앙상블, baseline 비교할 때 유용

분류 (Classification) 모델

분류

RidgeClassifier

개념

• 선형 분류 모델 + L2 정규화(가중치 패널티)
• LogisticRegression과 비슷하지만 loss 함수가 다름

특징

• 빠르고 단순함
• 이진/다중 분류 모두 가능
• 과적합 완화

언제 사용하나?

• 피처 수가 많고, 빠른 선형 분류가 필요할 때
• baseline 모델로 적합

사용 코드

from sklearn.linear_model import RidgeClassifier
model = RidgeClassifier()
model.fit(X_train, y_train)
y_pred = model.predict(X_test)

결과

[0, 1, 2, 2, 1]

GradientBoostingClassifier

개념

• 약한 분류기(예: 작은 트리)를 순차적으로 학습시켜

  이전 모델의 오류를 보완하는 부스팅 방식 분류기

특징

• 과적합에 비교적 강함

• 성능이 우수하지만 학습 속도는 느린 편

• 하이퍼파라미터가 많아 튜닝 필요

  언제 사용하나?

• 복잡한 분류 문제

• 과적합 방지 + 높은 예측력이 필요한 경우

• LogisticRegression, 트리 기반 모델보다 더 강력한 모델이 필요할 때

  사용 코드

from sklearn.ensemble import GradientBoostingClassifier
model = GradientBoostingClassifier(n_estimators=100, learning_rate=0.1)
model.fit(X_train, y_train)
y_pred = model.predict(X_test)

🔹 결과 예시

[1, 0, 0, 2, 2]

XGBoostClassifier

개념

• Gradient Boosting을 기반으로 한 고속/고성능 분류기
• 학습 속도와 정확도 모두 우수, 실무/대회에서 많이 사용

특징

• 과적합 제어 기능 탁월 (gamma, lambda, eta)
• missing value 자동 처리
• GPU 지원 가능

언제 사용하나?

• Kaggle, AI 경진대회
• 정형 데이터 예측 (카테고리 중심의 데이터셋)
• 복잡한 관계 학습이 필요할 때

사용 코드

from xgboost import XGBClassifier
model = XGBClassifier(n_estimators=100, use_label_encoder=False, eval_metric='mlogloss')
model.fit(X_train, y_train)
y_pred = model.predict(X_test)

🔹 결과 예시

[1, 0, 2, 2, 1]

LightGBMClassifier

개념

• XGBoost보다 더 빠르게 학습되는 부스팅 모델
• Leaf-wise 트리 성장 방식으로 성능 향상

특징

• 고속 처리, 적은 메모리
• 대규모, 고차원 데이터에 강함
• 범주형 변수 자동 인식 가능 (특정 설정 시)

언제 사용하나?

• 대용량 데이터
• 빠른 예측/학습이 필요한 온라인 서비스
• 실시간 분류기

사용 코드

from lightgbm import LGBMClassifier
model = LGBMClassifier(n_estimators=100)
model.fit(X_train, y_train)
y_pred = model.predict(X_test)

🔹 결과 예시

[0, 1, 1, 2, 0]

CatBoostClassifier

개념

• 범주형 데이터 자동 처리가 가능한 부스팅 기반 분류기
• 전처리 없이도 범주형 피처를 인식하고 처리 가능

특징

• Label Encoding 없이도 학습 가능
• 성능 우수 + 학습 속도 빠름
• 파라미터 튜닝 없이도 좋은 성능

언제 사용하나?

• 범주형 변수가 많은 데이터셋
• 전처리 부담 줄이고 싶을 때

사용 코드

from catboost import CatBoostClassifier
model = CatBoostClassifier(verbose=0)
model.fit(X_train, y_train)
y_pred = model.predict(X_test)

🔹 결과 예시

[1, 0, 1, 1, 2]

BaggingClassifier

개념

• 동일한 분류 모델(기본적으로 결정트리)을 여러 개 학습한 뒤,

  각 모델의 예측을 평균(분류에선 투표)하여 최종 예측

  → Bagging(Bootstrap Aggregating)

특징

• 과적합 감소
• 데이터의 일부만 샘플링 (부트스트랩)
• 병렬 처리 가능

언제 사용하나?

• 데이터가 작고 과적합이 우려될 때
• 단일 트리보다 안정적인 성능을 원할 때

사용 코드

from sklearn.ensemble import BaggingClassifier
from sklearn.tree import DecisionTreeClassifier

base_model = DecisionTreeClassifier()
model = BaggingClassifier(base_estimator=base_model, n_estimators=10)
model.fit(X_train, y_train)
y_pred = model.predict(X_test)

결과 예시

[0, 1, 1, 2, 1]

VotingClassifier

개념

• 여러 다른 종류의 분류 모델을 학습

  각 모델의 예측을 투표 방식(다수결)으로 결합하는 앙상블

특징

• 다양한 모델의 강점을 결합 가능
• 보통 Logistic + Tree + SVM 조합 추천
• hard vs soft voting 선택 가능

언제 사용?

• 개별 모델 간 예측이 상이할 때
• 서로 다른 성격의 모델을 조합하고 싶을 때

사용 코드

from sklearn.ensemble import VotingClassifier
from sklearn.linear_model import LogisticRegression
from sklearn.tree import DecisionTreeClassifier
from sklearn.svm import SVC

model1 = LogisticRegression()
model2 = DecisionTreeClassifier()
model3 = SVC(probability=True)

ensemble = VotingClassifier(
    estimators=[('lr', model1), ('dt', model2), ('svc', model3)],
    voting='soft'
)
ensemble.fit(X_train, y_train)
y_pred = ensemble.predict(X_test)

🔹 결과 예시

[1, 0, 2, 2, 1]

StackingClassifier

개념

• 여러 개의 기반 모델(base learners)이 예측한 결과를

  다시 하나의 메타 모델(meta learner)에 입력하여 최종 예측

특징

• 복잡하지만 성능 우수
• Voting보다 예측력이 더 높을 수 있음
• 예측 결과를 재학습하는 방식

언제 사용?

• 다양한 모델을 계층적으로 결합하고 싶을 때
• 대회, 앙상블 기반 고정밀 예측이 필요할 때

사용 코드

from sklearn.ensemble import StackingClassifier
from sklearn.linear_model import LogisticRegression
from sklearn.tree import DecisionTreeClassifier
from sklearn.svm import SVC

base_models = [
    ('dt', DecisionTreeClassifier()),
    ('svc', SVC(probability=True))
]
meta_model = LogisticRegression()

stack = StackingClassifier(estimators=base_models, final_estimator=meta_model)
stack.fit(X_train, y_train)
y_pred = stack.predict(X_test)

결과 예시

[0, 1, 1, 2, 2]

전체적인 코드 순서

base_models →

meta_model →

StackingClassifier(estimators=base_models, final_estimator=meta_model)

estimators : 여러 개의 모델(로지스틱, 트리, SVM 등)이 원래 입력 데이터를 보고 각각 예측하는 역할

final_estimator : 각 모델이 낸 예측값을 모아서 최종적으로 “이게 정답이다!” 라고 판단하는 역할

비지도 학습 (Unsupervised Learning) - 핵심

## 개념

- **KMeans**는 데이터를 **K개의 군집으로 분할**하는 알고리즘
- 각 군집은 하나의 중심점(centroid)을 가지고, 데이터는 이 중심점에 가장 가까운 군집에 속함
- 반복적으로 중심점과 군집을 재조정하면서 최적화

### 동작 과정:

1. 임의로 K개의 중심점(centroids)을 선택
2. 각 데이터를 가장 가까운 중심점에 할당
3. 각 군집의 평균값으로 중심점 업데이트
4. 중심점 변화가 거의 없거나 최대 반복 횟수 도달 시 종료

## 언제 사용하나?

- 데이터를 **명확히 K개의 그룹으로 나눌 수 있다고 가정**할 때
- 데이터의 **중심이 존재**하는 군집이 있을 때
- 고객 세분화, 문서 분류, 이미지 압축 등에서 자주 사용

## 사용 라이브러리 및 코드 예시

```python
from sklearn.cluster import KMeans
from sklearn.datasets import make_blobs
import matplotlib.pyplot as plt

# 예시 데이터 생성
X, _ = make_blobs(n_samples=300, centers=4, cluster_std=0.6, random_state=42)

# KMeans 모델 생성 및 학습
kmeans = KMeans(n_clusters=4, random_state=42)
kmeans.fit(X)

# 예측 결과
y_pred = kmeans.predict(X)

# 군집 중심점
centroids = kmeans.cluster_centers_

# 시각화
plt.scatter(X[:, 0], X[:, 1], c=y_pred, cmap='viridis', alpha=0.6)
plt.scatter(centroids[:, 0], centroids[:, 1], s=200, c='red', marker='X', label='Centroids')
plt.title('KMeans Clustering')
plt.legend()
plt.show()
```

---

## 결과 해석

- 산점도 위에 각 데이터 포인트는 색깔로 군집이 구분됨
- 빨간 X는 각 군집의 중심 (centroid)
- 군집이 잘 나눠진 형태일 경우, 비슷한 성향의 데이터를 같은 군집으로 묶음

## 특징 요약

| 항목 | 설명 |
| --- | --- |
| **장점** | 단순, 빠름, 대규모 데이터에 잘 작동 |
| **단점** | K를 사전에 알아야 함, 이상치에 민감 |
| **가정** | 각 군집이 원형이고, 같은 분산을 가짐 |

## 참고: 최적의 K 찾는 방법 (엘보우 방법)

```python
inertias = []
for k in range(1, 10):
    km = KMeans(n_clusters=k, random_state=42)
    km.fit(X)
    inertias.append(km.inertia_)  # 군집 내 거리합 (작을수록 군집 잘 됨)

plt.plot(range(1, 10), inertias, marker='o')
plt.title('Elbow Method')
plt.xlabel('K')
plt.ylabel('Inertia')
plt.show()
```

- 그래프에서 **급격히 감소하다가 완만해지는 지점**이 최적의 K

• DBSCAN → 필수

  개념

  • DBSCAN은 밀도 기반 군집화 알고리즘

  • 밀도가 높은 지역은 군집으로 묶고, 밀도가 낮은 지역은 이상치(노이즈)로 처리

    핵심 아이디어

  • 어떤 점의 주변 반경(ε, 입실론) 안에 최소 n개의 이웃(min_samples)이 있으면, 이 점은 코어 포인트(Core Point) 라고 부름.

  • 코어 포인트 주변에 연결된 점들을 같은 군집으로 묶음.

  • 밀도가 낮은 지역에 있는 점들은 노이즈 (Noise) 로 간주됨.

  ---

  언제 사용하나?

  사용 시점	이유
  클러스터 개수를 모르거나 정하기 어렵다	DBSCAN은 군집 수를 자동으로 결정해줘
  복잡한 모양의 군집이 있을 때	KMeans는 원형 군집만 잘 나누지만, DBSCAN은 자유로운 모양 가능
  이상치를 잘 처리하고 싶을 때	노이즈 포인트를 따로 분류해줌

  ---

  주요 파라미터

  파라미터	설명
  eps	점 주변의 반경 (이 거리 안에 몇 개의 점이 있는지 봄)
  min_samples	eps 거리 내에 있어야 할 최소 이웃 수 (이 수 이상이면 Core Point)

  ---

  사용 코드 (Scikit-learn)

    from sklearn.datasets import make_moons
    from sklearn.cluster import DBSCAN
    import matplotlib.pyplot as plt
    import numpy as np
  
    # 데이터 생성 (복잡한 모양)
    X, _ = make_moons(n_samples=300, noise=0.05, random_state=0)
  
    # DBSCAN 모델 생성 및 학습
    db = DBSCAN(eps=0.2, min_samples=5)
    y_db = db.fit_predict(X)
  
    # 시각화
    plt.scatter(X[:, 0], X[:, 1], c=y_db, cmap='plasma', s=50)
    plt.title("DBSCAN Clustering Result")
    plt.xlabel("X")
    plt.ylabel("Y")
    plt.show()

  ---

  결과 예시

  • 같은 색깔 → 같은 군집

  • 1로 라벨링된 점들 → 노이즈로 간주된 점들

    DBSCAN은 fit_predict()로 바로 군집 번호를 예측

    • 1은 이상치(노이즈)로 판별된 데이터 포인트를 의미

  ---

  예시 결과 (y_db 값 일부)

    array([0, 1, 1, 0, 0, 0, 1, 1, -1, 1, 1, 0, 0, ...])

  • 0, 1 → 군집 번호
  • 1 → 노이즈

  ---

  장단점 정리

  장점	단점
  군집 수 자동 결정 (K 설정 X)	eps와 min_samples 설정이 어렵고 민감함
  이상치 탐지 기능 포함	고차원에서는 성능 저하 가능
  비원형, 복잡한 모양도 잘 클러스터링	밀도가 균일하지 않으면 잘 안 나뉨

  ---

  적절한 eps 찾는 방법 (K-distance plot)

    from sklearn.neighbors import NearestNeighbors
  
    neigh = NearestNeighbors(n_neighbors=5)
    nbrs = neigh.fit(X)
    distances, indices = nbrs.kneighbors(X)
  
    # 거리 정렬 후 시각화
    distances = np.sort(distances[:, 4])
    plt.plot(distances)
    plt.title("K-distance Graph (5-NN)")
    plt.xlabel("Points")
    plt.ylabel("5th Nearest Distance")
    plt.show()

  • 꺾이는 지점(엘보우)을 eps 값으로 사용하면 좋음.

  ---

  DBSCAN 요약

  항목	내용
  군집 수 지정?	불필요
  이상치 감지	가능
  자유로운 군집 모양	가능
  복잡한 데이터	매우 적합
  대표 활용	지리정보(위치기반), 이상탐지, 이미지 분석

• PCA(차원축소)

  PCA란?

  PCA는 고차원 데이터를 저차원으로 줄이되, 데이터의 분산(정보)을 최대한 보존하는 방식의 차원 축소 기법

  • PCA는 데이터를 회전시켜 가장 잘 퍼져 있는 방향(=주성분)을 찾아
  • 원래 데이터의 축 대신 새 축(주성분 축)으로 데이터를 표현

  ---

  예시

  2차원 데이터

  
    x축 →
    ⬛      ⬛
       ⬛  ⬛
         ⬛
       ⬛  ⬛
    ⬛      ⬛
                      ↖  주성분 방향 (제일 넓게 퍼진 방향)
  

  → PCA는 이 대각선 방향을 새로운 x축으로 잡고,

  이 위에 데이터를 투영해서 1차원으로 줄이는 거예요.

  ---

  2. 언제 사용하는가?

  상황	설명
  피처 수가 너무 많아서 연산이 느릴 때	→ 불필요한 정보를 줄이고 빠르게 처리 가능
  데이터 시각화가 필요할 때	→ 2D, 3D로 축소하여 시각화
  머신러닝 전처리로 과적합 줄이고 싶을 때	→ 불필요한 노이즈 제거
  피처 간 상관관계가 높을 때	→ 새로운 축은 서로 직교함 (상관 X)

  ---

  3. PCA 내부 동작 원리 (수학 포함)

  1. 데이터 정규화 (평균 0, 분산 1)

     → StandardScaler 등으로 먼저 스케일 조정

  2. 공분산 행렬 계산Cov(X)=n−11XTX

     Cov(X)=1n−1XTX\text{Cov}(X) = \frac{1}{n-1} X^T X

     → 어떤 방향으로 데이터가 가장 잘 퍼져 있는지를 확인

  3. 고유값 분해 (Eigen Decomposition)

     → 공분산 행렬을 분해해서 고유값 + 고유벡터를 얻음

     → 고유벡터가 주성분 방향, 고유값은 분산의 크기

  4. 고유값이 큰 순으로 주성분 선택

     → 정보를 많이 담은 축부터 순서대로 사용

  5. 원 데이터를 주성분 축으로 투영 (변환)

     → 차원 축소된 새로운 데이터 완성

---

## 4. 파이썬 코드 예제

```python

import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import load_iris
from sklearn.preprocessing import StandardScaler
from sklearn.decomposition import PCA

# 1. 데이터 로딩
data = load_iris()
X = data.data
y = data.target

# 2. 스케일링 (PCA 전에 꼭 필요!)
X_scaled = StandardScaler().fit_transform(X)

# 3. PCA 적용 (2차원으로 축소)
pca = PCA(n_components=2)
X_pca = pca.fit_transform(X_scaled)

# 4. 시각화
plt.figure(figsize=(8,6))
plt.scatter(X_pca[:, 0], X_pca[:, 1], c=y, cmap='viridis')
plt.xlabel('PC 1')
plt.ylabel('PC 2')
plt.title('PCA - Iris Dataset')
plt.colorbar(label='Target')
plt.show()

```

---

## 5. 출력 결과 예시

- `X_pca.shape` → `(150, 2)` ← 원래는 4차원 → 2차원으로 줄어듦
- 시각화: 군집별로 **잘 분리된 결과 확인 가능** (꽃 종류에 따라 나뉨)

---

## 6. 주요 속성 및 메서드

| 속성 / 메서드 | 설명 |
| --- | --- |
| `pca.components_` | 주성분 축 (고유벡터들) |
| `pca.explained_variance_` | 각 주성분의 고유값 (분산 크기) |
| `pca.explained_variance_ratio_` | 각 주성분이 설명하는 전체 분산의 비율 |
| `pca.singular_values_` | 특이값 분해 시 사용하는 값 |
| `fit()` | 주성분 방향 계산만 함 |
| `transform()` | 이미 계산된 축으로 데이터 변환 |
| `fit_transform()` | 위 둘을 한 번에 실행 |

---

## 7. `explained_variance_ratio_`로 몇 개의 차원만 쓸지 결정 가능!

```python
print(pca.explained_variance_ratio_)
print(sum(pca.explained_variance_ratio_))  # 총 분산 설명량
```

> 예: [0.72, 0.23] → 총 95% 설명 → 2개만 써도 충분!
> 

- **??????????????**

    > pca.explained_variance_ratio_는
    > 
    > 
    > 각 **주성분 축(PC1, PC2, …)** 이 **원본 데이터의 분산을 얼마나 설명하는지를 비율로** 나타낸 거야.
    > 

    ---

    ## 예시

    원래 데이터가 **4차원**이었다고 해보자.

    그럼 PCA는 이렇게 물어봐요:

    > "이 4개의 축(컬럼)을 새로운 축으로 바꿔서, **정보(분산)**를 압축하고 싶은데...
    > 
    > 
    > 그럼 새로 만든 축(PCA 축)들이 원래 정보를 **얼마나 잘 담고 있는지** 확인해보자!"
    > 

    ---

    ## 실제 출력

    ```python

    from sklearn.decomposition import PCA
    from sklearn.preprocessing import StandardScaler
    from sklearn.datasets import load_iris

    data = load_iris()
    X = data.data

    # 표준화 → PCA 필수!
    X_scaled = StandardScaler().fit_transform(X)

    # PCA 전체 축 계산 (4개 원래 차원 전부)
    pca = PCA()
    X_pca = pca.fit_transform(X_scaled)

    print(pca.explained_variance_ratio_)
    print(sum(pca.explained_variance_ratio_))

    ```

    출력 예:

    ```

    [0.72962445 0.22850762 0.03668922 0.00517871]
    0.9999999999999999
    ```

    ---

    ### 이게 무슨 뜻이야?

    | 주성분 축 (PC) | 설명 비율 (%) |
    | --- | --- |
    | PC1 (1번째 축) | **72.96%** |
    | PC2 (2번째 축) | **22.85%** |
    | PC3 | 3.66% |
    | PC4 | 0.52% |
    | **총합** | 100% (모든 정보 포함) |

    ---

    ## 핵심 포인트! 왜 중요한가?

    > 주성분들은 정보를 많이 담은 순서대로 정렬돼 있어요.
    > 
    > 
    > 즉,
    > 
    - **PC1이 가장 중요**
    - **PC2는 그 다음**
    - …
    - **PC4는 거의 쓸모 없음**

    ---

    ## 그래서 `n_components`를 어떻게 결정해?

    예를 들어:

    ```python
    pca = PCA(n_components=2)
    ```

    이렇게 하면:

    → **PC1 + PC2만 사용**

    → 위 예에서 72.96% + 22.85% = **약 95.8%** 정보 유지됨

    즉! **2개 축만 사용해도 거의 모든 정보(95%)가 보존되는 것!**

    그래서:

    ```python
    print(pca.explained_variance_ratio_)
    print(sum(pca.explained_variance_ratio_))  # 총 분산 설명량
    ```

    이걸 출력해서 "**몇 개의 차원을 쓰면 충분한가?**" 판단하는 데 쓰는 거야!

    ---

    ## 시각적으로 보면?

    | PC1 | PC2 | PC3 | PC4 |
    | --- | --- | --- | --- |
    | ▓▓▓▓▓▓▓▓▓▓▓ | ▓▓▓▓▓▓▓▓ | ▓ | ░ |
    | 72.9% | 22.8% | 3.7% | 0.5% |

    ✔️ → 그럼 우리는 "PC1 + PC2만 쓰면 되겠다!" 하고 `n_components=2`로 줄일 수 있어.

    ---

    ## 만약 자동으로 차원 수를 정하고 싶다면?

    ```python
    pca = PCA(n_components=0.95)
    ```

    이렇게 쓰면:

    → **자동으로 95% 이상 분산을 설명하는 최소한의 차원 수만 유지!**

    → 사람이 직접 2, 3 이렇게 안 정해도 됨

    ---

    ## 정리 요약

    | 용어 | 의미 |
    | --- | --- |
    | `explained_variance_ratio_` | 각 PCA 축이 **전체 정보(분산)** 중 얼마나 설명하는지 비율 |
    | `sum(...)` | 총 몇 %의 정보를 보존하는지 확인 |
    | `n_components=2` | 앞에서 중요한 두 개의 축만 쓰겠다 |
    | `n_components=0.95` | 전체 분산의 95% 이상 설명하는 축을 자동으로 선택 |

---

## 실제 사용 예시

| 사용 상황 | 설명 |
| --- | --- |
| 시각화 | 고차원 데이터를 2D로 축소해서 plot |
| 전처리 | 차원을 줄이고 모델 성능 향상 |
| 노이즈 제거 | 주성분만 남기고 나머지는 버려서 잡음 제거 |
| 얼굴 인식 | Eigenface 기법도 PCA 기반 |

---

## 주의점

| 주의 사항 | 이유 |
| --- | --- |
| 꼭 `StandardScaler` 등으로 정규화 먼저 | 변수 스케일이 다르면 PCA가 왜곡됨 |
| 너무 많은 차원을 줄이면 정보 손실 | `explained_variance_ratio_`로 얼마나 설명하는지 확인해야 함 |
| 해석이 어려움 | 주성분 축은 기존 피처와 다르기 때문에 의미 해석 어려움 |

---

## 정리 요약

| 항목 | 설명 |
| --- | --- |
| 이름 | PCA (Principal Component Analysis) |
| 목적 | 차원 축소 + 정보 최대 보존 |
| 내부 동작 | 공분산 → 고유값 분해 → 투영 |
| 핵심 개념 | 분산을 많이 가진 방향으로 축을 새로 정함 |
| 언제 사용 | 고차원 데이터, 시각화, 과적합 방지 |
| 필수 전처리 | StandardScaler 등으로 정규화 |
| 결과 해석 | `explained_variance_ratio_`로 정보 보존량 확인 |

• 비지도 학습( Unsupervised Learning ) - 전체

  1. 군집화 (Clustering)

  비슷한 데이터끼리 그룹으로 묶는 작업

  알고리즘	설명	특징
  KMeans	중심점 기반 군집화	단순, 빠름. 군집 수(k) 미리 정해야 함
  DBSCAN	밀도 기반 클러스터링	이상치 탐지 포함, 클러스터 수 미정
  MeanShift	밀도 기반 클러스터링	자동으로 클러스터 수 찾음
  Agglomerative Clustering	계층적 군집화	덴드로그램 시각화 가능
  Spectral Clustering	그래프 기반 클러스터링	복잡한 경계도 잘 나눔

  군집화 알고리즘 비교표

  알고리즘	군집 수 자동	이상치 감지	비선형 구조	빠름	복잡도
  KMeans	❌ 필요	❌ 없음	❌ 약함	✅ 빠름	낮음
  DBSCAN	✅ 자동	✅ 강함	✅ 강함	✅ 보통	중간
  MeanShift	✅ 자동	❌ 약함	✅ 강함	❌ 느림	중간
  Agglomerative	❌ (덴드로그램으로 조절)	❌ 없음	✅ 강함	❌ 느림	중간
  Spectral	❌ 필요	❌ 없음	✅ 매우 강함	❌ 느림	높음
  - KMeans

    ## 개념
  
    - **KMeans**는 데이터를 **K개의 군집으로 분할**하는 알고리즘
    - 각 군집은 하나의 중심점(centroid)을 가지고, 데이터는 이 중심점에 가장 가까운 군집에 속함
    - 반복적으로 중심점과 군집을 재조정하면서 최적화
  
    ### 동작 과정:
  
    1. 임의로 K개의 중심점(centroids)을 선택
    2. 각 데이터를 가장 가까운 중심점에 할당
    3. 각 군집의 평균값으로 중심점 업데이트
    4. 중심점 변화가 거의 없거나 최대 반복 횟수 도달 시 종료
  
    ## 언제 사용하나?
  
    - 데이터를 **명확히 K개의 그룹으로 나눌 수 있다고 가정**할 때
    - 데이터의 **중심이 존재**하는 군집이 있을 때
    - 고객 세분화, 문서 분류, 이미지 압축 등에서 자주 사용
  
    ## 사용 라이브러리 및 코드 예시
  
    ```python
    from sklearn.cluster import KMeans
    from sklearn.datasets import make_blobs
    import matplotlib.pyplot as plt
  
    # 예시 데이터 생성
    X, _ = make_blobs(n_samples=300, centers=4, cluster_std=0.6, random_state=42)
  
    # KMeans 모델 생성 및 학습
    kmeans = KMeans(n_clusters=4, random_state=42)
    kmeans.fit(X)
  
    # 예측 결과
    y_pred = kmeans.predict(X)
  
    # 군집 중심점
    centroids = kmeans.cluster_centers_
  
    # 시각화
    plt.scatter(X[:, 0], X[:, 1], c=y_pred, cmap='viridis', alpha=0.6)
    plt.scatter(centroids[:, 0], centroids[:, 1], s=200, c='red', marker='X', label='Centroids')
    plt.title('KMeans Clustering')
    plt.legend()
    plt.show()
    ```
  
    ---
  
    ## 결과 해석
  
    - 산점도 위에 각 데이터 포인트는 색깔로 군집이 구분됨
    - 빨간 X는 각 군집의 중심 (centroid)
    - 군집이 잘 나눠진 형태일 경우, 비슷한 성향의 데이터를 같은 군집으로 묶음
  
    ## 특징 요약
  
    | 항목 | 설명 |
    | --- | --- |
    | **장점** | 단순, 빠름, 대규모 데이터에 잘 작동 |
    | **단점** | K를 사전에 알아야 함, 이상치에 민감 |
    | **가정** | 각 군집이 원형이고, 같은 분산을 가짐 |
  
    ## 참고: 최적의 K 찾는 방법 (엘보우 방법)
  
    ```python
    inertias = []
    for k in range(1, 10):
        km = KMeans(n_clusters=k, random_state=42)
        km.fit(X)
        inertias.append(km.inertia_)  # 군집 내 거리합 (작을수록 군집 잘 됨)
  
    plt.plot(range(1, 10), inertias, marker='o')
    plt.title('Elbow Method')
    plt.xlabel('K')
    plt.ylabel('Inertia')
    plt.show()
    ```
  
    - 그래프에서 **급격히 감소하다가 완만해지는 지점**이 최적의 K

  • DBSCAN

    개념

    • DBSCAN은 밀도 기반 군집화 알고리즘

    • 밀도가 높은 지역은 군집으로 묶고, 밀도가 낮은 지역은 이상치(노이즈)로 처리

      핵심 아이디어

    • 어떤 점의 주변 반경(ε, 입실론) 안에 최소 n개의 이웃(min_samples)이 있으면, 이 점은 코어 포인트(Core Point) 라고 부름.

    • 코어 포인트 주변에 연결된 점들을 같은 군집으로 묶음.

    • 밀도가 낮은 지역에 있는 점들은 노이즈 (Noise) 로 간주됨.

    ---

    언제 사용하나?

    사용 시점	이유
    클러스터 개수를 모르거나 정하기 어렵다	DBSCAN은 군집 수를 자동으로 결정해줘
    복잡한 모양의 군집이 있을 때	KMeans는 원형 군집만 잘 나누지만, DBSCAN은 자유로운 모양 가능
    이상치를 잘 처리하고 싶을 때	노이즈 포인트를 따로 분류해줌

    ---

    주요 파라미터

    파라미터	설명
    eps	점 주변의 반경 (이 거리 안에 몇 개의 점이 있는지 봄)
    min_samples	eps 거리 내에 있어야 할 최소 이웃 수 (이 수 이상이면 Core Point)

    ---

    사용 코드 (Scikit-learn)

      from sklearn.datasets import make_moons
      from sklearn.cluster import DBSCAN
      import matplotlib.pyplot as plt
      import numpy as np
    
      # 데이터 생성 (복잡한 모양)
      X, _ = make_moons(n_samples=300, noise=0.05, random_state=0)
    
      # DBSCAN 모델 생성 및 학습
      db = DBSCAN(eps=0.2, min_samples=5)
      y_db = db.fit_predict(X)
    
      # 시각화
      plt.scatter(X[:, 0], X[:, 1], c=y_db, cmap='plasma', s=50)
      plt.title("DBSCAN Clustering Result")
      plt.xlabel("X")
      plt.ylabel("Y")
      plt.show()

    ---

    결과 예시

    • 같은 색깔 → 같은 군집

    • 1로 라벨링된 점들 → 노이즈로 간주된 점들

      DBSCAN은 fit_predict()로 바로 군집 번호를 예측

      • 1은 이상치(노이즈)로 판별된 데이터 포인트를 의미

    ---

    예시 결과 (y_db 값 일부)

      array([0, 1, 1, 0, 0, 0, 1, 1, -1, 1, 1, 0, 0, ...])

    • 0, 1 → 군집 번호
    • 1 → 노이즈

    ---

    장단점 정리

    장점	단점
    군집 수 자동 결정 (K 설정 X)	eps와 min_samples 설정이 어렵고 민감함
    이상치 탐지 기능 포함	고차원에서는 성능 저하 가능
    비원형, 복잡한 모양도 잘 클러스터링	밀도가 균일하지 않으면 잘 안 나뉨

    ---

    적절한 eps 찾는 방법 (K-distance plot)

      from sklearn.neighbors import NearestNeighbors
    
      neigh = NearestNeighbors(n_neighbors=5)
      nbrs = neigh.fit(X)
      distances, indices = nbrs.kneighbors(X)
    
      # 거리 정렬 후 시각화
      distances = np.sort(distances[:, 4])
      plt.plot(distances)
      plt.title("K-distance Graph (5-NN)")
      plt.xlabel("Points")
      plt.ylabel("5th Nearest Distance")
      plt.show()

    • 꺾이는 지점(엘보우)을 eps 값으로 사용하면 좋음.

    ---

    DBSCAN 요약

    항목	내용
    군집 수 지정?	불필요
    이상치 감지	가능
    자유로운 군집 모양	가능
    복잡한 데이터	매우 적합
    대표 활용	지리정보(위치기반), 이상탐지, 이미지 분석

  • MeanShift

    개념

    • MeanShift는 데이터의 밀도(density)가 높은 방향으로 중심점을 이동시켜서 군집을 찾는 알고리즘

    • 이름 그대로, “평균(Mean)” 방향으로 이동(Shift)” 한다는 의미!

      핵심 아이디어

    • 각 데이터 포인트에서 주변 데이터를 살펴보고, 그들의 평균으로 계속 이동한다.

    • 이 과정을 반복하면서 밀도가 높은 지점으로 중심이 이동 → 결국 데이터 밀집된 지점들이 군집의 중심점이 됨.

    ---

    언제 사용?

    사용 상황	이유
    군집 수를 사전에 정하기 어려운 경우	MeanShift는 자동으로 군집 수를 결정함
    데이터 밀집 정도가 중요할 때	중심이 자동으로 조정되어 밀도가 높은 지점을 중심으로 클러스터 형성
    군집 모양이 복잡하거나 비선형적인 경우	KMeans와 달리 원형이 아니어도 잘 작동함

    ---

    파라미터

    파라미터	설명
    bandwidth	중심점이 이웃을 인식하는 반경 (kernel window size)
    → 클수록 더 큰 지역 평균, 작을수록 세밀한 군집화
    bin_seeding	빠른 계산을 위해 bin 기반 시드 사용 여부 (True로 하면 속도 ↑)

    bandwidth는 전체 밀도에 영향을 주는 핵심 하이퍼파라미터. 너무 크면 군집 수 적고, 너무 작으면 과도한 군집이 나옴.

    ---

    코드 예시 (scikit-learn)

      from sklearn.cluster import MeanShift, estimate_bandwidth
      from sklearn.datasets import make_blobs
      import matplotlib.pyplot as plt
    
      # 예시 데이터 생성
      X, _ = make_blobs(n_samples=300, centers=3, cluster_std=0.7, random_state=42)
    
      # bandwidth 자동 추정
      bandwidth = estimate_bandwidth(X, quantile=0.2)
    
      # MeanShift 모델 정의
      ms = MeanShift(bandwidth=bandwidth)
      ms.fit(X)
    
      # 결과
      labels = ms.labels_
      cluster_centers = ms.cluster_centers_
    
      # 시각화
      plt.scatter(X[:, 0], X[:, 1], c=labels, cmap='rainbow', s=50)
      plt.scatter(cluster_centers[:, 0], cluster_centers[:, 1], c='black', s=200, marker='X', label='Centers')
      plt.title('MeanShift Clustering')
      plt.legend()
      plt.show()

    ---

    예시 결과

    • 데이터 밀집도가 높은 지역 중심으로 자동 군집화
    • X 마커가 군집의 중심점 (centroid)
    • 군집 수는 따로 지정하지 않아도 bandwidth에 따라 자동 결정됨

    ---

    결과 출력 예시

      print("군집 수:", len(np.unique(labels)))
      print("레이블:", labels[:10])

    예시 출력:

      군집 수: 3
      레이블: [2 1 1 2 0 2 1 1 1 0]

    ---

    장점 & 단점

    장점	단점
    군집 수 자동 결정	느림 (특히 데이터 많을 때)
    비원형, 복잡한 군집도 탐지 가능	bandwidth 설정에 민감
    이상치에 어느 정도 강함	고차원에서는 성능 저하

    ---

    MeanShift 요약

    항목	설명
    군집 수 자동 결정	O
    이상치 감지	직접적으로는 안됨
    군집 모양	자유로움 (비선형 가능)
    중심 계산 방식	주변 평균으로 이동 (Kernel 밀도 추정 기반)
    추천 용도	GPS 기반 클러스터링, 이미지 분할, 복잡한 군집 탐색

  • Agglomerative Clustering(병합 계층적 군집화)

    개념

    • Agglomerative Clustering은 계층적 군집화(Hierarchical Clustering) 방식 중 하향식(Bottom-up) 접근법

    • 처음에는 모든 데이터를 하나씩 따로 군집으로 시작하고, 점차 서로 가까운 군집끼리 병합해서 하나의 트리 구조(덴드로그램)를 형성

      데이터들 간의 유사도(거리)를 기준으로 군집을 병합해 나가는 방식.

      최종적으로 사용자가 자르는 지점에 따라 군집 수를 정할 수 있음.

    ---

    작동 과정 (Bottom-Up 병합 방식)

    1. 모든 데이터 포인트를 자기 자신만 포함하는 군집으로 시작
    2. 가장 가까운 두 군집을 찾아 병합
    3. 이 과정을 하나의 군집이 남을 때까지 반복
    4. 군집 수는 최종 덴드로그램을 어디서 자르냐에 따라 정해짐

    ---

    언제 사용?

    상황	이유
    군집 수를 직접 조절하거나 시각적으로 판단하고 싶을 때	덴드로그램으로 군집 수를 결정 가능
    군집 간의 관계나 계층적 구조가 있는 데이터	예: 문서 분류, 생물 분류, 유전자 분석
    KMeans처럼 중심점 가정이 어색한 경우	중심점 기반이 아님, 거리 기반이라 자유로움

    ---

    주요 파라미터

    파라미터	설명
    n_clusters	최종적으로 남길 군집 수 (덴드로그램 자르는 위치)
    linkage	군집 간 거리 측정 방법 (ward, average, complete, single)
    affinity	거리 계산 방식 (euclidean, manhattan 등)

    linkage 설명

    linkage 종류	설명
    ward	군집 내 분산을 최소화 (기본값)
    average	군집 간 모든 점의 평균 거리
    complete	군집 간 가장 먼 점끼리 거리
    single	군집 간 가장 가까운 점끼리 거리 (연결만 잘 돼도 묶임)

    ---

    예제 코드 (sklearn + scipy for dendrogram)

      from sklearn.datasets import make_blobs
      from sklearn.cluster import AgglomerativeClustering
      import matplotlib.pyplot as plt
      import scipy.cluster.hierarchy as sch
    
      # 예시 데이터 생성
      X, _ = make_blobs(n_samples=200, centers=4, random_state=42)
    
      # 덴드로그램 그리기
      plt.figure(figsize=(10, 5))
      dendro = sch.dendrogram(sch.linkage(X, method='ward'))
      plt.title("Dendrogram")
      plt.xlabel("Data Index")
      plt.ylabel("Distance")
      plt.show()

    위 그래프에서 수직선이 길게 그려진 곳을 수평으로 자르면 군집 수가 정해짐. 예: 4개의 긴 가지 전에서 자르면 4개 군집.

    ---

    클러스터링 적용 코드

      # 군집 수 4개로 클러스터링
      cluster = AgglomerativeClustering(n_clusters=4, affinity='euclidean', linkage='ward')
      y_pred = cluster.fit_predict(X)
    
      # 시각화
      plt.scatter(X[:, 0], X[:, 1], c=y_pred, cmap='rainbow')
      plt.title("Agglomerative Clustering Result")
      plt.show()

    ---

    결과 예시 해석

    • 각 군집은 색상으로 구분됨
    • 덴드로그램으로 얼마나 유사한 군집끼리 먼저 병합됐는지 시각적으로 확인 가능
    • ward linkage는 KMeans와 비슷하게 원형 구조에 강함, complete, average는 다양한 모양 처리 가능

    ---

    결과 출력

      import numpy as np
      print("군집 레이블:", np.unique(y_pred))  # → [0 1 2 3]
      print("예측값 일부:", y_pred[:10])
    

    ---

    장점 & 단점 요약

    장점	단점
    덴드로그램으로 군집 수 조절 쉬움	큰 데이터셋엔 느림 (거리 계산이 많음)
    다양한 linkage 전략 사용 가능	거리 기반이라 고차원엔 어려움
    비선형, 다양한 군집 가능	이상치에 다소 민감

    ---

    Agglomerative Clustering 요약

    항목	설명
    군집 수 자동 결정	없음. 덴드로그램에서 수동 조정 필요
    이상치 감지	직접 탐지 기능 없음
    군집 모양	자유롭고 계층적 구조 탐색 가능
    중심점 사용	없음 (거리 기반 병합)
    추천 용도	문서 분류, 유전자 분석, 소셜 네트워크 분석, 텍스트 마이닝

  • Spectral Clustering

    개념

    • 스펙트럴(Spectral)이란 말 그대로 “스펙트럼 = 고유값(eigenvalue)” 기반의 클러스터링 기법

    • 데이터 간 유사도(similarity)로 만든 그래프 구조를 기반으로

      → 그래프의 라플라시안 행렬(Laplacian Matrix)을 분해한 뒤,

      → 얻은 고유벡터들을 새로운 축으로 사용해서 군집화

    ### 한마디로 요약

    > 복잡한 구조의 데이터라도, 데이터 간 유사도만 정의할 수 있다면 그래프 형태로 표현해서, **비선형 구조**도 잘 클러스터링할 수 있음
    > 

    ---

    ## 작동 원리 요약

    1. **유사도 행렬(Similarity Matrix)** 생성 (ex. 가우시안 커널, 거리 기반)
    2. 이걸로 **그래프 라플라시안 행렬**을 만든 뒤,
    3. **고유값 분해 (Eigen Decomposition)** 수행
    4. 주요 고유벡터들을 새로운 좌표(저차원 특징 공간)로 사용
    5. 이 특징 공간에서 **KMeans** 같은 방법으로 클러스터링 수행

    ---

    ## 언제 사용?

    | 사용 상황 | 이유 |
    | --- | --- |
    | 데이터의 구조가 **비선형 경계**일 때 | KMeans처럼 단순한 원형 분리가 불가능한 경우 |
    | **정확한 군집 수(K)를 알고 있고**, 복잡한 구조일 때 | 복잡한 경계의 데이터를 선형으로 잘 나눌 수 있음 |
    | **이미 유사도나 거리 정보가 있는 경우** | 유사도 기반이므로 다양한 입력 가능 |

    ---

    ## 장점 & 단점

    | 장점 | 단점 |
    | --- | --- |
    | 비선형 경계도 잘 나눔 | 계산 복잡도 높음 (대규모 데이터엔 느림) |
    | 유사도 정의만 가능하면 매우 유연 | 클러스터 수 K 필요 |
    | 라플라시안 그래프 기반 | 수학적으로 직관 어렵고 구현 비용 ↑ |

    ---

    ## Scikit-learn 사용 코드

    ```python
    from sklearn.datasets import make_circles
    from sklearn.cluster import SpectralClustering
    import matplotlib.pyplot as plt

    # 데이터 생성 (KMeans로는 분리 어려운 원형 구조)
    X, _ = make_circles(n_samples=300, factor=0.5, noise=0.05, random_state=42)

    # 스펙트럴 클러스터링 적용
    sc = SpectralClustering(n_clusters=2, affinity='rbf', random_state=42)
    y_sc = sc.fit_predict(X)

    # 시각화
    plt.scatter(X[:, 0], X[:, 1], c=y_sc, cmap='plasma', s=50)
    plt.title("Spectral Clustering (비선형 구조 분리)")
    plt.xlabel("X1")
    plt.ylabel("X2")
    plt.show()
    ```

    ---

    ## 예시 결과 해석

    - **내부 원과 외부 원**이 잘 분리됨 → 일반적인 KMeans로는 불가능한 분리 구조
    - Spectral은 데이터 간 **유사도 기반으로 변형된 공간에서 클러스터링**하기 때문에 이런 것도 가능

    ---

    ## 주요 파라미터 설명

    | 파라미터 | 설명 |
    | --- | --- |
    | `n_clusters` | 군집 수 K |
    | `affinity` | 유사도 방식 (`rbf`, `nearest_neighbors`, `precomputed`) |
    | `assign_labels` | 클러스터링 방법 (`kmeans`, `discretize`) |
    | `gamma` | RBF 커널 계수 (affinity='rbf'일 때 사용됨) |

    ---

    ## affinity 종류

    | 방식 | 설명 |
    | --- | --- |
    | `rbf` | 가우시안 커널 기반 거리 유사도 (기본값) |
    | `nearest_neighbors` | K-최근접 이웃 기반 그래프 생성 |
    | `precomputed` | 유사도 행렬 직접 전달 |

    ---

    ## 예시 출력

    ```python
    import numpy as np
    print("클러스터 레이블:", np.unique(y_sc))  # → [0 1]
    print("예측값 일부:", y_sc[:10])
    ```

    ---

    ## Spectral Clustering 요약

    | 항목 | 내용 |
    | --- | --- |
    | 군집 수 자동 설정 | 안됨. K 필요 |
    | 이상치 감지 | 지원 X |
    | 장점 | 복잡한 형태 분리 가능 (비선형, 복잡한 구조에 매우 강함) |
    | 핵심 기술 | 그래프 라플라시안 + 고유값 분해 + KMeans |
    | 추천 사용 | 이미지 분할, 원형·비선형 데이터, 정형화 어려운 문제 구조 |

    ---


---

### 2. **차원 축소 (Dimensionality Reduction)**

고차원 데이터를 **저차원**으로 압축하면서 **핵심 정보 유지**

| 알고리즘 | 설명 | 사용 용도 |
| --- | --- | --- |
| **PCA (주성분 분석)** | 선형 차원 축소 | 설명력 유지, 속도 빠름 |
| **t-SNE** | 비선형 축소, 시각화에 특화 | 데이터 구조 시각화 |
| **UMAP** | 시각화 + 군집 유지 | t-SNE보다 빠름, 군집형태 보존 |
| **TruncatedSVD** | 희소 행렬용 PCA | LSA에 사용 (텍스트) |
| **AutoEncoder** | 신경망 기반 차원 축소 | 비선형 축소, 재구성 가능 |
- **PCA**:
    - 가장 **기본적이면서도 강력**한 차원 축소 기법
    - 특히 머신러닝 전처리, 시각화 전 단계, 피처 압축에 자주 사용
- **t-SNE**:
    - 시각화 목적에 **매우 자주 사용**, 특히 **2D/3D 표현**
    - 단점: 속도 느리고, 새로운 데이터에 일반화 불가
- **UMAP**:
    - t-SNE 대체로 **요즘 인기 상승**
    - 시각화뿐 아니라 군집을 더 잘 유지함 (군집 기반 분석에 유리)
- **TruncatedSVD**:
    - **텍스트 데이터에 특화**, `CountVectorizer`, `TF-IDF` 결과에 사용
    - LSA (Latent Semantic Analysis)의 핵심 구성요소
- **AutoEncoder**:
    - 비선형 구조를 잘 잡아내지만, **신경망 설계 필요**
    - 실험적 분석이나 이상치 탐지, 이미지/신호 복원에 적합

### **많이 쓰는 경우 요약**

| 알고리즘 | 실제 사용 빈도 | 많이 쓰는 목적 |
| --- | --- | --- |
| **PCA** | 매우 높음 | 데이터 전처리, 속도 개선, 노이즈 제거 |
| **t-SNE** | 중간 | 고차원 데이터 시각화 (특히 논문/보고서용) |
| **UMAP** | 증가 추세 | 시각화 + 군집 형태 분석 (t-SNE 대체) |
| **TruncatedSVD** | 높음 (텍스트) | 희소 텍스트 데이터의 차원 축소 (LSA) |
| **AutoEncoder** | 실험적/깊이 있는 분석 | 비선형 차원 축소, 재구성/이상탐지 |
- **일반적인 데이터 전처리**: `PCA`
- **텍스트 (희소 행렬)**: `TruncatedSVD`
- **시각화**: `t-SNE`, `UMAP`
- **딥러닝 기반 실험/연구**: `AutoEncoder`

## PCA vs TruncatedSVD

## 1. 기본 개념 비교

| 항목 | **PCA (Principal Component Analysis)** | **TruncatedSVD (Truncated Singular Value Decomposition)** |
| --- | --- | --- |
| 목적 | 분산(설명력)이 큰 축을 기준으로 차원 축소 | SVD를 통해 주요 축만 남겨 차원 축소 |
| 입력 데이터 | **Dense (밀집)** 행렬에 적합 | **Sparse (희소)** 행렬도 처리 가능 |
| 특징 | 데이터를 **평균 중심화(mean centering)**함 | 평균 중심화하지 않음 (빠름, sparse 유지) |
| 주요 사용 | 수치 데이터 일반 차원 축소 | **텍스트 데이터**(TF-IDF 등) 차원 축소 |
| 결과 해석 | 분산 보존 기준 주성분 생성 | SVD 기반 주성분, 직관적 해석 어려움 |

---

## 2. 내부 작동 방식 차이

### PCA: 고전적인 방식

1. 입력 행렬 XXX에서 **평균 제거 (centering)**:Xcentered=X−Xˉ

    Xcentered=X−XˉX_{\text{centered}} = X - \bar{X}

2. 공분산 행렬 계산:Σ=n1X⊤X

    Σ=1nX⊤X\Sigma = \frac{1}{n} X^\top X

3. 고유값 분해 (Eigen Decomposition):Σ=VΛV⊤

    Σ=VΛV⊤\Sigma = V \Lambda V^\top

4. 고유값이 큰 순으로 일부 주성분 선택 → 저차원 투영

---

### TruncatedSVD: 희소 행렬 전용

1. 입력 행렬 XXX (희소 가능)에 대해 **SVD 수행**:X≈UkΣkVk⊤

    X≈UkΣkVk⊤X \approx U_k \Sigma_k V_k^\top

    단, 전체 SVD가 아닌 **앞부분 kkk개만 자름 (truncated)**

2. 결과로 **저차원 잠재 요인(latent semantics)** 공간 생성
3. **mean-centering을 하지 않으므로**, 텍스트처럼 0이 많은 희소 행렬의 구조 유지됨

---

## 3. 중요한 차이점 요약

| 구분 | PCA | TruncatedSVD |
| --- | --- | --- |
| **Mean-centering** | 수행함 | 수행 안 함 |
| **희소행렬 처리** | 어렵거나 비효율적 | 효율적 (희소성 유지) |
| **속도** | 느릴 수 있음 | 상대적으로 빠름 |
| **적용 예시** | 수치 데이터 | 텍스트 벡터 (TF-IDF, CountVectorizer) |
| **수학적 기반** | 공분산 행렬 고유값 분해 | SVD 분해 (특이값 분해) |
| **라이브러리** | `sklearn.decomposition.PCA` | `sklearn.decomposition.TruncatedSVD` |

---

## 4. 예제 코드 비교

### PCA 예제

```python
from sklearn.decomposition import PCA
from sklearn.preprocessing import StandardScaler
import pandas as pd

# 수치 데이터 예시
df = pd.DataFrame({
    'x1': [1, 2, 3],
    'x2': [4, 5, 6],
    'x3': [7, 8, 9]
})

scaler = StandardScaler()
X_scaled = scaler.fit_transform(df)

pca = PCA(n_components=2)
X_pca = pca.fit_transform(X_scaled)
```

---

### TruncatedSVD 예제 (TF-IDF 전처리 후)

```python
from sklearn.decomposition import TruncatedSVD
from sklearn.feature_extraction.text import TfidfVectorizer

corpus = [
    "dog cat mouse",
    "dog dog tiger",
    "cat tiger lion"
]

vectorizer = TfidfVectorizer()
X_tfidf = vectorizer.fit_transform(corpus)

svd = TruncatedSVD(n_components=2)
X_svd = svd.fit_transform(X_tfidf)
```

---

## 5. 결론

| 목적 | 추천 방법 |
| --- | --- |
| 일반 수치 데이터의 차원 축소 | **PCA** |
| **텍스트 벡터 (희소행렬)**의 차원 축소 | **TruncatedSVD** |
| 속도/희소성 유지가 중요할 때 | **TruncatedSVD** |
| 데이터 분산 기반 축소, 해석이 중요한 경우 | **PCA** |

---

### 3. **이상치 탐지 (Outlier Detection)**

다수와 다른 데이터 탐지 → 비정상 여부 판단

| 알고리즘 | 설명 | 장점 |
| --- | --- | --- |
| **Isolation Forest** | 트리 구조 기반, 이상치 격리 | 고차원 데이터에 강함 |
| **One-Class SVM** | SVM으로 경계 생성 | 정규 데이터만 학습 |
| **Elliptic Envelope** | 가우시안 분포 가정 | 통계 기반 탐지 |
| **LOF (Local Outlier Factor)** | 주변 밀도 비교 | 지역적 이상치 탐지 |

---

### 4. **연관 규칙 학습 (Association Rule Learning)**

물건 A를 사면 B도 살 확률은? → **장바구니 분석**

| 알고리즘 | 설명 | 대표 사용처 |
| --- | --- | --- |
| **Apriori** | 항목 집합의 지지도 계산 | 마트, 추천 시스템 |
| **FP-Growth** | 빈발 패턴 트리 기반 | 대규모 데이터에 적합 |

---

### 5. **행렬 분해(Matrix Factorization)**

추천 시스템의 핵심! → 사용자-아이템 관계 예측

| 알고리즘 | 설명 | 용도 |
| --- | --- | --- |
| **SVD (Singular Value Decomposition)** | 사용자-아이템 행렬 분해 | 추천 시스템 |
| **NMF (Non-negative Matrix Factorization)** | 음수가 없는 행렬 분해 | 해석 쉬움, 추천에 활용 |

강화학습

• 에이전트(Agent)가 환경(Environment)과 상호작용하면서 행동(Action)을 선택하고, 보상(Reward)을 받으며 학습
• 목표: 누적 보상(total reward)를 최대화하는 행동 전략(정책, policy) 학습

기본 구성 요소

구현 공통 구조

1. 환경 정의 (OpenAI Gym 등)
2. 에이전트 클래스 정의 (정책, 가치 함수, Q-table, 신경망 등)
3. 행동 선택 (탐험/이용)
4. 학습(업데이트) 로직
5. 학습 루프 (에피소드 반복)
6. 성능 평가 및 시각화

학습 과정 예시

1. 에이전트가 상태 $s_t$에서 행동 $a_t$ 선택
2. 환경이 행동에 대한 보상 $r_t$와 다음 상태 $s_{t+1}$ 제공
3. 에이전트는 경험을 바탕으로 정책/가치 함수 업데이트
4. 반복 → 최적 정책에 수렴

가치기반

• Q-Learning (Off-policy)

  • 에이전트는 행동을 탐험(랜덤)으로 선택하더라도,

    학습할 때는 항상 가장 좋은 행동을 했다고 가정해서 학습합니다.

  • 즉, 현재 정책이 아닌 이상적인 정책으로 학습 → Off-policy

  • Q-table로 Q(s,a)Q(s,a)Q(s,a) 값을 업데이트

  • 업데이트 공식:

    $Q(s, a) \leftarrow Q(s, a) + \alpha \left[ r + \gamma \max_{a'} Q(s', a') - Q(s, a) \right]$

  • 탐험 vs 이용: ε-greedy 전략 사용

    Q-Learning 작동 방식

  1. 상태 s에서 시작
  2. 행동 a선택 (탐험/이용 → ε-greedy)
  3. 보상 r, 다음 상태 s′받기
  4. Q-값 업데이트
  5. 상태를 s′s's′로 옮기고 반복

  예시

    # 환경 준비
    import gym  #gym: 강화학습 환경을 제공하는 라이브러리
    import numpy as np
  
    env = gym.make("FrozenLake-v1", is_slippery=False)
    # is_slippery=False   ->   내가 선택한 행동이 정확하게 실행
    # is_slippery=True (기본값)  ->  행동이 확률적으로 빗나감(실행하려던 방향이 아닐 수 있음)
  
    q_table = np.zeros((env.observation_space.n, env.action_space.n))
  
    # 학습 파라미터
    alpha = 0.1  # 학습률 : 새 정보 반영 비율 (0: 안 바꿈, 1: 완전 반영)
    gamma = 0.99  # 할인률 : 미래 보상의 중요도 (0: 현재만, 1: 미래도 중시)
    epsilon = 0.1  # 탐험 확률 : 무작위 행동을 선택할 확률 (0: 탐험X, 1: 항상 탐험) 
    # 10% 확률로 탐험 (random action)
    # 90% 확률로 이용 (가장 Q값이 큰 action)
  
    # 학습 루프
    for episode in range(1000):
        state = env.reset()
        done = False
  
        while not done:
            # ε-greedy 행동 선택
            if np.random.rand() < epsilon:
                action = env.action_space.sample() # 탐험
            else:
                action = np.argmax(q_table[state])
            next_state, reward, done, _ = env.step(action) # 이용
  
            # Q값 업데이트
            q_table[state, action] += alpha * (reward + gamma * np.max(q_table[next_state]) - q_table[state, action])
  
            state = next_state

  • is_slippery

    is_slippery 옵션의 의미

    설정	의미	행동 결과
    is_slippery=False	미끄럽지 않음	내가 선택한 행동이 정확하게 실행됨
    is_slippery=True (기본값)	미끄러움	행동이 확률적으로 빗나감 (실행하려던 방향이 아닐 수도 있음)

    ---

    예시 상황 (4방향: 상, 하, 좌, 우)

    is_slippery=False

    • 내가 "→"(오른쪽)으로 이동하려고 하면,

      → 정확히 오른쪽으로 이동함

    > ✔️ 초보자 실습이나 알고리즘 디버깅에 유리
    > 
    > 
    > ✔️ 학습이 빠르고 안정적
    > 

    ---

    ### `is_slippery=True` (기본값)

    - `"→"`로 이동하려고 해도,
        - 80% 확률: 오른쪽
        - 10% 확률: 위
        - 10% 확률: 아래

            → 즉, **원하는 방향으로 이동할 확률이 낮음**


    > 더 현실적인 환경 (로봇 제어, 자율주행처럼 제어가 완벽하지 않음)
    > 
    > 
    > 정책 학습이 더 어려워지고, Q값이 덜 안정적
    > 

    ---

    ## 시각적 요약

    | 행동 시도 | `is_slippery=False` | `is_slippery=True` |
    | --- | --- | --- |
    | `"→"` 선택 | 무조건 오른쪽으로 감 | 대부분 오른쪽, 가끔 위/아래 |

    ---

    ## 정리: 언제 어떤 설정을 쓰나?

    | 상황 | 추천 설정 |
    | --- | --- |
    | 입문, 구조 이해, Q-table 디버깅 | `is_slippery=False` |
    | 현실성 있는 학습, 일반 RL 연구 | `is_slippery=True` |
- epsilon

    ## ε-greedy 전략

    에이전트가 행동을 선택할 때 다음 두 가지 중 하나:

    | 선택 방식 | 설명 | 발생 확률 |
    | --- | --- | --- |
    | **탐험 (exploration)** | 무작위로 행동 선택 (새로운 정보 탐색) | **ε (epsilon)** |
    | **이용 (exploitation)** | 현재 Q-table에서 가장 Q값이 큰 행동 선택 | **1 − ε** |

    즉,

    ```python
    epsilon = 0.1
    ```

    - 10% 확률로 → **탐험 (random action)**
    - 90% 확률로 → **이용 (가장 Q값이 큰 action)**

    ---

    ## ε 값의 범위 의미

    | ε 값 | 의미 | 행동 방식 |
    | --- | --- | --- |
    | `0.0` | 탐험 X → 항상 최선 행동만 | 빠르지만 **과적합 위험**, 최적 정책 못 찾을 수도 |
    | `1.0` | 항상 무작위 행동 | 계속 탐험만 → **학습이 안 됨** |
    | `0.1` | 10% 확률로 랜덤 | 일반적으로 많이 사용되는 시작 값 |

    ---

    ## 실전에서는 ε 조정도 필요해요

    보통 학습이 진행되면, ε 값을 다음처럼 **점점 줄여서**:

    ```python
    epsilon = max(0.01, epsilon * 0.995)
    ```

    - 처음엔 **많이 탐험**
    - 나중엔 **이용 중심 학습**

    ---

    ## 요약

    | ε 값 | 행동 경향 | 설명 |
    | --- | --- | --- |
    | `0` | 완전한 이용 | 탐험 전혀 안 함, 빠르지만 불완전 |
    | `1` | 완전한 탐험 | 학습 안 됨 |
    | `0.1` | 탐험 10%, 이용 90% | 일반적인 설정 |
    | 점점 감소 | 초기 탐험 → 점차 최적화 | 현실적이고 효과적 |
- env.step(action)

    ### `env.step(action)`의 반환값 구조:

    ```python
    next_state, reward, done, info = env.step(action)
    ```

    | 반환값 | 의미 | 설명 |
    | --- | --- | --- |
    | `next_state` | 다음 상태 | 에이전트가 행동한 후, **바뀐 상태** (예: 카트 위치 등) |
    | `reward` | 보상 | 현재 행동 결과로 얻은 **즉각적인 점수** |
    | `done` | 종료 여부 | 게임이 끝났는지 여부 (`True`면 종료) |
    | `info` (`_`) | 디버깅 정보 | 추가 정보(예: 이유, 시간 등). **보통 안 쓰므로 `_`로 무시** |

    ---

    ## 각 요소 자세히 설명

    ### 1. `next_state`

    - 상태는 환경에 따라 다르지만:
        - `FrozenLake`: 정수 번호 (0 ~ 15)
        - `CartPole`: 연속형 벡터 (예: [0.01, 0.04, 0.03, -0.02])
    - 이 상태는 다음 행동을 결정하는 데 사용됨

    ---

    ### 2. `reward`

    - 행동의 **즉각적인 보상값**
    - 예시:
        - `FrozenLake`: 0 (실패), 1 (성공)
        - `CartPole`: 막대가 안 쓰러지면 계속 1, 쓰러지면 종료

    ---

    ### 3. `done`

    - 에피소드가 끝났는지를 알려줌:
        - `True`: 목표에 도달하거나 실패해서 게임 종료
        - `False`: 아직 게임 진행 중

    > → 이걸 while not done: 같은 조건에서 사용해요
    > 

    ---

    ### 4. `info` (또는 `_`)

    - 보통 **디버깅 정보**
    - 예:
        - TimeLimit이 끝났는지
        - 에이전트가 어떤 이유로 실패했는지
        - 어떤 목표를 달성했는지
    - 대부분 학습에는 **필요 없어서 `_`로 무시**합니다.

    ---

    ## 요약표

    | 이름 | 타입 | 설명 |
    | --- | --- | --- |
    | `next_state` | 상태 (정수 또는 벡터) | 다음 상태 |
    | `reward` | 숫자 (int or float) | 행동의 즉각적인 보상 |
    | `done` | bool | 게임 종료 여부 |
    | `info` | dict | 추가 정보 (보통 무시 가능) |

    ---

    ## 예시 (FrozenLake)

    ```python
    next_state, reward, done, info = env.step(2)

    print(next_state)  # 4
    print(reward)      # 0
    print(done)        # False
    print(info)        # {'prob': 1.0}
    ```


- 4x4 얼음판에서 **스타트 → 목표지점까지 이동**하는 환경
- 물에 빠지면 보상 0, 도착하면 보상 1
- Q-Learning은 최적 경로를 찾는 법을 학습함

## 장점 vs 단점

| 장점 | 단점 |
| --- | --- |
| 구현이 매우 간단함 | Q-table은 상태가 많아지면 메모리 낭비 심함 |
| 최적 정책으로 수렴함 (이론적으로) | 연속 공간에서는 사용 불가능 |
| Off-policy라 정책 변경과 분리 가능 | 고차원 문제에는 신경망 필요 (→ DQN) |

---

## 요약

- **Q-Learning은 테이블 기반의 가치 학습 알고리즘**
- 목표는 각 상태-행동 쌍의 Q값을 학습해서 최적의 행동 정책을 찾는 것
- 간단하지만 강화학습의 기본 중 기본

• SARSA (On-policy)

  SARSA는 Q-Learning과 비슷한 테이블 기반 강화학습 알고리즘

  • 이름은 S-A-R-S-A의 약자:

    $\textbf{S}tate,\ \textbf{A}ction,\ \textbf{R}eward,\ \textbf{S}tate',\ \textbf{A}ction'$

    즉, 현재 상태-행동 → 보상 → 다음 상태-행동까지 보고 Q값을 업데이트

  • 현재 정책을 따르는 행동 후의 Q값으로 업데이트

    $Q(s, a) \leftarrow Q(s, a) + \alpha \left[ r + \gamma Q(s', a') - Q(s, a) \right]$

  • Q-Learning과 다른 점: Q-Learning은 다음 상태에서 최고 Q값(max)을 사용, SARSA는 실제 선택된 행동 Q값을 사용

    왜 On-policy?

  • SARSA는 자신이 실제로 사용하는 정책에 따라 학습

  • 학습과 행동이 같은 정책을 따르므로 안정적이지만 탐험에 민감

    예시 (SARSA)

    import numpy as np
    import gym
    
    env = gym.make("FrozenLake-v1", is_slippery=False)
    q_table = np.zeros((env.observation_space.n, env.action_space.n))
    
    alpha = 0.1
    gamma = 0.99
    epsilon = 0.1
    
    for episode in range(1000):
      state = env.reset()
      # 현재 상태에서 행동 선택
      action = env.action_space.sample() if np.random.rand() < epsilon else np.argmax(q_table[state])
    
      done = False
      while not done:
          next_state, reward, done, _ = env.step(action)
    
          # 다음 행동도 ε-greedy로 선택
          next_action = env.action_space.sample() if np.random.rand() < epsilon else np.argmax(q_table[next_state])
    
          # SARSA 업데이트
          q_table[state, action] += alpha * (
              reward + gamma * q_table[next_state, next_action] - q_table[state, action]
          )
    
          state, action = next_state, next_action
    

    요약 흐름 그림

    (s, a) → (s', a') → (s'', a'') ...
            ↑
        실제 행동

    Q-Learning과 비교하면:

    알고리즘	다음 행동 기준	On/Off-policy
    Q-Learning	최대 Q값 사용 (max Q(s', a'))	Off-policy
    SARSA	실제 선택한 행동 사용 (Q(s', a'))	On-policy

    예시 상황

  • SARSA는 현실적인 환경에서,

    • 탐험도 반영하면서 학습해야 할 때

    • 에이전트가 실수를 줄이며 보수적으로 배워야 할 때

      유리합니다.

---

### 요약

- **SARSA는 실제 행동에 기반한 Q값 업데이트를 수행하는 On-policy 알고리즘**
- Q-Learning보다 **조금 더 보수적이고 안전한 학습 방식**
- 간단한 환경에서도 효과적이며, 이해하기 좋은 입문 알고리즘

## Q-Learning vs SARSA 요약 비교

| 항목 | Q-Learning | SARSA |
| --- | --- | --- |
| 정책 종류 | Off-policy | On-policy |
| 업데이트 기준 | 최대 Q값 사용 (max⁡Q(s′,a′)\max Q(s', a')maxQ(s′,a′)) | 실제 선택한 Q(s′,a′)Q(s', a')Q(s′,a′) |
| 탐험 고려 | 안 함 (가정만 함) | 함 (실제 행동 기반) |
| 수렴 속도 | 빠를 수 있음 | 더 안정적 |
| 위험성 | 과감한 선택 가능 | 보수적 학습 경향 |

• DQN (Deep Q-Network) → 딥러닝

  • DQN(Deep Q-Network)은 다음 두 가지가 결합된 구조
  1. Q-Learning: 강화학습 알고리즘
  2. Deep Neural Network: Q값을 근사하기 위한 신경망(딥러닝)

  • 기존 Q-Learning은 Q-table을 사용 (상태/행동이 적을 때 OK)

  • DQN은 Q값을 예측하는 신경망을 사용 (복잡한 환경도 가능)

    즉, Q(s, a)를 일일이 저장하지 않고, 신경망이 직접 계산하는 구조.

  • 주요 기법:

    • Experience Replay: 샘플 저장 → 랜덤 학습
    • Target Network: 안정성 향상

    왜 DQN이 필요한가?

    기존 Q-Learning 문제	DQN 해결 방법
    Q-table은 상태/행동이 많으면 메모리 폭발	NN으로 Q값 근사
    연속 상태, 이미지 상태는 Q-table 불가	CNN/MLP 등으로 상태 처리 가능
    학습 불안정, 진동 많음	경험 재플레이, 타겟 네트워크 등 도입

  ---

  구조 & 핵심 개념

  DQN 구성 요소

  구성 요소	설명
  Q-Network	상태를 받아 행동별 Q값을 출력하는 NN
  Experience Replay	과거 경험을 버퍼에 저장 & 무작위 샘플링
  Target Network	일정 주기로 Q-Network의 가중치를 복사해 학습 안정화
  ε-greedy	행동 선택 시 탐험 vs 이용 균형

  ---

  DQN 학습 순서

  1. 상태 s를 관찰
  2. NN으로 Q(s, a) 계산 → 행동 선택 (ε-greedy)
  3. 행동 수행 → 보상 r, 다음 상태 s′
  4. 경험 (s, a, r, s', done)을 버퍼에 저장
  5. 샘플을 꺼내서 손실 계산:
  6. $Loss=(r + \gamma \max Q_{target}(s^′,a^′)−Q(s,a))^2$
  7. 손실로 NN 학습 (역전파)
  8. 일정 주기로 타겟 네트워크 업데이트

  ---

  핵심 수식

  $\hat{Q}(s, a) \leftarrow r + \gamma \max_{a'} Q_{\text{target}}(s', a')$

  $\text{Loss} = \left( \hat{Q}(s, a) - Q(s, a) \right)^2$

  ---

  간단한 PyTorch 코드 구조 (의사코드)

    # Q-Network
    class DQN(nn.Module):
        def __init__(self, state_dim, action_dim):
            super().__init__()
            self.fc = nn.Sequential(
                nn.Linear(state_dim, 128), nn.ReLU(),
                nn.Linear(128, action_dim)
            )
        def forward(self, x):
            return self.fc(x)

  요소	설명
  nn.Module	PyTorch 신경망 클래스
  state_dim	상태 벡터의 차원 수 (입력 크기)
  action_dim	행동의 개수 (출력 노드 수)
  self.fc	2층 fully connected 신경망
  구조	상태 → 128노드 은닉층(ReLU) → 행동 수만큼 Q값 출력

  하나의 상태 벡터를 받아, 각 행동의 Q값을 출력

    # 메인 루프
    for each episode:
        state = env.reset()
        while not done:
            # 행동 선택
            if random < epsilon:
                action = random_action()
            else:
                action = argmax(Q(state))
  
                    # 행동수행
            next_state, reward, done = env.step(action)
            # 경험저장
            replay_buffer.append((state, action, reward, next_state, done))
  
            # 학습
            batch = sample(replay_buffer) 
            # → 버퍼에서 미니배치로 (s, a, r, s', done) 데이터를 무작위로 추출
            loss = compute_dqn_loss(batch)
            # → DQN 손실 함수 계산:
            optimizer.step()
            # → 손실을 줄이기 위해 신경망 파라미터를 업데이트 (역전파)
  
  
  
  

        # 타겟 네트워크 업데이트
        if step % C == 0:
            target_net.load_state_dict(q_net.state_dict())

```

- 일정 스텝마다 `q_net`의 가중치를 **타겟 네트워크에 복사**
- 이유: `max Q(s', a')`를 계산할 때 **안정된 값**을 사용하기 위함
- 타겟 네트워크는 학습하지 않고 **기준 역할만 수행**함

## 전체 구조 요약

| 단계 | 내용 |
| --- | --- |
| Q-Network 정의 | 상태 → Q값 예측 |
| ε-greedy 정책 | 탐험과 이용의 균형 |
| 경험 저장 | (s, a, r, s', done) 저장 |
| 배치 학습 | 손실 계산 + 파라미터 업데이트 |
| 타겟 네트워크 | 안정된 학습 보장 |

## 정리

| 개념 | 설명 |
| --- | --- |
| Q-Network | Q값을 예측하는 신경망 |
| Experience Replay | 샘플을 무작위로 뽑아 학습 안정화 |
| Target Network | 기준이 되는 별도 Q값 네트워크 |
| ε-greedy | 탐험과 이용 균형 조절 |
| 손실함수 | TD오차: (Q−Target)2(Q - \text{Target})^2(Q−Target)2 |

---

### 예제코드

```python
import numpy as np
import random
import gym
import torch
import torch.nn as nn
import torch.optim as optim
from collections import deque

# Q-Network 정의
class DQN(nn.Module):
    def __init__(self, state_dim, action_dim):
        super().__init__()
        self.fc = nn.Sequential(
            nn.Linear(state_dim, 128),
            nn.ReLU(),
            nn.Linear(128, action_dim)
        )
    def forward(self, x):
        return self.fc(x)

# 손실 함수 계산
def compute_loss(batch, q_net, target_net, gamma):
    states, actions, rewards, next_states, dones = batch
    states = torch.FloatTensor(states)
    actions = torch.LongTensor(actions).unsqueeze(1)
    rewards = torch.FloatTensor(rewards).unsqueeze(1)
    next_states = torch.FloatTensor(next_states)
    dones = torch.FloatTensor(dones).unsqueeze(1)

    q_values = q_net(states).gather(1, actions)
    next_q = target_net(next_states).max(1)[0].detach().unsqueeze(1)
    target = rewards + gamma * next_q * (1 - dones)
    return nn.MSELoss()(q_values, target)

# 환경 설정
env = gym.make("CartPole-v1")
state_dim = env.observation_space.shape[0]
action_dim = env.action_space.n

q_net = DQN(state_dim, action_dim)
target_net = DQN(state_dim, action_dim)
target_net.load_state_dict(q_net.state_dict())
optimizer = optim.Adam(q_net.parameters(), lr=0.001)

replay_buffer = deque(maxlen=10000)

# 하이퍼파라미터
episodes = 500
batch_size = 32
gamma = 0.99
epsilon = 0.1
target_update_freq = 10

# 학습 루프
for episode in range(episodes):
    state = env.reset()
    done = False
    total_reward = 0

    while not done:
        if random.random() < epsilon:
            action = env.action_space.sample()
        else:
            with torch.no_grad():
                action = q_net(torch.FloatTensor(state).unsqueeze(0)).argmax().item()

        next_state, reward, done, _ = env.step(action)
        replay_buffer.append((state, action, reward, next_state, done))
        state = next_state
        total_reward += reward

        if len(replay_buffer) >= batch_size:
            batch = random.sample(replay_buffer, batch_size)
            batch = list(zip(*batch))  # (states, actions, rewards, next_states, dones)
            loss = compute_loss(batch, q_net, target_net, gamma)

            optimizer.zero_grad()
            loss.backward()
            optimizer.step()

    if episode % target_update_freq == 0:
        target_net.load_state_dict(q_net.state_dict())

    print(f"Episode {episode}, Total Reward: {total_reward}")

env.close()

```

---

## 장단점

| 장점 | 단점 |
| --- | --- |
| 고차원 상태 입력 처리 가능 (ex. 이미지) | 연속 행동공간에는 부적합 (→ DDPG, SAC) |
| Q-table 없이 근사 가능 | overestimation 문제 있음 (→ Double DQN) |
| 다양한 환경에 적용 가능 | 학습 안정화 필요 (버퍼, 타겟넷 등 중요) |

---

## DQN이 효과적인 경우

- 이미지 기반 환경 (ex. Atari Pong)
- 상태공간이 큰 문제 (CartPole, LunarLander 등)
- discrete action space (행동이 정수형)

---

## 확장형 알고리즘

| 알고리즘 | 설명 |
| --- | --- |
| Double DQN | Q값 과대평가 완화 |
| Dueling DQN | 상태의 가치와 행동의 Advantage 분리 |
| Rainbow DQN | 다양한 기법을 결합 (지금까지 최고 성능 중 하나) |
| PER | Prioritized Experience Replay (더 중요한 경험 우선 학습) |

정책기반

• REINFORCE

- 가장 기본적인 정책 경사법 (에피소드 단위)
- 수렴 느리지만 개념적으로 중요
- 행동 확률의 로그에 보상을 곱해서 정책을 개선

$\nabla_\theta J(\theta) = \mathbb{E}{\pi\theta} \left[ \nabla_\theta \log \pi_\theta(a|s) \cdot R \right]$

## 구현 구조 요약

```
1. 에피소드 전체 수집 (s, a, r, s', a', ...)
2. 에피소드 종료 후 총 보상 계산
3. log(π(a|s)) * R로 정책 업데이트
```

---

## 간단한 PyTorch 스타일 예시

```python

# 정책 신경망
class PolicyNet(nn.Module):
    def __init__(self, state_dim, action_dim):
        super().__init__()
        self.fc = nn.Sequential(
            nn.Linear(state_dim, 128),
            nn.ReLU(),
            nn.Linear(128, action_dim),
            nn.Softmax(dim=-1)
        )

    def forward(self, x):
        return self.fc(x)

# 학습 루프 (REINFORCE)
log_probs = []
rewards = []

state = env.reset()
done = False
while not done:
    probs = policy(torch.tensor(state).float())
    dist = Categorical(probs)
    action = dist.sample()

    log_probs.append(dist.log_prob(action))
    state, reward, done, _ = env.step(action.item())
    rewards.append(reward)

# 전체 리턴 계산 후 역전파
G = sum(rewards)
loss = -sum([log_prob * G for log_prob in log_probs])
loss.backward()

```

---

### 이런 점에서 중요:

- **Policy Gradient 입문에 적합**
- 개념적으로 PPO, A2C 등 발전형의 뿌리가 됨
- 단점: **high variance**, 느린 수렴 속도

• Policy Gradient

  • 정책 함수 π(a∣s)\pi(a|s)π(a∣s) 직접 학습

  • 목표: 파라미터 θ\thetaθ에 대해 기대 보상 최대화

    $J(\theta) = \mathbb{E}{\pi\theta}[R]$

    $\nabla_\theta J(\theta) = \mathbb{E}{\pi\theta} \left[ \nabla_\theta \log \pi_\theta(a|s) \cdot R \right]$

정책 + 가치 (Actor-Critic)

• Actor-Critic

  • Actor: 정책 학습

  • Critic: 상태의 가치 V(s) 또는 Q(s, a) 평가

    $V(s): \text{ 상태 } s \text{에서 기대되는 누적 보상}$

    $Q(s, a): \text{ 상태 } s \text{에서 행동 } a \text{를 했을 때의 기대 보상}$

  • Advantage function 사용:

    $A(s, a) = Q(s, a) - V(s)$

• PPO (Proximal Policy Optimization)

  • 최근 가장 널리 쓰이는 안정적인 정책 경사법

  • 큰 업데이트를 방지하는 클리핑 함수 사용

    $L^{CLIP}(\theta) = \mathbb{E} \left[ \min \left( r(\theta) A, \ \text{clip}(r(\theta), 1 - \epsilon, 1 + \epsilon) A \right) \right]$

연속 제어

• DDPG / TD3 / SAC
  • 연속 공간에서 사용 가능 (로봇, 자율주행 등)
  • DDPG: DQN + Actor-Critic
  • TD3: DDPG의 안정화 버전 (2개의 critic)
  • SAC: 탐험성 높은 엔트로피 기반 기법

주요 알고리즘 분류 및 비교

알고리즘별 구현 방식 요약

활용 분야

학습 흐름 요약

1. 상태 관측 → 2. 행동 선택 → 3. 보상 + 상태 전이 → 4. 정책/가치 업데이트 → 반복

기타 특수 모델

실전에서 가장 많이 쓰이는 탑 5

1. RandomForestClassifier
2. XGBoostClassifier
3. LightGBMClassifier
4. LogisticRegression
5. GradientBoostingClassifier

\hat{y}_i^{(t)} = \hat{y}_i^{(t-1)} + \eta \cdot f_t(x_i)

정의

머신러닝(Machine Learning)은 컴퓨터가 명시적 규칙을 부여받지 않고, 데이터로부터 패턴을 스스로 학습하여 예측 또는 판단을 내리는 알고리즘입니다.

전통 프로그래밍 vs 머신러닝

실생활 예:

• 이메일 자동 분류: 스팸 or 정상?
• 넷플릭스 영화 추천: 어떤 장르를 좋아할까?
• 주가 예측: 과거 가격 → 미래 예측지도학습 / 비지도학습 / 강화학습 (학습 종류)

▶ 지도학습 (Supervised Learning)

• 정답(label)*이 있는 데이터를 기반으로 학습

→ "이걸 보고 앞으로 이런 정답을 예측해"

• 예시:

  데이터 구성:

  • 타이타닉 생존 예측 (분류)

    입력: [나이, 성별, 티켓등급] → 정답: [생존 여부 0 or 1]

  • 집값 예측 (회귀)

▶ 비지도학습 (Unsupervised Learning)

정답이 없는 데이터에서 패턴이나 군집을 찾는 학습

→ "그냥 데이터만 줄 테니, 스스로 구조를 찾아봐"

• 예시:
  • 고객 군집 분류 (군집화: KMeans)
  • 차원 축소 (PCA)

데이터 구성:

입력: [나이, 구매수, 클릭수] → 정답 없음

▶ 강화학습 (Reinforcement Learning)

행동(정책)을 선택하고, 보상(reward)을 받아가며 학습

→ "잘한 행동엔 보상, 못한 행동엔 패널티"

• 예시:
  • 체스/바둑 AI (알파고)
  • 로봇 경로 학습
  • 자율주행 차량

구성 요소 5가지 (강화학습의 기본 구조)

강화학습 순서

초기 상태 s₀
   ↓
Agent가 Policy에 따라 행동 a₀ 선택
   ↓
Environment가 행동 결과로 보상 r₁, 다음 상태 s₁ 반환
   ↓
Agent는 r₁과 s₁을 바탕으로 Policy 수정
   ↓
이 과정을 반복하며 보상 최적화

수학적 정의 (MDP)

강화학습은 보통 Markov Decision Process (MDP)로 모델링 됨

MDP 구성요소

주요 알고리즘 분류

강화학습용 Python 라이브러리

지도학습(Supervised) vs 비지도학습 vs 강화학습

회귀 vs 분류

▶ 회귀 (Regression)

• 목표: 숫자(연속형 값) 예측
• 예시: 주택 가격, 시험 점수, 주식 가격
• 출력: 123.4, 78.5 등

from sklearn.linear_model import LinearRegression
model = LinearRegression().fit(X_train, y_train)
y_pred = model.predict(X_test)

▶ 분류 (Classification)

• 목표: 카테고리(클래스) 예측
• 예시: 메일이 스팸인가?, 종양이 악성인가?
• 출력: 클래스 번호 (0, 1, 2...), 또는 확률

from sklearn.linear_model import LogisticRegression
model = LogisticRegression().fit(X_train, y_train)
y_pred = model.predict(X_test)

혼동 주의

• 회귀는 숫자 예측
• 분류는 "무엇에 속하는가?"를 예측

과적합(Overfitting) / 과소적합(Underfitting)

▶ 과적합이란?

학습 데이터에 너무 집착해서 테스트 데이터에서는 엉뚱한 결과를 내는 현상

발생 원인

• 너무 복잡한 모델 (불필요한 규칙까지 외움)
• 훈련 데이터가 적음
• 특성 수가 너무 많음

예시:

• 훈련 정확도: 100%
• 테스트 정확도: 60%

비유:

• 시험 공부할 때 모의고사만 외우고, 개념은 이해 안 함

▶ 과소적합이란?

모델이 너무 단순해서 패턴을 잡지 못하고 성능이 낮은 상태

발생 원인

• 너무 단순한 모델 사용
• 너무 적은 학습량
• 너무 강한 규제

예시:

• 훈련 정확도: 60%
• 테스트 정확도: 58%

비유:

• 공부를 거의 안 하고 시험을 보는 상황

편향(비뚤어진 단순함) vs 분산(불안정한 민감성)

▶ 편향(Bias): 너무 단순한 모델

• 데이터의 패턴을 무시하고 "대충 평균"으로 예측
• 과소적합과 연결

▶ 분산(Variance): 너무 민감한 모델

• 데이터에 따라 예측이 요동침
• 과적합과 연결

트레이드오프란?

복잡도 조절이 핵심!

→ 단순하면 성능 안 나오고, 복잡하면 오히려 망한다

수학적으로 보기 (참고)

선형 회귀 예시에서,

• 예측 함수: 𝑦 = 𝑤𝑥 + 𝑏
• 과적합: 𝑤가 너무 커서 데이터에 휘둘림
• 과소적합: 𝑤가 0에 가까워서 거의 평균만 예측

핵심 요약표 (암기용)

회귀 (Regression) 관련 모델 추가

분류 (Classification) 관련 모델 추가

비지도 학습 (Unsupervised Learning)

강화학습

기타 특수 모델

실전에서 가장 많이 쓰이는 탑 5

1. RandomForestClassifier
2. XGBoostClassifier
3. LightGBMClassifier
4. LogisticRegression
5. GradientBoostingClassifier