resultofeffort

공모전 사이트 17곳 총정리

ISFP의 블로그 — Fri, 31 Jul 2026 11:31:20 +0900

1. 링커리어

링커리어는 대학생과 취업 준비생을 위한 공모전·대외활동·교육·인턴·채용 정보 플랫폼입니다. 공모전 메뉴가 별도로 마련되어 있어 아이디어, 마케팅, 디자인, 영상, IT 등 다양한 분야의 모집 공고를 찾아볼 수 있습니다.

공고를 저장하거나 마감 일정을 확인할 수 있으며, 커뮤니티에서는 공모전 팀원 모집과 참가 관련 질문도 살펴볼 수 있습니다. 공모전 경험을 인턴이나 취업 준비와 연결하고 싶은 대학생에게 특히 유용합니다.

2. 온오프믹스

대표 URL: https://www.onoffmix.com/

온오프믹스는 세미나, 컨퍼런스, 교육, 네트워킹 모임과 각종 이벤트를 찾고 신청할 수 있는 행사 플랫폼입니다.

전통적인 공모전뿐만 아니라 해커톤, 창업 경진대회, 아이디어 대회, 개발자 행사와 지원사업도 찾아볼 수 있습니다. IT·스타트업 분야의 공모전이나 오프라인 행사를 함께 찾는 사람에게 잘 맞습니다.

3. 요즘것들

대표 URL: https://www.allforyoung.com/

요즘것들은 대학생과 청년을 위한 공모전, 대외활동, 교육, 인턴, 취업 및 청년정책 정보를 소개하는 플랫폼입니다.

공모전뿐 아니라 서포터즈, 기자단, 봉사활동, 청년 지원사업 등을 함께 찾을 수 있어 대학생활에 필요한 활동 정보를 폭넓게 확인하기 좋습니다. 여러 종류의 대외활동을 비교하면서 자신에게 맞는 경험을 찾고 싶은 사람에게 추천할 만합니다.

4. 스펙토리

대표 URL: https://www.spectory.net/

스펙토리는 공모전, 대외활동, 공모사업 정보를 제공하는 전문 플랫폼입니다. 참가자를 위한 공고 정보뿐 아니라 공모전을 개최하는 기관을 위한 접수·심사·운영 시스템도 제공합니다.

기업이나 공공기관이 스펙토리를 통해 별도의 공모전 홈페이지를 운영하는 경우가 있어, 작품을 실제로 제출하는 과정에서도 자주 접할 수 있습니다. 지원 전에는 제출 형식, 파일 용량, 저작권 조건을 자세히 확인하는 것이 좋습니다.

5. 캠퍼즈

대표 URL: http://www.campuz.net/

캠퍼즈는 대학생을 대상으로 공모전, 대외활동, 서포터즈, 봉사단과 체험단 정보를 제공해 온 사이트입니다. 대학생에게 필요한 교외활동 정보를 한곳에서 찾아보는 용도로 활용되어 왔습니다.

다만 현재는 접속 환경에 따라 홈페이지 내용이 정상적으로 표시되지 않을 수 있습니다. 캠퍼즈에서 공고 제목을 확인했다면 공모전명이나 주최 기관명을 다시 검색해 최신 공식 공고가 있는지 확인하는 것이 안전합니다.

6. 코워커

대표 URL: https://www.co-worker.co.kr/

코워커는 공모전과 공모사업, 채용 및 기관 정보를 함께 제공하는 지식정보·채용 플랫폼입니다.

공모전뿐 아니라 정부기관, 공공기관, 재단, 협회 등이 운영하는 지원사업과 채용 정보도 함께 살펴볼 수 있습니다. 공공기관 공모전이나 정책 아이디어 공모, 사업 지원 프로그램을 찾는 사람에게 유용합니다.

7. 씽유

대표 URL: https://thinkyou.co.kr/

씽유는 공모전과 서포터즈 등 각종 대외활동 정보를 제공하는 전문 사이트입니다.

아이디어·마케팅, 디자인, 사진, 영상, 문학, 학술, IT·소프트웨어 등 여러 분야의 공모전을 찾아볼 수 있습니다. 모집 기간과 참가 대상, 주최 기관, 접수 방법이 공고별로 정리되어 있어 관심 분야의 공모전을 비교하기 좋습니다.

8. 에이이노브

대표 URL: https://ainnov.co.kr/

에이이노브는 청년을 위한 공모전, 대외활동, 서포터즈, 스타트업 프로그램과 교육 정보를 소개하는 플랫폼입니다.

기획·아이디어, 사업·창업, IT·게임, 디자인, 영상, 논문·학술 등 관심 분야에 따라 공고를 찾아볼 수 있습니다. 공모전 상세 페이지에서 주요 일정과 참가 자격을 먼저 확인한 뒤 공식 접수 홈페이지로 이동하는 방식으로 활용하면 편리합니다.

9. 올콘

대표 URL: https://www.all-con.co.kr/

올콘은 대학생과 일반인, 청소년을 위한 공모전 및 대외활동 정보를 제공하는 종합 플랫폼입니다.

창업·아이디어·마케팅, 디자인·그림·웹툰, 문학·학술, 과학·공학, 사진·영상 등 분야별 공모전을 확인할 수 있습니다. 참가 대상에 따라 공고를 구분해 볼 수 있어 자신이 지원할 수 있는 대회를 찾기 편리합니다.

10. 콘테스트코리아

대표 URL: https://www.contestkorea.com/

콘테스트코리아는 공모전, 대회, 콘테스트, 서포터즈와 대외활동 정보를 폭넓게 제공하는 플랫폼입니다.

문학, 네이밍, 과학·IT, 스포츠, 미술·디자인·웹툰, 음악, 사진·영상, 아이디어·창업 등 분야가 세분되어 있습니다. 참가 대상, 지역, 주최 기관, 상금과 특전 등의 조건을 설정해 공모전을 검색할 수 있다는 점이 특징입니다.

11. 공모전알고

대표 URL: https://www.contestalgo.com/

공모전알고는 여러 기관과 기업이 개최하는 공모전 정보를 모아 제공하는 플랫폼입니다.

전체 공모전 목록뿐 아니라 인기 공모전과 주최사별 공고를 확인할 수 있습니다. 제공받은 링크가 기업회원 관리 페이지나 공모전 등록 페이지라면, 참가자는 위 대표 URL로 접속해 공모전 목록을 찾아보는 것이 편리합니다.

12. 씽굿

대표 URL: https://www.thinkcontest.com/

씽굿은 공모전 정보를 전문적으로 제공하는 공모전 미디어 플랫폼입니다. 공모전, 대외활동, 교육·강연 등의 모집 정보를 확인할 수 있습니다.

공고 검색뿐 아니라 공모전 전략, 수상자 인터뷰, 수상작 갤러리와 가이드 콘텐츠를 함께 살펴볼 수 있다는 점이 장점입니다. 처음 공모전에 도전한다면 비슷한 분야의 기존 수상작을 참고해 작품의 구성과 표현 방식을 분석해 보는 것도 좋습니다.

13. 슈퍼투데이

대표 URL: https://www.suto.co.kr/

슈퍼투데이는 공모전과 온라인 이벤트, 경품 행사, 체험단 정보를 제공하는 응모 정보 플랫폼입니다.

아이디어나 디자인 작품을 제출하는 일반적인 공모전보다는 SNS 참여 이벤트, 설문 이벤트, 퀴즈, 체험단과 경품 행사를 찾을 때 더욱 유용합니다. 응모 현황을 관리하거나 다른 이용자의 당첨 후기를 확인하는 용도로도 활용할 수 있습니다.

14. 스펙업

대표 URL: https://cafe.naver.com/specup

스펙업은 대학생과 취업 준비생이 이용하는 네이버 카페입니다. 공모전, 대외활동, 인턴, 봉사활동과 취업 준비 정보를 함께 찾아볼 수 있습니다.

카페 게시판과 내부 검색 기능을 이용해 관심 분야의 공모전을 찾을 수 있으며, 팀 단위 공모전에 함께 참가할 팀원을 모집할 때도 활용할 수 있습니다. 공모전과 취업 준비를 동시에 진행하는 대학생에게 잘 맞는 커뮤니티입니다.

15. 독취사

대표 URL: https://cafe.naver.com/dokchi

독취사는 ‘독하게 취업하는 사람들’이라는 이름의 취업 준비 네이버 카페입니다. 대기업·공기업 채용, 인턴, 자기소개서, 면접과 자격증 정보뿐 아니라 공모전 및 대외활동 정보도 공유됩니다.

기업이나 기관이 운영하는 서포터즈, 기자단, 마케팅 대외활동과 공모전을 취업 정보와 함께 찾고 싶을 때 유용합니다. 특정 게시글 링크보다는 카페 대표 페이지로 들어가 공모전·대외활동 관련 게시판을 확인하는 것이 편리합니다.

16. 뎁스노트

대표 URL: https://devsnote.com/p/seminar

뎁스노트는 개발자와 IT 종사자를 위한 커뮤니티입니다. 제공한 대표 URL은 모집·홍보 영역의 세미나·이벤트·공모전 게시판으로 바로 연결됩니다.

AI, 소프트웨어, 데이터, 정보보안, 오픈소스 분야의 경진대회와 해커톤을 찾는 사람에게 유용합니다. 일반 공모전 사이트에서 찾기 어려운 개발자 교육이나 기술 세미나 정보도 함께 확인할 수 있습니다.

17. PyTorchKR 행사·이벤트 홍보 게시판

대표 URL: https://discuss.pytorch.kr/c/promotion/12

PyTorchKR 행사·이벤트 홍보 게시판은 파이토치 한국 사용자 모임 커뮤니티에서 운영하는 홍보 공간입니다.

AI·머신러닝 경진대회, 데이터 분석 대회, 해커톤, 개발자 컨퍼런스, 교육과 부트캠프 정보를 찾을 때 유용합니다. 게시글은 외부 기관이 직접 홍보하는 경우가 있으므로 참가 일정과 규칙, 접수 주소는 연결된 공식 홈페이지에서 다시 확인하는 것이 좋습니다.

사이트 선택 방법

종합적인 공모전 정보를 찾는다면 링커리어, 씽유, 올콘, 콘테스트코리아와 씽굿을 먼저 확인해 볼 수 있습니다.

대학생 대외활동과 취업 정보를 함께 찾는다면 요즘것들, 스펙업과 독취사가 유용하며, AI·개발 분야에 관심이 있다면 뎁스노트와 PyTorchKR 행사·이벤트 홍보 게시판을 함께 확인하는 것이 좋습니다.

한 사이트에만 의존하기보다는 관심 분야에 맞는 사이트 두세 곳을 정해 주기적으로 확인하세요. 지원할 공모전을 발견했다면 마지막에는 반드시 주최 기관의 공식 공고에서 모집 기간, 참가 자격, 제출 형식과 저작권 조건을 확인해야 합니다.

거버넌스

ISFP의 블로그 — Thu, 23 Jul 2026 11:40:24 +0900

1단계 — 데이터베이스 기초 (토대)

먼저 "데이터를 표로 저장한다"는 감을 잡아야 나머지가 이해돼요.
- 테이블 / 행(row) / 컬럼(column): 데이터를 담는 표의 구조
- 기본키(Primary Key): 각 행을 구분하는 고유 값 (예: user_id)
- 외래키(Foreign Key): 다른 표와 연결하는 키 (예: 학습기록의 user_id → 사용자 표)
- 데이터 타입: 문자(VARCHAR)·숫자(INT)·날짜(DATE) 등
- 목표: "테이블끼리 키로 연결된다"를 이해

2단계 — 데이터 모델링 & ERD

"어떤 테이블을 만들고 어떻게 연결할지 설계"하는 단계.
- ERD (Entity Relationship Diagram): 테이블(엔티티)과 관계를 그림으로 표현
- 관계 종류: 1:1, 1:N, N:M (예: 트랙 1개 ↔ 콘텐츠 여러 개 = 1:N)
- 정규화(Normalization): 중복 없이 데이터를 나누는 원칙 (1NF·2NF·3NF, 개념만)
- 목표: 간단한 서비스(사용자·콘텐츠·구독)를 ERD로 그려볼 수 있기

3단계 — 택소노미 (분류 체계)

콘텐츠·데이터를 "어떤 기준으로 분류할지" 정하는 것.
- 택소노미 vs 온톨로지 차이(택소노미는 계층적 분류, 온톨로지는 관계까지)
- 분류 축(facet) 설계: 난이도 / 주제 / 유형처럼 여러 기준으로 나누기
- 분류값의 상호배타성·완전성: 겹치지 않고 빠짐없이 나누는 원칙
- 목표: "콘텐츠를 난이도·주제·유형으로 나눈 이유"를 설명할 수 있기

4단계 — 데이터 거버넌스 & 품질관리

