• 기간 2025.12.02 ~ 12.11 <(주말제외) 8일>

• 목적

• ESG 도메인에 특정한 AI AGENT*를 만드는 것이 목적.

• 배경 상반기에 제조업에서 유럽 규제 관련 ESG 업무 인턴을 했던 나로서는 복잡한 ESG 규제들과 관련 대응 보고서를 작성하는게 만만치 않은 일이었다. 대기업은 회계법인의 컨설팅을 받거나 ESG 담당 팀이 마련되어 있어 관련 대응에 그나마 용이할 수 있겠지만, 계열사나 협력사 등은 정보를 찾는 일 부터 관련 법규에 대응하는 일을 사람이 손수 서치해야하는게 쉽지 않다.

이런 배경과 함께 Agent 개발이라는 2차 프로젝트 목적성에 아주 부합한 ESG Agent 만들기라는 주제가 빠르게 확정되었다.

• Target ESG 규제는 도메인(ex. 자동차, 건설사 등)에 따라 주목해서 봐야할 규제가 다르기 때문에 초기 프로젝트에서는 도메인의 범위를 건설사로 특정하기로 했다. (아무래도 우리의 멘토링 기업이 HDC 랩스, 즉 건설사이기 때문)

2. 기능

ESG 목적 달성을 위해 해야할 일들은 크게 4가지로 생각해서 이 기능별로 tool을 만들기로 정했다.

1. 정책 요약/비교 [Policy Tool]

• K-ESG, SASB, GRI 등 어려운 정책 용어들을 설명해주고 자동 비교
• 건설사 맞춤 지침서 생성

2. 리스크 진단 [Risk Tool]

• 프로젝트별 ESG 리스크 자동 평가
• 현장 체크리스트 생성

3. 보고서 자동 작성 [Report Tool]

• K-ESG 61개 항목 기반 제출 보고서 자동생성 후 PDF/DOCX 다운로드

4. 규제 모니터링 [Regulation Tool]

• 환경부/고용부 규제 변경 감지
• 주간 요약 리포트

3. 기술 스택

Backend: FastAPI
AI: LangChain + LangGraph + GPT-4-mini
 - Embedding: bge-m3
 - Parsing: PyPDF, PyMuPDF, Tesseract
Vector DB: ChromaDB
Frontend: React

사실 2차 프로젝트는 10일짜리 단기 프로젝트여서 프로젝트의 목적에 맞게 AI agent 구축에만 신경을 쓸까하다가, 이 프로젝트를 단기 프로젝트로만 끝내고 싶지 않아서 backend와 frontend도 커버해보기로 했다. 멋사를 통해서 frontend로 프로젝트는 몇 번 해봐서 오랜만에 하더라도 프론트는 바이브 코딩으로도 충분했는데 백엔드는 아예 무지해서 로직을 이해하고 수정하는데 시간이 오래 걸렸다.😯

4. 개발 과정

• 8일 개발 일정

[AI 기능]

1. 문서 정제 및 청킹

PyMuPDF+조건부 OCR로 텍스트 확보 → 표지·목차·헤더 제거 → source_file, source_type, year, page, ocr 등 메타데이터 포함한 chunk 생성. - 조건부 OCR? : 기업에서 발행한 ESG 보고서 등은 그림 및 표 자료가 많아서 PyPDF 등으로는 파싱이 잘 안 됨 → 이럴 경우 OCR 이용

┌────────────────────────────────────────┐
│  🔵 1단계: PDF 로드 & 파싱           
├────────────────────────────────────────┤
│  - PDF 파일 읽기                     │
│  - 텍스트 추출                       │   
│  - 테이블/이미지 처리 (선택)           │
└────────────┬───────────────────────────┘
             ↓
┌────────────────────────────────────────┐
│  🔵 2단계: 청킹 (Chunking)          
├────────────────────────────────────────┤
│  - 문서를 작은 조각으로 분할          
│  - 메타데이터 추가                    │
│    (회사명, 연도, 페이지, 섹션 등)     
│  - 청크 크기: 500-1000 토큰           │
└────────────┬───────────────────────────┘ 

2. 임베딩·VectorDB 구축

BAAI/bge-m3 임베딩으로 chunk 벡터화 → Chroma에 collection_name 지정해 저장.

vector_db 디렉터리(vector_db/esg_all)에는 ESG 보고서·규제 문서·협력사 자료를 임베딩해 놓은 Chroma 컬렉션이 저장된다.

3. Retriever 구축

• fetch_k·top_k·MMR 값 결정해 다양성 있는 후보 확보.

• 메타데이터 필터(기업, 연도, 영역 등)를 사전 적용해 검색 범위를 줄임.

  • 이미 VectorDB에 저장된 메타데이터를 검색 시 필터로 쓰임

    ⇒ chunk마다 Document(..., metadata=...)를 만들어 Chroma에 넣음

• LLM 기반 query rewriting으로 도메인 용어를 보강한 검색어 생성.

• 필요 시 cross-encoder reranker(Cohere/bge-reranker)로 top-N 재정렬.

• post-filter 단계에서 도메인 규칙(메타데이터, 키워드 등)으로 최종 chunk를 정제.

[Retriever Logic]

1. retriever/retriever_pipeline.py는 이미 VectorDB에 저장돼 있는 메타데이터를 검색 시 필터로 쓰도록 구성.
   2. vector_db/esg_all.py에서 chunk마다 Document(..., metadata=...)를 만들어 Chroma에 넣었기 때문에, 저장 단계에서 포함된 필드(source_file, source_type, page, ocr, 앞으로 추가할 company, year, country 등)가 VectorDB에 그대로 남는다. 리트리버는 metadata_filter에 {"source_type": "companies", "company": "DL건설"} 같은 조건을 전달해서 “이미 저장돼 있는 메타데이터”를 기준으로 검색 범위를 좁히는 것!

만약, 필드를 더 쓰고 싶으면 ingestion 단계에서 metadata.update(...)에 추가하고 VectorDB를 다시 생성하면 됨

[ 각 TOOL 별 RAG 체인] 각 툴(policy_tool.py, regulation_tool.py, risk/…, supplier_eval.py 등)이 동일한 벡터 DB를 직접 로드하지만, retriever 설정·프롬프트·LLM 파라미터는 서로 다름.

4. LangChain/LangGraph 통합

위 Retriever를 그래프/체인 노드로 넣어 LLM이 항상 필터링된 chunk를 받도록 구성.

• src/workflows/custom_graph.py: policy → regulation → risk → report 노드를 StateGraph로 구성.
• run_custom_agent가 LangGraph를 호출해 종합 결과를 만드는 구조.

[데이터 흐름]

