끄적끄적

2025.08.21 추천시스템 & LLM 3회차

kminx — Thu, 21 Aug 2025 16:08:44 +0900

LLM에 대해 알아보자.

1️⃣ LLM

LLM은 LM(Language Model)로 기계가 언어를 학습하는 방식인데, 주어진 문장에서 간어의 등장 확률을 계산해 가장 자연스러운 문장을 생성한다.

발전 단계는 아래와 같다.

통계적 언어 모델(SLM, Statistical Language Model)
- 단어 빈도 기반, n-gram (짧은 문맥만 반영)
신경 언어 모델(NLM, Neural Language Model)
- 단어를 벡터로 표현, 신경망 기반으로 더 긴 문맥 이해 가능
사전 학습된 언어 모델(PLM, Pre-trained Language Model)
- 대규모 데이터로 일반 언어 지식 학습 → 이후 특정 과제에 Fine-Tuning
대형 언어 모델(LLM, Large Language Model)
- PLM에서 모델 규모와 데이터 크기가 폭발적으로 커짐 → 파인 튜닝 없이도 다목적 작업 가능

또한, 방향에 따라 예측하는 방식이 다른데, 이전 단어들을 기반으로 다음 단어를 예측하는 순붕향 예측 모델과 문장의 앞 뒤 정보를 모두 활용하는 양방향 예측 모델이 있다.

이때, LLM은 현재 주목받고 있는 모델로 Gemmini, ChatGPT, deepseek등 다양한 기업에서 서비스를 제공하고 있다.

Transformer 모델을 기반으로 방대한 범용 데이터를 학습한 초대형 자연어 처리 모델로, 수십억~수조 개의 파라미터가 필요하기에 고성은 GPU 및 대규모 분산 컴퓨팅 환경이 필수적이다.

LLM은 특정 Task를 위해 학습하고 한 문제만 잘 풀 수 있는 기존 AI 모델과 다르게

추가 학습 없이도 다양한 작업을 수행할 수 있고, 단순 정보 제공을 넘어선 창작 영역까지 확장하며 창발 현상을 보인다.

2️⃣ LLM 모델 발전 과정

기존 시퀀스 모델은 병렬 처리가 어려워 학습 속도가 느리고, 장기 의존성 문제가 발생하였다.

이를 극복한 것이 Transformer 모델이다.

Transformer 모델

self-attention 메커니즘을 기반으로 전체 시퀀스를 한 번에 처리할 수 있는 딥러닝 모델이다.
<추가 설명 블로그>

인코더(Encoder)
- 컴퓨터가 이해할 수 있도록 입력 문장을 압축해 핵심 정보를 담은 형태(고차원 벡터)로 바꾸는 역할
- 입력된 문장의 의미를 잘 이해시키는 것!
디코더(Decoder)
- 인코더에서 만들어진 벡터를 바탕으로 새로운 시퀀스를 생성하는 역할
- 새로운 문장을 생성하는 것! (AutoRegressive)

LLM 모델 발전 과정

인코더-디코더 모델 (Encoder-Decoder, Seq2Seq)
- 주로 번역, 요약, 질의응답(Q&A) 등 자연어 변환(Transformation) 작업에 적합한 모델
- 문장의 전체적인 의미를 인코더가 압축 → 디코더가 생성하는 방식
- 대표 모델 : T5, BART, UL2, mT5 등
- GPT 기반의 디코더 모델이 주목받으면서 상대적으로 관심이 줄어들었으나, 특정 NLP 작업에서는 여전히 강력한 성능을 보임
인코더 전용 모델 (Encoder-Only)
- 주어진 문장의 의미를 깊이 이해하는 데 초점을 맞추는 모델
- 주로 문서 분류, 감성 분석, 개체명 인식(NER) 등의 NLP 작업에 사용됨
- 대표 모델 : BERT, RoBERTa, ALBERT, ELECTRA 등
- BERT 등장 이후 NLP 연구를 주도했지만, 생성형 AI 성장으로 점차 관심이 감소하고 있음
디코더 전용 모델 (Decoder-Only, Autoregressive)
- 주어진 입력에 기반하여 다음 단어를 예측하는 방식으로 텍스트 생성에 최적화됨
- 주로 챗봇, 문서 생성, 코딩 지원 등 다양한 생성형 AI 작업에 활용
- 대표 모델 : GPT 계열, LaMDA, PaLM, LLaMA, Claude 등

< 요약 정리 >

구조	설명	대표 모델
인코더-디코더	번역 등 입력과 출력을 모두 고려하는 작업	기존 Transformer
인코더만 사용	입력을 인코딩해 분류, 특성 추출에 활용	BERT, RoBERTa
디코더만 사용	다음 문장 생성 등 생성 중심에 활용	GPT 시리즈

LLM의 한계

환각(Hallucination) 문제 : 사실이 아닌 정보를 사실처럼 생성하는 경향
실시간 정보 반영 불가 : LLM = 사전 학습 모델
- GPT-3 는 2021년까지의 데이터를 학습함 → 이후 정보 알기 어려움
- 보완책 : RAG
긴 문맥 유지가 어려움 : 한 번에 처리할 수 있는 최대 토큰 길이가 존재하기 때문
편향(Bias) 문제 & 창작물의 저작권 문제
높은 운영 비용
- A100 GPU 1개의 가격이 1,300만 원 이상인데 ChatGPT 구동을 위해 약 1만 개의 A100이 필요함 (2020년 기준)
보안 및 악용 문제

3️⃣ LLM 학습의 핵심 요소

LLM 학습 방식

LLM은 방대한 양의 데이터를 활용하여 기본적인 언어 능력을 학습하는 사전 훈련(Pre-training) 단계를 거친 뒤,

특정 Task에 맞춰 추가 학습하는 Fine-tuning 과정을 거친다.

이때, 사람의 피드백을 이용해 LLM 모델을 강화하는 강화학습 (RLHF: Reinforcement Learning From Human Feedback) 방법을 거칠 수 도 있다.

LLM 추론 과정

Prompt Engineering

프롬프트 (Prompt) : LLM에 입력하는 명령어나 질문 (= 어떤 작업을 수행하도록 요청하는 입력 텍스트)
프롬프트 엔지니어링 : LLM이 더 좋은 답변을 생성할 수 있도록 입력 프롬프트를 최적화하는 과정 = 질문을 잘 하기 위한 과정

프롬프트 엔지니어링 종류
- 지시형(Instruction Prompting): AI가 특정한 작업을 수행하도록 명령
  ex) "이 문장을 영어로 번역해 줘: '안녕하세요!'”
- 역할 지정(Role Prompting): AI가 특정한 역할을 수행하도록 지시함으로써 특정한 스타일과 전문성을 반영한 답변 생성
  ex) "당신은 글쓰기 전문가입니다. 초보자를 위한 효과적인 글쓰기 팁 5가지를 설명해 주세요.”
- 예제 제공(Few-shot Prompting): AI에게 예제를 주면서 원하는 답변 형식을 출력되게 하는 방법
  ex) "이 음식은 맛이 없다." → "이 음식은 내 입맛에는 맞지 않네요."
  "이 영화는 재미없다." → "이 영화는 나에게는 조금 지루했어요."
  이제 다음 문장도 더 부드럽게 바꿔줘:
  "이 옷은 별로야."
- 단계별 안내(Chain-of-Thought Prompting, COT): AI가 답을 바로 내지 않고, 논리적으로 생각하는 과정을 거치도록 유도하는 방법
  ex) "345명의 학생이 각 반에 23명씩 배정됩니다. 먼저 345를 23으로 나누어 총 몇 개의 반이 필요한지 계산하고, 나머지가 있다면 추가로 한 반을 만들어야 합니다. 답을 단계별로 설명해 주세요.”
- 금지어 설정 및 응답 스타일 지정(Constraints & Formatting): AI가 특정한 형식으로 답변을 출력하도록 제한하는 방식
  ex) "한 문장으로 50자 이내로 간단히 설명해 줘.”

⇒ 초기에는 모델이 질문을 잘 알아들어서 프롬프트 엔지니어링 역할이 중요했지만, 지금은 모델의 성능이 많이 올라갔기 때문에 일반적인 중요성은 점점 줄어드는 중.

토큰화(Tokenization)

텍스트를 AI가 이해할 수 있는 작은 단위(토큰)으로 변환하는 과정
- 토큰화 모델이 다르면 같은 문장도 다르게 표현됨 → 성능에 미치는 중요한 요소!
토큰화 방식
- 현재는 서브워드 기반(BPE, WordPiece, Unigram LM) 이 많이 사용되고 있음
- 토큰화를 통해 사전 정의된 토큰별 고유 ID로 변환됨

토큰화 모델 선택
- 규칙 기반(사전 내장된 토큰화 모델) : 사람이 미리 정해둔 규칙대로 자름 (예: 띄어쓰기 기준)
- 학습 기반(사전 학습된 토큰화 모델) : 데이터에서 단어 패턴을 배우고 토큰 단위를 스스로 결정 (BPE, WordPiece, SentencePiece 등)
  - HuggingFace의 AutoTokenizer를 사용하면 모델별 토큰화를 자동으로 설정 가능
- 미리 정의된 단어 사전에 없는 단어를 처리할 때 (OOV 문제)

Embedding

토큰을 숫자로 변환하여 모델이 이해할 수 있도록 의미를 반영한 벡터(숫자)로 표현하는 과정
임베딩 벡터의 특징
- 같은 의미를 가진 단어는 비슷한 벡터 값을 가짐
- 문맥(Context)에 따라 벡터 값이 달라질 수도 있음 (ex. 밤산책 vs 군밤)
토큰화를 통해 얻은 토큰 ID를 사전 학습된 임베딩 벡터로 변환
LLM마다 사용하는 임베딩 방식과 모델이 다르기 때문에, 동일한 단어라도 모델별로 임베딩 벡터 값이 달라질 수 있음!
Embedding 값이 Transformer 모델의 입력으로 들어감

Tokenization → Embedding
입력 문장 : “고양이는 귀엽다.”
1. Tokenization : ["고양이", "##는", "귀엽다", "."]
2. Token → 숫자 변환 : [10567, 9012, 4823, 102] (토큰화 모델이 가지고 있는 미리 정의된 고유 ID)
3. Embedding vector 생성: Transformer 모델의 입력이 되는 값

2025.08.19 추천시스템 & LLM 2회차

kminx — Tue, 19 Aug 2025 16:24:05 +0900

사용자와 아이템의 상호작용 데이터를 사용하는 협업 필터링에 대해 알아보자.

행렬 연산과 추천 시스템 평가 지표에 대해서 알아보자

️ 실습 코드

실습 코드

1️⃣ 협업 필터링

협업 필터링이란 비슷한 취향(상호작용 기록)을 가진 사람은 비슷한 것을 좋아할 가능성이 높다는 가정에 기반한 추천방식이다.

아이템의 콘텐츠를 보지 않고, 사용자-아이템 상호작용 데이터만으로 추천하는 방식으로 상호작용 데이터가 많을수록 추천의 정확도가 향상될 수 있다.

협업 필터링과 콘첸트 기반 필터링의 차이점은 아래와 같다.

	협업 필터링	콘텐츠 기반 필터링
추천 방식	유사한 사용자 또는 아이템 기반 추천	사용자가 선호하는 아이템의 특징에 기반한 추천
주요 데이터	사용자-아이템 간의 상호작용 데이터 (평점, 클릭, 구매 이력 등)	아이템 메타데이터(장르, 키워드, 설명 등)
사용자 콜드스타트	상호작용 이력이 없으면 추천 어려움	콜드스타트 문제가 상대적으로 적음
아이템 콜드스타트	아이템이 충분한 평가를 받아야 가능함	아이템의 특징만 있으면 바로 추천 가능
추천의 다양성	인기 아이템 추천 경향	유사한 콘텐츠만 추천되는 문제 발생 (의외성 부족)
설명 가능성	추천 이유를 설명하기 어려움	추천 근거를 설명하기 용이함

⇒ 콘텐츠 기반 필터링은 아이템의 속성(메타데이터)에 의존한 추천이고, 협업 필터링은 사용자가 직접적으로 선호를 표현한 인터랙션 데이터를 기반으로 잠재된 유사성을 파악하는 방식

