resultofeffort

[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')

[pytorch] DTM과 TF-IDF | 텍스트 전처리 | 자연어 처리

ISFP의 블로그 — Fri, 22 Nov 2024 12:23:43 +0900

DTM (Document-Term Matrix)이란?

DTM은 여러 문서에서 단어의 빈도를 기록한 행렬(matrix)입니다. BoW와 유사하지만, 여러 문서 간의 단어 빈도수를 한꺼번에 분석할 수 있도록 확장된 형태입니다.

- 행(Row): 문서 (Document)
- 열(Column): 단어 (Term)
- 값(Value): 특정 문서에 특정 단어가 등장한 빈도수

DTM은 m x n 형태의 행렬로, `m`은 문서의 개수, `n`은 고유 단어의 개수를 의미합니다.

DTM의 예시

다음과 같은 예제 문서들을 통해 DTM을 만들어 보겠습니다.

문서 1: "나는 오늘 밥을 먹었다"
문서 2: "밥을 먹고 운동을 했다"
문서 3: "오늘 운동을 마치고 밥을 먹었다"

1. 토큰화(Tokenization) 및 어휘 사전 생성

모든 문서에서 고유한 단어들을 추출하여 어휘 사전을 생성합니다.
Vocabulary: ['나는', '오늘', '밥을', '먹었다', '먹고', '운동을', '했다', '마치고']

2. DTM 생성

각 문서에서 단어 빈도를 어휘 사전 순서에 따라 벡터로 변환합니다.

	나는	오늘	밥을	먹었다	먹고	운동을	했다	마치고
문서 1	1	1	1	1	0	0	0	0
문서 2	0	0	1	0	1	1	1	0
문서 3	0	1	1	1	0	1	0	1

3. Python을 사용한 DTM 구현
`CountVectorizer`를 사용하면 Python에서 쉽게 DTM을 생성할 수 있습니다.

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

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

# CountVectorizer를 사용해 DTM 생성
vectorizer = CountVectorizer()
dtm = vectorizer.fit_transform(corpus)

# DTM을 Pandas DataFrame으로 변환
dtm_df = pd.DataFrame(dtm.toarray(), columns=vectorizer.get_feature_names_out())
print(dtm_df)

위에서 작성한 결과와 동일한 결과가 출력되었죠.

DTM의 장단점

장점
- 문서를 수치화하여 머신러닝 모델에 쉽게 활용할 수 있습니다.
- 단순한 구현으로 빠르게 분석을 시작할 수 있습니다.

단점
- 단어의 순서 정보가 손실됩니다.
- 문서가 많아질수록 희소 행렬(Sparse Matrix) 문제가 발생합니다.
- 어휘 사전이 클수록 메모리 사용량이 크게 증가합니다.

DTM의 확장: TF-IDF (Term Frequency-Inverse Document Frequency)

BoW와 DTM의 단점을 보완하기 위해 TF-IDF (Term Frequency-Inverse Document Frequency)가 자주 사용됩니다. TF-IDF는 단어 빈도뿐만 아니라 문서 내에서의 중요도를 반영하여 가중치를 조정합니다.

TF-IDF란?

TF-IDF는 단어 빈도(Term Frequency, TF)와 역문서 빈도(Inverse Document Frequency, IDF)를 결합하여 각 단어의 중요도를 측정하는 방법입니다.

BoW와 DTM이 단순히 단어의 빈도만을 고려하는 반면, TF-IDF는 문서 내에서의 빈도뿐만 아니라 해당 단어가 전체 문서에서 얼마나 자주 등장하는지를 고려하여 단어의 가중치를 계산합니다.

TF-IDF는 자주 등장하는 단어(예: "the", "is")는 여러 문서에 걸쳐 자주 사용되므로 중요도가 낮다고 판단하고, 특정 문서에서 드물게 등장하는 단어는 해당 문서를 특징짓는 중요한 단어로 간주합니다.

TF-IDF의 수식

TF-IDF는 두 가지 지표를 결합하여 계산합니다.

1️⃣ Term Frequency (TF)

TF(Term Frequency)는 특정 단어가 한 문서에서 얼마나 자주 등장하는지를 측정하기 위해 모든 단어에 대해 각 문서에서의 빈도를 계산합니다.
\[
\text{TF}(t, d) = \frac {\text {단어 } t \text {의 빈도}}{\text {문서 } d \text {의 전체 단어 수}}
\]

다음과 같은 예제 문서들을 통해 TF를 계산해보겠습니다.

문서 1: "나는 오늘 밥을 먹었다"
문서 2: "밥을 먹고 운동을 했다"
문서 3: "오늘 운동을 마치고 밥을 먹었다"

우선, 문서에서 고유한 단어들을 추출하여 어휘 사전을 만듭니다.
Vocabulary: ['나는', '오늘', '밥을', '먹었다', '먹고', '운동을', '했다', '마치고']

TF 값 계산
각 문서에서 각 단어의 빈도를 계산한 후, 문서 내 총 단어 수로 나눠서 TF 값을 구합니다.

문서별 TF 계산
- 문서 1: "나는 오늘 밥을 먹었다" (단어 수: 4개)
- 문서 2: "밥을 먹고 운동을 했다" (단어 수: 4개)
- 문서 3: "오늘 운동을 마치고 밥을 먹었다" (단어 수: 5개)

단어	문서 1 (TF)	문서 2 (TF)	문서 3 (TF)
나는	1/4 = 0.25	0/4 = 0	0/5 = 0
오늘	1/4 = 0.25	0/4 = 0	1/5 = 0.2
밥을	1/4 = 0.25	1/4 = 0.25	1/5 = 0.2
먹었다	1/4 = 0.25	0/4 = 0	1/5 = 0.2
먹고	0/4 = 0	1/4 = 0.25	0/5 = 0
운동을	0/4 = 0	1/4 = 0.25	1/5 = 0.2
했다	0/4 = 0	1/4 = 0.25	0/5 = 0
마치고	0/4 = 0	0/4 = 0	1/5 = 0.2

결과에서 보다시피 각 단어는 3개의 TF 값을 가집니다. (각 문서에서의 TF 값).
예를 들어, "밥을"이라는 단어의 경우
  - 문서 1에서의 TF 값: 0.25
  - 문서 2에서의 TF 값: 0.2
  - 문서 3에서의 TF 값: 약 0.17

따라서, 모든 단어가 각 문서별로 TF 값을 갖게 되어, 어휘 사전에 포함된 모든 단어에 대해 3개의 TF 값이 생성됩니다.

2️⃣ Inverse Document Frequency (IDF)

IDF는 특정 단어가 전체 문서에서 얼마나 드물게 등장하는지를 측정합니다.

단어가 많은 문서에서 등장할수록 IDF 값이 낮아지고, 반대로 특정 문서에서만 등장하는 단어는 IDF 값이 높아집니다.

이렇게 함으로써, 모든 문서에 자주 등장하는 불필요한 단어들은 중요도가 낮아지고, 특정 문서에서만 등장하는 특별한 단어들은 중요도가 높아집니다.

\[
\text {IDF}(t) = \log\left(\frac {\text {총 문서 수}}{1 + \text {단어 } t \text {가 포함된 문서 수}}\right)
\]

- 총 문서 수: 데이터에 포함된 전체 문서의 개수입니다.
- 단어 t가 포함된 문서 수: 단어 t가 등장한 문서의 개수입니다.
- 로그를 사용하는 이유: 값이 너무 커지지 않도록 조절하기 위해서입니다.
- 1을 더하는 이유: 단어가 포함된 문서 수가 0이 되는 경우를 방지하기 위해서입니다.

IDF 값 계산

다음과 같은 예제 문서들을 통해 IDF를 계산해 보겠습니다.

문서 1: "나는 오늘 밥을 먹었다"
문서 2: "밥을 먹고 운동을 했다"
문서 3: "오늘 운동을 마치고 밥을 먹었다"

우선, 문서에서 고유한 단어들을 추출하여 어휘 사전을 만듭니다.
Vocabulary: ['나는', '오늘', '밥을', '먹었다', '먹고', '운동을', '했다', '마치고']

단어	포함된 문서 수	IDF 계산	IDF 값
나는	1	log(3 / (1 + 1)) = log(3 / 2)	약 0.1761
오늘	2	log(3 / (1 + 2)) = log(3 / 3)	0
밥을	3	log(3 / (1 + 3)) = log(3 / 4)	약 -0.1249
먹었다	2	log(3 / (1 + 2)) = log(3 / 3)	0
먹고	1	log(3 / (1 + 1)) = log(3 / 2)	약 0.1761
운동을	2	log(3 / (1 + 2)) = log(3 / 3)	0
했다	1	log(3 / (1 + 1)) = log(3 / 2)	약 0.1761
마치고	1	log(3 / (1 + 1)) = log(3 / 2)	약 0.1761

위 결과를 보면,

단어 "오늘"은 문서 1과 문서 3에서 2번 등장합니다.
  - $\text {IDF}(\text {오늘}) = \log\left(\frac {3}{1 + 2}\right) = \log(1) = 0$
- 단어 "나는"은 문서 1에서만 등장합니다.
  - $\text {IDF}(\text {나는}) = \log\left(\frac {3}{1 + 1}\right) = \log(1.5) \approx 0.176$
- 단어 "밥을"은 모든 문서에서 등장합니다.
  - $\text {IDF}(\text {밥을}) = \log\left(\frac {3}{1 + 3}\right) = \log(0.75) \approx -0.125$

- "오늘": 여러 문서에 등장하므로 IDF 값이 낮습니다.(0에 가까움).
- "나는": 특정 문서에만 등장하므로 IDF 값이 높습니다.(약 0.176).
- "밥을": 모든 문서에 등장하므로 IDF 값이 매우 낮습니다.(심지어 음수).

이렇게 IDF를 통해 자주 등장하는 단어에는 낮은 가중치, 드물게 등장하는 단어에는 높은 가중치를 부여함으로써, 문서의 특징을 더 잘 반영할 수 있습니다.

결과를 보셨다시피, IDF는 특정 단어가 역수(Inverse)를 사용합니다.

다시 말해, 문서에서 자주 등장하는 단어일수록 중요도가 낮고, 반대로 드물게 등장하는 단어일수록 중요도가 높습니다.

왜 많이 등장하는 단어는 낮은 가중치를 받나요?

많이 등장하는 단어들(예: "the", "is", "and")은 대부분의 문서에서 자주 나타나므로 문서의 내용을 구별하는 데 별로 도움이 되지 않습니다. 반면, 특정 문서에만 등장하는 고유한 단어는 해당 문서를 특징짓는 중요한 단어가 되기 때문입니다.

즉, 많이 등장하는 단어는 대부분의 문서에서 흔히 나타나는 단어일 가능성이 높아서 중요도가 낮습니다. → 낮은 IDF 값
적게 등장하는 단어는 특정 문서에만 등장할 가능성이 높아서 그 문서를 설명하는 중요한 단어일 수 있습니다. → 높은 IDF 값

TF-IDF란?

TF-IDF(Term Frequency-Inverse Document Frequency)는 단어의 빈도(TF)와 역면서 빈도(IDF)를 곱하여 각 단어의 가중치를 계산하는 방식입니다. 이를 통해, 단어가 문서에서 자주 등장하지만 모든 문서에 공통적으로 나타나는 단어는 낮은 가중치를 받고, 특정 문서에서만 자주 등장하는 단어는 높은 가중치를 받습니다.

TF와 IDF를 결합한 TF-IDF 공식은 다음과 같습니다.

\[
\text {TF-IDF}(t, d) = \text {TF}(t, d) \times \text {IDF}(t)
\]

- $ t $: 특정 단어(term)
- $ d $: 특정 문서(document)
- TF: 특정 단어가 문서 내에서 얼마나 자주 등장하는지 나타냄
- IDF: 특정 단어가 전체 문서에서 얼마나 드물게 등장하는지 나타냄

TF-IDF 계산

앞서 사용한 예제 문서들을 다시 사용해 TF-IDF를 직접 계산해 보겠습니다.

단어	문서 1(TF)	문서 2(TF)	문서 3(TF)	IDF	문서 1 (TF-IDF)	문서 2 (TF-IDF)	문서 2 (TF-IDF)
나는	0.25	0	0	0.1761	0.044	0	0
오늘	0.25	0	0.2	0	0	0	0
밥을	0.25	0.25	0.2	-0.1249	-0.0312	-0.0312	-0.025
먹었다	0.25		0.2	0	0	0	0
먹고	0	0.25	0	0.1761	0	0.0440	0
운동을	0	0.25	0.2	0	0	0	0
했다	0	0.25	0	0.1761	0	0.0440	0
마치고	0	0	0.2	0.1761	0	0	0.0352

- "나는"이라는 단어는 문서 1에서만 등장했기 때문에, 문서1에서 높은 TF-IDF 값을 가집니다.
- "밥을"은 모든 문서에서 등장하기 때문에, TF는 높지만 IDF가 낮아 TF-IDF 값이 작아집니다.
- "마치고"는 문서 3에서만 등장하기 때문에 문서3에서 높은 TF-IDF 값을 가집니다.

Python을 사용한 TF-IDF 계산

Python의 `TfidfVectorizer`를 사용해 직접 TF-IDF를 계산할 수도 있습니다.

from sklearn.feature_extraction.text import TfidfVectorizer
import pandas as pd

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

# TfidfVectorizer를 사용해 TF-IDF 행렬 생성
vectorizer = TfidfVectorizer()
tfidf_matrix = vectorizer.fit_transform(corpus)

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

TF-IDF의 활용

- 문서 분류: 중요한 단어를 찾아 문서의 주제를 분류하는 데 활용합니다.
- 문서 유사도 분석: TF-IDF 벡터를 이용해 코사인 유사도(Cosine Similarity)를 계산하여 문서 간 유사도를 평가합니다.
- 검색 엔진 최적화: 사용자의 검색어와 문서 간 관련성을 평가하여 검색 결과의 순위를 매기는 데 활용됩니다.

TF-IDF의 장단점

장점
- 단어의 빈도뿐만 아니라 중요도를 고려하므로 BoW보다 효율적입니다.
- 중요한 단어에 높은 가중치를 부여해 문서의 특성을 잘 파악할 수 있습니다.

단점
- 문서가 많아질수록 희소 행렬(Sparse Matrix) 문제가 여전히 존재합니다.
- 문서 내 단어의 순서 정보가 손실됩니다.
- 단어의 문맥을 이해하지 못해 의미가 유사한 단어를 구분하지 못합니다.

하지만,
TF-IDF는 단어의 빈도와 가중치를 기반으로 하여 문맥을 반영하지 않습니다.

이를 보완하기 위해 Word2Vec, GloVe, BERT와 같은 임베딩(embedding) 기법들이 사용됩니다.

이러한 기법들은 단어 간의 문맥적 관계를 반영하여 더 나은 성능을 제공합니다.

[pytorch] Bag of Words (BOW) | CountVectorizer

ISFP의 블로그 — Tue, 19 Nov 2024 00:15:37 +0900

Bag of Words란?

Bag of Words의 개념과 활용

Bag of Words (BoW)는 문서를 단어의 빈도수로 표현하는 방법으로, 단어의 순서를 무시하고 각 단어가 문서에 얼마나 자주 등장했는지를 수치화하는 기법입니다. BoW는 단순하지만, 자연어 처리에서 기본적인 텍스트 표현 방법으로 널리 사용되며, 특히 문서 분류, 유사도 측정, 추천 시스템 등에서 유용합니다.

Bag of Words의 특징

BoW는 텍스트를 단어의 출현 빈도 기반으로 표현하기 때문에 두 가지 주요 특징을 가지고 있습니다.

1. 단어 순서 무시: BoW에서는 문장의 구조나 단어 순서를 전혀 고려하지 않습니다. 단어의 순서가 바뀌어도 단어 빈도만 같다면 BoW 벡터는 동일합니다.

2. 단어 빈도 중심: BoW 벡터는 단어가 등장한 횟수만을 기록합니다. 특정 단어가 자주 등장할수록 해당 단어의 중요성이 높다고 가정하는 방식입니다.

이러한 특징 덕분에 BoW는 계산이 단순하고 직관적이지만, 문맥이나 의미를 반영하지 못하는 한계도 있습니다.

Bag of Words 예시

아래 예시 문장의 등장 횟수를 수치화해서 단어의 빈도를 출력해 보겠습니다.

from konlpy.tag import Okt  # konlpy의 Okt 형태소 분석기 불러오기

okt = Okt()  # Okt 형태소 분석기 객체 생성

def build_bag_of_words(document):
    document = document.replace('.', '')      # 문장부호 '.' 제거
    tokenized_document = okt.morphs(document) # 형태소(단어) 단위로 토큰화

    word_to_index = {}  # 단어와 인덱스를 매핑할 딕셔너리
    bow = []            # Bag of Words(BOW)를 저장할 리스트

    for word in tokenized_document:
        if word not in word_to_index:                # 단어가 처음 등장하면
            word_to_index[word] = len(word_to_index) # 고유 인덱스 할당
            bow.insert(len(word_to_index) - 1, 1)    # BOW 리스트에 해당 단어 위치에 1 추가
        else:
            index = word_to_index.get(word)  # 기존에 있던 단어라면 해당 인덱스를 가져와서
            bow[index] += 1                  # 등장 횟수를 1 증가시킴

    return tokenized_document, word_to_index, bow  # 단어-인덱스 매핑과 BOW 벡터 반환

doc1 = "The dog loves playing in the park and the dog enjoys chasing birds."
tokenized_document, vocab, bow = build_bag_of_words(doc1)
print('토큰화 : ',tokenized_document)
print('정수 인코딩 :', vocab)
print('각 단어의 등장 횟수 :', bow)

> 토큰화 :  ['The', 'dog', 'loves', 'playing', 'in', 'the', 'park', 'and', 'the', 'dog', 'enjoys', 'chasing', 'birds']
정수 인코딩 : {'The': 0, 'dog': 1, 'loves': 2, 'playing': 3, 'in': 4, 'the': 5, 'park': 6, 'and': 7, 'enjoys': 8, 'chasing': 9, 'birds': 10}
각 단어의 등장 횟수 : [1, 2, 1, 1, 1, 2, 1, 1, 1, 1, 1]

CountVectorizer 클래스로 BoW 만들기

CountVectorizer 클래스를 사용하여 주어진 문장에서 Bag of Words (BoW)를 생성하는 방법을 보여줍니다.

from sklearn.feature_extraction.text import CountVectorizer

corpus = ["The dog loves playing in the park and the dog enjoys chasing birds."]
vector = CountVectorizer()

print('각 단어의 등장 횟수 :', vector.fit_transform(corpus).toarray()) 
print('정수 인코딩 :',vector.vocabulary_)

> 각 단어의 등장 횟수 : [[1 1 1 2 1 1 1 1 1 3]]
정수 인코딩 : {'the': 9, 'dog': 3, 'loves': 6, 'playing': 8, 'in': 5, 'park': 7, 'and': 0, 'enjoys': 4, 'chasing': 2, 'birds': 1}

출력된 결과를 보면

Bow의 결과가 좀 다릅니다.

CountVectorizer 클래스를 사용하지 않은 Bow는

각 단어의 등장 횟수 : [1, 2, 1, 1, 1, 2, 1, 1, 1, 1, 1]의 결과가 나왔으며,

CountVectorizer 클래스를 사용한 Bow는

각 단어의 등장 횟수 : [[1 1 1 2 1 1 1 1 1 3]]의 결과가 나왔습니다.

두 방식에서 생성된 Bag of Words (BoW)의 결과가 서로 다른 이유는, 단어의 전처리 방식과 단어 집합 구성 방식이 다르기 때문입니다.

1️⃣ 단어 집합 구성 방식

CountVectorizer를 사용하지 않은 BoW에서는 모든 단어와 구두점 등을 포함해 단어 집합을 구성합니다.

CountVectorizer를 사용한 BoW에서는 기본적으로 불필요한 구두점 등을 제거하고, 각 단어를 소문자로 변환하는 등의 추가 전처리를 수행합니다.

2️⃣구두점 및 대소문자 처리

CountVectorizer는 기본적으로 구두점과 대소문자를 무시하고, 모든 텍스트를 소문자로 변환하여 단어 집합을 구성합니다. 예를 들어, 문장에 "The"와 "the"가 함께 등장하더라도 CountVectorizer는 이를 같은 단어로 간주하고 "the"로 통일합니다.

반면, CountVectorizer를 사용하지 않은 BoW에서는 대소문자를 구분하여 "The"와 "the"를 각각 다른 단어로 인식하고 별도의 인덱스를 부여합니다.

(위 코드에서도 CountVectorizer를 사용하지 않은 BoW에서는 대문자 The는 0 인덱스로, 소문자 the는 5 인덱스로 처리가 되었습니다.)

3️⃣ 출력 포맷

CountVectorizer의 결과는 일반적으로 2차원 배열 형태([[...]])로 반환됩니다. 여러 문서의 BoW를 동시에 표현할 수 있기 때문입니다.

반면, 직접 구현한 BoW의 결과는 단일 벡터([...])로 나타났습니다. 이는 단일 문서에 대해서만 BoW를 생성했기 때문입니다.

CountVectorizer + 불용어 제거 (사용자가 직접 정의)

문장의 의미 전달에 큰 영향을 미치지 않으면서 자주 등장하는 단어들인 불용어를 정의하여 제거합니다.

from sklearn.feature_extraction.text import CountVectorizer
from nltk.corpus import stopwords

text = ["The dog loves playing in the park and the dog enjoys chasing birds."]
vect = CountVectorizer(stop_words=["the", "and", "in"])

print('bag of words vector :',vect.fit_transform(text).toarray())
print('vocabulary :',vect.vocabulary_)

> bag of words vector : [[1 1 1 2 1 1 1 1]]
vocabulary : {'dog': 3, 'loves': 5, 'playing': 7, 'park': 6, 'and': 0, 'enjoys': 4, 'chasing': 2, 'birds': 1}

CountVectorizer에서 제공하는 자체 불용어 사용

from sklearn.feature_extraction.text import CountVectorizer

text = ["The dog loves playing in the park and the dog enjoys chasing birds."]
vect = CountVectorizer(stop_words="english")  # 문자열로 "english" 설정

print('bag of words vector :', vect.fit_transform(text).toarray()) 
print('vocabulary :', vect.vocabulary_)

> bag of words vector : [[1 1 2 1 1 1 1]]
vocabulary : {'dog': 2, 'loves': 4, 'playing': 6, 'park': 5, 'enjoys': 3, 'chasing': 1, 'birds': 0}

NLTK에서 지원하는 불용어 사용

from nltk.corpus import stopwords

text = ["The dog loves playing in the park and the dog enjoys chasing birds."]
stop_words = stopwords.words("english")
vect = CountVectorizer(stop_words=stop_words)

print('bag of words vector :',vect.fit_transform(text).toarray()) 
print('vocabulary :',vect.vocabulary_)

> bag of words vector : [[1 1 2 1 1 1 1]]
vocabulary : {'dog': 2, 'loves': 4, 'playing': 6, 'park': 5, 'enjoys': 3, 'chasing': 1, 'birds': 0}

Bag of Words의 한계

BoW는 단순한 방법으로 텍스트를 표현하지만, 아래와 같은 한계도 있습니다.

• 문맥 정보 부족: BoW는 단어의 순서나 문맥을 반영하지 않기 때문에, 단어가 주변 단어와 함께 가지는 의미를 표현할 수 없습니다. 예를 들어, “강아지가 고양이를 쫓는다”와 “고양이가 강아지를 쫓는다”는 서로 다른 의미이지만, BoW에서는 같은 단어들이 등장하는 것으로만 인식합니다.

• 단어의 중요도 반영 어려움: 모든 단어의 빈도만 반영하기 때문에, 자주 등장하지만 정보량이 적은 불용어(stop words)들도 BoW 벡터에 포함됩니다. 이를 해결하기 위해 TF-IDF와 같은 가중치 기법을 추가로 활용하기도 합니다.