1. 사용자 업로드 → /api/upload → Redis context에 파일 목록 반영. [ Redis 기반 context 관리]
2. 특정 에이전트 요청(/api/agent/*) → LangChain 툴 실행 → 결과를 Redis context에 저장.
3. /api/chat/stream → 자동으로 custom 에이전트 실행 → 정책/규제/리스크/보고서를 컨텍스트에 추가 → LLM 프롬프트 생성 → 응답/스트리밍.

5. 확장성

• 협력사 종류별 찾은 내용 분야별로 주요기능에 연결 <도메인 지식 더 명확히 하기>

• 로그인 서버 디비

• 채팅창이랑 보고서창이랑 동적으로 이동시킬 수 있도록 전환

• 보고서/체크리스트 templete 제작

• 프론트 - 파일 업로드 속도 개선

  • 문제상황 : 백엔드 업로드 엔드포인트가 파일을 받은 뒤 즉시 임베딩을 계산하면서 오래 막혀 버림

  • 해결방안

    1. 더 가벼운 임베딩 모델을 사용(sentence-transformers/all-MiniLM-L6-v2 or BAAI/bge-small-en) -> CPU에서 빠르게 동작하는 모델로 교체
    2. 파일 업로드 시 즉시 벡터화하지 않고 백그라운드 작업으로 넘기거나, 업로드에선 파일 메타데이터만 저장하고 임베딩은 나중에 트리거하도록 비동기 처리

• 단일chroma → 멀티벡터리트리버 체인지

6. 마무리하며

🤩잘한 점

우선 Notion을 사용하여 매일 진행상황을 꼼꼼히 문서화한 것이 프로젝트 진행을 원활히 하는데 큰 도움이 되었다. 매일 아침 저녁으로 팀원마다 계획과 진행상황 점검을 하며 회의록을 작성하다보니, 나무만 보는 게 아니라 숲을 보며 프로젝트를 진행할 수 있어서 흐름이 끊기지 않아 좋았다. 3차 프로젝트를 시작하기 전까지 텀이 있을텐데, 노션을 보며 바로 상황을 파악하고 바로 진행할 수 있을 것 같다.

또한 깃허브의 중요성을 강조하여 팀원들 모두가 깃허브로 코드를 공유하며 협업할 수 있도록 이끈 점이 매우 뿌듯하다. 팀원 모두가 깃허브에 익숙한 것은 아니라서 사용하는데 어려움이 있었고 오류를 해결하는데 시간이 많이 걸렸지만, 그 과정에서 나 역시 깃허브에 더 익숙해졌고 각자 코드의 진행상황을 바로 공유할 수 있어서 좋았다.

😑아쉬운 점

도메인 특화적인 Agent였기 때문에 짧은 시간 내에 도메인 지식을 습득하고 정보와 문서를 찾아오는게 쉽지 않았다. 하루 안에 도메인 정보를 찾아오고 개발을 시작하려다 보니 그에 따라 성능이 낮아진 게 아쉬웠다. 3차 프로젝트에서는 도메인 지식을 확실히 하고 전처리나 모델의 성능들도 하나씩 테스트해가며 우리 프로젝트에 잘 맞는 모델과 기능들을 찾았으면 좋겠다.

👩🏻‍🎓배운 점

LangGraph, LangChain을 이용하면 RAG Agent를 만드는 게 그렇게 어렵지 않다고 오만했는데, 이론과 실전은 다르다는 것을 깨달았다. 문서를 파싱하여 청킹하는 것부터 깔끔하게 하는 게 쉽지 않았고, 문서를 찾아올 때도 정해진 로직을 따라서 하기만 하면 잘 찾아올 줄 알았는데 아니었다.. 넣고 싶었던 기능이 많다보니 tool 별로 retriever 설정도 다르게 해야했고, 단일 retirever를 쓰다보니 정확도도 낮았다. 그러나 여러 시행착오를 겪으며 디벨롭해나가야 할 부분이나 해결방안들이 현재로서는 명확하게 보여서 발전 가능성이 보인다. 그래도 RAG를 직접 사용해봤다는 경험에서 더 나은 성능을 내는 방법을 깨달은 것 같다. (전처리나 도메인 지식이나 이 프로젝트에 맞는 모델들은 써보면서 알 수 있다는 점 등등..) 짧은 기간이라서 부족했던 부분이 많지만 3차 프로젝트를 진행하면서 더 높은 완성도를 가진, 내가 원했던 그런 ESG Agent를 만들어 낼 수 있으면 좋겠다!!!

• 특정 도메인의 성능 불균형을 막기 위한 Structured Pruning

1. Introduction

• LLM은 뛰어난 성능을 내지만 모델 크기가 커지고 연산량이 많아지는 단점이 있다. structured pruning을 통해 모델 크기를 줄이고 추론 속도를 올릴 수 있으나, 도메인(분야)이나 작업(task)이 다양한 데이터에 대해 프루닝 후 성능이 고르게 떨어지지 않고 특정 도메인에서 상대적으로 더 나빠지는 문제가 있다. (즉 프루닝 → 도메인 간 성능 불균형 → bias가 생긴다.)
• 이를 해결하기 위해 논문은 Distriubutionally Robust Optimization(DRO) 개념을 차용하여 “ Pruning + 다도메인 데이터 분포 변화: Dynamic data distribution)을 통해 모델이 만든 도메인에서 보다 균형 있게 성능을 회복하도록 하는 방법인 DRPruning을 제안한다.

Why is this important?

• LLM이 커질수록 비용,메모리, 연산 모두 커지고 “모델을 가볍게 하면서도 성능을 유지”하는 것이 실용적 중요성이 높다.
• 구조적 프루닝은 단순히 작은 모델을 만드는 방법이지만, 다양한 데이터 분포(도메인)에서 성능이 불균형하게 나빠지는 문제가 있다. 프루닝 후 모델이 A 도메인에선 괜찮지만 B 도메인에선 성능이 크게 떨어진다면, 실제 응용에서는 공정성, 일반화 등의 측면에서 문제가 된다.
• 본 논문은 이런 도메인 간 불균형을 해결하려는 시도로, 단순히 모델을 작게 만드는 것 이상으로 “데이터 분포를 조정하면서 프루닝” 한다는 점에서 차별성이 있다.

2. Backgroud

2.1 Structured Pruning

Pruning은 Neural Network 를 경량화 하고자 할 때 사용하는 방법.

연결된 모든 node를, parameter가 0에 가깝다거나 훈련을 거의 안 했다는 지표를 판단하여 pruning 한다.

• 구조적 프루닝(Structured Pruning): 모델의 일부 구조(예: 층(layer), 헤드(attention head), 중간 피드포워드 네트워크(ffn)의 hidden dimension 등)를 완전히 제거하거나 축소하는 방식이다. 이는 비구조적(unstructured) 프루닝(임의의 weight를 0으로 만드는 방식)보다 하드웨어 친화적일 수 있다. 논문에서는 Sheared Llama (Xia et al., 2024) 프루닝 방식을 기반으로 한다.

모델의 각 모듈(예: attention head, FFN channel)을 mask vector $z^i∈RD$ 로 제어

• $z^i_j = 1:$ 유지
• $z^i_j = 0:$ 제거

→ 이 mask vector 스위치를 학습으로 자동 조정해서 어떤 걸 살리고 어떤걸 자를지 스스로 결정하게 함

1. L0 정규화: 모듈 제거하라고 독려

   • 더 많이 0으로 만들어 자르자라는 신호를 주는 벌칙이 L0 정규화
   • 문제: mask vector Z 는 0/1뿐이어서 미분 불가

2. Hard- Concrete 분포: 부드러운 가짜 스위치

   • 그래서 학습 중엔 0/1 대신 0과 1 사이를 오가는 “가짜 스위치(Hard-concrete)” 방법을 쓰고, 마지막에 진짜 0/1로 딱 결정을 내리는 트릭을 씀.

   • 마스크를 매개변수화하기 위해 ℓ₀-regularization (Louizos et al., 2018) + hard concrete 분포(hard concrete distribution)를 사용함.

   • 스위치 $z^i_j$ 는 원래 0 또는 1

   • 학습 중엔 $\tilde z_j \in [0,1]$(hard concrete gate)로 두고 미분/학습

   • 손실 = 언어모델 손실 + L0 정규화.

   • 학습 끝나면 $\tilde z_j→z_j​∈{0,1}$ 로 딱 잘라냄

3. Lagrange multipliers 라그랑주 승수 적용

   • 프루닝 후 목표 구조(target configuration)를 만족시키기 위해 라그랑주 승수를 적용
     • 예를 들어 “이 층에 헤드 8개 중에 4개만 남겨” 같은 목표 개수가 있지만.
     • 학습이 진행되면 스위치 합 $∑_j z_j$ 이 4와 다를 수 있음
     • 그래서 “목표와 다르면 벌점”을 주는 항을 손실에 추가 → 결국 정확히 4개 근처로 맞춰짐

• 최종적으로 모델 파라미터 θ 와 마스크 z 를 함께 최적화하는 손실(loss) 함수가 구성된다. 자세히 말하면 모델 언어모델링 손실 + 프루닝 제약 손실이 함께 최적화된다.
• 요약하자면: 구조적 프루닝은 모델을 경량화하는 훌륭한 도구이지만, 그 자체로 도메인 간 성능 불균형 문제를 자동으로 해결하진 않는다.

2.2 분포론적 강건최적화 (Distributionally Robust Optimization, DRO)

DRO는 머신러닝 모델이 여러 가능한 데이터 분포(distribution) 중 “가장 불리한(worst-case)” 분포에 대해서도 잘 작동하게끔 설계하는 최적화 기법이다. 예컨대, 여러 그룹(group) 또는 도메인(domain)이 있다면 그 중 가장 성능이 떨어지는 그룹을 고려해 최적화하는 방식이다.

여기서 $Di$는 도메인 i의 데이터이고, $q=(q1,…,qn)$은 각 도메인에 할당된 가중치(weight)이다.

$ℓ(θ;Di)$는 도메인 i의 손실,

$Q$ 는 가중치 벡터가 가질 수 있는 가능한 분포 집합이다.

→ 모델 θ를 바꿔서, worst-case 도메인도 불리하지 않게 성능이 떨어지는 것을 최소화 하자

• 이런 방식은 일반화(generalization)와 그룹 간 불균형(group imbalance) 문제를 완화하는 데 사용되어 왔다. 하지만 하이퍼파라미터(예: 참조 손실(reference loss), 기준 데이터 비율(reference data ratio) 등)를 적절히 설정하는 것이 어렵다는 문제가 있다.

3. Our Proposed DRPruning Method

3.1 Distributionally Robust Pruning

프루닝과 이어지는 사전학습(continued pretraining) 단계에 DRO를 통합한다.

• 먼저 프루닝을 통해 모델을 작게 만들고, 이어서 사전학습(또는 계속 학습) 단계를 통해 모델 성능을 회복시킨다. 이 과정에서 데이터가 여러 도메인에 걸쳐 있을 때, 도메인마다 회복 속도가 다르고 손실(loss)도 차이가 날 수 있다.
• 따라서 드러나는 문제: 프루닝 후 어떤 도메인은 빨리 회복하고, 어떤 도메인은 느리면 전체 모델은 도메인 간 격차가 커질 수 있다.
• 이를 막기 위해, DRPruning은 각 도메인의 평가 손실(validation loss 또는 evaluation loss) 를 이용해서 그 도메인이 얼마나 뒤처지는지를 추정하고, 그에 따라 “다음 학습 스텝에서 해당 도메인의 데이터를 더 많이 사용하도록(data proportion을 증가)” 하거나 가중치를 더 부여하는 방식으로 데이터 비율(q)과 손실 기준을 동적으로 조정한다.

1. 각 도메인 i에서 현재 손실 $\mathcal{L}_i$를 계산

2. 손실이 참조값(reference loss) 보다 크면

   → 그 도메인의 데이터 비율 $\mathcal{q}_i$ ↑ (더 공부시킴)

3. 손실이 참조값보다 작으면

   → $\mathcal{q}_i$↓ (덜 공부시킴)

이 과정을 반복하면서 모델은 잘린 상태에서도 모든 도메인에서 공평한 실력을 유지하게 됨

• θ: 모델 파라미터 (가중치)

• z: 어떤 부분을 남길지/자를지 결정하는 마스크
• qi: 각 도메인 데이터의 비율
• $\mathcal{L}_i$: i번째 도메인의 손실

즉, “마스크를 조정하면서 모델을 작게 만들되, 도메인 간 성능이 고르도록(손실이 균형잡히게) 학습하자”

3.2 참조 손실(Reference Loss) 및 예측

• 여기서는 “각 도메인이 이정도 손실(loss)을 가져야 한다”라는 참조 손실(reference loss,$τ$ 등으로 표기됨) 개념을 도입한다.
• 이유: 단순히 ‘가장 손실이 큰 도메인’에 무작정 집중하면 자칫 모델이 특이 도메인에 과도하게 치우칠 수 있고, 학습이 불안정해질 수 있다. 따라서 각 도메인이 달성해야 할 ‘목표 손실치’(참조 손실)를 설정해두고, 그 손실에서 얼마나 벗어났는지에 따라 가중치 조정 및 데이터 비율 조정한다.
• 그런데 이 참조 손실을 사람이 일일이 설정하기 어렵고, 모델 크기, 데이터양, 학습 스텝 등에 따라 달라지기 때문에 본 논문에서는 스케일링 법칙(scaling laws) 을 이용해 “학습 끝나고 나면 손실이 이 정도일 것이다”라고 예측하고 그것을 참조 손실로 사용한다.
• 예컨대, 파라미터 수 $N$ 및 학습 스텝 수 $S$ 등이 주어졌을 때, 아래와 같은 형태로 손실이 감소할 것이라는 것을 가정을 두고 이를 참조 손실로 설정한다.

3.3 Dynamic Potential Distribution(동적 잠재 분포)

• 이 절은 데이터 비율(잠재 분포, potential distribution) $q$ 를 단순히 고정하거나 손실 기준만으로 바꾸는 것이 아니라, 점진적으로 도메인이 학습에서 뒤처질수록 이 도메인의 데이터 비율(reference data ratio)을 증가시키는 전략을 제시한다.
• 보다 구체적으로: 기존 DRO 방식은 $q$ 가 가능한 모든 분포 집합$Q$안에 있다고 가정하고 최악의 경우에 대응하지만, 이는 지나치게 보수적(over-conservative)일 수 있고 결국 가장 나쁜 도메인만 집중 학습하게 될 수 있다.
• 이를 보완하기 위해, 본 논문은 $q$가 “어느 정도 참조 데이터 비율(reference data ratio) $r$” 주변의 -divergence ball 내에 있다고 가정한다. $q∈{q:D_KL​(q∥r)≤ϵ}$
• 그리고 학습이 진행됨에 따라, 만약 어떤 도메인이 손실이 크면 그 도메인의 참조 비율$r_i$ 를 조금씩 증가시켜 그 도메인 데이터 사용 비중을 높인다. 이렇게 하면 학습이 덜 된 도메인으로 자원을 점진적으로 옮겨갈 수 있다.
• 이런 방식으로 DRPruning은 프루닝된 모델이 다양하고 불균형한 도메인 분포에서도 균형 잡힌 성능(balanced performance) 을 갖게 하려 한다.

📍 전체 목차
Ch1. Vector, 행렬, 배열
Ch2. Data 저장
Ch3. 데이터 랭글링 (Data Wrangling)
Ch4. 수치형 Data 다루기 
Ch5. 범주형 Data 다루기
Ch6. Text 다루기 (예고)

💡 머신러닝 기초 회고 개요 데이터를 다루려면, → 행렬(Matrix) 은 “보관소” → 자유자재로 다룰 수 있어야 함!

🧩 Ch1. Vector, Matrix(행렬), 배열(from NumPy)

🔹 벡터 = 단순히 하나의 차원을 가진 배열

vector_row = np.array([1, 2, 3]) vector_column = np.array([[1], [2], [3]]) → 배열은 Vector로 표현할 수 있다.

🔹 행렬 (Matrix) = 2차원 numpy 배열

matrix = np.array([[1, 2, 3],
                   [1, 2, 3]])

🔹 희소행렬 (Sparse Matrix) = 대부분 원소가 0인 행렬을 효율적으로 저장하는 방법

from scipy import sparse

matrix = np.array([[0, 0, 1],
                   [0, 1, 0],
                   [3, 0, 3]])

matrix_sparse = sparse.csr_matrix(matrix)

(0,1) 0 (2,1) 3

역변환: matrix_sparse.toarray()

🔹 NumPy 배열 생성 함수들

np.zeros(shape=5)     # 0으로 채운 배열 -> 실수값 출력
np.ones(shape=5)      # 1로 채운 배열 -> 실수값 출력
np.full(shape=(3, 3), fill_value=1)  # 지정값으로 채움 -> 정수값 출력

🔹 인덱싱 / 슬라이싱

vector[::-1]      # 벡터의 원소 순서 뒤집기
matrix[:, 1:2]    # 모든 행 & 두번째 열 선택

→ 내가 헷갈리는 인덱싱

📘 Fancy Indexing : 인덱스 리스트만 전달 matrix[[0, 2]] → 1, 3번째 행만 선택

array([[0, 0, 1],
       [3, 0, 3]]

matrix[[0, 2], [1, 3]] → (0,1), (2,0) 위치 원소 선택

= 괄호 안쪽 첫 번째 인덱스는 행, 두 번째 인데스는 열

⚙️ 벡터 연산

🔹 Broadcasting : 서로 다른 크기의 배열끼리 연산(+,-,*,/) 을 가능하게 해주는 규칙

NumPy의 핵심 기능: 자동으로 크기 맞춰 연산 수행

1️⃣ 예시: (1,3) shape 배열

2️⃣ 예시: 1차원 vector

🔹 축(axis) 개념

💡 “axis가 고정되는 축” 을 뜻합니다. axis=0이면 “행을 따라 계산하라 (세로로 내려가라)” axis=1이면 “열을 따라 계산하라 (가로로 가라)”

np.max(matrix, axis=0) # 각 열의 최댓값 np.max(matrix, axis=1) # 각 행의 최댓값

🔹 평균, 분산, 표준편차 np.mean(matrix) np.var(matrix) np.std(matrix, ddof=1) # 표준편차, 자유도 조정 가능

🔹 배열 구조 변경 matrix.reshape(2, 6) # 2x6 형태로 변경 matrix.reshape(-1) = matrix.ravel() # 1차원으로 평탄화 ⬆️ (1,9) shape의 2차원 배열임

🔹 행렬 전치(Transpose)

matrix = np.array([[1,2,3],
                   [4,5,6],
                   [7,8,9]])

matrix.T

또는:

matrix.transpose()

• matrix.T와 .transpose()는 거의 동일 (다만, 여러 축이 있는 배열의 경우 .transpose(axes)로 지정 가능)

🔹 벡터 전치 시 주의 :1차원 벡터에는 전치가 적용되지 않음 → 2D로 바꿔야 함 np.array([[1,2,3,4,5,6]]).T

📏 행렬 평탄화 & 변형 matrix.flatten() # 평탄화 (복사본) matrix.reshape(-1) # 평탄화 (뷰)

대각선 요소 추출: np.diag(matrix)

⚡ Dot Product (내적)

행렬의 곱(일반적 개념) vs 내적(1차원 배열인 벡터 사이의 곱 = 결과: 스칼라)

🎲 난수 생성 및 제어 np.random.seed(0) # 랜덤 고정하여 초기값 지정 np.random.random(3) # 01 사이 float 3개 생성 np.random.randint(0, 11, 3) # 010 사이 정수 3개 생성 np.random.normal(0.0, 1.0, 3) # 평균=0, 표준편차=1 정규분포를 따르는 float 3개 생성

📂 Ch2. 데이터 저장 (Data Storage)

2.1 샘플 데이터 불러오기 from sklearn import datasets → 사이킷런 라이브러리 이용 → ex. load_iris load_digits

또는 직접 생성: from sklearn.datasets import make_regression :선형 회귀 from sklearn.datasets import make_classification: 분류 from sklearn.datasets import make_blobs: 군집 → 알고리즘에 적용할 dataset 직접 생성

2.2 CSV 파일 → DataFrame 형태로

import pandas as pd

dataframe = pd.read_csv(url) #csv는 값들이 콤마로 구분됨 → sep 매개변수에 파일이 사용하는 구분자 지정 가능
pd.read_csv(url, skiprows = range(1,11), nrows=5) # 1~10번째 행 건너뛰고, 다음 1개 행 읽기

2.3 Excel 파일 읽기

pd.read_excel(url, sheet_name=0, header=0)

• sheet_name 매개변수로 엑셀의 몇 번째 시트 가져올건지 지정 가능
• header 매개변수로 몇 번째 row가 제목인지 지정 가능

🔧 pip install openpyxl 필요

2.4 JSON 파일 읽기

pd.read_json(url, orient='columns')

• orient 매개변수는 JSON 파일이 어떻게 구성되었는지 지정 ex) 'columns'는 JSON 파일이 {열:{인덱스:값, ...},...} 구조를 가질 것으로 기대

📘 JSON 정규화: from pandas import json_normalize

2.5 Parquet 파일 읽기

pd.read_parquet(url)

🔧 pip install pyarrow 필요

2.6 SQL DB 불러오기

import pymysql
conn = pymysql.connect(host='localhost', user='root')

🧹 Ch3. 데이터 랭글링 (Data Wrangling)

데이터 정제하고, 사용 가능한 컬럼으로 변환하는 과정! 3.1 여러 소스에서 DF 생성

다양한 포맷 → DataFrame으로 변환

3.2 데이터 정보 확인 dataframe.head() dataframe.shape dataframe.describe() dataframe.info()

3.3 행/열 선택 from 스라이싱

1. .iloc = 데이터 프레임 위치를 참조[인덱스 기반] dataframe.iloc[0:3, [1, 2]]
2. .loc = 데이터프레임 인덱스가 레이블(ex. 문자열) 일 때 사용

   # 인덱스를 설정합니다.
   dataframe = dataframe.set_index(dataframe['Name'])
   

행을 확인합니다.

dataframe.loc['Allison', ['Age', 'Sex']]

**3.4 조건부 선택**
``dataframe[(dataframe['sex']=='female') & (dataframe['age']>=65)]``

**3.5 정렬**
``dataframe.sort_values(by=['Age'], ascending=False)``

**3.6 값 치환**
``dataframe['sex'].replace(['female','male'], ['woman','man'])``

**3.7 열 이름 바꾸기**
``dataframe.rename(columns={'pclass':'passenger_class','sex':'gender'})``

**3.8 통계치 계산**
min, max, sum, mean, count, var, std, kurt(첨도), skew(왜도), mode
- kurt(첨도): 확률 분포의 뾰족한 정도를 나타냄

- Skew (왜도): 
    - 0이면 대칭
    - 음수면 왼쪽 꼬리
    - 양수면 오른쪽 꼬리

**3.9 고유값 확인**
``dataframe['sex'].unique()``
``dataframe['sex'].value_counts()``
결측치 포함 시: ``dropna=False`` → 기본값은 true 임

**3.10 결측치 처리**
- 판다스: 자체적으로 NaN 구현 x
⬇️
- Numpy: np.nan으로 NaN 구현
```python
## 누락된 값을 선택하고 두 개의 행을 출력합니다.
dataframe[dataframe['Age'].isnull()].head(2)
# NaN으로 값을 바꿉니다.
dataframe['Sex'] = dataframe['Sex'].replace('male', np.nan)

dataframe.isna() dataframe.fillna()

3.11 열 삭제 dataframe.drop(['Age','Sex'], axis=1)

3.12 행 삭제

조건 필터링 후 drop: dataframe[dataframe['sex']=='male']

3.13 중복 행 제거 dataframe.drop_duplicates(subset=['sex'], keep='last') → 기본적으로 모든 열이 완벽히 동일한 행만 삭제 → subset 매개변수를 사용하면 일부 열만 대상으로 중복 행 삭제 → keep 매개변수는 남길 행을 의미 dataframe.duplicated(): 메서드는 행이 중복되었는지를 알려주는 불리언 시리즈를 반환

3.14 그룹핑(Grouping) groupby 메서드는 통계계산과 같이 각 그룹에 필요로 하는 연산이 필요

dataframe.groupby(['sex','survived'])['name'].count()
#1st 열 그룹핑 후 2nd 열 그룹핑 가능
dataframe.groupby(['sex'])['age'].mean()

3.15 시계열 리샘플링

dataframe.resample('W').sum()   # 주 단위
dataframe.resample('M').count() # 월 단위
dataframe.resample('2W').mean() # 2주 단위

3.16 열단위 통계 (Aggregation)

dataframe.agg('min') #각 열의 최솟값
dataframe.agg({'Age':['mean'], 'SexCode':['min','max']})
#age 열의 평균/ sexcode 열의 minmax 를 뱉어냄

✳️ 그룹별 집계 예시:

dataframe.groupby(['Pclass','Survived']).agg({'Survived':['count']})

groupby() : 데이터를 그룹으로 묶어 통계 계산 agg() : 집계 함수 지정 (평균, 합계, 최솟값 등)

📈 Ch4. 수치형 데이터 다루기 (Sklearn)

4.1 Scaling

수치형 특성이 두 값의 범위 안에 놓이도록 스케일링

• MinMaxScaler: 0–1 범위. NN/거리기반에서 추천.

  • 언제: 신경망(NN → 입력이 0~1로 안정되면 학습이 빠르고 안정적)/ 거리(KNN, SVM, K-means) 기반 모델, 입력 범위를 0–1(또는 -1–1)로 맞추고 싶을 때.

  • 주의: 훈련 세트로만 fit하고, 훈련/검증/테스트는 transform만 해야 데이터 누수 방지.

      (fit 메서드를 사용해 특성의 최솟값과 최댓값을 계산한 다음 transform 메서드로 특성의 스케일을 조정)

        from sklearn.preprocessing import MinMaxScaler
        import numpy as np
    
        X = np.array([[-500.5], [-100.1], [0], [100.1], [900.9]])
        scaler = MinMaxScaler(feature_range=(0, 1)).fit(X[:3])  # train에만 fit
        X_train = scaler.transform(X[:3])
        X_test  = scaler.transform(X[3:])
    

- ``StandardScaler``: 평균0·표준편차1.(가장 기본)
  - 언제: **선형모델/로지스틱, PCA** 등에서 기본값처럼 먼저 시도.

  - 팁: 이상치가 많으면 평균/표준편차가 흔들린다 → 아래 RobustScaler 고려.
  ```python
    from sklearn.preprocessing import StandardScaler, RobustScaler
    X_std = StandardScaler().fit_transform(X)
    X_rob = RobustScaler().fit_transform(X)  # 중앙값/IQR 기반, 이상치에 강함

- ``Robust/Quantile``: 이상치 많거나 분포 왜곡 시.
  - 언제: 분포가 틀어져 있거나 이상치 영향 최소화하고 싶을 때(0~1 균등 분포에 가깝게).

  | Scaler                  | 기준                       | 특징                                 | 언제 쓰면 좋을까                         |
| ----------------------- | ------------------------ | ---------------------------------- | --------------------------------- |
| **StandardScaler**      | 평균 0, 표준편차 1             | 가장 기본. 데이터가 정규분포(종 모양)에 가까울 때      | 로지스틱 회귀, 선형 회귀, PCA 등 대부분의 선형 모델  |
| **RobustScaler**        | 중앙값(median)과 IQR(사분위 범위) | **이상치(outlier)에 강함**               | 이상치가 섞여 있는 데이터                    |
| **QuantileTransformer** | 분위수(percentile)로 재조정     | 데이터 분포를 **균등하게 펴줌** (0~1 사이로 매끈하게) | 분포가 한쪽으로 치우친(skewed) 경우, 이상치 많을 때 |


#### 4.2 Normalization
- 포인트: 스케일링이 **“열(특성) 단위”** 라면, 정규화는 **“행(샘플) 단위”** 길이(=L2 norm)를 1로 만듦.
즉, “한 데이터 샘플이 벡터로 봤을 때, 그 벡터의 전체 길이를 1로 맞춰주는 것.”

  | 샘플 | 원본 벡터  | 길이         | 정규화 후      |
  | -- | ------ | ---------- | ---------- |
  | A  | [3, 4] | √(3²+4²)=5 | [0.6, 0.8] |
  | B  | [6, 8] | 10         | [0.6, 0.8] |

    결과적으로 A와 B는 같은 방향을 가진 벡터가 됨 
- ``텍스트 분류/코사인 유사도`` 등에서 자주 사용.
  ![](https://velog.velcdn.com/images/y-hyun2/post/44655811-5072-4d38-a628-01fc3ed8af16/image.png)

| 구분                | 핵심 포인트                          |
| ----------------- | ------------------------------- |
| **Scaling**       | 특성(feature) 단위로 크기(단위)를 맞춤      |
| **Normalization** | 샘플(행) 단위로 **벡터의 길이를 1로** 맞춤     |
| **이유**            | 코사인 유사도처럼 **방향 중심 비교** 시 중요     |
| **활용 분야**         | 텍스트 임베딩, 추천 시스템, 문장/이미지 벡터 비교 등 |

```python
from sklearn.preprocessing import Normalizer
import numpy as np

features = np.array([[0.5, 0.5], [1.1, 3.4], [1.5, 20.2]])
l2_norm = Normalizer(norm="l2").transform(features)  # 기본
l1_norm = Normalizer(norm="l1").transform(features)  # 합=1
max_norm = Normalizer(norm="max").transform(features)  # 행 최대값으로 나눔

4.3 Polynomial & Interaction

• 언제: 비선형성을 간단히 주입하고 싶을 때 (예: 나이², x1·x2 등). 선형 회귀/로지스틱 회귀 등 선형 모델은 기본적으로 "직선/평면"만 학습 그러나 실제 데이터는 굽은 모양(곡선), 변수 간 상호작용이 흔함 → 다항 & 교차항 추가

  언제 쓰면 좋은가

  1. 선형 모델(선형회귀, 로지스틱, 선형 SVM)을 쓰고 싶은데 관계가 곡선/상호작용일 때
  2. 해석성을 유지하면서 비선형성을 조금만 추가하고 싶을 때
  3. 데이터가 많지 않고 트리/딥러닝까지는 과하다고 느껴질 때
  4. 국소적 곡률을 반영하고 싶지만 스플라인/핸드메이드 변환이 번거로울 때

  언제 굳이 안 써도 되나

  1. 트리 계열(의사결정나무, 랜덤포레스트, 그레이디언트부스팅)은 자동으로 비선형/상호작용을 학습
  2. 커널 SVM/가우시안프로세스/딥러닝을 쓰는 경우도 모델 자체가 비선형이어서 안 써도 됨
  3. 고차원 희소데이터(텍스트 BoW 등)에서 무분별한 교차항은 차원 폭발 위험

• 주의: 차수/특성 수가 늘면 차원의 저주 →

  1. 특성 수 폭증
  2. 과적합 (overfitting) 위험 급증
  3. 계산, 메모리 비용 증가 + 해석 어려움

     해결 팁:

     • 규제(Regularization): Ridge/Lasso/ElasticNet
     • 부분만 확장: 중요한 열만 다항화, degree를 낮게, interaction_only 사용
     • 교차검증으로 적정 복잡도 선택
     • 표준화(Scaling)로 수치 안정화

from sklearn.preprocessing import PolynomialFeatures
import numpy as np

X = np.array([[2, 3], [2, 3], [2, 3]])
poly = PolynomialFeatures(degree=2, include_bias=False).fit_transform(X)     # 제곱+교차항
inter = PolynomialFeatures(degree=2, interaction_only=True, include_bias=False).fit_transform(X)  # 교차항만

4.4 Custom/ColumnTransformer

• 열별 서로 다른 변환을 깔끔하게 파이프라인. 🧱 1️⃣ 단순히 새 열 추가하는 방법의 한계

  물론 아래처럼 직접 처리

  df["f1_plus_10"] = df["f1"] + 10
  df["f2_plus_100"] = df["f2"] + 100

  이렇게 했을 때 문제점👇

  

⚙️ 2️⃣ ColumnTransformer의 역할

ColumnTransformer는 “열마다 다른 전처리기를 묶어서 하나의 통합 변환기” 로 만들어주는 도구

여러 개의 전처리 과정을 “하나의 변환기로 합쳐서” Pipeline 안에서 fit → transform이 자동으로 돌아가게 해줌

        from sklearn.compose import ColumnTransformer
        from sklearn.preprocessing import FunctionTransformer, StandardScaler, OneHotEncoder
        import pandas as pd
        import numpy as np

        df = pd.DataFrame({
            "age": [20, 30, 40],
            "income": [2000, 3000, 4000],
            "city": ["A", "B", "A"]
        })

        def add_ten(x): return x + 10
        def log_transform(x): return np.log(x)

        ct = ColumnTransformer([
            ("age_plus_10", FunctionTransformer(add_ten), ["age"]),
            ("income_log", FunctionTransformer(log_transform), ["income"]),
            ("city_onehot", OneHotEncoder(), ["city"])
        ])

        X_transformed = ct.fit_transform(df)

이제 이 변환기를 하나의 객체처럼 모델 파이프라인에 연결하기 👇

    from sklearn.linear_model import LinearRegression
    from sklearn.pipeline import Pipeline

    pipe = Pipeline([
        ("preprocess", ct),
        ("model", LinearRegression())
    ])
    pipe.fit(df, y)

✅ 장점 요약:

• fit() / transform() 체계 내에서 자동 관리

• 훈련·검증·테스트 데이터에 일관된 변환 적용

• 열마다 다른 변환 지정 가능

• 모델 학습 파이프라인에 바로 통합 가능

• GridSearchCV / cross_val_score 등과 완벽 호환

4.5 Outlier

• 5-1. 감지

• 통계적 타원 가정(EllipticEnvelope)* 또는 IQR 규칙(1.5×IQR)로 간단 감지.

   from sklearn.covariance import EllipticEnvelope
   detector = EllipticEnvelope(contamination=0.1).fit(features)
   labels = detector.predict(features)  # 1:정상, -1:이상치
  

   import numpy as np
   x = features[:,0]
   q1, q3 = np.percentile(x, [25, 75])
   iqr = q3 - q1
   out_idx = np.where((x < q1 - 1.5*iqr) | (x > q3 + 1.5*iqr))

• 5-2. 다루기 전략 3가지: (1) 삭제(최후의 수단), (2) 플래그로 포함(이상치 여부 이진 특성), (3) 변환(로그 등).

  import numpy as np, pandas as pd
  houses = pd.DataFrame({
      "Price":[534433,392333,293222,4322032],
      "Bathrooms":[2,3.5,2,116],
      "Square_Feet":[1500,2500,1500,48000]
  })
  houses["Outlier"] = (houses["Bathrooms"] >= 20).astype(int)  # 이상치 플래그
  houses["Log_Sqft"] = np.log(houses["Square_Feet"])           # 변환으로 영향 완화
  

#### 4.6 Discretization
- 언제: 연속형을 구간으로 나눠 범주형처럼 다루고 싶을 때(의사결정트리/규칙 기반 해석 편의).

- 간단 2분할은 ``Binarizer``, 다구간은 ``np.digitize`` 또는 ``KBinsDiscretizer``(quantile·uniform).
```python
  import numpy as np
  from sklearn.preprocessing import Binarizer, KBinsDiscretizer

  age = np.array([[6],[12],[20],[36],[65]])
  bin_age = Binarizer(threshold=18).fit_transform(age)  # 0/1
  kb = KBinsDiscretizer(n_bins=4, encode="onehot-dense", strategy="quantile")
  age_oh = kb.fit_transform(age)                        # 구간 원-핫
  edges = kb.bin_edges_                                  # 경계 확인

4.7 Missing

• 8-1. 삭제 대부분의 모델은 NaN 미지원 → 삭제는 간단하지만 정보 손실/편향 가능. (MCAR/MAR/MNAR 구분 고려)

• 8-2. 대체(Imputation) KNNImputer: 소규모 데이터에서 이웃 기반으로 더 정확한 경우 많음(대신 계산량 큼). SimpleImputer: 평균/중앙값/최빈값으로 빠르게 채움(대규모에 적합). 팁: 결측치를 채운 사실을 나타내는 플래그 특성을 추가하자.

  from sklearn.impute import KNNImputer, SimpleImputer
  from sklearn.preprocessing import StandardScaler
  from sklearn.datasets import make_blobs
  import numpy as np
  
  X, _ = make_blobs(n_samples=1000, n_features=2, random_state=1)
  X = StandardScaler().fit_transform(X)
  true_val = X[0,0]; X[0,0] = np.nan
  
  X_knn = KNNImputer(n_neighbors=5).fit_transform(X)     # 정교하지만 느릴 수 있음
  X_mean = SimpleImputer(strategy="mean").fit_transform(X)  # 빠르고 단순

📈 Ch5. 범주형 데이터 다루기 (Sklearn)

머신러닝 모델은 수치형 데이터만 이해할 수 있기 때문에, 문자열(텍스트)로 된 범주형 데이터를 숫자로 변환(인코딩) 해야 합니다.

1️⃣ 범주형 데이터란?

범주형 데이터를 숫자로 변환할 때는 순서 유무에 따라 다른 인코딩 방법을 써야 합니다.

2️⃣ 순서가 없는 범주형 데이터 인코딩하기

(1) LabelBinarizer — 단일 클래스 원-핫 인코딩

import numpy as np
from sklearn.preprocessing import LabelBinarizer

feature = np.array([["Texas"], ["California"], ["Texas"], ["Delaware"]])
one_hot = LabelBinarizer()
encoded = one_hot.fit_transform(feature)
print(encoded)
print(one_hot.classes_)  # ['California' 'Delaware' 'Texas']

• 각 클래스가 하나의 이진 열(column) 로 변환

• 클래스 간 순서 개념을 만들지 않음
• 원-핫 인코딩 결과의 합은 1 (소속된 클래스 하나만 1)

(2) MultiLabelBinarizer — 다중 클래스 원-핫 인코딩

from sklearn.preprocessing import MultiLabelBinarizer

multi_feature = [("Texas", "Florida"), ("California", "Alabama"), ("Texas", "Florida")]
multi_hot = MultiLabelBinarizer()
multi_encoded = multi_hot.fit_transform(multi_feature)
print(multi_hot.classes_)

한 샘플에 여러 클래스가 있을 때 (["Comedy", "Romance"] 등) 사용

(3) Pandas get_dummies — 간편한 더미 인코딩

import pandas as pd
pd.get_dummies(["Texas", "California", "Texas", "Delaware"])

데이터프레임에 바로 적용 가능 drop_first=True로 다중공선성(선형 의존성) 방지

(4) OneHotEncoder — 가장 일반적이고 강력한 방식

from sklearn.preprocessing import OneHotEncoder
import numpy as np

feature = np.array([["Texas", 1], ["California", 1], ["Texas", 3]])
encoder = OneHotEncoder(sparse_output=False)
encoded = encoder.fit_transform(feature)
print(encoder.categories_)  # 각 열의 클래스 목록

• 문자열과 숫자 모두 처리 가능

• sparse_output=False → 밀집 행렬 반환
• 여러 열 중 특정 열만 인코딩하려면 → ColumnTransformer로 지정

3️⃣ 순서가 있는 범주형 데이터 인코딩하기

(예: Low < Medium < High)

(1) 단순 매핑 (replace)

import pandas as pd

df = pd.DataFrame({"Score": ["Low", "Medium", "High"]})
mapper = {"Low": 1, "Medium": 2, "High": 3}
df["Score_num"] = df["Score"].replace(mapper)

수동 매핑은 간단하지만, 클래스 간 간격이 균등하다고 가정하기 때문에 주의 필요.

(2) OrdinalEncoder — 순서형 데이터 전용

from sklearn.preprocessing import OrdinalEncoder
import numpy as np

features = np.array([["Low", 10], ["High", 50], ["Medium", 3]])
encoder = OrdinalEncoder()
encoded = encoder.fit_transform(features)
print(encoder.categories_)

순서를 가진 범주를 자동으로 숫자로 변환 특정 열만 적용하려면 ColumnTransformer로 관리

4️⃣ 딕셔너리 형태 인코딩하기

✅ DictVectorizer

from sklearn.feature_extraction import DictVectorizer

data_dict = [{"Red": 2, "Blue": 4}, {"Red": 4, "Blue": 3}, {"Red": 1, "Yellow": 2}]
vec = DictVectorizer(sparse=False)
features = vec.fit_transform(data_dict)
print(vec.get_feature_names_out())  # ['Blue', 'Red', 'Yellow']

sparse=False → 밀집 행렬로 출력 자연어 처리에서 단어 빈도(counts) 를 벡터로 바꿀 때 자주 사용

5️⃣ 범주형 결측치 대체하기

(1) KNN으로 예측하여 대체

import numpy as np
from sklearn.neighbors import KNeighborsClassifier

X = np.array([[0, 2.1, 1.4], [1, 1.1, 1.3], [0, 1.2, 1.2], [1, -0.2, -1.1]])
X_nan = np.array([[np.nan, 0.8, 1.3]])
clf = KNeighborsClassifier(3, weights="distance").fit(X[:,1:], X[:,0])
pred = clf.predict(X_nan[:,1:])

(2) 최빈값으로 대체

from sklearn.impute import SimpleImputer

imputer = SimpleImputer(strategy="most_frequent")
imputer.fit_transform(X)

KNN은 정확하지만 느리고, SimpleImputer는 빠르지만 단순.

6️⃣ 불균형 클래스 다루기

from sklearn.ensemble import RandomForestClassifier
clf = RandomForestClassifier(class_weight="balanced")

7️⃣ 핵심 요약

☁️ 이번주 정리: 행렬과 배열의 개념부터 수치형/범주형 데이터에 따라 어떤 방식으로 전처리 해야하는지 체계적으로 쭉 정리하는 시간을 가진 것 같아서 좋았다. "데이터 전처리" 라는 카테고리로 봤을 땐 후루룩 넘길 수 있는 내용들이지만, 세부적으로 봤을 땐 내용이 상당히 방대해서 하나씩 살펴보며 정리하기 벅찼고 수업도 빨랐다 😧 이번 주차에 정리한 내용을 바탕으로 다음 프로젝트시 참고하여 더 체계적으로 데이터를 처리할 수 있을 듯하다 ❤︎

개요

이 논문은 대형 언어 모델(LLM: Large Language Models)의 추론(inference) 과정을 중심으로, 자원 제약 환경에서 더 효율적으로 작동하게 만드는 다양한 기술들을 정리한 리뷰(survey)

1. 왜 LLM 추론이 비효율적인가? 그 원인은 무엇인가? (챕터 2)
2. 효율화를 위한 분류체계(taxonomy) 제시 — 데이터 수준(data-level), 모델 수준(model-level), 시스템 수준(system-level) (챕터 3)
3. 각 수준별로 기존 연구와 기법들 정리 (챕터 4, 5, 6)
4. 응용 시나리오 및 토의 (챕터 7)
5. 결론 및 향후 연구 방향 (챕터 8)

Section 2: 배경 및 효율성 병목 요인 (Background & Bottlenecks)

• 대부분의 LLM은 Transformer 구조 기반 → Self-Attention과 Feed-Forward Network로 구성됨.
• 이 구조는 강력하지만 입력 길이에 따라 연산량이 폭증. 이 섹션은 LLM이 왜 “비효율적일 수밖에 없는지”를 수학적으로 설명함.

2.1 LLM 개념 및 발전

• 최근 LLM들이 자연어 이해 (NLU), 생성 (NLG), 추론(reasoning), 코드 생성(code generation) 등 다양한 영역에서 뛰어난 성능을 보여주고 있음.
• 하지만 이 모델들이 커질수록 연산량, 메모리 접근비용, 저장공간 요구 등이 급격히 증가함.

2.2 효율성 지표

• “추론 효율”은 보통 지연(latency), 처리량(throughput), 전력/에너지 소비, 메모리 사용량/저장용량 등으로 측정 가능함

2.3 병목 요인 분석

논문에서는 LLM 추론이 비효율이 되는 주된 원인 세 가지를 들고 있음:

1. 모델 크기 (Model size): 파라미터 수가 많으면 계산량·메모리 접근량이 증가함.
2. 어텐션 연산의 이차(Quadratic) 복잡도: Transformer 기반 모델에서 입력 길이가 늘면 self-attention 연산 비용이 입력 길이 제곱에 비례해서 증가함.
3. 자동회귀 디코딩(Autoregressive Decoding): 한 토큰씩 생성하며 매 스텝마다 이전 상태(예: KV cache)를 참조해야 하므로 메모리 및 연산 오버헤드가 크다는 점.

이 병목들 때문에 단순히 모델을 키우거나 데이터를 많이 쓰는 방식으로는 자원 제한 환경에서 LLM을 효과적으로 운용하기 어렵다는 것.

Section 3: 분류체계(Taxonomy)

“어떤 차원에서 효율화를 논할 수 있는가”라는 틀을 제시

주요 분류 :

• 데이터 수준 (Data-level optimization): 입력/출력에 대한 최적화, 프롬프트 입력 길이 감소, 불필요한 토큰 제거 등
• 모델 수준 (Model-level optimization): 모델 구조 변경, 파라미터 감소, 경량화, 압축, 특수 어텐션 기법 등
• 시스템 수준 (System-level optimization): 하드웨어/소프트웨어/프레임워크 수준에서의 최적화, 배치처리(batch processing), 메모리 관리, 병렬화 등

이 분류는 이후 각 챕터에서 다루는 기법들을 체계적으로 정리하는 데 사용됨

Section 4: 데이터 수준 최적화 (Data-level Optimization)

입출력 데이터 최적화 전략:

• 입력 압축(Input compression): Model에 전달하는 입력 프롬프트(prompt)나 문장 길이를 줄이거나, 불필요한 토큰을 제거해서 계산량을 줄임.
  • 대표 기법: Prompt Compression, Token Reduction, Prompt Pruning
• 출력 최적화(Output organization): 생성(디코딩) 과정에서 생성되는 출력 토큰의 구조나 생성 방식 자체를 바꿔 효율을 높이는 방법.
  • 대표 기법: Early Exit(디코딩 중 토큰 별 혹은 레이어 별로 조기 중단하여 연산 절감) , Adaptive Sampling( 디코딩 과정의 토큰 샘플링을 동적으로 조정하여 불필요한 탐색을 줄임)
• 프리에이치(prefill) 최적화: LLM이 생성 과정 전에 입력을 처리하는 단계에서 불필요한 연산을 줄이는 기법 등.
  • 대표 기법: KV-cache 재사용, Prefix reuse, Partial batch prefill 등

LLM의 추론 파이프라인 단계 [입력 → 생성 → 초기 연산 ]을 기준으로 효율화를 나눈 것.

이 챕터의 목적은 “모델 내부 구조나 하드웨어를 바꾸지 않고도, 데이터와 입력/출력 설계만으로 추론 비용을 낮출 수 있는 방법”을 설명하는 데 있음

Section 5: 모델 수준 최적화 (Model-level Optimization)

모델 자체 구조나 파라미터, 연산 방식 등을 바꿔 효율화를 꾀하는 방법들을 정리:

“모델이 하는 연산량 자체를 줄이거나, 같은 연산량으로 더 많은 일을 하게 만드는 구조적 개선”

Section 6: 시스템 수준 최적화 (System-level Optimization)

여기서는 하드웨어/소프트웨어/시스템 설계 측면에서 LLM 추론을 더 효율적으로 만드는 접근:

• 배치처리(Batching) 및 병렬처리(Parallelism): 여러 요청을 묶어서 처리하거나 여러 연산을 동시다발적으로 처리해 처리량(throughput)을 향상하고 자원 활용을 극대화함.

  • Batching/Prefill 병렬화: 여러 입력 요청을 묶어 GPU에 올리거나, Prefill 단계(입력 처리)를 병렬 수행하여 GPU 활용도 및 처리량 향상

• 메모리 관리 및 캐시(KV-cache, 메모리 단편화 등): 디코딩 과정에서 사용하는 키/값 캐시, 메모리 단편화 문제를 해결하여 디코딩 속도를 향상시키고, 중복 연산을 방지함

  • KV Cache 재사용: 디코딩 중 반복되는 Key/Value 연산 결과를 캐싱하여 재활용

    ⇒ 중복 계산 제거, 디코딩 속도 향상.

• 하드웨어 가속(Hardware accelerators): GPU, TPU, 특수 NPU에서 최적화된 커널(kernel) 사용 및 메모리 접근패턴 개선하여 하드웨어 수준에서 연산 효율을 개선함.

  • Offloading/Paging: GPU 메모리에 다 안 들어가는 모델/캐시를 CPU 또는 디스크로 분산(offload) 시켜 관리하여 대형 모델을 효율적으로 실행 가능하게 함.

• 서비스 시스템 설계(Serving system design): 엔터프라이즈 환경이나 클라우드/엣지 배포에서 요청 스케줄링, 리소스 예측, 지연시간/처리량 균형 맞추기 → 실제 LLM 서비스의 안정성 및 효율성 확보

  • Serving Optimization: 다수의 사용자 요청을 효율적으로 스케줄링,큐잉,우선순위를 처리하여 latency와 throughput 간 트레이드오프 조절.

“좋은 모델 설계만큼이나, 그것을 실제로 돌리는 시스템 환경이 중요하다”

부동산 시장 인사이트를 시각화하는 Streamlit 대시보드 프로젝트 회고록

해당 프로젝트는 국토교통부 실거래가 데이터를 중심으로, 매매·전월세 시장의 흐름, 리스크, 투자 가치, 페르소나별 분석을 대시보드를 통해 제공한다.

❤︎ 들어가며

약 5일간 만들었던 대시보드 제작 프로젝트. 우선, 이번 6개월간 3개의 프로젝트를 진행하면서 HDC 랩스에서 제공해준 데이터를 사용할 수 있다는 것이 가장 큰 메리트였던 부트캠프였다. 5개의 주제 중 지원할 때부터 해보고 싶던 부동산 데이터를 이용하는 주제를 선택했다. 그!런!데!!! 아쉽게도 이번 1차 프로젝트에선 적절한 데이터를 준비하지 못했다는 소식을 들어 .. 손수 발품을 팔아가며 사용할 만한 데이터 찾기에 나섰다. 그!런!데!!! 때마침 데이터센터 화재로 인해 국가 통계 포털에 접근할 수 조차 없게 되었던 상황.

유동인구 분석, 교통량 분석 등등 부동산 데이터와 관련된 주변 도메인도 분석하여 나타내고 싶은 건 많았는데, 데이터 접근부터 문제가 생겨 .. 우선은 국토교통부 부동산 실거래가 데이터만을 이용해서 뽑아낼 수 있는 다양한 인사이트를 뽑아내기로 결정했다.

☁️ 개발 이야기

부동산 데이터를 이용하여 대시보드를 만들고 싶었던 5명이 랜덤으로 모였다.

기획 단계에서는 정말 많은 아이디어가 나왔다. 아이디어 회의만 5일 중 이틀을 쏟았다. 하지만 그만큼 대시보드 개발에 아이디어가 절반 이상 중요하다고 생각했기 때문에 아깝지 않았다.

'들어가며'에서도 말했지만, 결국 데이터 센터 화재로 적절한 데이터를 구하는 게 어려워서 3년치 부동산 실거래가 데이터만 이용하여 유의미한 인사이트를 도출하는 걸로 결론이 났다.

이 프로젝트에서 특이했던 점은 우린 협업이 아니라 competition을 했다는 것 ^^

• 모여서 아이디어 회의 끝에 대시보드 제작의 갈피가 잡혔지만
• 모델 사용조차 필요없는 너무 소규모 미니 프록젝트이며
• 이 미니 프로젝트에서 어떻게 파트분배를 나눌 것에 대한 갈피는 잡히지 않았다.

아이디어 회의가 끝난 지금, 데이터 전처리를 파트 분배하는 것보다 모두가 한 번씩 데이터 전처리를 통한 대시보드 제작 과정을 경험할 필요가 있지 않는냐! 하는 의견이 있었다. 따라서 각자의 방식대로 데이터 전처리 후 각자의 것을 비교해보고 가장 나은 방식을 채택하여 대시보드를 만들기로 했다.

📊 데이터 전처리

데이터 구분:

• 매매/전월세
• 아파트/ 연립다세대 / 단독다가구 / 오피스텔 /상업업무용

매매와 전월세 데이터셋은 공통된 컬럼이 많이 없음. ➡ 매매 / 전월세로 나누어 하위 5개 유형(단독/연립/오피스텔/아파트)에 대해 형태·순서·이름 통일 완료

🏠 ① 전월세 데이터셋 컬럼 구조

✅ 총 14개 컬럼

🏢 ② 매매 데이터셋 컬럼 구조

✅ 총 16개 컬럼

1️⃣ 결측치 확인 및 처리

결측비율 계산

# 컬럼별 결측 비율을 계산하고 0보다 큰 항목만 확인합니다.
missing = sampled_df.isna().mean().sort_values(ascending=False)
missing = missing[missing > 0]
missing

층 0.250000 건물명 0.250000 건축년도 0.018388 번지 0.000612 dtype: float64

-> 결측치 이유 해석하여 결측치 제거 안 하는 것으로 함.

결측치

• 문자열 → "미상"으로 대체
• 수치형 → NaN 유지

2️⃣ 이상치 탐지 및 처리

✔︎ 이상치 처리

1. “어디가 이상한지” 숫자로 확인
   • numeric_summary, type_numeric_summary는 컬럼별 기초통계(최대값/사분위수 등)를 보여줌

• 여기에 추가로 아래처럼 유형별 상위 분위수(99%, 99.5%)를 보며 “꼬리”가 어디까지인지 감 잡기

  sampled_df.groupby("property_type")[["보증금(만원)", "월세금(만원)", "전용면적(㎡)"]].quantile([0.99, 0.995])

  목적: 현실적으로 말이 되는 상한선을 유형별로 가늠하기.

  유형	보증금(만원) 99.5%	월세(만원) 99.5%
  단독다가구	30,000	132
  아파트	135,000	290
  연립다세대	95,000	120
  오피스텔	55,000	165

이 값들은 실제 거래 데이터 기준 상위 0.5% 분위수 → 즉 그 이상 값은 거의 안 나오는 “꼬리 값”

이상치(극단값) 필터링 원칙

1. “행정상 불가능”은 바로 제외/NA ex. 보증금, 월세가 음수 or 전용면적 <0 or 층이 음수 등 → 무조건 제거
   2. “너무 큰 값”은 통계+ 도메인 상한으로 처리

• 통계적 기준(IQR):
  • upper = Q3 + 1.5*IQR 로 상한선을 잡고 초과치를 잘라내거나(clip) 제외(drop)
    • 도메인 기준(상식 상한): 예) 보증금 > 20억(=200,000만원) 이면 제외/clip, 월세 > 1,000만원(=1,000만원)도 동일

3️⃣ 타입 변환, 문자열/범주형 정리 , 스케일링

4️⃣ 파생 컬럼 생성

→ 원본 csv는 수정하지 않고, 전처리 결과 DataFrame을 파켓 파일로 저장

평당가 컬럼 추가

• 평당가(만원) = 거래금액 ÷ (전용면적 × 0.3025)
• 면적이 0 또는 결측이면 NaN 처리

• 목적: 계산의 효율적 접근

로그 스케일링 컬럼 추가

• 보증금_log, 월세_log, 거래금액_log 등 추가

📈 대용량 데이터 처리 전략

📂 1. 파일 구조 및 로딩

• 모듈 구조
  • modules/rent_processing.py — 전월세 데이터 전처리
  • modules/transaction_processing.py — 매매 데이터 전처리
  • build_dashboard_data.py — 전처리 결과 통합 및 저장 (Parquet 변환)
• 입력 데이터
  • rent_dataset/, transaction_dataset/ 폴더 내 CSV 파일 (자산유형별)
  • 한 파일당 수십~수백만 행, 20만 행 단위 청크(chunksize) 로 나누어 읽기

청크 단위 처리 이유

• 메모리 효율성 확보 (전체 데이터 5GB 이상)
• 부분 전처리 후 병합 가능
• 반복 실행 시 캐시나 중간결과 재활용 용이

Parquet 포맷 사용 이유

• 용량 효율적 (CSV 대비 70% 이상 압축)
• Streamlit 대시보드 로딩 속도 개선
• pandas로 빠르게 재로딩 가능

🧩 2. 층화 샘플링 (Stratified Sampling)

전체 유형별 2만행 sampling (총 20만행으로 샘플링) → 층화 sampling

• 1차 층: property_type (아파트, 오피스텔, 연립, 단독 등)

• 2차 층: 세부지역(STRATA_COLUMN) (서울 강남구 서초동, 부산 해운대구 등)

  ☞ 지역별 거래 비중을 유지하면서 일정 행 수(target_rows) 확보

• stratified_sample() 함수가 비율 계산 후

  → 그룹별 샘플링 수행, 부족한 그룹은 전량 사용

목적: 전국 대표성을 유지한 샘플 확보를 위함

📊 3. 월별 요약 (Monthly Summary)

월별로 산출할 항목들을 저장해 놓는 별도의 parquet 파일을 만들어 streamlit을 시행할 때마다 불필요한 연산을 반복하지 않도록 함.

• summarise_rent_monthly() / summarise_sale_monthly() → 계약년월, 자산군, 지역별로 집계

• 산출 항목:

  • 계약건수
  • 평균 / 중위 거래금액
  • 평균 / 중위 평당가

• 목적: 시계열 기반 Streamlit 그래프 및 KPI 카드에 활용

💾 4. 최종 저장 (build_dashboard_data.py: 31–59)

• 전처리된 결과를 다음 두 포맷으로 저장:
  • rent_sample.parquet, sale_sample.parquet (샘플)
  • rent_monthly_summary.parquet, sale_monthly_summary.parquet (월별요약)

❤︎ 후기

좋았던 점: 우선, 약 680만 행의 대용량 데이터를 다루뤄보면서 대용량 데이터를 다루는 데 거부감이 사라졌다는 점이 가장 좋았다. parquet 파일도 처음 이용하고, sampling도 활용하여 대용량 데이터를 큰 로딩시간 없이 streamlit으로 시각화할 수 있었다. 다음에 대용량 데이터를 처리할 때 큰 어려움을 겪지 않을 것 같다. 만족한다! 또, streamlit을 이용하여 단순 시각화 뿐만 아니라 유의미한 insight를 나타내는 대시보드를 만들어 봤다는 점에서 유익한 경험이었다.

아쉬웠던 점: 짧은 시간 내에 좋은 결과를 내려는 욕심이 있었다면 서로의 결과물 중 최적의 결과물로 제출하는 방식이 아닌 전처리,대시보드 제작까지 분업 및 협업하여 진행하면 더 좋은 결과물을 도출할 수 있지 않았을까 하는 아쉬움이 남는다. 최종적으로 내가 만든 전처리 과정 및 대시보드가 채택되어 나의 결과물을 제출할 수 있어서 기뻤지만, 분업을 했다면 더 섬세하고 만족할 만한 결과물을 낼 수 있었을 걸 하는 아쉬움이 남는다. 분업으로 진행하다보니, 야심차게 만들어 놓은 Github organization도 활용하지 못한 것이 아쉽다.

느낀점: 아이디어 도출부터 데이터 처리, 대시보드 제작, 발표까지 모든 과정에 크게 기여할 수 있었다는 점에서 애정이 높은 프로젝트이다. 5일 안에 압축적으로 많은 것을 경험할 수 있어서 좋았다. 계속되는 수업 속에서 잠깐의 프로젝트 과정이 한 줄기의 빛이었다 ㅎㅎ,, 이번 프로젝트에서 아쉬웠던 점을 보완해서 2,3차 땐 피드백을 바탕으로 더 만족할 만한 결과물이 나왔으면 한다!

• 웹 지식 없이 데이터 앱/대시보드를 손쉽게 만들 수 있음 .

• pip install streamlit → streamlit run app.py로 바로 실행 .

• .py 파일만 있으면 로컬에서 곧바로 웹 UI 확인 가능.

2) 텍스트·표 컴포넌트 핵심

• 제목/헤더/서브헤더/코드블록/마크다운/텍스트로 정보 구조화.

• st.divider() 섹션 구분선 만들기 → 주제별 그룹화에 유용 .

3) 가장 많이 쓰는 입력 위젯

• Button: 클릭 시 True 반환 → 조건문과 함께 동작 제어.

    def button_write():
        st.write('button activated')
  
    st.button('Reset', type='primary')
    st.button('activate', on_click=button_write)

• Checkbox/Toggle: 체크/스위치 형태. on_change 콜백 지원, 상태 변화마다 실행.

• Selectbox/Radio/Multiselect: 단일/복수 선택. label, options, index=None로 비선택 초기화 가능.

• Slider: 단일 값 또는 (시작, 종료) 튜플로 범위 선택.

• Input 계열: text_input(placeholder, max_chars, password), number_input, date_input, ime_input, camera_input.

• File uploader: 파일 타입 제한, 다중 업로드, on_change 콜백 지원.

4) 차트·이미지 붙이기

• Matplotlib → st.pyplot(fig) / Plotly → st.plotly_chart(fig)로 렌더링.

  import streamlit as st
  import matplotlib.pyplot as plt
  import seaborn as sns
  

df = sns.load_dataset('tips') fig, ax = plt.subplots() sns.histplot(df, x='total_bill', ax=ax, hue='time')

st.pyplot(fig)

- Selectbox로 x/y/hue(또는 color)를 고르는 인터랙티브 박스플롯/스캐터 구성 가능.

- `st.image()`는 PIL/numpy 이미지, `width/caption` 옵션 지원.


**5) 레이아웃 제대로 쓰기**

- Sidebar: with st.sidebar: 블록에 필터·설명 배치 (p.24).

- Columns: col1, col2 = st.columns(2)로 가로 배치 (p.25).

- Tabs: 여러 뷰를 탭으로 전환 (p.26).

- Expander: 상세/부가 정보를 접어서 깔끔하게 유지 (p.27).

```python
 # --- Tabs ---
    tab_h1, tab_h2, tab_h3 = st.tabs(["히트맵(AMT)", "TOP 페어(AMT)", "TOP 페어(AOV)"])

    with tab_h1:
        st.plotly_chart(
            px.imshow(
                pivot_amt,
                aspect="auto",
                color_continuous_scale="Viridis",
                labels=dict(color="AMT")
            ),
            use_container_width=True
        )

    with tab_h2:
        top_n = st.slider("TOP N (AMT 기준)", 5, 30, 10, 1, key="amt_topn")
        top_pairs = hot_agg.sort_values("AMT", ascending=False).head(top_n)
        st.dataframe(top_pairs, use_container_width=True)
        st.plotly_chart(
            px.bar(top_pairs, x="CTY_RGN_NM", y="AMT", color="TP_GRP_NM",
                   title=f"지역×업종 AMT TOP {top_n}", barmode="stack"),
            use_container_width=True
        )

    with tab_h3:
        top_aov = hot_agg.sort_values("AOV", ascending=False).head(10)
        st.dataframe(top_aov, use_container_width=True)
        fig_aov = px.bar(
            top_aov,
            x="CTY_RGN_NM", y="AOV", color="TP_GRP_NM",
            title="지역 × 업종 객단가(AOV) TOP 10",
            barmode="group",
            text_auto=".0f"
        )
        st.plotly_chart(fig_aov, use_container_width=True)

streamlit 패키지 이용! 시각화하기 좋은 툴을 이제야 알았다는 것에 아수운 마음이다. 리액트보다 훨씬 수월하고 쉽게 사용 가능 ..

Streamlit

데이터 과학자/분석가가 빠르게 프로토타입을 만들 수 있도록 설계됨. 코드 작성 방식이 일반적인 파이썬 스크립트와 거의 동일해서 진입 장벽이 낮음. “실험용 앱/내부 툴/보고용 대시보드”에 최적.

Dash (by Plotly)

웹 앱을 좀 더 체계적이고 정교하게 개발하는 데 초점. 레이아웃과 콜백 구조가 필요해 학습곡선이 Streamlit보다 다소 있음. “엔터프라이즈 대시보드/고객-facing 앱/멀티 페이지 앱”에 더 적합.

༼ つ ◕_◕ ༽つ Dash도 파이썬 기반 웹/앱 프레임워크 각 특징을 확인하면서 프레임워크를 적절히 골라 사용하면 좋을 거 같다. 개인적으로는 streamlit이 기본 ui가 더 예뿌다.

(☞ﾟヮﾟ)☞ 한달후기

파이썬, mysql, 대쉬보드 만들기까지 한 달 동안 매우 많은 것들을 배우고 실습했다. 학부 때 배운 걸 한 달 동안 후다닥 정리해볼 수 있어서 유익했다. 프로젝트가 매우매우 기대된다. 끝.

근데 내가 SQL을 언제 쓸 수 있을까 ..?

📑 목차

• 1. SQL 기본 문법

  • SQL SELECT ~ FROM ~ WHERE 실습 정리
  • WHERE절 vs HAVING / 서브쿼리 차이점
  • ORDER BY, LIMIT, DISTINCT, GROUP BY, HAVING

• 2. SQL 고급 문법

  • MySQL 데이터 형식
  • Prepared Statement (준비된 구문)
  • JOIN
  • SQL Programming

• 3. 데이터베이스 개체

  • 뷰 (VIEW)
  • 인덱스
  • Stored procedure

1. SQL 기본 문법

📌 SQL SELECT ~ FROM ~ WHERE 실습 정리

- 제품 이름에 ‘지갑’이 포함된 구매 내역 조회

SELECT * 
FROM market_db.buy 
WHERE prod_name = '지갑';

-- 어디에 지갑이 있는 지 모르니까..
SELECT * 
FROM market_db.buy 
WHERE prod_name LIKE '%지갑%';

- 멤버 중 전화정보가 하나라도 비어있는(국번 또는 나머지 번호가 NULL) 사람 조회 (IS NULL)

SELECT * 
FROM market_db.member 
WHERE phone1 IS NULL OR phone2 IS NULL;

💡 NULL 값과 비교 연산자

• SQL에서 NULL은 알 수 없음(unknown) 을 의미하는 특별한 값
• 숫자 0이나 공백('')과는 다르며, 어떤 값과도 같거나 같지 않다고 비교할 수 없음
• 따라서 NULL = NULL, NULL = '특정 값' 같은 비교는 항상 FALSE
  👉 그래서 WHERE phone1 = null 은 항상 거짓(false)이므로 IS NULL을 사용해야 함.

- 멤버 이름이 두 글자인 행 조회

SELECT * 
FROM market_db.member 
WHERE CHAR_LENGTH(mem_name) = 2;

SELECT * 
FROM market_db.member 
WHERE mem_name LIKE '__';

💡 MySQL 문자열 길이 계산

• LENGTH() → 바이트(byte) 단위 길이
• CHAR_LENGTH() → 문자(character) 단위 길이
• 한글은 글자당 3바이트 → "잇지"(2글자) → LENGTH(mem_name)=6
  👉 따라서 한글은 CHAR_LENGTH() 또는 LIKE '__'를 사용해야 함.

- 디지털 또는 서적 분류에서 구매, 제품명이 ‘폰’으로 끝나는 내역 조회

SELECT * 
FROM market_db.buy 
WHERE (group_name = '디지털' OR group_name = '서적') 
  AND prod_name LIKE '%폰';

❌ 잘못된 예시

SELECT * 
FROM market_db.buy 
WHERE prod_name LIKE '%폰' 
IN (SELECT prod_name 
    FROM market_db.buy 
    WHERE group_name = '디지털' OR group_name = '서적');

💡 오류 이유

• = + 서브쿼리 → = 연산자는 단일 값과 단일 값을 비교할 때 사용됨. 다중 값 반환 시 오류 발생
• 여러 값 비교할 땐 IN 사용해야 함
• 조건은 독립적으로가 아니라 AND로 연결해야 논리적으로 맞음

WHERE절 vs HAVING / 서브쿼리 차이점

💡 집계 함수 주의

• MAX() 같은 집계 함수는 HAVING이나 서브쿼리에서 사용해야 함
• WHERE MAX(height) → 문법 오류 발생

📌 ORDER BY, LIMIT, DISTINCT, GROUP BY, HAVING

1. SELECT절 기본 구조

SELECT 열_이름
FROM 테이블_이름
WHERE 조건식
GROUP BY 열_이름
HAVING 조건식
ORDER BY 열_이름
LIMIT 숫자;

2. ORDER BY

• ASC (기본): 오름차순
• DESC: 내림차순

SELECT mem_id, mem_name, debut_date, height
FROM member
WHERE height >= 164
ORDER BY height DESC, debut_date;

2.1 LIMIT

SELECT mem_name, height
FROM member
ORDER BY height DESC
LIMIT 3, 2;

👉 3번째 행부터 2개 조회

2.2 DISTINCT

SELECT DISTINCT addr 
FROM member;

👉 중복 제거 후 결과 반환

3. GROUP BY & HAVING

• GROUP BY → 그룹 묶기
• 집계 함수 (SUM(), AVG(), MIN(), MAX(), COUNT())와 함께 사용

SELECT group_name, prod_name, SUM(amount) AS total
FROM buy
WHERE group_name IS NOT NULL
GROUP BY prod_name, group_name;

👉 GROUP BY prod_name, group_name → 두 컬럼 조합으로 그룹 생성. 예를 들어, '디지털', '아이폰'은 하나의 그룹이 되고, '디지털', '맥북프로'는 또 다른 그룹이 됨.

평균보다 많이 팔린 제품 조회

SELECT prod_name, SUM(amount) AS prod_amount
FROM buy
GROUP BY prod_name
HAVING prod_amount > (
    SELECT AVG(total_amount)
    FROM (
        SELECT prod_name, SUM(amount) AS total_amount
        FROM buy
        GROUP BY prod_name
    ) AS t
);

💡 포인트

• 별칭(alias)을 어디서 지정했는지에 따라 사용 가능 여부 달라짐
• FROM 절에선, 다중이면 무조건 별칭 사용해야함
• 첫 번째 SELECT → prod_amount
• 두 번째 서브쿼리 → total_amount

2. SQL 고급 문법

1. MySQL 데이터 형식

- 문자열로 받은 최소키(height) '165'를 정수로 형 변환 후, '최소 키' 이상인 멤버 조회

USE market_db;

set @min_h_str = '165';
set @min_h = cast( @min_h_str as signed);

select mem_id,mem_name, height,
    date_format(debut_date,'%Y - %m') as debut_ym
from member
where height >= @min_h
order by height desc, mem_id;

DATE_FORMAT(debut_date, '%Y-%m'): debut_date를 YYYY-MM 형식으로 변환합니다. %Y는 4자리 연도, %m은 2자리 월을 나타냅니다.

- 구매 테이블에서 각 행의 구매 금액(price*amount)을 소수 2자리 DECIMAL로 변환

select *, cast(price * amount as decimal (10,2)) as line_amount
from market_db.buy;

총 10자리를 사용하며, 그중 소수점 아래는 2자리.

• 이는 정수부가 최대 8자리(10-2=8)까지 가능하다는 것을 뜻함.
• DECIMAL(10, 2) → 총 10자리, 소수점 2자리 (정수부 8자리까지 가능)

Prepared Statement (준비된 구문)

• 미리 SQL을 컴파일(준비)해두고, 동일한 쿼리를 다른 값으로 여러 번 실행 가능 → SQL Injection 방지하는 보안상 이점이 있음
• 3단계: PREPARE → EXECUTE → DEALLOCATE
  • PREPARE 구문:SQL 구문을 정의하고, 값이 들어갈 위치에 ? 와 같은 자리표시자 사용
  • EXECUTE: USING 절을 사용하여 변수들을 자리표시자에 바인딩
  • 해제 (DEALLOCATE): 사용이 끝난 준비된 구문을 메모리에서 해제

SET @addr = '서울';
SET @min_h = 165;
SET @sql = 'SELECT mem_id, mem_name, addr, height FROM member WHERE addr = ? AND height >= ?';

PREPARE stmt FROM @sql;
EXECUTE stmt USING @addr, @min_h;
DEALLOCATE PREPARE stmt;

2. JOIN

LEFT JOIN

• 왼쪽 테이블의 모든 행 + 조건에 맞는 오른쪽 테이블의 행 결합
  • 조건에 맞는 행이 있는 경우: 양쪽 테이블의 데이터가 결합되어 출력
  • 조건에 맞는 행이 없는 경우: 왼쪽 테이블의 행은 유지하고, 오른쪽 테이블의 열은 모두 NULL 값으로 채워짐.
• LEFT JOIN + IS NULL 조합 → Anti-join (차집합 구하기)

3. SQL Programming

• MySQL에서 프로그래밍 기능은 스토어드 프로시저에 작성
• DELIMITER $$ ... END$$ 안에 작성, CALL로 호출

1) IF문

IF <조건식> THEN
    SQL 문장들
END IF;

2) CASE문

• IF는 2중 분기 / CASE는 다중 분기

3) WHILE문

• ITERATE [레이블]: 반복 계속
• LEAVE [레이블]: 반복 종료

3. 데이터베이스 개체

1. 뷰 (VIEW)

• 뷰는 데이터 저장하지 않음 → SELECT 실행 결과를 가상 테이블처럼 보여줌
• 종류: 단순 뷰(1개 테이블), 복합 뷰(2개 이상 테이블)
• 복합 뷰로는 테이블의 데이터 수정 불가

  CREATE VIEW 뷰_이름
  AS
    SELECT문;

뷰의 장점

1. 보안(SECURITY)
2. 복잡한 SQL 단순화

뷰의 작동

• 사용자는 뷰를 테이블이라고 생각하고 접근
• MySQL이 뷰 안에 있는 SELECT를 실행해서 그 결과를 사용자에게 보냄
• 뷰는 기본적으로 '읽기 전용'이지만, 원본 테이블의 데이터를 수정할 수도 있음

뷰 관련 명령

• 생성: CREATE VIEW 뷰이름 AS SELECT ...
• 수정: ALTER VIEW ...
• 삭제: DROP VIEW ...

뷰에 접근 → 일반 테이블처럼 SELECT 사용

SELECT 열이름 FROM 뷰이름
    [where 조건];

2. 인덱스

데이터를 빠르게 찾을 수 있도록 도와주는 도구

• Clustered Index
  • 기본 키로 지정하면 자동 생성되며 테이블에 1개만 만들 수 있음
  • 기본 키로 지정한 열을 기준으로 자동 정렬됨
• Secondary Index
  • 고유 키로 지정하면 자동 생성되며 여러 개를 만들 수 있음
  • 자동 정렬되지는 않음
  • 고유 인덱스는 값이 중복되지 않는 인덱스 → 기본 키나 고유 키로 지정하면 고유 인덱스가 자동 생성됨

인덱스의 문제점

• 필요 없는 인덱스를 만드는 바람에 데이터베이스가 차지하는 공간만 더 늘어남
• 인덱스를 이용해서 데이터를 찾는 것이 전체 테이블을 찾는 것보다 느려짐

인덱스의 장점

• select 문으로 검색하는 속도가 매우 빨라짐
• 그 결과 컴퓨터의 부담이 줄어서 결국 전체 시스템의 성능이 향상됨

1. 인덱스의 내부 작동 원리

• Clusterd Index와 Secondary Index는 모두 내부적으로 균형 트리(B-tree)로 만들어짐

• Balanced tree, B-tree는 자료 구조에서 범용적으로 사용되는 데이터 구조 B-tree 구조에서 데이터가 저장되는 공간을 node라고 함

  → Root node, Internal node, Leaf node로 구성 → MySQL에서는 node를 page라고 부름 → 페이지는 최소한의 저장 단위로, 16kbyte 크기를 가짐

균형 트리의 페이지 분할

• 인덱스를 구성하면 데이터 변경 작업( INSERT, UPDATE, DELETE) 시 성능이 나빠짐
• 특히 INSERT 작업이 일어날 때 더 느리게 입력될 수 있음 → “페이지 분할” 작업 때문

1. 클러스터형 인덱스 구성

→ 실제 데이터는 다음과 같이 데이터 페이지가 정렬되고 균형 트리 형태의 인덱스가 형성됨

 ALTER TABLE cluster
     ADD CONSTRAINT
     PRIMARY KEY(mem_id);

2. 보조 인덱스 구성

ALTER TABLE second
        ADD CONSTRAINT
        UNIQUE (mem_id);

    SELECT* FROM second;

• 보조 인덱스가 생성되었는데도 입력한 것과 순서가 동일
• 데이터 페이지를 건드리지 않음

3. 인덱스에서 데이터 검색하기

클러스터형 vs 보조 인덱스

💡 FULL SCAN: 전체 테이블 검색은 데이터를 처음부터 끝까지 검색하는 것. 인덱스가 없으면 전체 페이지를 검색하는 방법밖에 없음 페이지 분할은 데이터를 입력할 때, 입력할 페이지에 공간이 없어서 2개 페이지로 데이터가 나눠지는 것을 말함 인덱스 검색은 클러스터형 또는 보조 인덱스를 이용해서 데이터를 검색하는 것. 속도는 인덱스를 사용하지 않았을 때보다 빠름

2. 인덱스 생성 제거

인덱스 생성 문법

CREATE (UNIQUE) INDEX 인덱스_이름
    ON 테이블_이름(열_이름) (ASC or DESC)

→ UNIQUE를 사용하면 고유 인덱스 생성, 생략하면 중복 허용 보조 인덱스 생성

인덱스 제거 문법

DROP INDEX 인덱스_이름
    ON 테이블_이름

→ 기본 키, 고유 키로 자동 생성된 인덱스는 DROP INDEX로 제거하지 못함 → ALTER TABLE 문으로 자동 생성된 인덱스 제거 가능

• 인덱스 생성 실습

CREATE INDEX idx_member_addr
    ON member(addr)

ANALYZE TABLE member;

생성한 인덱스를 실제로 적용시키려면 ANALYZE TABLE 문으로 먼저 테이블을 분석/처리해줘야 함

3. Stored procedure

• SQL에 프로그래밍 기능을 추가해서 일반 프로그래밍 언어와 비슷한 효과를 낼 수 있음 : SQL + 프로그래밍 기능 -> 스토어드 프로시저

• 특징:

  • CREATE PROCEDURE로 정의, CALL로 실행.
  • 매개변수 3종: 입력(IN), 출력(OUT), 입출력(INOUT).
  • 조건문(IF), 반복문(WHILE), 동적 SQL 등 프로그래밍 로직 작성 가능.

• 활용 예시: 회원 검색, 계산 처리, 반복 작업 자동화 등. 복잡한 쿼리를 재사용할 때 효율적.

• CREATE PROCEDURE는 스토어드 프로시저를 만든 것뿐이며, 아직 실행한 것은 아님

• CALL 스토어드_프로시저_이름(); 로 호출함

• DROP PROCUDURE

📌 실습 예제

1) 입력 매개변수

DELIMITER $$
CREATE PROCEDURE user_proc1(IN username VARCHAR(20))
BEGIN
    SELECT * FROM member WHERE mem_name = username;
END $$
DELIMITER ;

CALL user_proc1('APINK');

2) 출력 매개변수

DELIMITER $$
CREATE PROCEDURE user_proc2(OUT cnt INT)
BEGIN
    SELECT COUNT(*) INTO cnt FROM member;
END $$
DELIMITER ;

CALL user_proc2(@total);
SELECT @total;  -- 출력 값 확인

3) 조건문 활용

DELIMITER $$
CREATE PROCEDURE checkAgeProc(IN age INT)
BEGIN
    IF age >= 20 THEN
        SELECT '성인입니다.';
    ELSE
        SELECT '미성년자입니다.';
    END IF;
END $$
DELIMITER ;

CALL checkAgeProc(25);

이번 주에는 Titanic 데이터셋과 MNIST 데이터셋을 통해
데이터 전처리(Pandas & Numpy)와 MLP(다층 퍼셉트론) 기본기를 익힘

📚 목차

• 1. Pandas 조건 검색
• 2. 결측치 처리 & map vs apply
• 3. 데이터 변환 & 통계 함수
• 4. NumPy 배열 기초 & 조작
• 5. 신경망 기초 (Feedforward Neural Network)
• 6. MLPClassifier 실습 (Iris & MNIST)
• 7. 로지스틱 회귀 vs 랜덤포레스트 비교
• 8. 이번 주 학습 포인트 총정리

1. Pandas 조건 검색

2. 결측치 처리 & map vs apply

🟡 결측치 확인

df['Age'].isna()           # True/False
df['Age'].isnull().sum()   # NaN 개수
df['Age'].notnull()        # 결측 아닌 값

🟡 결측치 채우기

df['Cabin'] = df['Cabin'].fillna('U')

🔵 map vs apply 차이

3. 데이터 변환 & 통계 함수

• 숫자 변환: pd.to_numeric(errors='coerce') → 변환 불가 시 NaN
  • errors = ‘ignore’ : 숫자형으로 변경할 수 없는 데이터라면 원본 데이터 그대로 반환
  • errors = ‘coerce’ : 숫자형으로 변경할 수 없는 데이터라면 기존 데이터는 지우고 NaN으로 설정하여 반환
  • erros= ‘ raise’ : 숫자형으로 변경할 수 없는 데이터라면 오류가 발생하며 코드가 중단
• 데이터 타입 변경: astype()
• 구간별 카테고리화: pd.cut()
• 통계: df.describe(), df['col'].mean() 등

4. NumPy 배열 기초 & 조작

1. NumPy와 Pandas 비교

2. NumPy 배열 생성

① arange + reshape

import numpy as np

d = np.arange(12).reshape(3,4)
print(d, d.shape)

[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]] (3, 4)

• arange(): 특정 수열을 만들어 배열 생성
• reshape(): 배열의 차원/형태를 변경

② 배열 속성

• dtype : 데이터형
• ndim : 배열 차원
• T : 행/열 전치 (Transpose)
• size : 총 원소 수
• nbytes : 총 바이트 수
• flat : 모든 요소 일괄 변경 (d.flat = 1)

③ np.array()로 직접 생성

1차원

a = np.arange(0,5,2)
print(a, a.shape)

2차원

m = np.array([np.arange(0,4,3),
              np.arange(1,5,3),
              np.arange(2,6,3)])
print(m, m.shape)

# [[0 3]
#  [1 4]
#  [2 5]] (3,2)

3차원

m = np.array([[[0,1,2],
               [3,4,5]],
              [[0,1,2],
               [3,4,5]]])
print(m.shape)

# (2,2,3)

💡 Python range() vs NumPy arange() → arange()는 실수 간격도 가능, NumPy 배열 반환.

3. 배열 다루기 (reshape, flatten, 방향 변경)

① reshape()로 형태 변경

m1 = np.arange(6)
m2 = m1.reshape(6,1)   # 6행 1열
m3 = m1.reshape(2,3)   # 2행 3열
m4 = m1.reshape(2,2,3) # 2면 2행 3열

행 수를 -1로 주면 자동 계산:

m2 = m1.reshape(-1,2)  # 2열, 행은 자동

② flatten() : 다차원 → 1차원

flat = m4.flatten()

③ 배열 방향 뒤집기

arr[::-1]  # 행 방향 뒤집기
arr[:, ::-1]  # 열 방향 뒤집기

4. 배열 통합과 분할

① 합치기

5. Numpy 배열의 연산

브로드캐스팅: 차원의 크기가 다른 배열끼리 산술연산이 가능하도록 하는 것.

A = np.array([[1,2,3],
              [4,5,6]])
B = np.array([[2],
              [4]])
print(A+B)

[[ 3  4  5]
 [ 8  9 10]]

5. 신경망 기초 (Neural Network)

📌 순전파 신경망(Feedforward Neural Network) 로직

1. 입력층 (Input Layer)

   • 데이터 x가 들어옵니다. 예를 들어, 특징(feature) 벡터 [x1,x2,...,xn][x_1, x_2, ..., x_n][x1,x2,...,xn].

2. 가중치 및 편향 (Weights, Bias)

   • 각 층에는 가중치 행렬 W와 편향 벡터 b가 있습니다.
   • 수식:z=W⋅x+b

3. 활성화 함수 (Activation Function)

   • 비선형성을 추가하기 위해 z를 활성화 함수 f 에 통과시킵니다.

   • 예: ReLU, Sigmoid, Tanh

     a=f(z)

4. 다음 층으로 전달 (Forward Propagation)

   • 계산된 a는 다음 층의 입력이 됩니다. [다중 Hidden Layer]
   • 이를 반복해서 출력층까지 진행.

5. 출력층 (Output Layer)

   • 회귀 문제라면 보통 활성화 없이 그대로 출력.
   • 분류 문제라면 Softmax를 써서 확률 분포로 변환.
   • 이진 분류 문제라면 Sigmoid 를 사용하여 0~1 확률로 변환

순전파(Forward)로 입력→출력, 역전파(Backpropagation)로 가중치 업데이트

6. MLPClassifier 실습 (Iris & MNIST)

🔹 Iris 데이터

from sklearn.neural_network import MLPClassifier

mlp = MLPClassifier(hidden_layer_sizes=(10,),
                    activation='logistic',
                    solver='lbfgs')
mlp.fit(X_train, y_train) # 학습
# 작은 데이터셋(150개) → 작은 은닉층으로도 높은 정확도

🔹 MNIST 데이터

from sklearn.datasets import fetch_openml
from sklearn.model_selection import train_test_split
from sklearn.neural_network import MLPClassifier

mnist = fetch_openml('mnist_784', version=1, as_frame=False)
X, y = mnist.data / 255.0, mnist.target.astype(int)

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

mlp = MLPClassifier(hidden_layer_sizes=(128,64),
                    activation='relu',
                    solver='adam',
                    max_iter=100)
mlp.fit(X_train, y_train)

• fetch_openml('mnist_784') : 28×28 픽셀 → 784 벡터

• 정규화: /255.0 → 0~1 스케일링(scaling).

  • 원래 픽셀 값은 0=검정, 255=흰색.
  • 신경망 학습 시 입력 값이 크면 기울기 폭발(gradient explosion) 문제 생김.
  • 스케일링을 통해 학습 안정성과 속도를 개선.

• 라벨 변환: .astype(int)

• 은닉층: 고차원 데이터 → 큰 네트워크(128→64) 설정 hidden_layer_sizes 에 전달하는 튜플(tuple) 의 각 원소는 각 은닉층의 뉴런(유닛) 개수를 의미.

  (100, 50) 은

  • 첫 번째 은닉층: 100개의 뉴런

  • 두 번째 은닉층: 50개의 뉴런

    → 즉 2개의 은닉층을 가진 구조입니다.

  (3,) 은 은닉층 1개, 뉴런 3개. (5, 3, 2) 는 은닉층 3개(5→3→2).

  ---

  7. 로지스틱 회귀 vs 랜덤포레스트 비교

• 로지스틱 회귀 → "성별이 생존에 미치는 영향이 얼마나 큰가?" (계수 해석, 오즈비 Odds Ratio, AUC/Recall 중점): 선형 분류 모델, 예측 확률을 직접 제공

  👉 중요한 평가지표

  1. 정확도(Accuracy)
     • 전체 예측 중 맞춘 비율
     • 클래스 불균형(예: 생존자보다 사망자가 많음)이 심할 때는 맹점이 있음
  2. 정밀도(Precision) / 재현율(Recall) / F1-score
     • 생존자 예측 문제처럼 "양성 클래스(1=생존)"가 중요한 경우, Accuracy만 보면 안 되고 재현율(Recall) 이 중요해요.
     • 정밀도: 모델이 "생존"이라고 한 사람 중 실제 생존한 비율
     • 재현율: 실제 생존한 사람 중 모델이 맞게 "생존"이라 한 비율
     • F1-score: Precision과 Recall의 조화평균

• 랜덤 포레스트 → "성별, 요금, 나이, 가족 수 중 어떤 변수가 가장 중요한가?" (Feature Importance, Accuracy 중점): 앙상블 트리 기반 모델, 변수 중요도를 산출

  👉 중요한 평가지표

  1. 정확도(Accuracy)
     • 랜덤 포레스트는 기본적으로 정확도를 높이기 위한 모델이라 많이 씀

👉 따라서,

• 설명력 중시 (변수가 생존 확률에 미치는 영향 해석) → 로지스틱 회귀 + Precision/Recall/AUC
• 예측력 중시 (변수 중요도와 분류 정확도) → 랜덤 포레스트 + Accuracy/AUC/Feature Importance

8. 이번 주 학습 포인트 총정리

✔︎ 데이터 전처리:

• [Pandas] 조건 검색, 결측치 처리, 데이터형 변환
• [Numpy] 배열 조작, 배열 연산(브로드캐스팅)

✔︎ 신경망 기초: [입력층]입력→ [은닉층] 가중치→활성화 → [출력층] 출력 순서

• 활성화함수: 시그모이드 함수,ReLU, Tanh

✔︎ 사이킷런을 통한 신경망 구현:

• MLPClassifier: 작은 데이터는 작은 네트워크, 큰 데이터는 큰 네트워크 + 정규화 필수

  mlp = MLPClassifier(hidden_layer_sizes=(128, 64),  # 은닉층 2개 (128 → 64)
                    activation='relu',
                    solver='adam', #모델 학습 방법
                    max_iter=100,   # 반복 횟수 (20 → 100 실험 가능)
                    random_state=42, #초기 가중치 값 고정
                    verbose=True)
  

``` ✔︎ 로지스틱 회귀 vs 랜덤포레스트: 해석력 vs 예측력

☁️ 총평: 실습해보면서 계속 자주 쓰이는 함수/패키지들을 익히고 모델들의 특성을 익혀서 어떨 때 사용하면 좋을지 바로 아는 능력을 기르는 게 중요할 듯. 다음주도 화이팅~

처음에는 학부 연구생을 하면서 2025 하반기를 보낼 생각이었다. 7월은 체코에서 돌아와 일상에 적응하면서 가고 싶은 연구실을 찾고 하고 싶은 것들 다 하면서 방학을 보내던 중 우연히 HDC LABS NOVA 지원링크를 전달받게 되었다.

2차 모집 마감 d-2, HDC LABS가 무슨 회사인지도 몰랐던 내가 끌렸던 이유는 딱 두 가지였다.

❶ HDC랩스 데이터(IoT, 영상, 음성 등)를 이용한 프로젝트 가능 학교 다닐 때 했던 프로젝트들에서는 이 데이터를 찾는 게 정말 고역이었다. 손수 크롤링을 하거나 공공 데이터, AI hub 데이터를 이용할 수 밖에 없어, 데이터를 못 구해 프로젝트 방향을 아예 바꾼 적도 있었다. 이 부트캠프를는 실무 데이터를 활용하여 프로젝트를 진행할 수 있다는 점이 정말 큰 메리트라고 생각했다. 그 중에서도 부동산 데이터 기반 AIoT 통합 서비스 개발 주제로 프로젝트를 진행한다면 재밌을 것 같다고 생각했다.

❷ ** 현직자 강의 & 멘토링 ** 실제 현업에서는 어떤 식으로 프로젝트를 진행하고 관리하는 지가 항상 궁금했다. 우리끼리 매일 학교에서 "진짜 회사에서도 이런식으로 데이터를 처리한다고??"하면서 의문을 가졌다. 현직자가 직접 강의 및 멘토링을 해주시면서 이런 궁금증이 좀 더 해소되고 실제 취업에 조금 더 가깝게 도움을 받을 수 있지 않을까하는 생각이었다.

• 그 외에도 우리 학교에서는 인도네시아 교수님이 데이터 수업을 전적으로 맡아 강의하시다보니.. 수업 때 100% 이해한 적이 많지 않고, 제대로 배워보고 싶다는 생각을 많이 하긴했다. 파이썬부터 SQL, 머신 러닝~딥러닝까지 체계적으로 전문 강사님께 배워보고, 컴공에서 다루지만 항상 배워보고 싶었던 CV, LLM까지 배우는 커리큘럼이다보니 나에게 굉장히 fit해보였다.
• 한학기동안 제대로된 프로젝트로 포폴 쌓기
• 우수 수료생은 HDC LABS 서류 면제

그렇지만 주변에서 들어본 SAFFY, Naver 등 유명한 부트캠프도 아니었고 뭐가 뭔지 하나도 몰라 고민을 했지만.. 일단 시간과 기회가 있으니 일단 GO . 유명한 부트캠프들은 코딩테스트 준비한다고 고민만 하다가 지원도 못했을 것 같다. 어차피 해야하는 휴학. 시간을 그냥 흘려보내기보단 하길 잘 한 것 같다.

power 개발자를 꿈꾸며 ..

☺︎ week1 : 현직자 특강

25.08.26 Tue - 부트캠프 시작 week1은 무려 5일동안 현직자 특강으로 진행되었다. HDC LABS AI LAB의 NLP, CV, DS 파트의 현직자 분들이 오셔서 각 분야에 대해 강의를 해주셨다.

✔︎ NLP [AIoT 음성 챗봇 만들기]

🌐 실습도구

• STT : Whisper model 다운받아 실행 [edge Layer]
• LLM: Groq 클라우드 서비스 (API 사용) [Cloud Layer]
• TTS: Edge-TTS [Cloud Layer]

🌐 Edge-Cloud 분산 아키텍처

- Edge Layer: 데이터 발생지점에서 처리
    → 빅스비/시리 같은 Wake Word감지 (항상 대기: 전력 소모가 심함.. )
    → 장점: 빠른 응답, 네트워크 독립
- Cloud Layer:  중앙서버/데이터 센터를 이용
    → 클라우드에서 처리된 결과를 다시 edge로 전달
    → 장점: 강력한 AI, 최신 정보, 복잡한 추론  

🔄 음성챗봇 처리 파이프라인

👤 사용자 음성 → 🎤 STT → 🧠 LLM → 🔊 TTS → 🔈 AI 음성

1. SST 기술 심화 [Whisper 중심]

STT

• 기술: Transformer
• 특징: 다국어 지원
• 대표 사례: Whisper, Wav2Vec

🏗️ 모델 구조

📊 Audio Input (16kHz)
    ⬇️
🔄 Mel-Spectrogram 변환
    ⬇️  
🧠 Encoder (음성 특징 추출)
    ⬇️
🧠 Decoder (텍스트 생성)
    ⬇️
📝 Text Output (UTF-8)

📊 모델 크기별 특성

🆚 주요 STT 기술 비교

→ 무료로 사용: Whisper → 한국어로 높은 정확도: 네이버 클로바 사용하는 게 좋을 듯하죠?

2. LLM 기술 심화 - Groq 중심

Groq = 클라우드 서비스, AI 모델 추론에서 초고속 연산을 지원하는 하드웨어 및 소프트웨어 솔루션을 제공하는 기업과 그 기술을 가르킴. GPU 대안으로 주목받고 있음. (LPU라는 자체 아키텍처를 사용, GPU 대신 낮은 전력 소모로 에너지 효율이 높음)

→ GPU 없이 사용 가능, 로컬 환경(또는 Colab CPU 런타임)에서 API 호출만 하면 됨. 
모델 연산은 Groq 서버에서 수행하므로 컴퓨터 성능과는 무관

🏗️ LPU 기술

LPU (Language Processing Unit)

GPU 대비 10배 빠른 토큰 생성 속도

초당 500-1000 토큰 생성 가능

3. TTS 기술 심화 - Edge TTS 중심

TTS

• 기술: Neural TTS
• 특징: 기존 통계 기반에 비해 사람과 구별이 어려운 목소리
• 대표 사례: Edge-TTS, ElevenLabs

🆚 주요 TTS 기술 비교

→ ElevenLabs가 가장 자연스럽지만 비용문제로, 상업적 품질을 무료로 제공하는 Edge-TTS를 많이 사용

** 🚀 지연시간 최소화**

🎯 (실제 구현시) 비용 절감 전략

📦 캐싱 활용

자주 묻는 질문 → 미리 생성된 응답 사용

🎚️ 모델 선택

간단한 질문 → 작은 모델

복잡한 질문 → 큰 모델

✔︎ AI/ML 기본 지식

📌 AI > 머신러닝 > 딥러닝

• 머신러닝 (ML)
  • 정형 데이터 기반, 패턴 탐색 (예: 온습도 센서, 서버 로그 등)
• 딥러닝 (DL)
  • 비정형 데이터(이미지, 텍스트) 처리
  • GPU 필요, 학습 시간 길다
• 머신러닝은 블랙박스 성격 → 전적으로 맡기기엔 위험

⚙️ 모델링 프로세스

1. 문제 정의
2. 데이터 수집
3. 데이터 탐색
   • 분포 확인
   • 이상치/결측치 처리
   • 변수 간 상관성 확인
4. 데이터 전처리
   • 결측값 처리, 데이터 통합
   • 원핫인코딩
   • 비정형 데이터 행렬 변환 등
5. 모델링
   • 모델 선택, 하이퍼파라미터 설정, 학습
6. 모델 평가
   • Precision, Recall, Accuracy, F1 Score 등

🔄 피드백 루프: 평가 → 전처리 → 모델링 반복

💡 주요 개념

• Chain of Thought: 모델이 추론 과정을 단계적으로 설명하도록 유도
• Few-shot Learning: 예시 기반 학습
• Prompt Engineering: 프롬프트 설계 중요
• Fine-tuning: LORA 등 경량화 방식 활용
• RAG (Retrieval-Augmented Generation): 벡터 검색 기반 지식 활용

☁️ 느낀점

NLP, CV, LLM, DS .. 그냥 뭉뚱그려 데이터 라고만 알고 있던 내게 세분화하여 정리될 수 있는 아주 유익한 시간이었다.

학부 때 주변에서 사용하라고 권해서 뭔지도 제대로 모르고 써봤던 Hugging Face, Kaggle, Dacon 등 데이터 공유 플랫폼이나 RAG, LoRA 등의 기법들에 대해 거시적인 개념들을 잡을 수 있어서 좋았다. 그리고 바이브 코딩의 도구들 Cursor, claude code. 처음들어보는데 점점 IT 지식이 늘어가는 것 같아 즐거웠음~.. 특히, DAY3에 NLP 파트에서 오신 현직자 분의 특강이 가장 유익했다. 작년에 데이콘 AI 경진대회에서 뭔지도 모르고 사용했던 STT, TTS 모델들의 종류들도 명확히 알게 되었고, 프로젝트 진행 시 주요 모델들의 선택 기준(?)을 정리해서 알려주셔서 재밌었다. (뭐가 뭔지도 모르고 일단 GPT가 쓰라는 대로 사용하다가, 모델들의 개념, 장단점 및 활용 방안을 알게 되어서 좋았달까..)