사용자-아이템 상호작용 데이터란?

전체 사용자 ID = 행 인덱스, 전체 아이템 ID = 열 인덱스
상호작용 여부, 평점, 횟수/빈도 등의 값으로 구성할 수 있음

희소 행렬 (Sparse Matrix)

대부분의 원소가 0 또는 비어 있는 값(None, NaN)으로 구성된 행렬
추천 시스템에서는 모든 사용자가 모든 아이템을 소비하지 않기 때문에 대부분의 셀은 빈 값으로 채워짐
- 메모리 낭비 및 비효율 해결 필요 → Scipy의 csr_matrix와 같은 희소 행렬 전용 자료구조 사용
- 정보 부족으로 추천이 어려움 → 부족한 정보를 보완하기 위한 모델링 기법(잠재 요인, 딥러닝, LLM) 사용

협업 필터링 분류

기업 기반 협업 필터링 = 최근접 이웃 방식

상호작용 데이터를 그대로 활용하여 유사한 사용자나 아이템을 찾아 추천하는 협업 필터링

대표 방식
- 사용자 기반(User-based): 나와 취향이 비슷한 사용자가 좋아한 아이템 추천
- 아이템 기반(Item-based): 내가 좋아한 아이템과 유사한 아이템 추천
학습 없이 추천이 필요할 때마다 실시간으로 유사도를 계산 혹은 일/주 단위로 상호작용 데이터 업데이트 해서 미리 계산한 결과를 사용

모델 기반 협업 필터링

상호작용 데이터를 학습하여 일반화된 예측 모델을 만든 뒤 추천

대표 방식 : 잠재 요인 분해(Latent Factor Model)
- 사용자와 아이템을 벡터로 표현하고, 이들 간의 내적으로 선호도를 예측
- 사용자의 취향과 아이템 특성을 잠재적으로 추정
- 사용자가 평점은 주지 않았지만 좋아할 가능성이 높은 아이템을 예측 가능
협업 필터링은 기본적으로 상호작용 데이터만 사용하지만, 실무에서는 정확도를 높이기 위해 사용자/아이템 피처도 함께 사용하는 확장 모델들로 발전됨

최근접 이웃 방식 협업 필터링

과거 데이터를 그대로 활용하여 유사한 사용자나 아이템을 찹아 추천 방식으로 사용자 기반 협업 필터링과 아이템 기반 협업 필터링이 있다.

사용자 기반 협업 필터링 (User-Based CF)

나와 비슷한 취향을 가진 가까운 사용자(이웃)을 찾아 그들이 좋아한 다른 아이템을 추천 받음

Q.
위 그림은 4명의 사용자가 각각의 6개 아이템에 대한 평점 데이터이다. 평점 데이터를 바탕으로 사용자 A와 가장 가까운 사람은?

정답은 B

코사인 유사도 : (A, B) = 0.804, (A, C) = 0.54, (A, D) = 0.51
A와 취향이 비슷한 B에게 A가 본 영화 중 평점이 좋은 영화를 추천해주는 방식

아이템 기반 협업 필터링 (Item-Based CF)

내가 좋아한 아이템과 유사한 아이템을 찾아 추천

⁉️콘텐츠 기반 필터링과 비슷한 것 아닌가요?
- 콘텐츠 기반 필터링 : 슬램덩크를 좋아하는 사용자에게 똑같이 ‘스포츠’ 만화인 테니스의 왕자를 추천
→ 유사함의 기준이 아이템의 속성
- 아이템 기반 협업 필터링 : 슬램덩크를 본 ‘사용자가 많이 본’ 강철의 연금술사를 추천
→ 유사함의 기준이 해당 아이템을 본 사용자가 인터랙션 했는가

Q.
위 그림을 통해 사용자 B에게 아이템을 추천한다고 합시다. 사용자 B가 가장 좋은 평점을 매긴 아이템 다과 유사한 어떤 아이템을 추천하면 될까요?

정답은 아이템 나

유사도 : (다, 가) = 0.982 / (다, 나) = 0.563 / (다, 라) = 0.572 / (다, 마) = 0.291 / (다, 바) = 0.39
유사도는 가 → 라 → 나 순으로 높으나 가와 라는 이미 본 영화이기 때문에 나를 추천

장점

도메인 지식과 아이템의 메타데이터가 필요 없음
단순하고 직관적이라 빠르게 적용 가능함
비슷한 사용자 A가 이 영화를 좋아했기 때문에 추천 가능하다 등 설명이 가능함

한계

데이터 희소성 문제 : 실제 데이터는 대부분 비어 있는 경우가 많아서 유사도를 계산할 데이터가 부족함
콜드스타트 문제 : 사용자, 아이템 모두 상호작용 기록이 없는 경우 사용할 수 없음
확장성 문제 : 사용자 수와 아이템 수가 많아질수록 유사도 계산 비용이 기하급수적으로 증가함
유사도 기반 추천의 한계 : 추천 이유를 설명할 수 없음

⇒ 데이터가 커지거나 복잡해지면 모델 기반으로 넘어가는 것이 일반적

잠재 요인 협업 필터링

전통적인 협업 필터링인 최근접 이웃 기반 협업 필터링의 한계점을 극복하기 위해 등장했으며, Netflix Prize 대회에서 처음 등장한 방법으로도 유명함
행렬 분해(Matrix Factorization) 기법을 사용해서 사용자와 아이템의 숨겨진 특징(Latent Factors)을 학습하는 방법

상호작용 없음(0)은 ‘불호’의 표시가 아니라 잠재적인 ‘선호’ 표시일 수 있다. 잠재적인 선호도가 얼마인지를 계산해서 추천하는 방법 = 잠재 요인 협업 필터링

이때 행렬 분해란 행렬 A를 2개 이상의 작은 행렬 B, C로 분해하는 것으로 희소 행렬을 해결할 수 있다.

동작 방식

사용자-아이템 행렬 데이터 생성 (희소 행렬 형태)
행렬 분해(Matrix Factorization)
- 사용자-아이템 행렬을 두 개의 잠재 행렬로 분해
- 사용자 잠재 행렬(U) : 각 사용자의 잠재 요인을 나타내며, 사용자가 특정 특징에 얼마나 관심이 있는지를 나타내는 값들이 포함됨
- 아이템 잠재 행렬(V) : 각 아이템의 잠재요인을 나타내며, 아이템의 특정 특징에 얼마나 관련되어 있는지를 나타내는 값들이 포함됨 (*T : 전치 행렬을 의미함)
- 사용자 잠재 행렬 * 아이템 잠재 행렬을 최대한 기존 상호작용 데이터와 유사하게 복원하는 것이 목표
학습 과정

초기에는 U와 V를 무작위 값으로 설정한 뒤, 예측값과 실제값의 차이(오차)를 줄이기 위해 최적화를 반복 (ex. 경사 하강법)
학습이 진행될수록 사용자 잠재 행렬과 아이템 잠재 행렬의 값이 업데이트 되면서 예측 정확도가 높아짐 → 숨겨진 패턴 반영

예측값 계산
- 학습이 완료되면 U × Vᵀ 를 계산해 비어 있던 셀에 대한 예측 평점을 생성
- 이 예측 평점은 "사용자 A는 아이템 B를 얼마나 좋아할 가능성이 높은가?"를 의미함 → 실제값과 똑같아 지는 게 아니라 전체 패턴을 잘 근사하는 것을 목표로 함
추천리스트 생성
- 예측된 평점 중에서 사용자가 아직 보지 않은 아이템들 중 점수가 높은 순으로 정렬하여 추천 리스트를 생성

주요 행렬 분해 기법

어떻게 나누느냐에 따라 다양한 기법이 있다.

1. SVD (Singular Value Decomposition)

모든 정방행렬 또는 직사각 행렬을 세 개의 행렬의 곱으로 분해하는 방법 (=선형 대수 기반의 행렬 분해 기법)
장점
- 수학적으로 가장 정확한 행렬 분해 방법
- 정방행렬뿐만 아니라 직사각 행렬에도 적용 가능
- 차원 축소 효과를 가지며 최적의 근사값 제공
한계
- 결측값(missing values)이 있으면 적용 불가능 (희소 행렬에서는 적용 어려움)
- 계산량이 많아 대규모 데이터에서는 사용 어려움
- 보완방법으로 Truncated SVD 사용

2. 교대 최소제곱법(ALS, Alternating Least Squares)

행렬을 직접 최적화하는 방법
장점
- 결측값이 있는 데이터에도 적용 가능
- 추천시스템에서 대규모 행렬 분해에 최적화
한계
- 하이퍼 파라미터(잠재 요인 개수 k)에 따라 성능이 달라짐
- 계산량이 많아 병렬 연산이 필요할 수 있음

장점

성능 우수 : 희소한 데이터에서도 사용자의 잠재적인 선호를 파악하여 높은 추천 정확도 낼 수 있음
압축 표현 가능 : 사용자와 아이템의 특성을 소수의 잠재 요인으로 표현함으로써 계산 효율성이 높아짐
비선형 관계 학습 가능 : 단순 유사도 기반 접근보다 더 복잡한 사용자-아이템 간의 관계 포착 가능
대규모 데이터에 적합 : SGD, ALS 등의 최적화 알고리즘을 사용하여 대규모 데이터도 학습 가능
예측 기반 추천 : 아직 상호작용하지 않은 아이템에 대한 예측 평점 생성 가능

한계

해석의 어려움 : 잠재 요인이 추상적이기 때문에 추천 이유 설명 어려움
콜드 스타트 문제 : 신규 사용자나 아이템은 상호작용 정보가 없어서 추천 불가능
학습 및 튜닝 필요 : 최적화 과정, 하이퍼파라미터 튜닝 등 모델 개선에 리소스가 많이 필요함
과적합 필요 : 적절한 정규화를 하지 않으면 특정 사용자나 아이템에 과적합 될 수 있음

최근 추천 시스템의 발전 방향

하이브리드 추천 시스템 : 콘텐츠 기반 + 협업 필터링을 결합하여 장점을 극대화
LLM, 강화학습, 멀티모달 추천 등 발전된 형태의 추천 모델 등장

2️⃣ 추천 시스템 평가 지표

오프라인 평가 vs. 온라인 평가
- 오프라인 평가 : 미리 수집된 데이터(과거 사용자 행동 데이터)를 기반으로 모델의 성능을 측정하는 방식. 추천시스템이 제공되기 전에 미리 성능을 테스트하는 데 사용됨
- 온라인 평가 : 실제 사용자 반응(클릭, 구매 등 실시간 행동 데이터)을 바탕으로 추천 시스템의 효과를 측정하는 방식

CH 4. 실전 프로젝트 - 가설 검증 및 대시보드 생성

kminx — Mon, 18 Aug 2025 18:19:11 +0900

온라인 강의 플랫폼 데이터 분석 및 인사이트 도출

이번 프로젝트에서는 온라인 강의 플랫폼 학습 데이터를 바탕으로 수강생들의 이탈률, 학습 활동, 학력별 성과 차이를 분석하였습니다.
분석 결과를 토대로 회원 유지율과 고객 충성도를 높이기 위한 전략을 제안하고, 이를 시각화할 수 있는 대시보드 설계안도 마련했습니다.

1️⃣ 주요 분석 결과

1) 영어권 vs 비영어권 이탈률간 차이가 클 것이다.

영어권과 비영어권 수강생 간 전체적인 이탈률 차이는 크지 않음.
다만, Viewed 단계 → Explored 단계 전환 시점에서 이탈률이 급격히 증가하는 패턴이 발견됨.
따라서 초기 몰입도 강화 전략이 필요함을 확인.

2) 수강 중 활동이 활발할수록 성적과 수료율이 높을 것이다.

활동 지표(nevents, ndays_act, nchapters)가 많을수록 성적과 수료율이 높음.
즉, 활동량이 곧 성과와 직결됨.
학습 활동을 촉진하는 기능이 고객 유지율에 큰 영향을 미칠 수 있다는 결론을 도출.

3) 학력이 높을수록 성적과 수료율이 높을 것이다.

학력이 높을수록 성적 및 수료율이 높은 경향 확인.
또한 성적과 수료율 간에도 양의 상관관계 존재.
학습 몰입도를 유지·관리하는 것이 교육 서비스 활성화에 기여할 수 있음.