"데이터를 믿고 쓸 수 있게 관리"하는 규칙.
- 데이터 거버넌스: 데이터 관리 정책·책임·규칙의 전체 틀
- 데이터 품질 6대 차원: 정확성 / 완전성(누락) / 일관성 / 유효성 / 유일성(중복) / 적시성 — 이건 꼭 외워두세요 (면접 단골)
- 데이터 딕셔너리 / 메타데이터: 각 컬럼이 무슨 뜻인지 정의한 문서
- 정합성(Integrity): 데이터가 규칙에 맞고 서로 모순 없는 상태
- 목표: "품질 점검할 때 뭘 봤냐"에 6대 차원으로 답하기

5단계 (선택) — 실무 도구/키워드

- SQL 기본(SELECT·JOIN·GROUP BY): 실제로 데이터 확인·점검할 때 씀
- BigQuery / 데이터 웨어हाउस 개념 (이력서에 있으니 연결됨)

데이콘 주식회사

3년 11개월

2025.08 ~ 2026.08

AX실 · 매니저 / AI 대시보드 개발 · 데이터 분석

정규직 · 4년차

AI(Gemini) 활용 대시보드 풀스택 개발 (프론트/백엔드)
사내 이원화 DB 통합
Tableau / Power BI 학습 성과 대시보드 구축
Airflow 기반 ETL 파이프라인 자동화
대회 홍보 업무 자동화
VOC 분석 및 학습–대회 연계 플로우 개선

2024.08 ~ 2025.08

DS · 교육팀 · 매니저 / 학습 서비스 분석 · 경영 리포팅

정규직 · 3년차

학습 트랙 효과 분석 및 C-level 대상 격주 정기 리포팅
BigQuery(MySQL 연동) 기반 경영 지표 대시보드 설계·구축
고객 이탈(Churn) 예측 모델 개발 및 타깃 리텐션 캠페인 운영
검색어 로그 분석을 통한 콘텐츠 제작 우선순위 도출
콘텐츠 진행률·이탈 구간 분석(히트맵) 및 개선 제안

2023.08 ~ 2024.08

DS · 교육팀 · 매니저 / 학습 콘텐츠 기획 · 서비스 운영

정규직 · 2년차

콘텐츠 이용·검색 데이터 기반 PBL 자기주도학습 콘텐츠 기획·제작 (월 1개)
학습 수요·이용 데이터를 반영한 트랙(커리큘럼 패키지) 상품 기획 참여
구독 부가 혜택(랭커특강) 기획·운영 및 참여 데이터 점검
데이터 기반 AI 해커톤 기획·운영

2022.08 ~ 2023.07

DS 파트 · 매니저 / AI 교육 콘텐츠 · 해커톤 운영

인턴 · 1년차

학습 서비스 DB 설계 참여(데이터 택소노미)·거버넌스 점검
AI 해커톤 기획·데이터 탐색·가공·운영 보조
AI 교육 콘텐츠(파이썬 / 머신러닝 / 딥러닝) 제작 보조

[python] macOS에서 Apache Airflow 시작하기 (ETL 파이프라인 구축)

ISFP의 블로그 — Fri, 12 Dec 2025 09:38:14 +0900

1.Airflow 초기 설정

Apache airflow는 Linux 기반이지만, macOS에서도 터미널을 통해 쉽게 설치하고 실행할 수 있습니다.

1.1. 가상환경 생성(conda)

anaconda를 사용해서 python 3.10 버전의 가상환경을 생성 합니다.

# Anaconda를 사용하여 Python 3.10 환경을 생성
conda create -n airflow_lab python=3.10

# 가상환경 활성화
conda activate airflow_lab

1.2. Airflow 설치

Airflow 공식 문서에서는 pip 로 설치를 권장하기 때문에 Airflow와 MySQL Provider 패키지는 pip 로 설치 합니다.
mysqlclient는 conda로 설치해주었습니다.

# Airflow 설치
pip install apache-airflow

# MySQL Provider 설치
pip install apache-airflow-providers-mysql

# [중요] MySQL Client 설치 (이거 안 하면 에러 남)
conda install -c conda-forge mysqlclient

1.3. 환경 변수 설정

macOS의 시스템 보안 정책으로 인해 Airflow가 갑작스럽게 종료되는 현상이 발생할 수 있습니다. 이를 방지하기 위해 다음 환경변수를 설정합니다.

⚠️ 주의: 이 설정은 현재 터미널에만 적용됩니다.

해당 명령어는 현재 열려 있는 터미널 창을 닫으면 초기화됩니다. Airflow를 실행할 때마다 해당 명령어를 입력해 주어야 에러가 발생하지 않습니다.

# macOS 프록시 설정 (보안 정책 충돌 방지)
export no_proxy="*"

1.4. 서버 실행