2️⃣ 대시보드 설계

분석 결과를 효과적으로 모니터링하기 위해 두 가지 대시보드를 설계했습니다.

대시보드 1: 학습 성과 및 현황

KPI 지표
- 평균 점수, 고성과 학습자 비율, 등록자 수, 수료자 수, 수료율
전환 퍼널: 단계별 전환율 및 전환 인원 수
학습자 특성 분포: 연령대·학력·지역별 분포
등록자 추이: 연도별 등록자 수

대시보드 2: 학습 몰입도 및 이탈 현황

KPI 지표
- 초기 이탈률, 중도 이탈률, 저몰입군 점유율, 일평균 학습 몰입도
이탈자 현황: 단계별 이탈자 수 + 평균 활동량
강의별 평균 활동량: 연도에 따른 강의별 활동량
몰입도-수료율 차트: 몰입도 수준별 수료율 분포

3️⃣ 도출된 인사이트 및 실행 전략

1) 이탈률 관리

문제: 초기 진입과 중도 학습 지속 단계에서 이탈률이 매우 높음 (초기 34.8%, 중도 95.9%)
방안:
- 등록 직후 1~2일 내 미활동자에게 알림 메시지 발송
- 학습 가이드라인 제공
목표: 초기 이탈률 25% 이하, 중도 이탈률 90% 이하
기대 효과: 초기/중도 이탈률 감소 → 장기 학습자 확대

2) 저몰입 강의 개선

문제: 저몰입 강의가 전체 평균 몰입도를 끌어내리고, 수료율에도 악영향
방안:
- 강의 길이·난이도 조정
- 맛보기 퀴즈, 토론, 실습 자료 제공
목표: 저몰입 강의 비율 19% → 5% 이하
기대 효과: 저몰입 강의 수료율 개선, 평균 몰입도 회복

3) 신규 유입 회복

문제: 등록자 수는 증가했지만 특정 시점에서 급감
방안:
- 성수기/비수기 차별화된 마케팅
- 인기 강의 재홍보 및 신규 강의 론칭 시 티저 캠페인
목표: 전년 대비 등록자 수 15% 이상 증가
기대 효과: 안정적인 신규 유입 확보, 기반 확대

4) 전환 퍼널 개선

문제: Viewed → Explored 전환율 8.28%로 급감 → 병목 현상
방안:
- 초반 시청 직후 퀴즈/토론 참여를 유도하는 참여형 인트로 콘텐츠 도입
목표: 전환율 15% 이상
기대 효과: 하위 단계 진입률 상승, 충성도 높은 이용자 확보

5) 성취 기반 참여 확대

문제: 평균 점수 및 고성과자 비율 하락
방안:
- 성취도 랭킹 공개
- 주간·월간 챌린지 운영
- 성과 배지·포인트 보상 제공
목표: 고성과자 비율 5% 이상
기대 효과: 충성도 높은 장기 이용자 확보

✅ 결론

이번 분석을 통해 이탈률 관리, 저몰입 강의 개선, 신규 유입 회복, 전환 퍼널 개선, 성취 기반 참여 확대라는 5가지 인사이트를 도출했습니다.

이를 기반으로 설계된 대시보드를 운영하면,

학습자의 초기·중도 이탈을 줄이고,
학습 몰입도를 높이며,
충성도 있는 장기 학습자를 확보하는 교육 서비스 활성화 전략을 실행할 수 있습니다.

CH 4. 실전 프로젝트 - 데이터 전처리

kminx — Mon, 18 Aug 2025 18:00:05 +0900

온라인 강의 플랫폼 데이터 전처리 과정

이번 포스트에서는 온라인 강의 플랫폼 데이터를 불러와, 분석이 가능한 형태로 전처리 및 파생변수 생성까지 진행한 과정을 정리했습니다.
데이터 출처: Kaggle – Online Course Student Engagement Metrics

1️⃣ 데이터 로드 및 기본 확인

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

plt.rcParams['font.family'] ='Malgun Gothic'
plt.rcParams['axes.unicode_minus'] =False
pd.set_option('display.max_columns', None)

df = pd.read_csv('./Courses.csv')
df.info()
df.head()

총 16개 컬럼이 존재하며, 학생들의 등록/수강 여부, 성적, 국가, 학력, 나이, 이벤트 활동 수 등을 포함하고 있습니다.
incomplete_flag를 확인해보니 일부 레코드에 결측치가 포함되어 있음도 알 수 있었습니다.

2️⃣ 성적(grade) 결측치 처리

grade 컬럼에는 ' ' (공백) 값이 존재 → 이를 NaN으로 변환했습니다.

df['grade'] = df['grade'].replace(' ', np.nan)

3️⃣ 이상치 처리

전처리 과정에서 여러 논리적/통계적 이상치를 정의하고 제거했습니다.

(1) 수강 이력과 이벤트 불일치

조건 컬럼: nplay_video, nchapters, nevents, ndays_act
규칙
1. viewed == False 이면서 위 조건 값이 모두 존재 → 삭제
2. viewed == False 이면서 일부 값만 존재 → 해당 값들을 0으로 치환

conditions = ['nplay_video', 'nchapters', 'nevents', 'ndays_act']
condition_not = (~df['nevents'].isna()) & (~df['ndays_act'].isna()) & (~df['nplay_video'].isna()) & (~df['nchapters'].isna())

drop_index = df[(df['viewed']==False) & condition_not].index
df = df.drop(index=list(drop_index)).reset_index(drop=True)

mask = (df['viewed']==False) & (df[conditions].notna().any(axis=1))
df.loc[mask, conditions] = 0

(2) 출생연도(YoB) 이상치

IQR을 사용하여 이상치 탐지
상한값(upper) = 2004.5
2005년 이후 출생 데이터는 잘못 입력된 값으로 판단하여 삭제

q1, q3 = df['YoB'].quantile([0.25, 0.75])
iqr = q3 - q1
upper = q3 + 1.5*iqr
drop_index = df[df['YoB'] > upper].index
df = df.drop(index=list(drop_index)).reset_index(drop=True)

(3) 불필요/결측 처리

roles 컬럼: 분석에 필요 없으므로 삭제
LoE_DI, gender: 결측치는 "Unknown"으로 대체

df.drop(columns='roles', inplace=True)
df = df.fillna({'LoE_DI': 'Unknown', 'gender': 'Unknown'})

(4) 성적(grade) 특수값

값이 1.01인 경우 실제 100% 성적 의미 → 1.0으로 변환

df['grade'] = df['grade'].replace('1.01', '1')

(5) 논리적 오류 데이터 삭제

viewed == False인데 explored 또는 certified == True → 불가능한 케이스 → 삭제
nevents가 197,757회인 데이터(이상치) → 삭제
last_event_DI < start_time_DI (시간 역전) → 삭제

drop_index = df[(df['viewed']==False)&((df['explored']==True)|(df['certified']==True))].index
df = df.drop(index=list(drop_index)).reset_index(drop=True)

drop_index = df[df['nevents']==197757].index
df = df.drop(index=list(drop_index)).reset_index(drop=True)

drop_index = df[(df['last_event_DI'].notna()) & (df['start_time_DI'].notna()) &(df['last_event_DI'] < df['start_time_DI'])].index
df = df.drop(index=list(drop_index)).reset_index(drop=True)

4️⃣ 파생변수 생성

데이터를 더 분석하기 쉽게 새로운 컬럼들을 추가했습니다.

(1) 대학, 강의 코드, 학기, 연도

uni_course_seme = df['course_id'].str.split('/', expand=True)
uni_course_seme.columns = ['university', 'course_code', 'semester']
date = uni_course_seme['semester'].str.split('_', expand=True)
date.columns = ['year', 'semester']

new_col = pd.concat([uni_course_seme[['university','course_code']], date], axis=1)
df_f = pd.concat([df, new_col], axis=1)

(2) 강의명 매핑

course_dict = {
    "HarvardX/CB22x/2013_Spring": "The Ancient Greek Hero",
    "HarvardX/CS50x/2012": "Introduction to Computer Science",
    "HarvardX/ER22x/2013_Spring": "Justice",
    "HarvardX/PH207x/2012_Fall": "Health in Numbers: Quantitative Methods in Clinical & Public Health Research",
    "HarvardX/PH278x/2013_Spring": "Human Health and Global Environmental Change",
    "MITx/6.002x/2012_Fall": "Circuits and Electronics",
    "MITx/6.002x/2013_Spring": "Circuits and Electronics",
    "MITx/14.73x/2013_Spring": "The Challenges of Global Poverty",
    "MITx/2.01x/2013_Spring": "Elements of Structures",
    "MITx/3.091x/2012_Fall": "Introduction to Solid State Chemistry",
    "MITx/3.091x/2013_Spring": "Introduction to Solid State Chemistry",
    "MITx/6.00x/2012_Fall": "Introduction to Computer Science and Programming",
    "MITx/6.00x/2013_Spring": "Introduction to Computer Science and Programming",
    "MITx/7.00x/2013_Spring": "Introduction to Biology - The Secret of Life",
    "MITx/8.02x/2013_Spring": "Physics II: Electricity and Magnetism",
    "MITx/8.MReV/2013_Summer": "Mechanics ReView"
}

df_f['course_title'] = df_f['course_id'].map(course_dict)

(3) 학습일수(study_days)

df_f['study_days'] = (pd.to_datetime(df_f['last_event_DI']) - pd.to_datetime(df_f['start_time_DI'])).dt.days
df_f['study_days'] = df_f['study_days'].fillna(0).astype(int)

(4) 나이(age)

기준 연도 = 2013년

df_f['age'] = 2013 - df_f['YoB']

(5) 지역(region)

국가(final_cc_cname_DI)를 대륙 단위로 매핑

region_map = {
    'United States': 'North America',
    'Canada': 'North America',
    'Mexico': 'North America',
    'Other North & Central Amer., Caribbean': 'North America',
    'Brazil': 'South America',
    'Colombia': 'South America',
    'Other South America': 'South America',
    'France': 'Europe',
    'United Kingdom': 'Europe',
    'Germany': 'Europe',
    'Spain': 'Europe',
    'Greece': 'Europe',
    'Portugal': 'Europe',
    'Poland': 'Europe',
    'Ukraine': 'Europe',
    'Russian Federation': 'Europe',
    'Other Europe': 'Europe',
    'India': 'South Asia',
    'Pakistan': 'South Asia',
    'Bangladesh': 'South Asia',
    'Other South Asia': 'South Asia',
    'China': 'East Asia',
    'Japan': 'East Asia',
    'Other East Asia': 'East Asia',
    'Philippines': 'Southeast Asia',
    'Indonesia': 'Southeast Asia',
    'Egypt': 'Middle East & North Africa',
    'Morocco': 'Middle East & North Africa',
    'Other Middle East/Central Asia': 'Middle East & Central Asia',
    'Nigeria': 'Sub-Saharan Africa',
    'Other Africa': 'Sub-Saharan Africa',
    'Australia': 'Oceania',
    'Other Oceania': 'Oceania',
    'Unknown/Other': 'Unknown'
}

df_f['region'] = df_f['final_cc_cname_DI'].map(region_map)

(6) 연령대(age_group)

bins = [0, 19, 29, 39, 49, 59, 100]
labels = ['10대', '20대', '30대', '40대', '50대', '60대 이상']
df_f['age_group'] = pd.cut(df_f['age'], bins=bins, labels=labels, right=True)

5️⃣ 최종 저장

마지막으로 전처리 및 파생변수 생성이 완료된 데이터를 CSV로 저장했습니다.

✅ 정리

이번 전처리 과정에서는

결측치 및 이상치 처리
논리적 오류 데이터 제거
분석을 위한 파생변수 생성

까지 수행하여, 학습자 데이터를 분석 가능한 형태로 변환했습니다.

이제 이 데이터를 활용해 수강 패턴 분석, 학습 성과 예측, 학습자 세분화(클러스터링) 등을 진행할 수 있습니다

2025.08.18 추천시스템 & LLM 1회차 (과제)

kminx — Mon, 18 Aug 2025 17:33:06 +0900

과제

지금까지 콘텐츠 기반 필터링 프로세스에 대해 코드를 배웠습니다.

아래 스켈레톤 코드를 바탕으로 user_id를 입력 받았을 때 추천 웹툰을 반환하는 함수를 만들어봅시다.

조건

TF-IDF로 'keyword' 컬럼 기준 웹툰을 벡터화한다.
사용자가 읽은 웹툰들의 평균 벡터를 계산해서 사용자 벡터를 만든다.
사용자 벡터와 전체 웹툰 벡터 간의 유사도를 계산한다.
아직 읽지 않은 웹툰 중에서 상위 5개를 추천한다.

1. TF-IDF로 keyword 컬럼 벡터화를 진행할 것이기에 필요한 라이브러리를 import하고, 사용할 데이터를 불러온다.

from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.metrics.pairwise import cosine_similarity
import numpy as np
import pandas as pd

webtoon = pd.read_csv('/content/drive/MyDrive/Colab Notebooks/스파르타/llm세션/1강/cbf_webtoon_data.csv')
user_logs = pd.read_csv('/content/drive/MyDrive/Colab Notebooks/스파르타/llm세션/1강/cbf_user_logs.csv')

이때, webtoon과 user_logs는 아래와 같은 데이터이다.

2. 각 웹툰에 대한 TF-IDF 벡터를 생성하고, user_id 별로 데이터를 묶어준다.

tfidf = TfidfVectorizer()
tfidf_matrix = tfidf.fit_transform(webtoon['keyword'])
user_read_webtoons = user_logs.groupby('user_id')['webtoon_id'].apply(set).reset_index()

3. 입력된 사용자가 본 웹툰 목록을 정의한다.

이 때, 사용자 정보가 없거나, 사용자의 시청 기록이 없는 경우도 고려한다.

user_data = user_read_webtoons[user_read_webtoons['user_id'] == user_id]
if user_data.empty:
    return print(f"{user_id}의 사용자 정보가 없습니다.")

user_read_webtoonids = list(user_data['webtoon_id'].iloc[0])
if not user_read_webtoonids:
    return print(f"{user_id}의 시청 기록이 없습니다.")

4. 사용자가 본 웹툰들의 TF-IDF 평균을 구해 사용자 벡터를 구한다.

user_vector = tfidf_matrix[user_read_webtoonids].mean(axis=0)
user_vec = np.asarray(user_vector)

5. 사용자 벡터와 전체 웹툰과의 유사도를 계산한다.

cos_sim = cosine_similarity(user_vec,tfidf_matrix)
recommend_indicies = cos_sim.argsort()[0][::-1]

6. 사용자가 이미 본 웹툰을 제외한 상위 N개의 웹툰 목록을 반환한다.

recommend_indicies = [i for i in recommend_indicies if i not in user_read_webtoonids]

top_n_webtoons = recommend_indicies[:top_n]

print(f'{user_id}에게 추천하는 웹툰 Top {top_n}')
recommended_webtoons = webtoon.loc[top_n_webtoons][['webtoon_title', 'main_genre']]

최종코드

# HINT : 웹툰을 벡터화하는 연산은 추천 함수 안에 들어갈 필요가 없습니다. (모든 사용자가 공통으로 사용하는 값이기 때문에)
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.metrics.pairwise import cosine_similarity
import numpy as np
import pandas as pd

webtoon = pd.read_csv('/content/drive/MyDrive/Colab Notebooks/스파르타/llm세션/1강/cbf_webtoon_data.csv')
user_logs = pd.read_csv('/content/drive/MyDrive/Colab Notebooks/스파르타/llm세션/1강/cbf_user_logs.csv')

# 1. 웹툰 아이템에 대한 TF-IDF 벡터 생성 및 user_id 그룹화
tfidf = TfidfVectorizer()
tfidf_matrix = tfidf.fit_transform(webtoon['keyword'])
user_read_webtoons = user_logs.groupby('user_id')['webtoon_id'].apply(set).reset_index()

# 2. 추천 함수 정의
def cbf_recommend(user_id, top_n=5) :
  # (1) 해당 유저가 본 웹툰 목록 정의
    user_data = user_read_webtoons[user_read_webtoons['user_id'] == user_id]
    if user_data.empty:
        return print(f"{user_id}의 사용자 정보가 없습니다.")

    user_read_webtoonids = list(user_data['webtoon_id'].iloc[0])
    if not user_read_webtoonids:
        return print(f"{user_id}의 시청 기록이 없습니다.")

  # (2) 사용자가 본 웹툰들의 TF-IDF 벡터 평균을 통해 사용자 벡터 구하기
    user_vector = tfidf_matrix[user_read_webtoonids].mean(axis=0)
    user_vec = np.asarray(user_vector)

  # (3) 전체 웹툰과의 유사도 계산
    cos_sim = cosine_similarity(user_vec,tfidf_matrix)
    recommend_indicies = cos_sim.argsort()[0][::-1]

  # (4) 사용자가 이미 본 웹툰 제외하기
    recommend_indicies = [i for i in recommend_indicies if i not in user_read_webtoonids]

  # (5) 유사도 기준으로 top-N 웹툰 추천하기
    top_n_webtoons = recommend_indicies[:top_n]

  # (6) 결과 반환 (DataFrame, webtoon_title과 main_genre 포함)
    print(f'{user_id}에게 추천하는 웹툰 Top {top_n}')
    recommended_webtoons = webtoon.loc[top_n_webtoons][['webtoon_title', 'main_genre']]

    return recommended_webtoons

cbf_recommend('user_1',5)

2025.08.18 추천시스템 & LLM 1회차

kminx — Mon, 18 Aug 2025 10:49:35 +0900

추천 시스템 개요와 장바구니 분석, 콘텐츠 기반 추천에 대해 알아보자.

️ 실습 코드

실습 코드

1️⃣ 추천 시스템

추천 시스템이란 수많은 선택지 중에 어떤 것을 선택하면 좋을지 의사결정을 도와주는 기술로 넷플릿스, 쿠팡 등 다양한 기업에서 관심을 가지고 있는 분야다.

2️⃣ 장바구니 분석

장바구니 분석이란 연관성에 기인한 새로움을 찾는 분석이다.

A를 샀을 때 B도 살 호가률이 높다면 B를 추천하는 방식으로 진행되는데 과연 얼마나 많은 사람이 그런 행동을 했을 때, 연관이 있다고 판단할까?

용어	설명
지지도 (Support)	특정 규칙이 얼마나 자주 발생하는지 = 규칙의 일반성
신뢰도 (Confidence)	X를 구매한 사람 중 Y도 함께 구매한 비율 = 규칙의 신뢰성
향상도 (Lift)	X와 Y의 관계가 정말로 유의미한지, 또는 단순히 우연에 의한 것인지 평가

향상도 해석
- 향상도 = 1 : X와 Y는 서로 독립적이다. 즉, X를 구매한다고 해서 Y를 구매할 가능성이 높아지지 않는다.
- 향상도 > 1 : X와 Y는 양의 상관관계를 가진다. X를 구매하면 Y를 구매할 확률이 증가한다.
- 향상도 < 1 : X와 Y는 음의 상관관계를 가진다. X를 구매하면 Y를 구매할 확률이 감소한다.

장점:

이해와 해석이 매우 직관적
데이터가 적어도 사용 가능하고 복잡한 모델 없이 규칙 생성 가능
실제 마케팅/프로모션 전략에 바로 활용 가능
콜드 스타트 문제에 대응 가능해 초기 추천 시스템에 적합

단점

개인화된 추천이 불가능 (모든 사용자에게 동일한 규칙 적용)
시간의 흐름(구매 순서, 시점 등)을 반영하지 못함
설정값에 따라 결과가 크게 달라지며 아이템 수가 많아질수록 규칙 수가 폭증 (계산 비용 증가)
맥락(날씨, 요일, 상황 등)을 고려하지 않음

장바구니 분석은 추천 시스템의 입문 단계로 적합한 추천 방식 추천이 왜 발생했는지 쉽게 설명할 수 있고, 데이터가 적어도 활용할 수 있다는 장점이 있다.
하지만 개인화가 어렵고 시계열이나 맥락 정보를 반영하기 어렵다는 점에서 고도화된 추천 시스템에는 한계가 있다.

3️⃣ 콘텐츠 기반 필터링

콘텐츠 기반 필터링은 아이템의 특징을 분석해서 사용자에게 비슷한 콘텐츠를 추천하는 방법이다.

콘첸트 기반 필터링 흐름

각 아이템의 특징 추출 (텍스트, 태그 등)
예: 장르, 키워드, 설명, 카테고리 등
특징을 벡터화 (TF-IDF, Word2Vec, BERT 등)
→ 컴퓨터가 비교 가능하도록 수치화
사용자가 좋아한 아이템들의 벡터 평균 생성
→ “사용자 취향 벡터” 생성
다른 아이템들과 유사도 계산
→ 가장 비슷한 콘텐츠를 추천

이때 특징을 벡터화하는 것이란 아이템의 특징을 수치로 변환하는 과정으로 TF-IDF와 임베딩을 사용할 수 있다.

TF-IDF (Term Frequency - Inverse Document Frequency)

문서에서 단어(키워드)의 중요도를 측정하는 기법
특정 단어가 문서 내에서 자주 등장하지만(Term Frequency) 모든 문서에서 흔히 등장하는 단어라면 중요도가 낮음(Inverse Document Frequency)을 반영하는 방식
⇒ 특정 문서에서 많이 등장하지만, 다른 문서에서는 드문 단어일수록 중요한 단어로 간주 (단어의 중요도를 벡터에 반영, But 의미를 반영하진 않음)
특징
- 간단하고 빠르게 구현 가능하며, 어떤 단어가 중요해서 추천되었는지 해석 가능해 설명 가능성이 높음
- 작은 데이터셋에서도 작동하고 학습이 불필요해 효율적인 추천이 가능함
- 의미 반영이 불가하기 때문에 유사도 계산에 있어서 한계가 있고, 대부분의 값이 0인 희소 벡터가 되기 때문에 계산 비효율성이 증가함
- 사용자별 개인 취향을 반영하기 어렵고 OOV(Out of Vocabulary) 문제가 발생함

임베딩 (Embedding)

학습을 통해 데이터 간 의미적 관계를 유지하면서, 각 항목을 연속적인 벡터 공간에 표현하는 과정
단순한 숫자 변환이 아니라 유사한 데이터끼리 가깝게 배치
임베딩의 차원을 너무 낮게 설정하면 충분한 정보를 학습할 수 없고, 너무 높기 설정하면 과적합(overfitting) 위험 발생

Word2Vec

단어를 ‘의미 있는 벡터 공간’에 매핑하는 임베딩 기법
단어들이 함께 등장하는 문맥(Context)을 학습해, 의미적으로 비슷한 단어들이 가까운 벡터로 매핑됨
사용 방식
- 사전 학습(pretrained) : 빠르고 일반적 의미 반영할 수 있지만 맥락 반영이 어려움
- 직접 학습(custom) : 도메인 특화 의미 반영 가능하지만 많은 말뭉치 필요하고 학습 과정에서 리소스가 필요함
특징
- 의미를 반영한 추천 가능하며 유사도를 계산할 수 있음 (예: 유사한 강의명, 설명 간 거리 계산)
- 비정형 텍스트 기반 추천에 효과적
- OOV 문제가 발생할 수 있고 사용자 맞춤형 벡터 표현은 어려움
- 학습데이터가 많아야 품질이 높아짐

BERT 등 LLM 기반 임베딩

문맥(Context)을 반영하는 동적 임베딩
BERT 등의 LLM 기반 임베딩 모델은 동일한 단어라도 문맥에 따라 다른 벡터를 생성
- Word2Vec은 ‘밤’이라는 단어가 항상 동일한 벡터로 표현되는 반면 BERT는 ‘군밤’에서의 밤과 ‘밤바다’에서의 밤을 다른 의미로 벡터화 가능
- 단어뿐 아니라 전체 문장의 의미를 반영한 문장 임베딩도 가능
Self-Attention 기반 구조 : 문장 전체를 동시에 이해하면서 각 단어의 의미를 문맥 속에서 해석
검색, 유사도 계산, 자연어 이해 등에 강력한 성능을 보임