이제 Airflow 서버를 실행합니다. 실행 후 터미널에 표시되는 웹 주소(일반적으로 http://localhost:8080)로 접속하면 Airflow 대시보드를 확인할 수 있습니다.

airflow standalone

2. Airflow 대시보드 접속하기

2.1.터미널에서 인증정보 확인하기

airflow standalone 명령어를 실행하면 여러 로그가 빠르게 출력됩니다.

로그가 나타나타가 멈추는 순간, 위쪽을 잘 살펴보면 다음과 같은 박스를 찾을 수 있습니다.

터미널에 출력된 Password 문자열을 복사해야 합니다.

Standalone mode created: ...
User: admin
Password: [여기에_적힌_복잡한_문자열]  <-- 이걸 복사하세요!

※ 주의: 만약 로그에 비밀번호가 안 보인다면?
Airflow 재실행 시에는 보안상 비밀번호가 로그에 뜨지 않습니다.
이런 경우에는 새 터미널 창을 열어 아래 명령어중 하나를 실행하세요.

# 비밀번호 확인 명령어 (둘 중 하나 실행)
cat ~/airflow/standalone_admin_password.txt

# 또는 (Airflow 버전에 따라)
cat ~/airflow/simple_auth_manager_passwords.json.generated

admin: "이 부분이 비밀번호 입니다."

2.2.웹 브라우저에 접속하기

웹 브라우저를(Chrome 등) 열고 주소창에 아래 주소를 입력합니다.

http://localhost:8080

2.3.로그인 하기

Airflow 로그인 화면이 표시되면 앞서 확인한 인증정보를 입력합니다.

- Username: admin 입력하시면 됩니다.

- Password: 위에서 복사한 비밀번호를 입력해줍니다.

로그인에 성공하면 Airflow 대시보드가 나타납니다.

3.실습용 데이터 생성하기

Airflow와 연결하기 전에, Airflow가 가져올 실습용 데이터를 MySQL에 먼저 만들어 둬야 합니다.

3.1. MySQL 접속하기
새로운 터미널 창을 열고 (command + n) 터미널에서 MySQL에 관리자 권한으로 접속합니다.

(비밀번호가 있다면 입력 후 엔터, 비밀번호를 설정하신 적이 없다면 그냥 엔터!)

mysql -u root -p

3.2. 데이터 생성 SQL 실행 (복사+붙여넣기)
접속된 MySQL 화면(mysql>)에 아래 SQL 문을 통째로 복사해서 붙여넣으세요.

game_log_db라는 데이터베이스를 만들고, 그 안에 가상의 유저 로그 3개를 넣는 명령어입니다.

CREATE DATABASE IF NOT EXISTS game_log_db;
USE game_log_db;

CREATE TABLE IF NOT EXISTS access_log (
    user_id VARCHAR(50),
    event VARCHAR(50),
    created_at DATE
);

INSERT INTO access_log VALUES ('user_1', 'login', '2025-01-01');
INSERT INTO access_log VALUES ('user_2', 'logout', '2025-01-01');
INSERT INTO access_log VALUES ('user_3', 'level_up', '2025-01-01');

SELECT * FROM access_log;

3.3. 확인 및 종료
마지막에 SELECT 결과로 데이터 3줄이 잘 출력되었다면 성공입니다!
exit를 입력해 MySQL을 빠져나옵니다.

4.Airflow - MySQL 커넥션 설정

Airflow에서 MySQL 데이터베이스에 접근하려면 먼저 연결 설정을 등록해야 합니다.

Airflow 웹 대시보드의 '관리자' 메뉴에서 커넥션을 추가합니다.

경로: 좌측 탭 > 관리자 > 커넥션들 > 커넥션 추가

4.1.기본 정보 입력

- 커넥션ID: game_mysql_conn

(Airflow 가 이 연결 설정을 부를 때 사용하는 고유한 식별자입니다. python 코드에서 이 이름으로 DB에 접속합니다.)

- 커넥션 유형: Mysql
(데이터베이스 유형을 지정합니다.)

4.2.데이터베이스 연결 정보 입력

맥북 로컬 환경에서 에러 없이 연결하려면 아래 4가지는 꼭 채워야 합니다

1. Host (호스트): localhost

(주의: 127.0.0.1로 쓰면 맥북 보안 설정 때문에 연결이 거부될 수 있습니다.)

2. Login (로그인): root

(MySQL 설치 시 기본 관리자 계정입니다.)

3. Password (비밀번호): (본인 설정에 따라 다름)

(Mysqk울 설치할 때 비밀번호를 따로 설정 안 했다면 비워두세요.)

4. Schema:game_log_db

(앞서 생성한 데이터베이스 이름입니다.)

4.3.Mac OS 호환성 설정

(이걸 입력해야 TCP/IP 통신 오류를 우회하여 소켓으로 직통 연결됩니다.

경로는 터미널에서 mysql -u root -> status로 확인하세요.)

{"socket": "/tmp/mysql.sock"}

왜 이 설정(Mac OS 호환성 설정)이 필요한가?

macOS에서 MySQL은 기본적으로 Unix Socket을 통해 통신합니다.

TCP/IP로 연결하려고 하면 ‘Connection Refused’ 에러가 발생할 수 있습니다.

이 설정은 Airflow에게 소켓 통신 방식을 사용하도록 지시합니다.

MySQL 소켓 경로 확인하기 터미널에서 다음 명령어를 실행하여 정확한 경로를 확인하세요.

Copymysql -u root
mysql> status

출력된 정보에서 'UNIX socket'으로 시작하는 라인을 찾으면, 소켓 파일의 경로를 확인할 수 있습니다 (보통 /tmp/mysql.sock).

만약 /var/run/mysqld/mysql.sock이라면, Extra 필드를 그에 맞게 수정하면 됩니다.

저장을 누르고 커넥션 목록 화면으로 돌아옵니다.

리스트에 game_mysql_conn이 추가된 것을 확인할 수 있습니다.

이제 Airflow가 MySQL에 접근할 수 있는 경로가 설정되었습니다.

이 'game_mysql_conn'이라는 연결 정보를 사용하여 다음 단계에서 Python DAG 코드를 작성할 예정입니다.

5.DAG 파일 생성(ETL 구현)

Airflow와 MySQL 연결 설정이 끝났으니, 이제 실제로 데이터를 추출(Extract)해서 파일로 저장(Load)하는 DAG를 작성해 봅시다.

5.1. 데이터를 저장할 폴더 만들기

CSV 파일을 저장할 폴더가 없으면 에러가 발생할 수 있습니다. 터미널에서 미리 폴더를 생성해 줍니다.

mkdir -p ~/airflow/data

5.2. DAG 파일 생성하기

Airflow의 DAG 폴더 (~/airflow/dags/)에 Python 파일을 생성합니다.

이 DAG는 다음 기능을 수행합니다.

- Extract: MySQL의 access_log 테이블에서 모든 데이터를 조회(SELECT)

- Load: 조회된 데이터를 CSV 파일로 로컬 컴퓨터 저장

다음 명령어를 터미널에 복사하여 실행하면 DAG 파일이 생성됩니다.

(터미널에 아래 내용을 그대로 복사+붙여넣기 하세요. 파일 생성과 내용 작성이 한 번에 됩니다!)

cat <<EOF > ~/airflow/dags/practice_connection.py
from airflow import DAG
from airflow.providers.common.sql.operators.sql import SQLExecuteQueryOperator
from airflow.operators.python import PythonOperator
from datetime import datetime
import csv

# ============================================
# 1단계: 데이터를 받아서 CSV 파일로 저장하는 함수 (Load)
# ============================================
def save_to_csv(**context):
    '''
    XCom(Airflow 우편함)에서 이전 Task가 조회한 데이터를 받아서
    CSV 파일로 저장합니다.
    '''
    # XCom에서 'read_db' Task의 결과 데이터를 꺼내옵니다
    data = context['ti'].xcom_pull(task_ids='read_db')
    
    # ⚠️ 중요: 아래 경로를 본인 사용자 이름에 맞게 수정하세요!
    # 예: /Users/[본인_사용자명]/airflow/data/game_log.csv
    file_path = '/Users/song/airflow/data/game_log.csv'
    
    # CSV 파일에 데이터를 쓰기 모드로 저장
    with open(file_path, 'w', newline='') as f:
        writer = csv.writer(f)
        writer.writerow(['user_id', 'event', 'date'])  # CSV 컬럼 제목
        for row in data:
            writer.writerow(row)  # 각 행의 데이터 입력
            
    print(f"✅ 파일 저장 완료: {file_path}")

# ============================================
# 2단계: DAG(작업 흐름) 정의
# ============================================
with DAG(
    dag_id='mysql_to_csv_v1',        # Airflow 웹 대시보드에 보일 DAG 이름
    start_date=datetime(2025, 1, 1), # DAG 시작 날짜
    schedule='@daily',               # 매일 UTC 0시(한국시간 9시)에 자동 실행
    catchup=False                    # 과거 날짜의 미실행 작업을 실행하지 않음
) as dag:

    # [Task 1] MySQL 데이터베이스에서 데이터 조회하기 (Extract)
    read_db = SQLExecuteQueryOperator(
        task_id='read_db',                  # Task의 고유한 이름
        conn_id='game_mysql_conn',          # 아까 웹에서 설정한 MySQL 커넥션 ID
        sql="SELECT * FROM access_log;"     # 실행할 SQL 쿼리
    )

    # [Task 2] 조회한 데이터를 파일로 변환하기 (Load)
    write_csv = PythonOperator(
        task_id='write_csv',                # Task의 고유한 이름
        python_callable=save_to_csv         # 실행할 Python 함수
    )

    # Task 의존성 설정: read_db를 먼저 실행 → write_csv를 나중에 실행
    read_db >> write_csv
EOF

6.실행 및 결과 확인 (Result)

코드를 저장했다면 이제 Airflow 웹 화면에서 실행해 볼 차례입니다.

DAG 확인 및 실행

1. Airflow 웹 화면(localhost:8080)에서 [DAGs] 메뉴를 클릭하고 새로고침(F5)을 합니다.

2. 약 30초~1분 정도 기다리면 목록에 mysql_to_csv_v1 이 나타납니다.
(만약 나오지 않는다면, Airflow 서버를 껐다 키신 후 진행해보세요)

3. 왼쪽의 토글 스위치(On/Off)를 켜서 파란색(Unpaused) 상태로 만듭니다.

4. 오른쪽의 [▶] (Trigger DAG) 버튼을 눌러 작업을 실행합니다.

5. 성공 여부 확인 (Web UI)

read_db와 write_csv 두 작업이 모두 진한 초록색(Success)으로 변하면 성공입니다!

(만약 빨간색(Failed)이 뜬다면, 클릭해서 [Log]를 확인해야 합니다.)

6. 최종 결과물 확인 (CSV 파일)

마지막으로 터미널에서 아래 명령어를 입력해 진짜 파일이 생성되었는지 확인합니다.

# 파일 내용 출력하기
cat ~/airflow/data/game_log.csv

아래와 같이 MySQL에 들어있던 데이터가 콤마(,)로 구분된 텍스트 형태로 출력된다면 ETL 파이프라인 구축 성공입니다!

[통계] 직관적 의사결정 vs 데이터 기반 의사결정

ISFP의 블로그 — Tue, 30 Sep 2025 18:23:05 +0900

ㄹㄷㄹㄷㄹe

 문서 리스트
corpus = [
    "나는 오늘 밥을 먹었다",
    "밥을 먹고 운동을 했다",
    "오늘 운동을 마치고 밥을 먹었다"
]

# TF-IDF 벡터화
vectorizer = TfidfVectorizer()
tfidf_matrix = vectorizer.fit_transform(corpus)

# 코사인 유사도 계산
cosine_sim = cosine_similarity(tfidf_matrix, tfidf_matrix)

# 결과를 데이터프레임으로 보기 좋게 출력
df = pd.DataFrame(cosine_sim, index=["문서1", "문서2", "문서3"], columns=["문서1", "문서2", "문서3"])
print("코사인 유사도 행렬:")
print(df)
출처: https://resultofeffort.tistory.com/147 [resultofeffort:티스토리]

두 가지 의사결정 방식의 이해

우리는 매일 수많은 의사결정을 내립니다.

아침에 무엇을 입을지부터 저녁에는 무엇을 먹을지 말이죠.

이러한 선택을 할 때 우리가 사용하는 방식은 크게 두 가지로 나눌 수 있습니다.

첫 번째는 "직관적 의사결정"입니다.
이는 우리가 가장 많이 사용하는 방식입니다.

예를 들어 제가 티셔츠를 판매하는 판매자라고 해볼게요.

판매하고자 하는 티셔츠의 색상을 선택해야 합니다.

저는 이 티셔츠를 최대한 많이 팔아야 하는 판매자이기 때문에 사람들이 가장 많이 구매할 것 같은 색상을 고를 것입니다.

검정색이 가장 많이 판매가 될 것 같으니 100개를 발주하고 핑크색은 팔리지 않을 것 같아서 발주를 넣지 않을 겁니다.

이러한 결정이 바로 본인이 지금까지 쌓아온 경험과 직감으로 의사결정을 하는 방식입니다.

직관적 의사결정의 장점은 "속도"입니다. 데이터 수집이나 복잡한 분석 과정 없이도 빠르게 결정을 내릴 수 있기 때문입니다.

이러한 과정에서 데이터로 설명할 수 없는 아이디어나 접근 방법을 떠올리기도 합니다.

하지만 이러한 방법에는 단점이 있습니다. 의사결정자의 개인적인 편견이나 감정이 개입되기 때문에 같은 상황이라도 사람에 따라, 같은 사람이라도 기분에 따라 다른 결정을 내릴 수 있습니다.

두 번째는 "데이터 기반 의사결정"입니다.

이는 객관적인 수치와 분석 결과를 바탕으로 하는 결정을 내리는 방식입니다.

예를 들어 넷플릭스에서 새로운 컨텐츠를 제작하려면 과거의 사람들이 가장 많이 소비한 컨텐츠의 종류와 분야, 시청자의 나이, 한달에 소비하는 시간을 고려해서 새로운 컨텐츠를 기획하고 생산하는 방식입니다.

데이터 기반의 의사결정의 장점은 객관성과 재현성입니다. 동일한 데이터로 동일한 분석을 한다면 누가 분석하든 비슷한 결론에 도달할 수 있습니다. 또한 결정의 근거를 명확히 제시할 수 있어서 다른 사람들을 설득하기도 쉽습니다. 하지만 이 방식도 단점이 존재합니다. 데이터를 분석하는데 수많은 리소스가 소요되고, 무엇보다 과거의 데이터를 기반으로 미래를 예측하는 것이기 때문에 전혀 새로운 상황에서는 한계가 있을 수 있습니다.

## ‍ 데이터 사이언티스트가 갖춰야 할 역량

그렇다면 데이터 기반 의사결정을 주도하는 데이터 사이언티스트는 어떤 능력을 갖춰야 할까요? 많은 사람들이 프로그래밍이나 통계학만 잘하면 된다고 생각하지만, 실제로는 훨씬 다양한 역량이 필요합니다.

가장 기본이 되는 것은 당연히 기술적 역량입니다. 통계학의 기초 개념들을 이해하고, Python이나 R 같은 프로그래밍 언어를 다룰 수 있어야 하죠. SQL로 데이터베이스에서 필요한 데이터를 추출할 수 있어야 하고, 머신러닝 알고리즘들을 상황에 맞게 적용할 수 있어야 합니다. 하지만 이것만으로는 충분하지 않습니다.

더 중요한 것은 분석적 사고력입니다. 복잡한 비즈니스 문제를 보았을 때 이것을 어떻게 데이터로 분석할 수 있는 형태로 바꿀 수 있는지 생각할 수 있어야 해요. 예를 들어 "고객 만족도를 높이고 싶다"는 막연한 요청을 받았을 때, 이를 "고객 서비스 응답 시간과 만족도 점수 간의 관계 분석" 같은 구체적인 분석 문제로 변환할 수 있어야 합니다.

또한 비즈니스에 대한 이해도 필수입니다. 아무리 정교한 분석을 했더라도 그것이 실제 비즈니스에 어떤 의미가 있는지, 어떤 가치를 창출할 수 있는지 알지 못한다면 의미가 없거든요. 예를 들어 전자상거래 회사에서 일한다면 고객 획득 비용, 생애 가치, 전환율 같은 핵심 지표들을 이해하고 있어야 합니다.

마지막으로, 많은 사람들이 간과하는 것이 커뮤니케이션 능력입니다. 데이터 분석 결과를 기술적 배경이 없는 경영진이나 동료들에게 이해하기 쉽게 설명할 수 있어야 해요. 복잡한 통계 분석 결과를 직관적인 시각화로 표현하고, 그것이 비즈니스에 미치는 영향을 스토리텔링으로 전달할 수 있어야 합니다.

## 통계적 의사결정 모형의 이해

데이터 기반 의사결정을 체계적으로 수행하기 위해서는 일정한 프레임워크가 필요합니다. 가장 널리 사용되는 것 중 하나가 CRISP-DM 모형입니다. 이는 비즈니스 이해에서 시작해서 데이터 이해, 데이터 준비, 모델링, 평가, 배포까지의 순환적 과정을 제시합니다.

예를 들어 온라인 쇼핑몰에서 고객 이탈을 예측하고 싶다고 해봅시다. 먼저 비즈니스 이해 단계에서는 왜 고객 이탈 예측이 중요한지, 어떤 비즈니스 가치를 창출할 수 있는지 명확히 해야 합니다. 데이터 이해 단계에서는 어떤 데이터가 있는지, 데이터의 품질은 어떤지 파악합니다. 데이터 준비 단계에서는 분석에 적합하도록 데이터를 정제하고 변환합니다. 모델링 단계에서는 적절한 머신러닝 알고리즘을 선택하고 모델을 구축합니다. 평가 단계에서는 모델의 성능을 검증하고, 마지막 배포 단계에서는 실제 업무에 적용합니다.

또 다른 중요한 프레임워크는 통계적 가설검정입니다. 이는 특정 주장이나 가설이 통계적으로 의미가 있는지 객관적으로 판단하는 방법입니다. 예를 들어 새로운 웹사이트 디자인이 기존 디자인보다 전환율을 높인다고 주장할 때, 이를 단순히 "느낌상 좋아 보인다"가 아니라 통계적으로 검증할 수 있어야 합니다.

## 실무에서의 균형잡힌 접근

하지만 실제 업무에서는 데이터와 직관을 완전히 분리해서 생각할 수 없습니다. 가장 효과적인 의사결정은 두 방식을 적절히 조합할 때 나옵니다. 직관으로 가설을 세우고 데이터로 검증하거나, 데이터 분석 결과를 직관과 경험으로 해석하는 것이죠.

예를 들어, 데이터 분석 결과 특정 고객 그룹의 구매율이 급격히 떨어졌다고 나타났다면, 이것만으로는 원인을 알 수 없습니다. 이때 현장 경험이 풍부한 마케팅 담당자의 직관이 "아, 최근에 경쟁사가 대대적인 할인 이벤트를 했었지"라는 통찰을 제공할 수 있어요. 반대로 "고객들이 모바일 앱을 더 선호할 것 같다"는 직관적 가설을 세웠다면, 이를 A/B 테스트나 사용자 행동 데이터 분석으로 검증할 수 있습니다.

결국 이 섹션에서 가장 중요한 것은 데이터 분석의 가치를 이해하는 것입니다. 데이터 기반 의사결정이 만능은 아니지만, 객관성과 재현성, 그리고 예측 가능성이라는 강력한 장점을 가지고 있다는 점을 알아야 합니다. 동시에 데이터 사이언티스트로서 성공하기 위해서는 기술적 역량뿐만 아니라 비즈니스 이해력과 커뮤니케이션 능력까지 갖춰야 한다는 점도 기억해두세요.

[오류Error] RateLimitError: Error code: 429 - {'error': {'message': 'You exceeded your current quota, please check your plan and billing details. For more information on this error, read the docs: https://platform.openai.com/docs/guides/error-codes/api-erro

ISFP의 블로그 — Tue, 10 Jun 2025 14:09:35 +0900

OpenAI API를 호출하려고 보니 갑자기 다음과 같은 에러가 떴습니다.

> “You exceeded your current quota, please check your plan and billing details. For more information on this error, read the docs: https://platform.openai.com/docs/guides/error-codes/api-errors.”

즉, [오류] RateLimitError: 429 – 현재 할당량을 초과했습니다. 요금제 및 결제 정보를 확인해 주세요.

"https://platform.openai.com/docs/guides/error-codes/api-errors." 사이트에 접속하여
에러 설명(429)을 살펴보니 “API 월간 사용량 한도에 도달했거나, 선불 크레딧을 모두 사용했음을 나타냅니다.” 라고 적혀있었다.

근데 난 현재 유료 계정을 사용 중이고 과도한 API 호출을 하지 않았는데도이런 에러가 발생했어서 .. 이유를 찾는데 좀 헤매다가

확인해보니 결제 수단(신용카드)이 등록되어 있지 않아 Auto-recharge가 작동하지 않았기 때문이었다.

결론적으로 Payment methods에 카드 등록을 해주니 해결이 되었음.

1. OpenAI Console → Billing → Payment methods

2. Auto-recharge 설정 확인

- Billing → Overview → Auto-recharge가 On 상태인지 확인

- (최소 잔액 $5 이하 시, 자동으로 $100 충전)

카드등록 해두니 자동으로 충전이 잘 된다..!

3. API 호출 재실행

[오류Error] Failed to start project studioError invoking remote method 'up': Error: Docker not installed or not running: ExecaError: Command failed with exit code 1: which docker

ISFP의 블로그 — Fri, 18 Apr 2025 18:21:55 +0900

LangGraph를 공부하던 중 Agentic Application을 만들기 위한 IDE인 LangGraph Studio라는 서비스를 알게 되었습니다. 이 도구가 AI 에이전트 개발을 시각적으로 도와준다고 하여 설치해보기로 했습니다.

설치 과정

LangGraph Studio는 현재 맥북에서만 지원되는 것 같습니다. 공식 사이트에서 dmg 파일을 다운로드하여 설치했습니다.

첫 번째 오류: Docker 관련 문제

설치 후 실행했더니 다음과 같은 오류가 발생했습니다.

Failed to start project studio
Error invoking remote method 'up': Error: Docker not installed or not running: ExecaError: Command failed with exit code 1: which docker

(도커가 필요한 줄 몰랐다.. 그래서 바로 Docker 를 설치해주었다.)

해결 방법

Docker Desktop: The #1 Containerization Tool for Developers | Docker

Docker Desktop is collaborative containerization software for developers. Get started and download Docker Desktop today on Mac, Windows, or Linux.

www.docker.com

Docker 설치 확인하기 Docker가 설치되어 있지 않다면, Docker 공식 사이트에서 운영체제에 맞는 Docker Desktop을 다운로드하여 설치한다.
Docker 실행 확인하기 Docker Desktop을 실행하고, 상태 표시기(시스템 트레이/메뉴바)에서 Docker가 실행 중인지 확인한다.
Docker 버전 확인하기 LangGraph Studio는 Docker Compose 버전 2.22.0 이상을 요구합니다. 터미널에서 docker-compose --version 명령으로 버전을 확인하고, 필요시 업데이트한다.

두 번째 오류: .env 파일 문제

Docker를 설치하고 실행한 후 LangGraph Studio를 다시 시작했더니 오류 메시지가 바뀌었다.

Failed to start project studio
Error invoking remote method 'up': Error: Could not read env file: /Users/path/to/project/studio/.env

LangGraph Studio가 API 키와 같은 환경 변수를 담고 있는 .env 파일을 찾을 수 없어서 발생한 문제였습니다.

해결 방법

다행히 제가 사용하려던 프로젝트 폴더에는 .env.example 파일이 이미 존재했습니다. 이 파일은 필요한 환경 변수의 템플릿 역할을 합니다.

1. .env.example 파일을 .env 파일로 복사해주었습니다.

cp /path/to/project/studio/.env.example /path/to/project/studio/.env

2. 텍스트 에디터로 .env 파일을 열고 OpenAI API 키를 입력했습니다.

OPENAI_API_KEY=sk-my_api_key_here

LangGraph Studio를 재시작했더니 드디어 정상적으로 로드 성공!

[오류Error] VS Code Remote-SSH: "원격 호스트가 VS Code Server를 실행하기 위한 필수 구성 요소를 충족하지 않습니다" 오류 해결 후기

ISFP의 블로그 — Fri, 11 Apr 2025 11:55:49 +0900

could not establish connection to "서버ip": the remote host does not meet the prerequisites for running vs code server.

~~2시간 30분 삽질 완료^^~~

~~그래도 해결했으니 진짜 다행...........~~

문제 상황

오늘 출근해서 VS Code에서 Remote - SSH 기능을 사용하려고 했는데,
SSH로는 접속이 잘 되는데도 불구하고 아래와 같은 에러 메시지가 반복적으로 발생하였음.

(분명 어제까지는 멀쩡하게 접속이 되었단 말이지.ㅠㅠㅠ)

"원격 호스트가 VS Code Server를 실행하기 위한 필수 구성 요소를 충족하지 않습니다."

나의 환경

로컬 OS: macOS Sonoma 14.4.1 (Darwin x64 23.5.0, Apple Silicon)

로컬 VS Code 버전: 1.99.2 (최신 버전)

서버 OS: Ubuntu 18.04 LTS (glibc: 2.27 / Node.js: v14.16.0)

시도했던 해결 방법들 (실패)

/etc/hosts 정리
환경 변수 / 프록시 확인
.zshrc / .bashrc 초기화
known_hosts 삭제
VS Code 초기화 & 재설치
settings.json 수동 생성
Remote-SSH 확장 재설치

→ 모두 실패.
원인은 glibc 2.27 환경에서 VS Code 최신 버전이 원격 서버 환경을 차단하기 때문.

최종 해결 방법

결론부터 말하자면, "VS Code 버전 다운그레이드 + 자동 업데이트 비활성화"가 답이었습니다.

해결 순서 정리

1. VS Code 1.85.1 버전 설치 (기존에 설치 되어있는 Vs Code는 제거해주었음)

# 기존 VS Code 삭제
sudo rm -rf /Applications/Visual\ Studio\ Code.app

다운로드 링크 (VS Code 1.85.1)

2. 업데이트 모드 끄기 (처음에 이거 안했더니 자동 업데이트 되서 다시 설치함^^)

VS Code 실행 → Cmd + , → "업데이트" 검색 → 응용 프로그램 > 업데이트 모드: "none" 으로 설정

3. 확장 프로그램에서 Remote - SSH 를 제거 후 다시 설치

4. 서버 접속 완료

참고

The remote host may not meet vs code server's prerequisites for glibc and libstdc++ vscod

I was working on the host server. Everything was great till yesterday and today when I start my server, suddenly error occurs in VS code. And my server is not connecting anymore. What should I do? ...

stackoverflow.com

The remote host may not meet VS Code Server's prerequisites for glibc and libstdc++ · Issue #9501 · microsoft/vscode-remote-re

There was no problem with remote SSH until 3 days ago. Now I'm getting the following error and I can't connect to the server The remote host may not meet VS Code Server's prerequisites for glibc an...

github.com

[pytorch] 시퀀스-투-시퀀스(seq2seq)

ISFP의 블로그 — Tue, 31 Dec 2024 09:44:17 +0900

seq2seq의 기본 구조와 작동 원리

Sequence-to-Sequence(seq2seq) 모델은 한 시퀀스를 다른 시퀀스로 변환하는 신경망 모델입니다.
예를 들어, "안녕하세요"라는 한국어 문장을 "Hello"라는 영어 문장으로 번역하는 것처럼, 입력 시퀀스를 받아서 다른 형태의 출력 시퀀스를 생성합니다.

인코더(Encoder)-디코더(Decoder) 아키텍처

seq2seq 모델은 크게 두 부분으로 구성됩니다.

인코더 (Encoder)

인코더는 입력 시퀀스를 처리하여 컨텍스트 벡터(Context Vector)를

* 시퀀스: 시간적 순서 또는 일정한 순서에 따라 배열된 데이터의 집합을 의미함. 이는 데이터가 순차적으로 의존관계를 가지며, 앞뒤의 데이터가 서로 연결되어 있는 경우를 말함. 예를 들어, 문장, 음성, 음악, 비디오 등이 모두 시퀀스 데이터의 예임.

인코더는 다음과 같이 동작합니다.

1️⃣ 시퀀스 데이터의 처리

문장 "I love cats"를 예로 들면

1. 첫 번째 입력: "I"
- 입력
단어 “l”의 임베딩 벡터 .
초기 hidden state : 보통 [0, 0, 0] 또는 무작위 값으로 초기화.
- 결과
hidden state1: [0.2, -0.1, 0.1]

2. 두 번째 입력: “love”
- 입력
단어 “love”의 임베딩 벡터.
이전 hidden state : [0.2, -0.1, 0.1].
- 결과
hidden state2: [0.5, -0.2, 0.3].

3. 세 번째 입력: “cat”
- 입력
단어 “cat”의 임베딩 벡터.
이전 hidden state : [0.5, -0.2, 0.3].
- 결과
hidden state3: [0.7, -0.3, 0.4].

이와 같이, 입력 단어들은 순차적으로 RNN을 통과하면서 hidden state를 업데이트하며, 입력 시퀀스의 마지막 hidden state가 컨텍스트 벡터로 사용됩니다.

2️⃣ 컨텍스트 벡터 생성

컨텍스트 벡터(context vector) 생성
- 마지막 hidden state : [0.7, -0.3, 0.4].
- 이 벡터는 입력 시퀀스의 정보를 압축한 컨텍스트 벡터로 사용됩니다.
- 디코더는 이 컨텍스트 벡터를 바탕으로 출력 시퀀스를 생성합니다.

* 컨텍스트 벡터(마지막 hidden state)는 입력 시퀀스 전체를 요약한 벡터입니다. 이 벡터는 입력 시퀀스에 대한 모든 중요한 정보를 담고 있으며, 디코더가 이를 기반으로 출력 시퀀스를 생성합니다.

컨텍스트벡터는 입력 문장의 길이와 관계없이 항상 같은 크기의 벡터로 변환합니다.
예를 들어
- "I love cats" (3 단어) 후→ [0.8, -0.5, 0.3] (3차원 벡터)
- "I really love cute cats" (5 단어) → [0.7, -0.6, 0.4] (같은 3차원 벡터)
이렇게 다른 길이의 문장도 같은 크기의 벡터로 표현됩니다.

이런 과정을 통해 인코더는 가변 길이의 입력 문장을 고정된 크기의 의미 있는 벡터로 변환할 수 있습니다.

디코더 (Decoder)

디코더는 인코더에서 받은 컨텍스트 벡터를 바탕으로 출력 시퀀스를 생성합니다. 디코더도 RNN 기반 구조를 가지며, 다음과 같이 동작합니다.

1️⃣ 컨텍스트 벡터로 초기화

인코더에서 생성된 컨텍스트 벡터를 첫 hidden state로 사용하여 출력을 생성합니다.

- 초기 hidden state: 컨텍스트 벡터 [0.7, -0.3, 0.4]

- 초기 입력: 시작 토큰 <sos>

2️⃣ 출력 시퀀스 생성

입력 토큰(< sos>)과 hidden state를 사용하여 다음 단어를 예측합니다.

예를 들어, “I love cats”라는 문장의 출력을 생성하는 과정을 단계적으로 살펴보겠습니다.

1. 첫 번째 예측
- 입력: <sos> 토큰 + 초기 hidden state [0.7, -0.3, 0.4]
- 출력: "I" + 업데이트된 hidden state, cell state

2. 두 번째 예측
- 입력: "I" + 첫 번째 예측에서 계산된 hidden state, cell state
- 출력: "love" + 업데이트된 hidden state, cell state

3. 세 번째 예측
- 입력: "love" + 두 번째 예측에서 계산된 hidden state, cell state
- 출력: "cats"

4. 종료

- 입력: “cats” (세 번째 출력 단어) + 세 번째 예측에서 계산된 hidden state, cell state

- 출력 단어: <eos> (종료 토큰)

디코더는 종료 토큰을 예측한 후 작업을 멈춥니다.

디코더 과정에서 Teacher Forcing 기법이 사용될 수 있습니다. (학습 시 정답 토큰을 입력으로 사용하는 방법).

Teacher Forcing 기법
학습 과정에서만 사용되는 특별한 방법입니다.

일반적인 방식과 Teacher Forcing의 차이

Teacher Forcing 사용 시

입력: <START> → 출력: "나는" (정답 사용)

입력: "나는" → 출력: "고양이를" (정답 사용)

입력: "고양이를" → 출력: "좋아해" (정답 사용)

Teacher Forcing 미사용 시

입력: <START> → 출력: "나는" (예측값 사용)

입력: "나는" → 출력: "강아지를" (잘못된 예측)

입력: "고양이를" → 출력: "좋아해" (오류 전파)

학습 시: 모델이"강아지를"이라고 잘못 예측했더라도,
다음 입력으로 정답인 "고양이를"을 사용하여 학습하는 방법입니다.

이렇게 하면 한 번의 오류가 후속 예측에 영향을 주지 않아 학습이 더 안정적입니다.
하지만 추론(Inference)할 때는 정답을 알 수 없으므로, 모델이 생성한 출력을 그대로 다음 입력으로 사용합니다.

hidden state는 어떻게 업데이트되나요?

RNN, LSTM, GRU와 같은 순환 구조를 사용하며, 이들은 다음과 같은 방식으로 hidden state를 업데이트합니다.
1. 입력: 현재 단어("나는")와 이전 hidden state
2. 계산: RNN/LSTM/GRU가 입력 데이터를 처리하여 새로운 hidden state를 계산
3. 출력: 다음 단어를 예측하고, 새로운 hidden state를 반환

왜 "순환 신경망을 사용" 할까?

RNN은 이전 시점의 정보를 현재 시점의 처리에 활용할 수 있습니다. 예를 들어 "cats"를 처리할 때, 앞에 나온 "I"와 "love"의 정보도 함께 고려됩니다. 이를 통해 문장의 순서와 문맥 정보를 보존할 수 있습니다.

단순 벡터 변환 vs. 컨텍스트 벡터

단순히 벡터로 변환하는 임베딩 벡터와 컨텍스트 벡터는 다른 용어인데요. 어떤 차이가 있는지 보시죠.

단순 벡터 변환
- 입력 데이터(예: 단어)를 임베딩(embedding)하여 고정된 차원의 벡터로 표현합니다.
- 예: "I" → [0.2, 0.8], "love" → [0.5, 0.1], "cats" → [0.3, 0.6].

Seq2Seq의 컨텍스트 벡터
- 단순히 단어를 벡터로 변환하는 것을 넘어, 입력 시퀀스의 순서와 의미를 학습한 결과입니다.
- Encoder는 RNN, LSTM, GRU 같은 순환 구조를 통해 시퀀스를 순차적으로 처리하며, 이전 단어들과의 관계를 반영한 hidden state를 생성합니다.
- 마지막 hidden state(컨텍스트 벡터)는 단어 간의 연관성과 문맥적 의미를 포함합니다.
- 예: "I love cats" → [0.7, -0.4, 0.3]
(이 값은 "I", "love", "cats"의 관계와 순서를 반영한 결과)

seq2seq 모델의 주요 특징

1️⃣ 가변 길이의 입력을 받아서 가변 길이의 출력을 생성할 수 있습니다.
입력 문장의 길이가 고정되어 있지 않아도 된다는 의미인데요.

예를 들어, 번역 작업에서
     * "I am happy" (3 단어)
     * "I am very very happy today" (6 단어)
이렇게 길이가 다른 두 문장 모두를 입력으로 처리할 수 있습니다.
전통적인 신경망은 보통 고정된 크기의 입력만 받을 수 있었지만, seq2seq는 이런 제약이 없습니다.

2️⃣ 문맥을 고려한 시퀀스 생성이 가능

이는 출력을 생성할 때 전체 입력 문장의 의미를 고려한다는 의미입니다.
예를 들어, "bank"라는 단어를 번역할 때
     * "I went to the bank to withdraw money" → "은행"으로 번역
     * "I sat by the river bank" → "강둑"으로 번역
이처럼 같은 단어라도 문장 전체의 문맥을 보고 적절한 의미를 선택할 수 있습니다. 이는 인코더가 입력 문장 전체의 정보를 압축해서 저장하고, 디코더가 이 정보를 바탕으로 출력을 생성하기 때문에 가능합니다.

예시를 하나 더 들어보겠습니다
문장: "The movie was not bad at all"
이 문장을 한국어로 번역할 때, seq2seq는 "not bad"라는 표현이 실제로는 긍정적인 의미라는 것을 문맥상에서 파악하여 "영화가 꽤 좋았다"와 같이 적절하게 번역할 수 있습니다. 단순히 단어 단위로 번역하면 "영화는 나쁘지 않았다"가 되어 뉘앙스가 달라질 수 있습니다.

3️⃣ 입력과 출력의 길이가 서로 다를 수 있음

Seq2Seq 모델의 한계점

1. 긴 시퀀스 처리의 한계
- 입력 시퀀스가 길어질수록 정보 손실이 발생
- 초기에 입력된 정보가 마지막 컨텍스트 벡터에 충분히 반영되지 못하는 문제 (장기 의존성 문제)
- 예시: "Last month, I went to Paris..."로 시작하는 긴 문장에서 마지막 부분을 생성할 때 "Last month"라는 시간 정보가 잘 반영되지 않을 수 있음

2. 고정 크기 컨텍스트 벡터의 병목 현상
- 입력 문장의 길이와 관계없이 항상 같은 크기의 컨텍스트 벡터를 사용
- 긴 문장의 경우 모든 정보를 제한된 크기의 벡터에 압축하다 보니 정보 손실이 불가피
- 이는 나중에 어텐션(Attention) 메커니즘의 도입 계기가 됨

3. 출력 생성의 일관성 문제
- 한 번 잘못된 예측을 하면 그 오류가 이후 생성에 계속 영향을 미침
- 예시: "I am" → "나는" → "사과를" → "먹었다"
만약 "나는" 대신 "그는"이라고 잘못 예측하면, 이후 문장의 일관성이 무너질 수 있음

4. 연산 비용과 속도
- 시퀀스를 순차적으로 처리해야 하므로 병렬 처리가 어려움
- 특히 긴 시퀀스의 경우 처리 시간이 크게 증가
- GPU를 활용한 병렬 처리의 이점을 충분히 활용하기 어려움

5. 단방향 문맥 이해의 한계
- 기본적인 seq2seq는 입력을 순차적으로만 처리
- 문장의 전체적인 문맥을 양방향으로 이해하는 데 한계가 있음
- 이는 나중에 양방향 RNN (Bidirectional RNN)의 도입 계기가 됨

이러한 한계점들을 극복하기 위한 후속 발전
- 어텐션 메커니즘 도입
- Transformer 아키텍처 개발
- 양방향 인코더 사용
- 빔 서치(Beam Search) 같은 디코딩 전략 도입

이러한 한계점들은 seq2seq 모델이 발전하는 과정에서 새로운 아키텍처와 기법들이 등장하는 계기가 되었으며, 현대의 많은 자연어 처리 모델들은 이러한 문제들을 해결하기 위한 다양한 개선 방법들을 포함하고 있습니다.

class Encoder(nn.Module):
    def __init__(self, src_vocab_size, embedding_dim, hidden_units):
        super(Encoder, self).__init__()
        self.embedding = nn.Embedding(src_vocab_size, embedding_dim, padding_idx=0)
        self.lstm = nn.LSTM(embedding_dim, hidden_units, batch_first=True)

    def forward(self, x):     # x.shape == (batch_size, seq_len)
        # 1.단어 임베딩
        x = self.embedding(x) # 임베딩층 통과 후 x.shape = (batch_size, seq_len, embedding_dim)
        # 2.LSTM 처리
        _, (hidden, cell) = self.lstm(x) # hidden.shape == (1, batch_size, hidden_units), cell.shape == (1, batch_size, hidden_units)
        return hidden, cell # 인코더의 출력은 hidden state, cell state

class Decoder(nn.Module):
    def __init__(self, tar_vocab_size, embedding_dim, hidden_units):
        super(Decoder, self).__init__()
        self.embedding = nn.Embedding(tar_vocab_size, embedding_dim, padding_idx=0)
        self.lstm = nn.LSTM(embedding_dim, hidden_units, batch_first=True)
        self.fc = nn.Linear(hidden_units, tar_vocab_size)

    def forward(self, x, hidden, cell): # x.shape == (batch_size, seq_len)
        # 1. 단어 임베딩
        x = self.embedding(x) # x.shape == (batch_size, seq_len, embedding_dim)

        # 2.LSTM 처리
        # 디코더의 LSTM으로 인코더의 hidden state, cell state를 전달.
        # output.shape == (batch_size, seq_len, hidden_units)
        # hidden.shape == (1, batch_size, hidden_units)
        # cell.shape == (1, batch_size, hidden_units)
        output, (hidden, cell) = self.lstm(x, (hidden, cell))
        # 3.출력 예측
        output = self.fc(output) # output.shape: (batch_size, seq_len, tar_vocab_size)

        # 디코더의 출력은 예측값, hidden state, cell state
        return output, hidden, cell

class Seq2Seq(nn.Module):
    def __init__(self, encoder, decoder):
        super(Seq2Seq, self).__init__()
        self.encoder = encoder
        self.decoder = decoder

    def forward(self, src, trg):
        hidden, cell = self.encoder(src) # 인코더 입력 (정수 인코딩된 소스 시퀀스, 예: 영어 문장).

        # 훈련 중에는 디코더의 출력 중 오직 output만 사용한다.
        output, _, _ = self.decoder(trg, hidden, cell) # 디코더 입력 (정수 인코딩된 타겟 시퀀스, 예: 프랑스어 문장).
        return output
    
encoder = Encoder(src_vocab_size, embedding_dim, hidden_units)
decoder = Decoder(tar_vocab_size, embedding_dim, hidden_units)
model = Seq2Seq(encoder, decoder)

[pytorch] 코사인 유사도(Cosine Similarity) | 유클리드 거리 (Euclidean Distance) | 자카드 유사도(Jaccard Similarity) | 코사인 유사도를 이용한 영화 추천 시스템 | cosine_similarity

ISFP의 블로그 — Sun, 1 Dec 2024 23:13:18 +0900

앞서 TF-IDF (Term Frequency-Inverse Document Frequency)를 사용하여 텍스트 데이터를 벡터화하는 방법을 배웠습니다.

이제, 이 TF-IDF 벡터를 활용하여 문서 간 유사도를 계산해보려 합니다.

텍스트 데이터의 유사도를 측정하는 방법으로는 여러 가지가 있지만, 이번에는 코사인 유사도 (Cosine Similarity), 유클리드 거리 (Euclidean Distance), 그리고 자카드 유사도 (Jaccard Similarity)를 사용하여 영화 추천 시스템을 구축해 보겠습니다.

유클리드 거리 vs 코사인 유사도 vs 자카드 유사도 비교

기준	유클리드 거리 (Euclidean Distance)	코사인 유사도 (Cosine Similarity)	자카드 유사도 (Jaccard Similarity)
측정 방식	벡터 간의 직선 거리	벡터 간의 각도	두 집합 간의 교집합과 합집합 비율
벡터 크기 영향	벡터의 크기에 민감	벡터의 크기를 무시하고 방향만 고려	벡터의 크기보다는 단어의 존재 여부에 중점
주요 활용 분야	수치 데이터 분석, 좌표 거리 측정	텍스트 데이터 분석, 추천 시스템	문서 유사도 분석, 검색 엔진 최적화
스케일링 필요 여부	필수	불필요	불필요
회소 행렬에서의 성능	부정확한 결과 가능	상대적으로 효율적	공통 단어가 적을 경우 부정확
문서 길이 영향	영향 있음	영향 없음	영향 없음 (단어의 존재 여부만 반영)
장점	- 좌표 공간에서의 실제 거리 측정 가능 - 수치 데이터 분석에 유리	- 텍스트 데이터에서 문서 길이와 관계없이 유사도 평가 가능	- 단어의 존재 여부만으로 유사도 측정 가능 - 빠른 계산 속도
단점	- 벡터의 크기에 민감하여 텍스트 데이터에 부적합 - 스케일링 필요	- 단어 간 문맥을 고려하지 못함	- 단어가 희귀할 경우 유사도 평가가 어려움 - 연속형 데이터에는 부적합

- 코사인 유사도는 두 벡터 간의 방향을 기준으로 유사도를 측정합니다. 벡터의 크기와 관계없이 방향이 유사할수록 높은 유사도로 평가되기 때문에, 텍스트 데이터나 추천 시스템에서 자주 사용됩니다.

- 유클리드 거리는 두 벡터 간의 직선거리를 측정합니다. 벡터 간의 거리가 가까울수록 두 텍스트가 더 유사하다고 판단합니다. 다만, 벡터의 크기에 영향을 받기 때문에 문서 길이에 따라 왜곡된 결과를 초래할 수 있습니다.

- 자카드 유사도는 두 집합 간의 유사도를 측정하는 방법으로, 공통된 요소의 비율을 기반으로 합니다. 텍스트 데이터를 집합 형태로 변환하여 단어의 중복도를 제거하고, 두 텍스트 간의 공통된 단어 비율을 비교합니다. 이 방법은 텍스트의 내용이 유사하지만 단어 빈도가 다른 경우에도 문서 간의 유사성을 잘 평가할 수 있습니다.

이제, 각 유사도 측정 방법을 활용하여 영화 줄거리 데이터를 분석하고, 사용자가 입력한 영화와 유사한 영화를 추천하는 시스템을 만들어 보겠습니다.

코사인 유사도(Cosine Similarity)란?

코사인 유사도는 두 벡터 간의 각도를 이용해 유사도를 측정하는 방법입니다.

벡터의 크기가 아니라 방향이 얼마나 유사한지를 평가하기 때문에, 텍스트 데이터나 추천 시스템에서 자주 활용됩니다.

\[
\text {Cosine Similarity}(A, B) = \frac {A \cdot B}{\|A\| \|B\|}
\]

- $ A \cdot B $: 두 벡터의 내적
- $ \|A\| $: 벡터 $ A $의 크기(길이)
- $ \|B\| $: 벡터 $ B $의 크기(길이)

(문서 단어 행렬이나 TF-IDF 행렬을 통해서 문서의 유사도를 구하는 경우에는 문서 단어 행렬이나 TF-IDF 행렬이 각각의 벡터 A, B가 됩니다.)

코사인 유사도의 값이
- 1에 가까울수록 두 벡터가 유사함을 의미합니다.
- 0에 가까울수록 두 벡터가 서로 직각임을 의미합니다(즉, 유사하지 않음).
- -1에 가까울수록 두 벡터가 반대 방향을 가리킴을 의미합니다(이 경우는 텍스트나 추천 시스템에서 거의 발생하지 않음).

코사인 유사도가 벡터의 크기에 영향을 받지 않는 이유

공식에서 보시다시피, 코사인 유사도는 두 벡터의 내적을 각 벡터의 크기(길이)로 나눕니다.

이 과정을 통해 벡터의 크기를 정규화하게 됩니다.

즉, 벡터의 크기가 아무리 커도 내적 값은 그 크기로 나눠지기 때문에 결과적으로 크기(길이)의 영향을 제거하게 됩니다.

예를 들어,
벡터의 크기가 다른 경우
   - 벡터 $ A = [1, 1] $
   - 벡터 $ B = [2, 2] $

   코사인 유사도 계산
   \[
   A \cdot B = 1 \times 2 + 1 \times 2 = 4
   \]
   \[
   \|A\| = \sqrt {1^2 + 1^2} = \sqrt {2}, \quad \|B\| = \sqrt {2^2 + 2^2} = \sqrt {8}
   \]
   \[
   \text {Cosine Similarity}(A, B) = \frac {4}{\sqrt {2} \times \sqrt {8}} = \frac {4}{4} = 1
   \]

   결과적으로, 벡터의 크기가 다르지만 방향이 동일하기 때문에 코사인 유사도는 1이 됩니다.

벡터의 방향이 다른 경우
   - 벡터 $ A = [1, 0] $
   - 벡터 $ B = [0, 1] $

   코사인 유사도 계산
   \[
   A \cdot B = 1 \times 0 + 0 \times 1 = 0
   \]
   \[
   \|A\| = \sqrt {1^2 + 0^2} = 1, \quad \|B\| = \sqrt {0^2 + 1^2} = 1
   \]
   \[
   \text {Cosine Similarity}(A, B) = \frac {0}{1 \times 1} = 0
   \]

여기서, 벡터의 크기가 같아도 방향이 다르기 때문에 코사인 유사도는 0이 됩니다.

정리하자면,
코사인 유사도는 벡터의 크기를 정규화하기 때문에, 벡터의 길이(크기)에는 영향을 받지 않습니다. 대신, 두 벡터의 방향(각도)에만 초점을 맞추어 유사도를 측정합니다. 따라서 문서의 길이(단어 수)와 관계없이, 내용의 유사성을 더 잘 평가할 수 있습니다.

텍스트 데이터에서 코사인 유사도는 어떻게 계산할까?

예를 들어, 세 개의 문서에 대해 TF-IDF를 계산했다고 가정해 보겠습니다.

1. 문서 1의 TF-IDF 결과: `[0.5, 0.3, 0.0, 0.2]`
2. 문서 2의 TF-IDF 결과: `[0.1, 0.7, 0.0, 0.4]`
3. 문서 3의 TF-IDF 결과: `[0.0, 0.2, 0.6, 0.1]`

TF-IDF 벡터를 사용해 코사인 유사도를 계산하는 과정은 다음과 같습니다.

     \[
     \text{Cosine Similarity}(A, B) = \frac {A \cdot B}{\|A\| \times \|B\|}
     \]

만약, 우리가 문서 1과 문서 2의 코사인 유사도를 계산한다고 가정해 보겠습니다.

- 문서 1의 벡터: `[0.5, 0.3, 0.0, 0.2]`
- 문서 2의 벡터: `[0.1, 0.7, 0.0, 0.4]`

1. 내적 계산 ($ A \cdot B $):
   \[
   (0.5 \times 0.1) + (0.3 \times 0.7) + (0.0 \times 0.0) + (0.2 \times 0.4) = 0.05 + 0.21 + 0 + 0.08 = 0.34
   \]

2. 벡터의 크기 계산 ($ \|A\| $와 $ \|B\| $):
   \[
   \|A\| = \sqrt {0.5^2 + 0.3^2 + 0.0^2 + 0.2^2} = \sqrt {0.25 + 0.09 + 0 + 0.04} = \sqrt {0.38} \approx 0.616
   \]
   \[
   \|B\| = \sqrt {0.1^2 + 0.7^2 + 0.0^2 + 0.4^2} = \sqrt {0.01 + 0.49 + 0 + 0.16} = \sqrt {0.66} \approx 0.812
   \]

3. 코사인 유사도 계산:
   \[
   \text {Cosine Similarity}(A, B) = \frac {0.34}{0.616 \times 0.812} = \frac {0.34}{0.500} \approx 0.68
   \]

코사인 유사도 (Cosine Similarity)의 장단점

장점

- 코사인 유사도는 벡터의 크기(길이)가 아닌 방향에 초점을 맞춰 두 벡터 간의 유사도를 측정하기 때문에 텍스트 데이터에서 문서의 길이와 무관하게 내용의 유사성을 평가할 수 있어, 문서 분류, 추천 시스템 등에 효과적입니다.

- 희소 행렬(Sparse Matrix)에서 0이 많은 경우에도 유사도를 측정하는 데 있어 유클리드 거리보다 더 정확한 결과를 제공합니다.

- 코사인 유사도는 벡터의 방향만 고려하므로, 벡터의 크기에 영향을 받지 않습니다. 따라서 정규화 과정 없이 바로 유사도를 계산할 수 있어 계산 비용을 줄일 수 있습니다.

- 추천 시스템, 문서 검색, 클러스터링 등에서 문서 간의 내용 유사성을 평가할 때 자주 사용됩니다. 특히 텍스트 데이터와 같이 벡터의 크기보다는 단어의 조합과 빈도가 중요한 경우에 유리합니다.

단점

- 코사인 유사도는 단순히 단어의 빈도와 중요도만을 사용하여 벡터를 비교하기 때문에, 단어 간의 문맥적 관계를 고려하지 못합니다. 예를 들어, 동의어나 유사한 의미를 가진 단어가 다른 벡터로 표현되면, 문서의 의미가 유사하더라도 낮은 유사도 값을 가질 수 있습니다.

예를 들어, "car"와 "vehicle"이 동의어이더라도, "car"가 한 문서에서 자주 등장해 TF-IDF 값이 낮고, "vehicle"이 다른 문서에서 드물게 등장해 TF-IDF 값이 높다면, 두 벡터는 다른 방향을 가질 수 있습니다. 이로 인해 코사인 유사도 값이 낮게 나오게 되는 거죠. 이를 해결하기 위해 Word2Vec, BERT와 같은 임베딩 기법을 활용하면 단어 간의 문맥을 반영하여 더 정확한 유사도 측정이 가능합니다.

- 희소 행렬에서 공통으로 등장하는 단어가 거의 없는 경우, 대부분의 값이 0이 됩니다. 예를 들어, 'car'라는 단어가 문서 1에만 1번 등장하고 다른 문서에는 전혀 등장하지 않는다면, 다른 문서에서는 해당 단어의 값이 모두 0이 됩니다. 이로 인해 문서 간 유사도를 비교할 때 코사인 유사도가 낮게 나올 수 있습니다.

- 단어의 순서를 무시하고 벡터화된 단어 빈도만을 사용하기 때문에 문장의 구조나 문맥을 반영하지 못해, 같은 단어들이 포함되어 있어도 다른 의미를 가질 수 있는 문장들을 구분하지 못합니다.

결론적으로, 코사인 유사도는 텍스트 데이터에서 문서의 길이에 영향을 받지 않고 유사도를 측정할 수 있어, 추천 시스템과 텍스트 분류 등에 매우 적합하지만, 단어의 순서나 문맥을 고려하지 않기 때문에, 더 깊은 의미를 이해하는 데 한계가 있습니다.

따라서 코사인 유사도는 텍스트 데이터에서 주로 사용되지만, 더 높은 수준의 이해가 필요한 분석에서는 Word2Vec, BERT와 같은 임베딩 기법을 사용할 수도 있습니다.

코사인 유사도를 이용한 텍스트 문서 유사도 분석 (예제)

우리가 앞서 학습한 TF-IDF를 이용해 문서를 벡터로 변환한 후, 코사인 유사도를 통해 문서 간 유사도를 측정해 보겠습니다.

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

# 예제 문서 리스트
corpus = [
    "나는 오늘 밥을 먹었다",
    "밥을 먹고 운동을 했다",
    "오늘 운동을 마치고 밥을 먹었다"
]

# TF-IDF 벡터화
vectorizer = TfidfVectorizer()
tfidf_matrix = vectorizer.fit_transform(corpus)

# 코사인 유사도 계산
cosine_sim = cosine_similarity(tfidf_matrix, tfidf_matrix)

# 결과를 데이터프레임으로 보기 좋게 출력
df = pd.DataFrame(cosine_sim, index=["문서1", "문서2", "문서3"], columns=["문서1", "문서2", "문서3"])
print("코사인 유사도 행렬:")
print(df)

문서 1, 2, 3의 코사인 유사도 결과를 보면,
문서 1과 문서 3의 유사도가 0.552로 가장 높습니다. 이는 두 문서에 유사한 단어가 많이 포함되어 있다는 것을 의미합니다.
또한 문서 2와 다른 문서들 간의 유사도는 상대적으로 낮습니다.

코사인 유사도를 이용한 영화 추천 시스템 (실습)

추천 시스템이란?
- 추천 시스템은 사용자의 취향을 분석하여 관련된 콘텐츠(예: 영화, 음악, 도서)를 추천하는 시스템입니다.
- 콘텐츠 기반 추천과 협업 필터링 추천 방식이 대표적입니다.

이제 코사인 유사도를 활용하여,

좋아하는 영화를 입력하면 해당 영화의 줄거리와 유사한 줄거리의 영화를 찾아서 추천하는 코드를 작성해 보도록 해요.

우선 사용할 데이터셋을 불러옵니다.

import pandas as pd

# 인코딩을 'ISO-8859-1'로 지정하여 파일 로드
movies_df = pd.read_csv('movies_metadata_low.csv', encoding='ISO-8859-1')

`movies_metadata_low.csv` 파일에는 24개의 열(column)과 45466개의 행(row)이 포함되어 있습니다.

사용할 칼럼만 불러와서 확인해 볼게요.

movies_df[['title','overview']]

title과 overview 칼럼에는 결측값이 존재하네요.

이제 `overview`(줄거리 설명)을 활용해, 영화 간 유사도를 측정하고 추천 시스템을 구축할 수 있습니다.

1️⃣ 데이터 전처리: overview 열에 결측치 처리 및 텍스트 전처리를 합니다.

from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.metrics.pairwise import cosine_similarity

# Step 1: 결측치 처리 (overview 열에서 결측값을 빈 문자열로 대체)
movies_df['overview'] = movies_df['overview'].fillna('')

2️⃣ TF-IDF 벡터화: overview 텍스트를 TF-IDF 벡터화하여 문서를 수치화합니다.

# Step 2: TF-IDF 벡터화 (overview 텍스트를 수치화)
tfidf_vectorizer = TfidfVectorizer(stop_words='english')
tfidf_matrix = tfidf_vectorizer.fit_transform(movies_df['overview'])

# TF-IDF 행렬을 Pandas DataFrame으로 변환
tfidf_df = pd.DataFrame(tfidf_matrix.toarray(), columns=tfidf_vectorizer.get_feature_names_out())
print(tfidf_df)

TF-IDF 벡터화한 결과를 보면 총 45466개의 행(row)과 19741개의 열(column)이 출력되었습니다.

이는 45466개의 영화가 있으며, 19741개의 고유한 단어들을 나타냅니다.

3️⃣ 코사인 유사도 계산: 영화 줄거리 간의 코사인 유사도를 계산하여, 특정 영화와 유사한 영화를 찾습니다.

# Step 3: 코사인 유사도 계산 (모든 영화 간의 유사도)
cosine_sim = cosine_similarity(tfidf_matrix, tfidf_matrix)
print('코사인 유사도 연산 결과 :',cosine_sim.shape)

> 코사인 유사도 연산 결과 : (45466, 45466)

코사인 유사도 연산 결과로 생성된 행렬은 45466개의 행과 열을 가지고 있습니다.

이는 45466개의 각 문서 벡터(영화 줄거리 벡터)와 자기 자신을 포함한 다른 45466개의 문서 벡터 간의 유사도를 기록한 행렬입니다. 이 행렬에는 모든 영화 간의 상호 유사도가 기록되어 있습니다.

이제 기존 데이터프레임으로부터 영화의 타이틀을 key, 영화의 인덱스를 value로 하는 딕셔너리 movie_indices를 만들어둡니다.

# 영화 제목을 키(key)로, 데이터프레임의 인덱스를 값(value)으로 갖는 딕셔너리 생성
movie_indices = dict(zip(movies_df['title'], movies_df.index))
movie_indices

> {'Toy Story': 0,
 'Jumanji': 1,
 'Grumpier Old Men': 2,
 'Waiting to Exhale': 3,
 'Father of the Bride Part II': 4,
 'Heat': 5,
 'Sabrina': 888,
 'Tom and Huck': 7,
 'Sudden Death': 8,
 'GoldenEye': 9,
 'The American President': 10,
 'Dracula: Dead and Loving It': 11,
 'Balto': 12,
 'Nixon': 13,
 'Cutthroat Island': 14,
 'Casino': 15,
 'Sense and Sensibility': 16,
 'Four Rooms': 17,
 'Ace Ventura: When Nature Calls': 18,
 'Money Train': 19,
 'Get Shorty': 20,
 'Copycat': 21,
 'Assassins': 22,
 'Powder': 23,
 'Leaving Las Vegas': 24,
...
 'Robin Hood: Prince of Thieves': 998,
 'Mary Poppins': 999,
 'Dumbo': 1000,
 "Pete's Dragon": 1001,
 ...}

4️⃣ 추천 시스템 구현: 영화의 제목을 입력하면 사용자가 선택한 영화와 가장 유사한 영화 5개를 추천합니다.

# 코사인 유사도를 기반으로 영화 추천 함수 정의
def get_recommendations(title, cosine_sim=cosine_sim):
    # 선택한 영화의 인덱스 가져오기
    idx = movie_indices.get(title) # 주어진 영화 제목(title)에 해당하는 인덱스(idx) 값을 반환합니다. ex) 485
    if idx is None:
        return "해당 영화 제목이 데이터에 없습니다."
    
    # 해당 영화와 다른 영화 간의 유사도 점수 추출
    sim_scores = list(enumerate(cosine_sim[idx])) # (영화 인덱스, 유사도 점수) -> [(0, 0.143), (1, 0.0)...]

    # 유사도 점수를 기준으로 정렬 (내림차순)
    sim_scores = sorted(sim_scores, key=lambda x: x[1], reverse=True)
    
    # 가장 유사한 영화 5개 선택 (자기 자신 제외)
    sim_scores = sim_scores[1:6] # [(0, 0.14393405169022885), (959, 0.13863297484628673), (2371, 0.13518346539986825), (3201, 0.12138975288943879), (2845, 0.1172780131667607)]

    # 추천 영화 목록 출력
    recommended_indices = [i[0] for i in sim_scores] # 영화 인덱스
    recommended_titles = movies_df['title'].iloc[recommended_indices] # 영화 제목
    return recommended_titles.tolist()

# 예시: 'Malice'와 유사한 영화 추천
get_recommendations("Malice")

> ['Toy Story', 'Bliss', 'Tinseltown', 'Judy Berlin', 'The Story of Us']

유클리드 거리 (Euclidean Distance)란?

유클리드 거리는 두 벡터 간의 직선거리를 의미합니다.

값이 작을수록 두 문서가 더 유사하다는 의미이며, 반대로 값이 클수록 문서 간의 차이가 크다는 의미입니다.

주로 좌표 공간에서 두 점 사이의 거리를 구할 때 사용됩니다.

\[
\text {Euclidean Distance}(A, B) = \sqrt {\sum_{i=1}^{n} (A_i - B_i)^2}
\]

- $ A $와 $ B $: 두 벡터
- $ n $: 벡터의 차원 수
- $ A_i, B_i $: 두 벡터의 각 성분

TF-IDF 벡터화를 통해 각 문서는 수치화된 벡터로 변환됩니다.

각 벡터는 단어의 중요도를 반영한 값들로 구성되어 있으며, 단어마다 다른 TF-IDF 점수를 가집니다.
예를 들어, 두 문서가 비슷한 내용을 가지고 있다면, 이 두 문서의 TF-IDF 벡터는 비슷한 값들을 갖게 되죠.

거리 계산은 다음과 같이 이루어지는데요.
  \[
  \text {Euclidean Distance}(A, B) = \sqrt {\sum_{i=1}^{n} (A_i - B_i)^2}
  \]
여기서 $A_i$와 $B_i$는 두 문서의 TF-IDF 벡터에서 각 단어의 중요도를 나타내는 값입니다.
TF-IDF 값이 비슷한 문서들은, 위 식에서 각 성분의 차이 $(A_i - B_i)$가 작아지므로, 유클리드 거리 값이 작게 나오겠죠.

만약, 아래와 같은 3개의 문서가 있는 경우
- 문서 A: "고양이가 귀엽다"
- 문서 B: "고양이가 매우 귀엽다"
- 문서 C: "자동차를 운전하다"

TF-IDF로 벡터화하면 문서 A와 B는 비슷한 단어를 사용하므로 유사한 벡터를 가질 것입니다.

반면, 문서 C는 전혀 다른 단어를 사용하므로 벡터가 다를 것입니다.

결국 유클리드 거리 계산 결과는,
A와 B 간의 거리는 짧고 (비슷한 문서)
A와 C 또는 B와 C 간의 거리는 길어집니다. (내용이 다른 문서)

텍스트 데이터에서 유클리드 거리를 어떻게 계산할까?

예를 들어, 세 개의 문서에 대해 TF-IDF를 계산했다고 가정해 보겠습니다.

1. 문서 1의 TF-IDF 결과: `[0.5, 0.3, 0.0, 0.2]`
2. 문서 2의 TF-IDF 결과: `[0.1, 0.7, 0.0, 0.4]`
3. 문서 3의 TF-IDF 결과: `[0.0, 0.2, 0.6, 0.1]`

TF-IDF 벡터를 사용해 유클리드 거리를 계산하는 과정은 다음과 같습니다.

\[
\text{Euclidean Distance}(A, B) = \sqrt{\sum_{i=1}^{n} (A_i - B_i)^2}
\]

만약, 문서 1과 문서 2의 유클리드 거리를 계산한다면
- 문서 1의 벡터: `[0.5, 0.3, 0.0, 0.2]`
- 문서 2의 벡터: `[0.1, 0.7, 0.0, 0.4]`

1. 벡터 성분 간의 차이 계산
\[
(0.5 - 0.1)^2 = 0.16
\]
\[
(0.3 - 0.7)^2 = 0.16
\]
\[
(0.0 - 0.0)^2 = 0
\]
\[
(0.2 - 0.4)^2 = 0.04
\]

2. 차이 제곱합 계산
\[
0.16 + 0.16 + 0 + 0.04 = 0.36
\]

#### 3. 제곱근 계산
\[
\sqrt {0.36} = 0.6
\]

따라서, 문서 1과 문서 2의 유클리드 거리는 0.6입니다.

유클리드 거리 (Euclidean Distance)의 장단점

장점

- 두 벡터 간의 직선거리를 측정하기 때문에 개념적으로 매우 직관적입니다. 좌표 공간에서 두 점 사이의 거리와 동일한 방식으로 계산되므로, 수치화된 데이터를 분석할 때 쉽게 적용할 수 있습니다.

- 수치형 데이터나 좌표 공간에서의 거리 측정에 적합합니다. 예를 들어, 고객의 위치, 제품의 특징 벡터 등 수치형 데이터를 다룰 때 유용합니다.

- 벡터의 각 성분 간 차이를 고려하기 때문에, 데이터 간의 절대적인 차이를 반영하는 데 유리합니다. 이로 인해 벡터의 크기가 중요한 분석에서 유클리드 거리가 효과적입니다.

단점

- 텍스트 데이터의 경우, 유클리드 거리는 벡터의 크기에 영향을 받습니다. 즉, 문서가 길어지면 해당 벡터의 크기도 커지므로, 두 문서 간의 거리가 실제 유사성과 관계없이 멀어질 수 있습니다. 따라서 문서 길이가 다를 경우, 유클리드 거리는 왜곡된 결과를 초래할 수 있습니다.

- 데이터의 스케일에 매우 민감합니다. 데이터의 범위가 다를 경우, 큰 값이 작은 값보다 더 큰 영향을 미치게 되므로, 데이터를 스케일링(정규화) 하지 않으면 부정확한 결과를 가져올 수 있습니다. (TfidfVectorizer는 정규화를 포함하고 있어서 적용하지 않아도 됨)

- 텍스트 데이터를 TF-IDF로 변환하면, 보통 희소 행렬(Sparse Matrix) 형태로 나타나게 됩니다. 희소 행렬에서 0이 많은 경우, 벡터 성분 간의 차이 값이 커질 수 있어 왜곡된 거리를 초래할 수 있습니다.

- 유클리드 거리는 벡터의 크기 차이만을 반영하기 때문에 텍스트 데이터처럼 벡터의 방향(내용의 유사성)이 중요한 경우에는 부적합할 수 있습니다. 예를 들어, 문서의 길이가 다르지만 내용이 유사한 문서들 간의 유사도를 정확히 평가하기 어렵습니다.

유클리드 거리를 이용한 텍스트 문서 유사도 분석 (예제)

TF-IDF로 벡터화한 문서 데이터를 활용해 유클리드 거리를 계산하고, 문서 간 유사도를 측정해 보겠습니다.

1️⃣ 예제 데이터 준비

from sklearn.feature_extraction.text import TfidfVectorizer
import pandas as pd
from scipy.spatial.distance import euclidean

# 예제 문서 리스트
corpus = [
    "나는 오늘 밥을 먹었다",
    "밥을 먹고 운동을 했다",
    "오늘 운동을 마치고 밥을 먹었다"
]

# TF-IDF 벡터화
vectorizer = TfidfVectorizer()
tfidf_matrix = vectorizer.fit_transform(corpus).toarray()

# 문서 간 유클리드 거리 계산
def calculate_euclidean_distance(matrix):
    n = matrix.shape[0] # 문서의 개수
    distances = pd.DataFrame(index=range(n), columns=range(n)) # n x n 크기의 빈 데이터프레임 생성
    # 문서 간 유클리드 거리 계산
    for i in range(n):
        for j in range(n):
            distances.iloc[i, j] = euclidean(matrix[i], matrix[j])
    return distances

# 유클리드 거리 행렬 출력
euclidean_distances = calculate_euclidean_distance(tfidf_matrix)
euclidean_distances.index = ["문서1", "문서2", "문서3"]
euclidean_distances.columns = ["문서1", "문서2", "문서3"]
print("\n유클리드 거리 행렬:")
print(euclidean_distances)

문서 1, 2, 3의 유클리드 거리 결과를 보면,

1. 문서 1과 문서 3의 유클리드 거리가 0.96으로 가장 가깝습니다. 즉, 이 두 문서는 서로 가장 유사한 내용을 가지고 있습니다.

2. 문서 1과 문서 2의 거리는 1.32로, 서로 더 멀리 떨어져 있어 덜 유사합니다.

3. 문서 2와 문서 3의 거리는 1.18입니다. 이 값은 문서 1과 문서 2의 거리보다는 가깝지만, 문서 1과 문서 3만큼 가깝지는 않습니다.

4. 자기 자신과의 거리는 항상 0입니다.

결론적으로

• 문서1과 문서 3이 가장 유사하며,

• 문서1과 문서 2는 가장 덜 유사합니다.

유클리드 거리를 이용한 영화 추천 시스템 (실습)

이제 영화 데이터셋을 활용하여, 영화 줄거리(overview)를 유클리드 거리로 비교해 유사한 영화를 추천하는 시스템을 구축해 보겠습니다.

1️⃣ 데이터 준비 및 전처리

전처리까지는 위에서 진행한 코사인 유사도와 동일한 코드입니다.

import pandas as pd
from sklearn.feature_extraction.text import TfidfVectorizer
from scipy.spatial.distance import euclidean

# 데이터 로드 및 전처리
movies_df = pd.read_csv('movies_metadata_low.csv', encoding='ISO-8859-1')
movies_df['overview'] = movies_df['overview'].fillna('')

# TF-IDF 벡터화
tfidf_vectorizer = TfidfVectorizer(stop_words='english')
tfidf_matrix = tfidf_vectorizer.fit_transform(movies_df['overview']).toarray()

# 영화 제목과 인덱스를 매핑하는 딕셔너리 생성
movie_indices = dict(zip(movies_df['title'], movies_df.index))

2️⃣ 유클리드 거리 기반 추천 함수 구현

def get_recommendations_euclidean(title, n_recommendations=5):
    # 선택한 영화의 인덱스 가져오기
    idx = movie_indices.get(title)
    if idx is None:
        return "해당 영화 제목이 데이터에 없습니다."
    
    # 선택한 영화의 TF-IDF 벡터
    target_vector = tfidf_matrix[idx]
    
    # 모든 영화와의 유클리드 거리 계산
    distances = []
    for i in range(len(tfidf_matrix)):
        # 선택된 영화(target_vector)와 모든 영화 간의 유클리드 거리를 계산
        dist = euclidean(target_vector, tfidf_matrix[i])
        distances.append((i, dist))
    
    # 거리 기준으로 정렬 (가까운 순)
    distances = sorted(distances, key=lambda x: x[1])
    
    # 가장 가까운 영화 n개 선택 (자기 자신 제외)
    recommended_indices = [i[0] for i in distances[1:n_recommendations + 1]]
    recommended_titles = movies_df['title'].iloc[recommended_indices]
    return recommended_titles.tolist()

# 예시: 'Malice'와 유사한 영화 추천
print(get_recommendations_euclidean("Malice"))

> ['Wings of Courage', 'Roommates', 'Peanuts  Die Bank zahlt alles', 'Happy Weekend', 'The Superwife']

자카드 유사도(Jaccard Similarity)란?

자카드 유사도는 두 집합 간의 유사도를 측정하는 지표로, 두 집합의 교집합 크기를 합집합 크기로 나눈 값으로 정의됩니다.

\[
\text {Jaccard Similarity}(A, B) = \frac {|A \cap B|}{|A \cup B|}
\]

- $A$, $B$: 비교하고자 하는 두 개의 집합
- $|A \cap B|$: 두 집합의 교집합 크기
- $|A \cup B|$: 두 집합의 합집합 크기

자카드 유사도 값은 0부터 1 사이의 값을 가집니다.

- 1에 가까울수록 두 집합이 유사함을 의미합니다.

- 0에 가까울수록 두 집합이 겹치는 부분이 거의 없음을 의미합니다.

텍스트 데이터에서 자카드 유사도(Jaccard Similarity)는 어떻게 계산할까?

아래와 같은 세 개의 문서가 있습니다.
1. 문서 1: "나는 오늘 밥을 먹었다"
2. 문서 2: "밥을 먹고 운동을 했다"
3. 문서 3: "오늘 운동을 마치고 밥을 먹었다"

1. 문서의 토큰화 (단어 집합 생성)

우선, 각 문서를 단어 단위로 분리하여 집합으로 만듭니다.
- 문서 1의 집합: `{나는, 오늘, 밥을, 먹었다}`
- 문서 2의 집합: `{밥을, 먹고, 운동을, 했다}`
- 문서 3의 집합: `{오늘, 운동을, 마치고, 밥을, 먹었다}`

2. 자카드 유사도 계산

문서 1과 문서 2의 자카드 유사도
- 교집합 ($ A \cap B $): `{밥을}`
- 합집합 ($ A \cup B $): `{나는, 오늘, 밥을, 먹었다, 먹고, 운동을, 했다}`

\[
\text{Jaccard Similarity}(A, B) = \frac{|A \cap B|}{|A \cup B|} = \frac {1}{7} \approx 0.143
\]

자카드 유사도(Jaccard Similarity)의 장단점

장점
- 집합 간의 유사도를 단순히 교집합과 합집합의 비율로 측정하기 때문에 이해하기 쉽고 계산이 간단합니다.
- 단어의 존재 여부에만 초점을 맞추므로, 이진 데이터(존재/부재)를 분석할 때 유용합니다. 예를 들어, 검색 엔진, 추천 시스템 등에서 주로 사용됩니다.
- 빈도나 가중치 대신 단어의 존재 여부만 고려하기 때문에, 단어 빈도 차이로 인한 영향이 적고, 노이즈에 강합니다.

단점
- 단어의 빈도나 중요도를 반영하지 않기 때문에, 문서에서 단어가 얼마나 중요한지를 고려하지 못합니다. 즉, 단어가 여러 번 등장하더라도 단순히 한 번 존재하는 것과 동일하게 취급됩니다.
- 단어의 문맥적 의미를 반영하지 못합니다. 따라서 동의어나 유사한 의미를 가진 단어가 포함된 문서들이 실제로는 유사하더라도, 낮은 유사도 값을 가질 수 있습니다. 예를 들어, "car"와 "vehicle"이 각각 다른 문서에 포함된 경우, 자카드 유사도는 두 문서를 낮은 유사도로 평가할 수 있습니다.
- 텍스트 데이터를 자카드 유사도로 비교할 때, 공통된 단어가 거의 없는 희소 행렬에서 유사도가 낮게 나옵니다. 특히, 단어가 많고 문서 간에 공통 단어가 적을수록 유사도가 낮아질 수 있어 정확한 유사도 측정이 어려워집니다.
- 단어 수가 매우 적은 짧은 문서 간의 유사도 계산 시, 한 단어의 차이로도 유사도 값이 크게 변동할 수 있습니다.

결론적으로, 자카드 유사도는 단어의 존재 여부를 기준으로 간단하게 유사도를 측정할 수 있는 방법이지만, 단어의 빈도, 중요도, 문맥적 의미를 반영하지 못합니다. 특히, 희소한 데이터나 짧은 문서를 비교할 때는 신뢰도가 낮아질 수 있습니다. 이러한 이유로, 자카드 유사도는 텍스트 데이터 분석보다는 이진 데이터 분석에 더 적합한 경우가 많습니다.

자카드 유사도를 이용한 텍스트 문서 유사도 분석 (예제)

from sklearn.feature_extraction.text import CountVectorizer
from sklearn.metrics import jaccard_score

# 예제 문서 리스트
corpus = [
    "나는 오늘 밥을 먹었다",
    "밥을 먹고 운동을 했다",
    "오늘 운동을 마치고 밥을 먹었다"
]

# CountVectorizer를 사용해 단어 집합 생성 (1-gram 기준)
vectorizer = CountVectorizer()
binary_matrix = vectorizer.fit_transform(corpus).toarray()

# 자카드 유사도 계산
def calculate_jaccard_similarity(matrix):
    n = matrix.shape[0]
    similarities = []
    for i in range(n):
        for j in range(i + 1, n):
            sim = jaccard_score(matrix[i], matrix[j], average='binary')
            similarities.append((f"문서 {i + 1}", f"문서 {j + 1}", sim))
    return similarities

# 결과 출력
jaccard_similarities = calculate_jaccard_similarity(binary_matrix)
for doc1, doc2, sim in jaccard_similarities:
    print(f"{doc1}와 {doc2}의 자카드 유사도: {sim:.3f}")

문서 1과 문서 3의 자카드 유사도(0.500)가 가장 높습니다. 즉, 문서 1과 문서 3이 다른 문서 쌍에 비해 공통된 단어를 더 많이 가지고 있어서 가장 유사한 것으로 해석할 수 있습니다.

자카드 유사도를 이용한 영화 추천 시스템 (실습)

이제 영화 데이터셋을 활용하여, 영화 줄거리(overview)를 자카드 유사도로 비교해 유사한 영화를 추천하는 시스템을 구축해 보겠습니다.

자카드 유사도를 텍스트 데이터에 적용하려면, 먼저 TF-IDF 대신 이진 벡터를 사용해야 합니다.

`CountVectorizer`를 이용해 이진 벡터로 변환한 후 자카드 유사도를 계산할 수 있습니다.
(CountVectorizer(binary=True)를 사용하여 텍스트를 이진 벡터화합니다. 각 단어가 문서에 존재하면 1, 없으면 0으로 표시합니다.)

import pandas as pd
from sklearn.feature_extraction.text import CountVectorizer
from sklearn.metrics import jaccard_score

# 데이터 로드 및 전처리
movies_df = pd.read_csv('movies_metadata_low.csv', encoding='ISO-8859-1')
movies_df['overview'] = movies_df['overview'].fillna('')

# CountVectorizer를 사용해 이진 벡터화
count_vectorizer = CountVectorizer(stop_words='english', binary=True)
binary_matrix = count_vectorizer.fit_transform(movies_df['overview']).toarray()

# 영화 제목과 인덱스를 매핑하는 딕셔너리 생성
movie_indices = dict(zip(movies_df['title'], movies_df.index))

def get_recommendations_jaccard(title, n_recommendations=5):
    # 선택한 영화의 인덱스 가져오기
    idx = movie_indices.get(title)
    if idx is None:
        return "해당 영화 제목이 데이터에 없습니다."
    
    # 선택한 영화의 이진 벡터 가져오기
    target_vector = binary_matrix[idx]
    
    # 모든 영화와의 자카드 유사도 계산
    similarities = []
    for i in range(len(binary_matrix)):
        sim = jaccard_score(target_vector, binary_matrix[i])
        similarities.append((i, sim))
    
    # 유사도 기준으로 정렬 (내림차순)
    similarities = sorted(similarities, key=lambda x: x[1], reverse=True)
    
    # 가장 유사한 영화 n개 선택 (자기 자신 제외)
    recommended_indices = [i[0] for i in similarities[1:n_recommendations + 1]]
    recommended_titles = movies_df['title'].iloc[recommended_indices]
    return recommended_titles.tolist()

# 'Malice'와 유사한 영화 추천
print(get_recommendations_jaccard("Malice"))

> ['Bliss', 'The Story of Us', 'Judy Berlin', 'American Graffiti', 'In Dreams']

[오류Error] Resource punkt_tab not found. Please use the NLTK Downloader to obtain the resource:

ISFP의 블로그 — Fri, 22 Nov 2024 12:24:31 +0900

텍스트 전처리 공부하는 중에 로컬에서 토크나이저를 수행하려고 하니 에러가 발생했다.

sent_text = sent_tokenize(content_text)

{
	"name": "LookupError",
	"message": "
**********************************************************************
  Resource punkt_tab not found.
  Please use the NLTK Downloader to obtain the resource:

  >>> import nltk
  >>> nltk.download('punkt_tab')
  
  For more information see: https://www.nltk.org/data.html

  Attempted to load tokenizers/punkt_tab/english/

  Searched in:
    - '/Users/song/nltk_data'
    - '/Users/song/opt/anaconda3/envs/song38/nltk_data'
    - '/Users/song/opt/anaconda3/envs/song38/share/nltk_data'
    - '/Users/song/opt/anaconda3/envs/song38/lib/nltk_data'
    - '/usr/share/nltk_data'
    - '/usr/local/share/nltk_data'
    - '/usr/lib/nltk_data'
    - '/usr/local/lib/nltk_data'
**********************************************************************
",
	"stack": "---------------------------------------------------------------------------
LookupError                               Traceback (most recent call last)
Cell In[8], line 2
      1 # 입력 코퍼스에 대해서 NLTK를 이용하여 문장 토큰화를 수행.
----> 2 sent_text = sent_tokenize(content_text)
      4 # # 각 문장에 대해서 구두점을 제거하고, 대문자를 소문자로 변환.
      5 # normalized_text = []
      6 # for string in sent_text:
   (...)
     10 # # 각 문장에 대해서 NLTK를 이용하여 단어 토큰화를 수행.
     11 # result = [word_tokenize(sentence) for sentence in normalized_text]

File ~/opt/anaconda3/envs/song38/lib/python3.8/site-packages/nltk/tokenize/__init__.py:119, in sent_tokenize(text, language)
    109 def sent_tokenize(text, language=\"english\"):
    110     \"\"\"
    111     Return a sentence-tokenized copy of *text*,
    112     using NLTK's recommended sentence tokenizer
   (...)
    117     :param language: the model name in the Punkt corpus
    118     \"\"\"
--> 119     tokenizer = _get_punkt_tokenizer(language)
    120     return tokenizer.tokenize(text)

File ~/opt/anaconda3/envs/song38/lib/python3.8/site-packages/nltk/tokenize/__init__.py:105, in _get_punkt_tokenizer(language)
     96 @functools.lru_cache
     97 def _get_punkt_tokenizer(language=\"english\"):
     98     \"\"\"
     99     A constructor for the PunktTokenizer that utilizes
    100     a lru cache for performance.
   (...)
    103     :type language: str
    104     \"\"\"
--> 105     return PunktTokenizer(language)

File ~/opt/anaconda3/envs/song38/lib/python3.8/site-packages/nltk/tokenize/punkt.py:1744, in PunktTokenizer.__init__(self, lang)
   1742 def __init__(self, lang=\"english\"):
   1743     PunktSentenceTokenizer.__init__(self)
-> 1744     self.load_lang(lang)

File ~/opt/anaconda3/envs/song38/lib/python3.8/site-packages/nltk/tokenize/punkt.py:1749, in PunktTokenizer.load_lang(self, lang)
   1746 def load_lang(self, lang=\"english\"):
   1747     from nltk.data import find
-> 1749     lang_dir = find(f\"tokenizers/punkt_tab/{lang}/\")
   1750     self._params = load_punkt_params(lang_dir)
   1751     self._lang = lang

File ~/opt/anaconda3/envs/song38/lib/python3.8/site-packages/nltk/data.py:579, in find(resource_name, paths)
    577 sep = \"*\" * 70
    578 resource_not_found = f\"\
{sep}\
{msg}\
{sep}\
\"
--> 579 raise LookupError(resource_not_found)

LookupError: 
**********************************************************************
  Resource punkt_tab not found.
  Please use the NLTK Downloader to obtain the resource:

  >>> import nltk
  >>> nltk.download('punkt_tab')
  
  For more information see: https://www.nltk.org/data.html

  Attempted to load tokenizers/punkt_tab/english/

  Searched in:
    - '/Users/song/nltk_data'
    - '/Users/song/opt/anaconda3/envs/song38/nltk_data'
    - '/Users/song/opt/anaconda3/envs/song38/share/nltk_data'
    - '/Users/song/opt/anaconda3/envs/song38/lib/nltk_data'
    - '/usr/share/nltk_data'
    - '/usr/local/share/nltk_data'
    - '/usr/lib/nltk_data'
    - '/usr/local/lib/nltk_data'
**********************************************************************
"
}

에러 메시지를 보면, nltk 라이브러리가 punkt_tab 리소스를 찾지 못해서 발생한 문제이다.

punkt는 NLTK의 문장 토큰화를 위해 필요한 데이터이기 때문에 nltk.download() 함수를 사용하여 필요한 데이터를 설치해야 한다.

해결 방법

import nltk

# punkt 데이터 다운로드
nltk.download('punkt')