정적 vs 문맥 임베딩 비교

항목	Word2Vec (정적)	BERT 등 (문맥 기반)
벡터 고정 여부	항상 동일한 벡터	문맥 따라 동적 벡터 생성
문맥 반영	X	O
추천/검색 정확도	낮음	높음 (특히 문장/문서 단위)
학습 필요 여부	직접 학습 or 사전 모델 사용	사전 모델 사용 권장

학습량이 적당하고, 문맥보단 단어 간 연관이 중요한 경우(예: 제품명, 진단코드 등)와 같은 도메인 특화 데이터나 빠르고 가벼운 모델이 필요한 경우 Word2Vec을 사용할 수 있음
LLM의 발전에 따라 BERT 등 문맥을 반영할 수 있는 대형 임베딩 모델이 선호되는 추세

임베딩은

추천시스템에서 단순한 데이터 변환이 아니라, 사용자와 아이템 간의 관계를 학습하는 핵심 기술

LLM에서 텍스트 데이터를 숫자로 변환하고 의미적 관계를 학습하는 핵심 요소

이렇게 임베딩된 벡터들은 사용자가 이전에 좋아한 콘텐츠와 비슷한 아이템을 찾아주기 위해 ‘비슷한 정도(유사도)’를 계산해야 한다.

이를 위해 코사인 유사도, 유클리디안 거리. 자카드 유사도가 상황에 맞게 사용된다.

희소(Sparse) 데이터란? 데이터에서 실제 의미 있는 값(Non-zero 값)의 비율이 매우 낮은 경우 추천시스템은 대부분 Sparse 한 데이터를 다룬다! (아이템이 넘쳐나니까)

코사인 유사도 vs 유클리디안 거리
→ 코사인 유사도는 방향만 고려, 유클리디안 거리는 크기까지 고려.
코사인 유사도 vs 자카드 유사도
→ 코사인 유사도는 연속형 벡터 비교, 자카드 유사도는 태그(이진값) 기반 비교.
유클리디안 거리 vs 자카드 유사도
→ 유클리디안 거리는 거리(절대값 차이), 자카드 유사도는 공통 요소 비율.

콘텐츠 기반 필터링

1. 아이템 속성과 아이템에 대한 사용자 선호 속성(콘텐츠) 데이터를 만든다.
2. Feature 를 적절하게 벡터화 한다.
3. 유사도를 계산해 유사한 아이템을 추천한다.

장점
- 개인의 취향 반영 : 사용자의 과거 기록을 기반으로 개인화된 추천
- 아이템 콜드 스타트 문제 없음 : 신규 사용자라도 콘텐츠 기반으로 추천 가능
- 추천 이유 설명 가능 : 어떤 특징이 비슷해서 추천했는지 설명할 수 있음
단점
- 콘텐츠 정보 의존 : 콘텐츠 정보가 부실하거나 누락되면 추천 어려움
- 취향 확대 어려움 : 사용자가 선호하던 범위 내에서만 추천이 반복됨 (Serendipity 부족)
- 사용자 콜드 스타트 문제 : 사용자의 로그(선호 콘텐츠)가 없으면 사용자 벡터 생성 불가 → 미리 선호 취향 받기
- 넷플릭스에 처음 가입했을 때 관심 있는 콘텐츠 클릭

⇒ 콘텐츠 자체에 집중하기 때문에 개인화에 강하고 설명이 가능하지만, 새로운 취향을 발견하는 데 한계가 있음. 이후 나올 협업 필터링 등 다른 모델과 결합한 하이브리드 방식 도입 추세

CH 3. 심화 프로젝트 - 데이터전처리

kminx — Thu, 17 Jul 2025 21:55:01 +0900

사용하는 데이터

데이터

1. card_data.csv

컬럼	설명
id	카드 ID(카드 고유 식별자)
client_id	고객 ID
card_brand	카드 브랜드
card_type	카드 유형
card_number	카드 번호
expires	만료기간
cvv	카드 보안 코드
has_chip	칩 유무(마그네틱 카드와 IC카드 구분)
num_cards_issued	발급된 카드 총 개수
credit_limit	카드 한도
acct_open_date	계좌 개설 날짜
year_pin_last_changed	PIN 마지막 변경 연도
card_on_dark_web	다크웹에서 카드 정보 발견 여부

2. transactions_data.csv

컬럼	설명
id	거래 고유 ID
date	거래 날짜
client_id	고객 ID
card_id	사용된 카드 ID
amount	거래 금액
use_chip	칩 사용 여부
merchant_id	가맹점 고유 ID.
merchant_city	가맹점 위치(도시)
merchant_state	가맹점 위치(주)
zip	가맹점 우편번호
mcc	가맹점 업종 코드 : 금융 서비스에서 제공하는 상품 또는 서비스 유형에 따라 부여되는 4자리 숫자입니다.
errors	거래 중 발생한 오류 (있다면 상세 코드)

3. users_data.csv

컬럼	설명
id	고객 ID
current_age	나이
retirement_age	예상 은퇴 나이
birth_year	출생 연도
birth_month	출생 월
gender	성별
address	주소
latitude	주소의 위도
longitude	주소의 경도
per_capita_income	1인당 소득
yearly_income	연간 소득
total_debt	총 부채
credit_score	신용 점수
num_credit_cards	보유 신용카드 수

데이터 설명

고객 정보, 거래 정보, 카드 정보를 담은 3가지 데이터가 존재한다.

해당 데이터는 각 client_id, card_id를 통해 merge 할 수 있다.

과제 설명

데이터셋은 총 3개의 CSV 파일로 구성되어 있습니다.

해당 데이터셋은 2024년 AI 해커톤을 위해 만들어졌습니다.
테이블 간 관계를 파악하여, 클러스터링을 위한 하나의 Dataframe 으로 만들어주세요.

필수 사항

이상치 처리 기법을 활용하거나, 특정 기준을 세워 이상치를 정의 하고 그 이유를 설명해주세요.
클러스터링시, 초기 군집의 갯수와 사용할 컬럼의 갯수는 python 머신러닝 라이브러리를 활용하여 진행해주세요.
컬럼별 raw data 분포를 그려주세요.
컬럼 간 상관계수를 히트맵 차트로 구현해주세요.(유의미한 기준은 +0.6(양의 상관관계) 또는 -0.6(음의 상관관계)으로 판단해주시면 됩니다)

선택 사항

필요하다면 파생변수를 생성해도 좋습니다.
데이터 표준화가 필요한 경우 진행해주세요. 표준화 방법을 여러가지 사용해보시고, 비교해주셔도 됩니다.
범주형 데이터를 사용할 경우, 인코딩을 진행해주세요. 원-핫 인코딩/라벨인코딩 모두 사용해도 됩니다. 다만, 범주의 갯수가 많은 경우, 별도 세그멘테이션이 필요할 수 있겠습니다. 의미있는 기준을 세워주시고 그 값을 인코딩 진행해주세요. (예시: 국가가 100개인 경우 육대륙으로 나누어 인코딩). 참고자료: https://nicola-ml.tistory.com/62#google_vignette
분석 결과를 한 눈에 파악할 수 있도록 datapane 또는 streamlit 으로 리포트를 구현해주세요.

분석 목표: 리스크 관리 전략 수립

분석 방향

아래 2가지 리스크를 고려하였다.

1. 신용 리스크

신용 점수, 부채 등 칼럼을 사용해 고객의 신용 리스크 별로 군집을 구하자.

그 중 고위험군, 즉 채무 불이행 가능이 높은 고객에게 대응하는 방법을 탐색하자.

2. 운영 리스크

보안 측면에서의 고객 군집을 구하자.

그 중 보안이 취약해 보이는 고객에게 대응하는 방법을 탐색하자.

데이터에 존재하는 결측치는 일단 신경쓰지 않고 진행하였다.

why? 우리가 사용할 컬럼에 속해있지 않았기 때문이다.

1. Card Data

Null 값은 존재하지 않았다.

추가로 object 타입의 데이터를 살펴보니 'credit_limit'이 '$문자열' 형태로 되어있어 이를 숫자형으로 변환하였다.

category_card = card.select_dtypes(['object'])
for c in category_card.columns:
    if c not in ['acct_open_date', 'expires']:
        print(f'{c}: {card[c].unique()}')
        
# 문자열 제거
card['credit_limit'] = pd.to_numeric(card['credit_limit'].str.replace('$',''), errors='coerce')

아래의 4가지 경우를 이상치가 될 수 있다고 판단했다.

1. 카드 번호가 16/15자리인지
2. cvv 번호가 3/4자리인지
3. expires가 acct_open_date보다 빠른 경우
4. year_pin_last_changed가 acct_open_date보다 빠른 경우

-> cvv 번호가 2번에 해당하는 이상치가 존재해 제거

추가로 수치형 데이터를 Boxplot을 통해 살펴보았을 때, 일부 이상치가 있다고 나오지만

신용한도가 높은 경우는 고소득층에겐 가능하다 생각하여 이상치로 판단하지 않았다.

numeric_card_col = ['num_cards_issued','credit_limit', 'year_pin_last_changed']

fig, ax = plt.subplots(1,3,figsize=(10,4))
ax = ax.flatten()

for i,c in enumerate(numeric_card_col):
    ax[i].boxplot(card[c])
    ax[i].set_title(f'{c}의 Boxplot')
    ax[i].tick_params(axis='x', rotation=45)

plt.tight_layout()
plt.show()

2. User Data

card 데이터와 마찬가지로 null 값이 없으며, 가격을 뜻하는 컬럼의 불필요한 문자열을 제거하고 수치형 데이터로 변환하였다.

category_user = user.select_dtypes(['object'])
for c in category_user.columns:
    print(f'{c}: {user[c].unique()}')
    
# 타입 변경
user['per_capita_income'] = pd.to_numeric(user['per_capita_income'].str.replace('$',''), errors='coerce')
user['yearly_income'] = pd.to_numeric(user['yearly_income'].str.replace('$',''), errors='coerce')
user['total_debt'] = pd.to_numeric(user['total_debt'].str.replace('$',''), errors='coerce')

user 데이터의 이상치를 탐지하기 위해 Boxplot을 그려보면

소득에 관련된 데이터를 제외하면, 충분히 가능한 수치라 생각해서 'per_capita_income', 'yearly_income'만 고려한다.

IQR 이상치 제거를 수행하려고 했는데, 낮은 값에 치중이 되어있었고, 소득이 비정상적으로 낮은게 높은 것 보다 이상하다고 생각하여 로그변환을 수행해 Q1 - 1.5*IQR보다 작은 값을 제거해주었다.

fig, ax = plt.subplots(1,2,figsize=(12,4))
sns.histplot(user['yearly_income'], bins=50, ax=ax[0])
ax[0].set_title('yearly_income')
ax[0].tick_params(axis='x', rotation=45)

sns.histplot(user['per_capita_income'], bins=50, ax=ax[1])
ax[1].set_title('per_capita_income')
ax[1].tick_params(axis='x', rotation=45)

plt.show()

# 로그 변환
user['log_yearly_income'] = np.log(user['yearly_income'] + 1)  # 0 대비 +1 처리
user['log_per_capita_income'] = np.log(user['per_capita_income'] + 1)  # 0 대비 +1 처리

fig, ax = plt.subplots(1,2,figsize=(12,4))
sns.histplot(user['log_yearly_income'], bins=50, ax=ax[0])
ax[0].set_title('log_yearly_income')
ax[0].tick_params(axis='x', rotation=45)

sns.histplot(user['log_per_capita_income'], bins=50, ax=ax[1])
ax[1].set_title('log_per_capita_income')
ax[1].tick_params(axis='x', rotation=45)

plt.show()

# 연간 소득 이상
q1 = user['log_yearly_income'].quantile(0.25)
q3 = user['log_yearly_income'].quantile(0.75)
iqr = (q3 - q1)
user.drop(index=list(user[user['log_yearly_income']<=q1- 1.5*iqr].index), inplace=True)

# 1인 소득 이상
q1 = user['log_per_capita_income'].quantile(0.25)
q3 = user['log_per_capita_income'].quantile(0.75)
iqr = (q3 - q1)

user.drop(index=list(user[user['log_per_capita_income']<=q1- 1.5*iqr].index), inplace=True)

3. Transaction Data

우선 거래날짜 컬럼으로 거래년도, 거래월, 거래요일 컬럼을 추가 생성했다.

이후에 결측치를 찾았을 때, 존재하긴 했지만 우리가 이후에 사용할 컬럼에는 존재하지 않았기에 그냥 무시해주었다.

'errors' 컬럼의 존재하는 Nan 값은 에러가 발생하지 않았다는 의미로 'No'로 Nan 값을 채워주었다.

또한, Insufficient Balance인 상태만 필요하기에 나머지는 'Other'로 변경해주었다.

def error_category(x):
    if 'Insufficient Balance' in x:
        return 'Insufficient Balance'
    elif x == 'No':
        return x
    else:
        return "Other"
    
trans['errors'] = trans['errors'].apply(error_category)

Transaction도 앞선 데이터와 같이 가격 데이터를 필요없는 문자열 제거 후 수치형으로 변경하였다.

# 문자열 제거
trans['amount'] = pd.to_numeric(trans['amount'].str.replace('$',''), errors='coerce')
trans.head()

수치형 데이터를 가지고 Boxplot을 그렸을 때, 값이 -가 나오는 데이터가 존재하였다.

그러나, 이를 동일 client_id와 card_id, merchant_id인 데이터와 비교하니 결제 취소 데이터임을 파악하였다.

2025.07.11 문제 풀이 (114)

kminx — Fri, 11 Jul 2025 09:56:44 +0900

문제 풀 때 조심할 부분
1. 테스트 케이스에 없는 내용도 꼼꼼하게 생각하기

문제 풀이

114. Exchage Seats

문제

풀이

WITH swap_id AS(
    SELECT id, student, 
        CASE
            WHEN id % 2 =0 THEN id - 1
            WHEN id % 2 != 0 THEN id + 1
        END s_id
    FROM Seat
    )
SELECT swap_id.id, COALESCE(Seat.student, swap_id.student) student 
FROM swap_id LEFT JOIN Seat ON swap_id.s_id = Seat.id
ORDER BY 1

42일차 - 머신러닝 5주차

kminx — Thu, 10 Jul 2025 21:33:02 +0900

머신러닝

5주차 - 앙상블

1️⃣ 앙상블이란

앙상블은 여러 개의 모델을 조합하여, 하나의 모델보다 더 좋은 예측 성능을 내는 방법이다.

앙상블 사용하는 이유

서로 다른 모델을 결합함으로써 오류를 줄일 수 있다.
개별 모델의 편향과 분산을 상호 보완할 수 있다.

배깅과 부스팅이 이에 속한다.

배깅(Bagging)

학습 데이터를 무작위로 여러 부분 샘플(부트스트랩)로 나누어 각각 독립적으로 모델을 학습
예측 시에는 여러 모델의 결과를 평균(회귀) 혹은 다수결(분류)로 결정
예시
- 랜덤 포레스트(분류, 회귀 둘 다 가능)
  3
장점
- 각 모델이 독립적으로 학습되므로 병렬 처리 가능 (학습 속도가 상대적으로 빠름)
- 모델 간 상호 간섭이 적어 안정적
- 과적합을 줄여주는 효과 (예측의 분산 감소)
단점
- 많은 수의 모델을 학습해야 하므로 메모리 사용량이 많아질 수 있음
- 해석이 어려움

from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import accuracy_score, confusion_matrix, classification_report

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

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

# 3. 랜덤 포레스트 모델 생성
# n_estimators는 사용할 트리의 개수, max_depth는 각 트리의 최대 깊이를 의미하며
# 위 2개의 값을 높일 수록 시간과 연산량은 늘어나지만 더욱 복잡한 특징을 잡을 수 있음
rf_model = RandomForestClassifier(
    n_estimators=100,
    max_depth=None,
    random_state=42
)

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

# 5. 예측
y_pred = rf_model.predict(X_test)

# 6. 성능 평가
acc = accuracy_score(y_test, y_pred)
cm = confusion_matrix(y_test, y_pred)
report = classification_report(y_test, y_pred)

print(f"Accuracy: {acc:.4f}")
print("Confusion Matrix:\n", cm)
print("Classification Report:\n", report)

부스팅(Boosting)

순차적으로 모델을 학습하면서 이전 모델이 만든 예측 오류를 보정하도록 설계
각각의 모델은 이전 모델이 틀린 부분에 가중치를 더 둬서 학습
대표 알고리즘 - 분류 회귀 모두 가능
1. XGBoost (Extreme Gradient Boosting)
2. LightGBM
3. CatBoost
장점
- 높은 정확도 달성 가능
- 각 단계에서의 오류를 보정하기 때문에, 복잡한 데이터 패턴을 잘 포착
단점
- 순차적(Sequential)으로 학습하므로 병렬화가 쉽지 않음
- 하이퍼파라미터가 많고 튜닝이 까다롭다
작동 예시(XGBoost) 간단 시나리오
1. 기본 모델(약한 결정 트리) 훈련 → 예측 오류 확인
2. 예측 오류가 컸던 샘플에 높은 가중치 부여
3. 다음 모델(결정 트리) 훈련 → 다시 오류 보정
4. 이 과정을 여러 번 반복하여, 최종 예측 시에는 모두 합산

# 1. 데이터 준비 (Titanic 예시: 범주형 컬럼 존재)
from sklearn.datasets import fetch_openml
import pandas as pd
import numpy as np

# OpenML에서 Titanic 데이터셋 로드
titanic = fetch_openml('titanic', version=1, as_frame=True)
df = titanic.frame

# 주요 컬럼만 사용하고, 결측치가 있는 행 제거(XGB와 Light GBM을 위해)
# pclass(객실 등급, 범주형), sex(성별, 범주형), age(나이, 연속형), fare(티켓 요금, 연속형)
# embarked(탑승항구, 범주형), survived(생존 여부, 타깃)
df = df[['pclass', 'sex', 'age', 'fare', 'embarked', 'survived']]
df.dropna(inplace=True)

# 입력(X), 타깃(y) 분리
X = df.drop('survived', axis=1)
y = df['survived'].astype(int)  # survived 컬럼을 int형으로 변환

# 2. 데이터 전처리
#    XGBoost/LightGBM은 숫자형 입력만 허용하므로, 범주형 칼럼을 인코딩
from sklearn.preprocessing import LabelEncoder

cat_cols = ['sex', 'embarked']  # 범주형으로 간주할 컬럼들
for col in cat_cols:
    le = LabelEncoder()
    X[col] = le.fit_transform(X[col])

# 3. 학습/테스트 데이터 분할
from sklearn.model_selection import train_test_split

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

# 4. XGBoost 실습
# (설치가 필요할 수 있습니다) ! pip install xgboost
from xgboost import XGBClassifier
from sklearn.metrics import accuracy_score, confusion_matrix, classification_report

xgb_model = XGBClassifier(random_state=42)
xgb_model.fit(X_train, y_train)
y_pred_xgb = xgb_model.predict(X_test)

print("=== XGBoost ===")
print("Accuracy:", accuracy_score(y_test, y_pred_xgb))
print("Confusion Matrix:\n", confusion_matrix(y_test, y_pred_xgb))
print("Classification Report:\n", classification_report(y_test, y_pred_xgb))

# 5. LightGBM 실습
# (설치가 필요할 수 있습니다) ! pip install lightgbm
from lightgbm import LGBMClassifier

lgb_model = LGBMClassifier(random_state=42)
lgb_model.fit(X_train, y_train)
y_pred_lgb = lgb_model.predict(X_test)

print("\n=== LightGBM ===")
print("Accuracy:", accuracy_score(y_test, y_pred_lgb))
print("Confusion Matrix:\n", confusion_matrix(y_test, y_pred_lgb))
print("Classification Report:\n", classification_report(y_test, y_pred_lgb))

################################################################################## 
# 설치 필수!
! pip install catboost

# 6. CatBoost 실습 (범주형 특성 직접 지정 예시)
#    -> 별도의 인코딩 없이도 'cat_features' 인덱스를 지정 가능
# 이전 예시에선 이미 LabelEncoder로 숫자로 바꿨지만,
# CatBoost는 원본 범주형(문자열) 상태로도 학습 가능.

from catboost import CatBoostClassifier

# CatBoost용 데이터 준비: 원본 df에서 결측 제거(위에서 한 것 동일)
df_cat = titanic.frame[['pclass', 'sex', 'age', 'fare', 'embarked', 'survived']].dropna()
X_cat = df_cat.drop('survived', axis=1)
y_cat = df_cat['survived'].astype(int)

# cat_features 인덱스: 'sex', 'embarked' 컬럼(원본 df에서의 컬럼 인덱스)
# DataFrame 사용 시에는 컬럼 이름이 아니라 "열의 위치"를 지정해야 함
#   - pclass : 0, sex: 1, age: 2, fare: 3, embarked: 4
cat_features_idx = [1, 4]

X_cat_train, X_cat_test, y_cat_train, y_cat_test = train_test_split(
    X_cat, y_cat, test_size=0.2, random_state=42, stratify=y_cat
)

cat_model = CatBoostClassifier(
    cat_features=cat_features_idx,
    verbose=1,           # 학습과정 확인 가능
    random_state=42
)
cat_model.fit(X_cat_train, y_cat_train)
y_pred_cat = cat_model.predict(X_cat_test)

print("\n=== CatBoost ===")
print("Accuracy:", accuracy_score(y_cat_test, y_pred_cat))
print("Confusion Matrix:\n", confusion_matrix(y_cat_test, y_pred_cat))
print("Classification Report:\n", classification_report(y_cat_test, y_pred_cat))

2️⃣ 하이퍼파라미터 튜닝

하이퍼파라미터란 모델이 학습을 시작하기 전에 사람이 설정해야 하는 값을 의미한다.

튜닝 방법

Grid Search

미리 정의된 하이퍼파라미터 후보들의 ‘모든 조합’을 시도
장점: 완전 탐색이므로 최적값을 놓치지 않음
단점: 후보가 많아질수록 연산량이 급격히 증가

Randomized Search

임의로 샘플링된 하이퍼파라미터 조합을 일정 횟수만 시도
장점: 다양한 영역을 빠르게 탐색 가능, 속도 빠름
단점: 최적 조합을 정확히 찾지 못할 수도 있음

베이지안 최적화(Bayesian Optimization)

과거의 탐색 결과를 바탕으로 ‘가장 유망한 하이퍼파라미터 범위’를 중점적으로 탐색
장점: 탐색 시간이 더 짧고 효율적
단점: 구현 복잡도가 높음

from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split, GridSearchCV
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import accuracy_score

# 1. 데이터 로드
iris = load_iris()
X = iris.data
y = iris.target

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

# 3. 하이퍼 파라미터 후보군 설정
param_grid = {
    'n_estimators': [50, 100, 200],
    'max_depth': [None, 5, 10]
}

# 4. GridSearchCV 생성
rf = RandomForestClassifier(random_state=42)
grid_search = GridSearchCV(
    estimator=rf,
    param_grid=param_grid,
    cv=5,              # 교차검증(fold) 횟수
    scoring='accuracy',
    n_jobs=-1,          # 병렬 처리(가능한 모든 코어 사용)
)

# 5. 학습(그리드서치 수행)
grid_search.fit(X_train, y_train)

# 6. 최적 파라미터 및 성능 확인
print("Best Parameters:", grid_search.best_params_)
print("Best CV Score:", grid_search.best_score_)

# 7. 테스트 데이터 성능 확인
best_model = grid_search.best_estimator_
y_pred = best_model.predict(X_test)
test_acc = accuracy_score(y_test, y_pred)
print("Test Accuracy:", test_acc)

3️⃣ 머신러닝 추가 개념

최적화 (Optimization)

하이퍼파라미터 튜닝(GridSearchCV, RandomizedSearchCV 등)
피처 엔지니어링(새로운 파생 변수 생성, 불필요한 변수 제거)
과적합 방지(교차검증, 규제 적용, 드롭아웃 등)

배포 (Deployment)

학습 완료 모델을 운영 환경에 배포
API 서버 구축, 클라우드(AWS, GCP) 또는 엣지 디바이스(임베디드 환경)
지속적 모니터링으로 모델 성능이 저하될 경우 재학습 주기 설정

MLOps(머신러닝 운영)란?

Machine Learning + DevOps의 합성어
머신러닝 모델 개발부터 배포, 모니터링, 재학습, 롤백(Rollback) 등 전 과정을 자동화하고 효율적으로 운영하는 방법론

MLOps(머신러닝 운영)은 왜 중요할까?

프로젝트 완성 → 실제 운영 단계에서 지속적인 모니터링과 데이터/모델 업데이트가 필요

4️⃣ 모델 해석 가능성(Explainable AI, XAI)

머신러닝은 블랙박스 동작이라고 그 내부에서 어떤 작업이 일어났는지 알 수 없다.
그러나, 의료/금융 등 규제 산업에서는 왜 이런 결과가 나왔는지에 대한 설명을 요구한다.

주요 기법

LIME(Local Interpretable Model-agnostic Explanations)
SHAP(Shapley Additive Explanations)
Feature Importance 시각화(트리 기반 모델)

import matplotlib.pyplot as plt
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier

# 1. 데이터 로드
iris = load_iris()
X = iris.data
y = iris.target
feature_names = iris.feature_names

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

# 3. 랜덤 포레스트 모델 학습
rf = RandomForestClassifier(random_state=42)
rf.fit(X_train, y_train)

# 4. 피처 중요도 추출
importances = rf.feature_importances_

# 5. 시각화
plt.bar(range(len(importances)), importances)
plt.xticks(range(len(importances)), feature_names, rotation=45)
plt.xlabel("Feature")
plt.ylabel("Importance")
plt.title("Feature Importances in RandomForest")
plt.tight_layout()
plt.show()

# 가장 중요한 변수
most_important_idx = importances.argmax()
most_important_feature = feature_names[most_important_idx]
print("가장 중요한 변수:", most_important_feature)

5️⃣ 앙상블 실습 문제

다음 안내에 따라 Wine 데이터를 분류하는 실습을 진행해 보세요.

[실습 안내]

유방암 데이터셋을 사이킷런에서 불러오세요.
학습용/테스트용 데이터로 분할하세요.
XGBoost 분류 모델을 생성하여 학습하세요.
- random_state 를 지정해야 하는 경우 42로 지정하세요.
테스트 세트로 예측을 수행하고, 정확도(Accuracy), 혼동 행렬(Confusion Matrix), 분류 보고서(Classification Report) 등을 구해 성능 평가를 하세요.
피처 중요도를 시각화한 뒤, 그중 가장 중요한 변수가 무엇인지 찾아 출력하십시오.

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

from sklearn.datasets import load_breast_cancer
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score, confusion_matrix, classification_report
from xgboost import XGBClassifier

# 유방암 데이터셋 로드
data = load_breast_cancer()
X = data.data
y = data.target
feature_names = data.feature_names

df = pd.DataFrame(data.data, columns=data.feature_names)
# 타깃(target) 레이블을 새로운 컬럼으로 추가
df['target'] = data.target

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

# XGBClassifier
xgb_model = XGBClassifier(random_state=42)
xgb_model.fit(X_train, y_train)
y_pred_xgb = xgb_model.predict(X_test)

print("=== XGBoost ===")
print("Accuracy:", accuracy_score(y_test, y_pred_xgb))
print("Confusion Matrix:\n", confusion_matrix(y_test, y_pred_xgb))
print("Classification Report:\n", classification_report(y_test, y_pred_xgb))

rf = RandomForestClassifier(random_state=42)
rf.fit(X_train, y_train)

# 피처 중요도 추출
importances = rf.feature_importances_

# 시각화
plt.figure(figsize=(12,6))
plt.bar(range(len(importances)), importances)
plt.xticks(range(len(importances)), feature_names, rotation=45)
plt.xlabel("Feature")
plt.ylabel("Importance")
plt.title("Feature Importances in RandomForest")
plt.tight_layout()
plt.show()

# 가장 중요한 변수
most_important_idx = importances.argmax()
most_important_feature = feature_names[most_important_idx]
print("가장 중요한 변수:", most_important_feature)

추가팁

앙상블 전략 정리
- 배깅(Bagging) : 여러 모델을 병렬로 학습해 평균/투표로 결과 결합.
- 부스팅(Boosting) : 모델을 순차로 학습, 이전 오류를 단계적으로 보정.
- 복잡한 패턴·높은 성능이 필요할 때 유용.
과적합 vs 과소적합 대응법
- 과적합(Overshooting) ➜ 모델 복잡도 ↓, 정규화·드롭아웃·조기 종료·데이터 증강 활용.
- 과소적합(Undershooting) ➜ 모델 복잡도 ↑, 파라미터·에폭 늘려 학습 용량 확대.
- 두 지표(훈련·검증 성능) 간 격차를 비교해 빠르게 판단.
하이퍼파라미터 튜닝 가이드
- 후보 범위가 좁고 규칙적이면 GridSearchCV.
- 범위가 넓고 변수 많음 ➜ RandomizedSearchCV로 시간 절약.
- 최종 모델은 교차검증(cv) 점수가 가장 높은 조합을 채택.
Feature Importance 활용
- 트리 기반 모델(랜덤 포레스트·XGBoost 등)은 중요 변수 시각화로 해석력 확보.
- 비즈니스 의사결정에 “어떤 변수가 기여했는가?”를 설명할 때 효과적.
모델 선택 실전 팁
- 로지스틱 회귀: 빠르고 해석 용이 → 선형 경향·실시간 예측 등에 유리.
- 랜덤 포레스트 / XGBoost: 비선형·복잡 패턴에 강함 → 예측력 우선 과제에 적합.
- 데이터 규모·목적(해석 vs 예측)·연산 자원을 함께 고려.
앙상블 적용 시기
- 단일 모델 성능이 부족하고 예측 정확도가 핵심일 때(금융 사기 탐지·의료 진단 등).
- 데이터 패턴이 복잡하거나 잡음이 많을 때 효과가 크다.
학습률(learning_rate) 설정
- Boosting 계열의 업데이트 “한 걸음” 크기.
- 보통 0.1 ~ 0.01에서 시작 → 낮추면 안정, 높이면 빠르지만 불안정.
- learning_rate ↓ + estimator 수 ↑ 로 균형 맞추기도 함.
과적합 빠른 체크
- 훈련 vs 검증 지표 차이가 크면 과적합 의심.
- 조기 종료(Early Stopping) 모니터링으로 학습 도중 차이를 바로 확인.
앙상블 대안 고려
- 데이터·시간 제약이 크면 배깅(랜덤 포레스트) 로 간단히 성능을 올릴 수 있다.
- 실시간 처리·모델 크기 제약 땐 조정된 단순 모델이 더 적합할 수 있음.

2025.07.02 - [[스파르타]내일배움캠프 데이터 분석 트랙/Lecture] - 36일차 - 머신러닝 1주차

36일차 - 머신러닝 1주차

머신러닝 1주차 - 머신러닝이란?1️⃣ 머신러닝이란?머신러닝이란 컴퓨터가 데이터를 학습하여 패턴을 찾아내고, 새로운 데이터에 대해 예측이나 분류를 수행하는 기술이다. 머신러닝은 데

kminx.tistory.com

2025.07.02 - [[스파르타]내일배움캠프 데이터 분석 트랙/Lecture] - 36일차 - 머신러닝 2주차

36일차 - 머신러닝 2주차

머신러닝 2주차 - 데이터 전처리 (이론)1️⃣ 데이터 전처리 개요데이터 전처리란 데이터에서 불필요하거나 손실이 있는 부분을 처리하고, 분석 목적에 맞게 처리하는 과정이다. 이상치나 결

kminx.tistory.com

2025.07.10 - [[스파르타]내일배움캠프 데이터 분석 트랙/Lecture] - 42일차 - 머신러닝 3주차

42일차 - 머신러닝 3주차

머신러닝 3주차 - 회귀1️⃣ 회귀분석이란회귀 분석이란 종속변수(Y)와 하나 이상의 독립변수(X) 간의 관계를 추정하여, 연속형 종속변수를 예측하는 통계/머신러닝 기법회귀모델을 사용하는

kminx.tistory.com

2025.07.10 - [[스파르타]내일배움캠프 데이터 분석 트랙/Lecture] - 42일차 - 머신러닝 4주차

42일차 - 머신러닝 4주차

머신러닝 4주차 - 분류1️⃣ 분류 모델 개요지도학습이란?입력 데이터(특징, Feature)와 정답(Label)이 주어졌을 때, 모델이 정답을 예측하도록 학습하는 방식.회귀(연속값 예측)와 분류(범주 예측

kminx.tistory.com

42일차 - 머신러닝 4주차

kminx — Thu, 10 Jul 2025 18:37:48 +0900

머신러닝

4주차 - 분류

1️⃣ 분류 모델 개요

지도학습이란?

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

분류(Classification)의 정의

분류의 목적
- 데이터가 어느 범주(클래스)에 속하는지 예측.
- ex) 스팸 메일 분류(스팸/정상), 질병 여부(양성/음성), 제조 공정 품질(불량/정상) 등.
분류 문제를 해결하기 위해 자주 활용되는 알고리즘 : Logistic Regression, SVM

분류 모델이 많이 쓰이는 이유

이진 분류(양성/음성, 합격/불합격, 정상/불량 등)는 직관적이고 다양한 산업에서 필요함.
데이터 분석에서 가장 먼저 접하는 모델 중 하나.

2️⃣ 주요 분류 모델

로지스틱 회귀(Logistic Regression)

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

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

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

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

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

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

# 5. 성능 평가

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

SVM(Support Vector Machine)

데이터를 가장 잘(안전 여유공간을 크게) 구분하는 경계를 찾는 알고리즘
예를들면, 두 부류(ex: 고양이 vs 개)를 잘 구분해주는 경계를 찾는데, 두 부류가 최대한 멀리 떨어지도록(안전 여유공간이 넓도록) 찾는 방식"
장점
- 차원이 높은 데이터에서도 좋은 성능을 보일 수 있음.
- 결정 경계를 명확하게 찾는 경우, 예측 성능이 우수함.
  - 결정경계란? → SVM이 찾은 최적의 분류선(또는 초평면)
  - ex) 한쪽 편을 '고양이'로, 다른 한편을 '개'로 구분해주는 기준선
단점
- 파라미터(C, 커널 종류 등)를 적절히 찾아야 하므로 튜닝 비용이 큼.
- 대규모 데이터 세트에 대해서는 학습 속도가 느릴 수 있음.

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

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

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

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

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

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

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

추가로 알면 좋은 모델

K-NN(K-최근접 이웃): 간단하지만 대규모 데이터에서 계산량이 큼.
나이브 베이즈(Naive Bayes): 통계적 가정(독립성)에 기반하므로 계산이 빠름, 스팸 필터 등에서 자주 사용.
신경망(MLP) 또는 딥러닝 모델: 복잡도는 높지만 대규모 데이터에서 강점.

3️⃣ 분류 모델의 산업별 적용 사례

금융(FinTech)

사기 거래 탐지(Fraud Detection): 거래 패턴이 정상 고객과 다른 이상 패턴을 보이는지 분류 모델로 판단.
대출 상환 가능성 예측: 대출 신청 고객의 과거 신용 기록, 소득, 직업, 기타 특성 등을 종합해 상환이 가능한지 여부 분류.
적용 모델: 로지스틱 회귀, 랜덤 포레스트, XGBoost, 딥러닝 등 자주 사용.

헬스케어

질병 진단: 양성(Positive)/음성(Negative) 여부 분류. ex) 암 진단, 당뇨병 예측 등.
임상 데이터(혈액 검사 수치, 환자 진료 기록)와 의료 영상을 기반으로 머신러닝 모델을 훈련.
적용 모델: 로지스틱 회귀, SVM, 최근에는 딥러닝도 활발히 연구.

마케팅

고객 이탈 예측: 고객이 서비스를 해지할 가능성이 있는지 분류.
캠페인 반응 예측: 이메일 또는 광고 캠페인에 대한 반응(열람/미열람, 구매/미구매) 여부 예측.
적용 모델: 로지스틱 회귀, 랜덤 포레스트, 나이브 베이즈 등.

제조업

불량 검출: 공정에서 생산된 부품이 불량인지 아닌지 분류.
장비 이상 탐지: 센서 데이터(온도, 진동, 압력 등)를 기반으로 이상 여부 분류.
적용 모델: 랜덤 포레스트, SVM, 앙상블 모델, 딥러닝이 주로 활용됨.

4️⃣ 모델 평가 방법

Cross Entropy, Hinge Loss
- 분류(Classification) 모델에 사용되는 손실함수
- Binary Cross Entropy / Cross Entropy
  - Binary Cross Entropy 2진 분류에서 자주 사용
  - 일반적으로 다중 분류에서 Cross Entropy를 사용
  - 예측 확률이 실제 레이블과 얼마나 차이가 있는지 측정
- Hinge Loss
  - SVM(Support Vector Machine)에서 많이 사용
  - 마진을 고려하여 오분류된 샘플에 페널티를 부여 평균 제곱 오차라고도 하며, 회귀 모델 평가에서 매우 자주 사용됨
혼동 행렬(Confusion Matrix)
- 실제 클래스와 예측 클래스의 관계를 행렬 형태로 나타낸 것.
  - True Positive(TP), False Positive(FP), False Negative(FN), True Negative(TN)
- 분류 모델 해석의 기초이므로, 용어와 의미를 잘 숙지해야 함.
Precision, Recall, F1-score
- Precision(정밀도): 예측을 Positive라고 한 사례 중, 실제로 Positive인 비율.
  - “예측 정확도” 관점에서 중요. (예: 스팸 예측)
- Recall(재현율): 실제 Positive 사례 중, 모델이 Positive로 맞춘 비율.
  - “놓치지 않는 것”이 중요한 경우(예: 질병 진단) 강조.
- F1-score: Precision과 Recall의 조화평균.
  - 두 지표가 모두 중요한 경우를 종합적으로 평가하기 좋음.
ROC 곡선과 AUC(Area Under the Curve)
- ROC 곡선
  - 임계값(Threshold)을 변화시키며, TPR(True Positive Rate)과 FPR(False Positive Rate)의 변화를 시각화한 곡선
    - TPR(True Positive Rate)
      - 다른 말로 재현율(Recall) 또는 민감도(Sensitivity)
      - 실제 양성(Positive) 샘플 중 모델이 양성이라고 예측한 비율
      - 0~1 사이의 값을 가지며 1에 가까울 수록 좋음
    - FPR(False Positive Rate)
      - 실제 음성(Negative) 샘플 중 모델이 양성이라고 잘못 예측한 비율
      - 0~1 사이의 값을 가지며 0에 가까울 수록 좋음
  - TPR과 FPR은 트레이드 오프 관계 (한 쪽이 좋을 수록 한 쪽이 좋지 않음)
  - 이 지표도 클래스 불균형 상황에서 사용
  - 임계값을 조정해서 생기는 성능 변화 전체를 보여주기 때문에 단순히 성능 하나만 얘기하는 위의 지표들과는 다름
- AUC
  - ROC 곡선 아래 면적. 1에 가까울수록 모델이 우수함.
- 불균형 데이터(Positive가 매우 적거나 많은 경우)에서도 모델 성능 비교에 유용.

import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import load_breast_cancer
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import train_test_split
from sklearn.metrics import roc_curve, roc_auc_score

# 1. 데이터 로드 (유방암 데이터셋: 이진 분류)
data = load_breast_cancer()
X = data.data
y = data.target

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

# 3. 모델 생성 및 학습
model = LogisticRegression(max_iter=500)  # 반복횟수를 충분히 늘려줌
model.fit(X_train, y_train)

# 4. 예측(특히 ROC-AUC 계산을 위해 확률값이 필요하므로 predict_proba 사용)
y_proba = model.predict_proba(X_test)[:, 1]  
# predict_proba의 결과 shape는 (샘플 수, 클래스 수).
# 여기서는 양성 클래스(1)에 대한 확률만 사용

# 5. ROC 곡선 계산
fpr, tpr, thresholds = roc_curve(y_test, y_proba)
# fpr: False Positive Rate
# tpr: True Positive Rate (재현율과 동일)
# thresholds: 임계값(이 값을 기준으로 양성/음성 분류가 달라짐)

# 6. AUC 계산
auc_score = roc_auc_score(y_test, y_proba)

# 7. ROC 곡선 시각화
plt.figure()
plt.plot(fpr, tpr, label=f'Logistic (AUC = {auc_score:.3f})')
plt.plot([0, 1], [0, 1], linestyle='--')  # 랜덤 분류선
plt.xlabel('False Positive Rate')
plt.ylabel('True Positive Rate')
plt.title('ROC Curve')
plt.legend()
plt.show()

print("ROC-AUC Score:", auc_score)

실전 팁!

데이터가 불균형할 경우(ex : 사기 거래 탐지, 질병 예측 등) Accuracy(정확도)만으로는 모델을 평가하기 어려움 → Precision, Recall, F1-score, ROC-AUC 등 지표를 함께 봐야 함.
현업 목표에 따라 어떤 지표를 중시할지 결정(ex : 암 진단은 Recall 중요, 스팸 필터는 Precision 중요 등).

5️⃣ 분류 실습 문제

다음 안내에 따라 Wine 데이터를 분류하는 실습을 진행해 보세요.

[실습 안내]

Wine 데이터셋을 로드하세요.
학습용/테스트용 데이터를 적절한 비율로 분할하세요.
Logistic Regression, SVM 모델을 생성하고, 모델을 학습시키세요.
- 적절히 하이퍼파라미터(예: max_iter 등)를 설정해볼 것
테스트 데이터를 이용해 예측을 수행하고, 다음을 구하세요.
- 정확도(Accuracy)
- 분류 보고서(Classification Report)
- 혼동행렬(Confusion_matrix) → 선택사항
  - 참고!) sklearn의 confusion matrix는 아래와 같은 형태로 나온다는 점을 참고하세요!
- ROC, AUC
random_state를 설정해야 하는 경우가 있으면 42로 설정

from sklearn.datasets import load_wine
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression
from sklearn.svm import SVC
from sklearn.metrics import accuracy_score, confusion_matrix, classification_report

# Wine 데이터셋 로드
wine = load_wine()
X = wine.data
y = wine.target

###################################################
# Wine 데이터를 dataframe으로도 확인하고 싶은 분은 아래 코드 실행
# wine.data(특성 부분)를 데이터프레임으로 변환
df = pd.DataFrame(wine.data, columns=wine.feature_names)
# 타깃(target) 레이블을 새로운 컬럼으로 추가
df['target'] = wine.target

X = df.drop(columns='target')
y = df['target']
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42, stratify=y)

# 로지스틱 회귀

model = LogisticRegression(max_iter=500)
model.fit(X_train, y_train)

# 4. 예측(특히 ROC-AUC 계산을 위해 확률값이 필요하므로 predict_proba 사용)
y_proba = model.predict_proba(X_test)[:, 1]  
# predict_proba의 결과 shape는 (샘플 수, 클래스 수).
# 여기서는 양성 클래스(1)에 대한 확률만 사용
y_pred_logistic = model.predict(X_test)

#  성능평가
print("=== Logistic Regression ===")
print("Accuracy:", accuracy_score(y_test, y_pred_logistic))
print(classification_report(y_test, y_pred_logistic))

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

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

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

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

추가팁

회귀 vs 분류 – 출력 형태부터 구분
- 회귀(Regression) : 연속적 숫자 예측(주가·매출 등)
- 분류(Classification) : 범주/라벨 예측(스팸·불량 등)
  → 모델 선택 전에 목표 값이 “숫자?” vs “범주?” 인지 먼저 확인한다.
정확도(Accuracy) 함정
- 불균형 데이터(정상 99% vs 불량 1%)에선 전부 정상이라 예측해도 Accuracy 99%.
- 반드시 Precision·Recall·F1·ROC-AUC 등 다양한 지표로 성능을 평가한다.
극단적 불균형(불량 ≤ 1%) 대응법
1. 데이터 재구성
  - SMOTE·ADASYN 등 오버샘플링
  - 언더샘플링으로 다수 클래스 줄이기
2. 클래스 가중치 조정
  - class_weight='balanced'(Scikit-learn) 같이 소수 클래스 페널티 ↑
3. 모델 평가
  - 정확도 대신 Recall·Precision·ROC-AUC·PR 곡선을 집중 확인
  - 특히 제조 공정은 불량 탐지 실패 비용이 크므로 Recall(재현율) 우선

2025.07.02 - [[스파르타]내일배움캠프 데이터 분석 트랙/Lecture] - 36일차 - 머신러닝 1주차

36일차 - 머신러닝 1주차

kminx.tistory.com

2025.07.02 - [[스파르타]내일배움캠프 데이터 분석 트랙/Lecture] - 36일차 - 머신러닝 2주차

36일차 - 머신러닝 2주차

kminx.tistory.com

2025.07.10 - [[스파르타]내일배움캠프 데이터 분석 트랙/Lecture] - 42일차 - 머신러닝 3주차

42일차 - 머신러닝 3주차

kminx.tistory.com

끄적끄적

2025.08.21 추천시스템 & LLM 3회차

1️⃣ LLM

2️⃣ LLM 모델 발전 과정

Transformer 모델

LLM 모델 발전 과정

LLM의 한계

3️⃣ LLM 학습의 핵심 요소

LLM 학습 방식

LLM 추론 과정

2025.08.19 추천시스템 & LLM 2회차

️ 실습 코드

1️⃣ 협업 필터링

협업 필터링 분류

최근접 이웃 방식 협업 필터링

잠재 요인 협업 필터링

최근 추천 시스템의 발전 방향

2️⃣ 추천 시스템 평가 지표

추천 품질 관련 지표

추천 효율성 (시스템 성능 중심)

CH 4. 실전 프로젝트 - 가설 검증 및 대시보드 생성

온라인 강의 플랫폼 데이터 분석 및 인사이트 도출

1️⃣ 주요 분석 결과

1) 영어권 vs 비영어권 이탈률간 차이가 클 것이다.

2) 수강 중 활동이 활발할수록 성적과 수료율이 높을 것이다.

3) 학력이 높을수록 성적과 수료율이 높을 것이다.

2️⃣ 대시보드 설계

대시보드 1: 학습 성과 및 현황

대시보드 2: 학습 몰입도 및 이탈 현황

3️⃣ 도출된 인사이트 및 실행 전략

1) 이탈률 관리

2) 저몰입 강의 개선

3) 신규 유입 회복

4) 전환 퍼널 개선

5) 성취 기반 참여 확대

✅ 결론

CH 4. 실전 프로젝트 - 데이터 전처리

온라인 강의 플랫폼 데이터 전처리 과정

1️⃣ 데이터 로드 및 기본 확인

2️⃣ 성적(grade) 결측치 처리

3️⃣ 이상치 처리

(1) 수강 이력과 이벤트 불일치

(2) 출생연도(YoB) 이상치

(3) 불필요/결측 처리

(4) 성적(grade) 특수값

(5) 논리적 오류 데이터 삭제

4️⃣ 파생변수 생성

(1) 대학, 강의 코드, 학기, 연도

(2) 강의명 매핑

(3) 학습일수(study_days)

(4) 나이(age)

(5) 지역(region)

(6) 연령대(age_group)

5️⃣ 최종 저장

✅ 정리

2025.08.18 추천시스템 & LLM 1회차 (과제)

과제

2025.08.18 추천시스템 & LLM 1회차

️ 실습 코드

1️⃣ 추천 시스템

2️⃣ 장바구니 분석

3️⃣ 콘텐츠 기반 필터링

TF-IDF (Term Frequency - Inverse Document Frequency)

임베딩 (Embedding)

정적 vs 문맥 임베딩 비교

CH 3. 심화 프로젝트 - 데이터전처리

사용하는 데이터

데이터 설명

과제 설명

분석 목표: 리스크 관리 전략 수립

분석 방향

1. 신용 리스크

2. 운영 리스크

1. Card Data

2. User Data

3. Transaction Data

2025.07.11 문제 풀이 (114)

문제 풀이

114. Exchage Seats

42일차 - 머신러닝 5주차