🔧 NLTK: 자연어 처리의 스위스 아미 나이프

NLTK(Natural Language Toolkit)는 파이썬에서 가장 유명한 NLP 라이브러리 중 하나야.
2001년에 처음 나왔으니까 벌써 20년이 넘은 베테랑 라이브러리지 ㅋㅋㅋ

NLTK의 가장 큰 장점은 교육용으로 설계되어서 배우기 쉽다는 거야.
NLP의 거의 모든 기능을 제공하면서도, 각 기능이 어떻게 작동하는지 이해하기 쉽게 구성되어 있어.

실무에서는 속도 때문에 spaCy를 더 많이 쓰긴 하지만, NLTK는 여전히:
• NLP 학습용으로 최고
• 프로토타이핑할 때 빠르게 테스트하기 좋음
• 특정 언어학적 분석이 필요할 때 유용함

이런 이유로 많이 사용되고 있어 👍

NLTK 설치는 진짜 간단함. pip로 한 방이야:

pip install nltk

설치 후에는 필요한 데이터를 다운로드해야 하는데, 이것도 코드 몇 줄이면 끝:

import nltk

# 기본 데이터 다운로드
nltk.download('punkt')  # 토큰화 도구
nltk.download('stopwords')  # 불용어 사전
nltk.download('averaged_perceptron_tagger')  # 품사 태거
nltk.download('wordnet')  # WordNet 사전
nltk.download('omw-1.4')  # 다국어 WordNet

# 또는 전체 다운로드 (용량 큼, 시간 걸림)
# nltk.download('all')

이제 본격적으로 NLTK로 뭘 할 수 있는지 코드와 함께 알아보자!

1️⃣ 토큰화(Tokenization)

토큰화는 텍스트를 문장이나 단어 단위로 쪼개는 작업이야.
NLTK는 여러 종류의 토크나이저를 제공하는데, 상황에 맞게 골라 쓰면 돼:

from nltk.tokenize import word_tokenize, sent_tokenize, TreebankWordTokenizer

text = "안녕하세요! NLTK를 배우고 있습니다. 정말 재미있네요 ㅎㅎ"

# 문장 토큰화
sentences = sent_tokenize(text)
print("문장 토큰화:", sentences)
# 출력: ['안녕하세요!', 'NLTK를 배우고 있습니다.', '정말 재미있네요 ㅎㅎ']

# 단어 토큰화
words = word_tokenize(text)
print("단어 토큰화:", words)
# 출력: ['안녕하세요', '!', 'NLTK를', '배우고', '있습니다', '.', '정말', '재미있네요', 'ㅎㅎ']

# 영어 텍스트 예시
eng_text = "I can't believe it's already 2024! Time flies."
eng_words = word_tokenize(eng_text)
print("영어 토큰화:", eng_words)
# 출력: ['I', 'ca', "n't", 'believe', 'it', "'s", 'already', '2024', '!', 'Time', 'flies', '.']

보면 알겠지만 NLTK의 기본 토크나이저는 영어에 최적화되어 있어.
한국어는 좀 어색하게 나올 수 있는데, 이건 나중에 KoNLPy 같은 한국어 전용 라이브러리로 보완할 수 있음 👌

2️⃣ 불용어(Stopwords) 제거

불용어는 "the", "a", "is" 같이 자주 나오지만 분석에는 큰 의미가 없는 단어들이야.
이런 걸 제거하면 분석 정확도가 올라가고 처리 속도도 빨라짐:

from nltk.corpus import stopwords
from nltk.tokenize import word_tokenize

# 영어 불용어 목록 가져오기
stop_words = set(stopwords.words('english'))
print(f"영어 불용어 개수: {len(stop_words)}개")
print("불용어 예시:", list(stop_words)[:10])

# 불용어 제거 실습
text = "This is a sample sentence demonstrating the removal of stop words."
words = word_tokenize(text.lower())

filtered_words = [word for word in words if word not in stop_words and word.isalpha()]
print("원본:", words)
print("불용어 제거 후:", filtered_words)
# 출력: ['sample', 'sentence', 'demonstrating', 'removal', 'stop', 'words']

3️⃣ 어간 추출(Stemming)과 표제어 추출(Lemmatization)

이 둘은 비슷해 보이지만 접근 방식이 다른 기술이야:

from nltk.stem import PorterStemmer, LancasterStemmer, WordNetLemmatizer
from nltk.corpus import wordnet

# Stemming (어간 추출)
porter = PorterStemmer()
lancaster = LancasterStemmer()

words = ["running", "runs", "ran", "runner", "easily", "fairly"]

print("Porter Stemmer:")
for word in words:
    print(f"{word} → {porter.stem(word)}")

print("\nLancaster Stemmer:")
for word in words:
    print(f"{word} → {lancaster.stem(word)}")

# Lemmatization (표제어 추출)
lemmatizer = WordNetLemmatizer()

print("\nLemmatization:")
print(f"running (동사) → {lemmatizer.lemmatize('running', pos='v')}")
print(f"running (명사) → {lemmatizer.lemmatize('running', pos='n')}")
print(f"better (형용사) → {lemmatizer.lemmatize('better', pos='a')}")
print(f"cacti (명사) → {lemmatizer.lemmatize('cacti', pos='n')}")

Stemming vs Lemmatization 차이점:

Stemming: 규칙 기반으로 단어 끝을 잘라냄. 빠르지만 부정확할 수 있음
• "running" → "run" ✅
• "better" → "better" ❌ (good으로 못 바꿈)

Lemmatization: 사전 기반으로 정확한 기본형 찾음. 느리지만 정확함
• "running" → "run" ✅
• "better" → "good" ✅

실무에서는 정확도가 중요하면 Lemmatization, 속도가 중요하면 Stemming을 쓰는 편이야 ㅇㅇ

4️⃣ 품사 태깅(POS Tagging)

품사 태깅은 각 단어가 명사인지, 동사인지, 형용사인지 등을 판별하는 작업이야.
이게 왜 중요하냐면, 같은 단어도 품사에 따라 의미가 완전히 달라지거든:

from nltk import pos_tag
from nltk.tokenize import word_tokenize

# 품사 태깅 예시
text1 = "They refuse to permit us to obtain the refuse permit."
words1 = word_tokenize(text1)
pos_tags1 = pos_tag(words1)

print("품사 태깅 결과:")
for word, tag in pos_tags1:
    print(f"{word}: {tag}")

# 주요 품사 태그 설명
# NN: 명사(단수), NNS: 명사(복수), NNP: 고유명사
# VB: 동사(기본형), VBD: 동사(과거형), VBG: 동사(현재분사)
# JJ: 형용사, RB: 부사
# DT: 관사, IN: 전치사

5️⃣ 개체명 인식(Named Entity Recognition)

개체명 인식은 텍스트에서 사람 이름, 지명, 조직명, 날짜 등을 자동으로 찾아내는 기술이야:

from nltk import ne_chunk, pos_tag, word_tokenize
from nltk.tree import Tree

text = "Apple Inc. was founded by Steve Jobs in Cupertino, California on April 1, 1976."
words = word_tokenize(text)
pos_tags = pos_tag(words)
named_entities = ne_chunk(pos_tags)

print("개체명 인식 결과:")
for chunk in named_entities:
    if isinstance(chunk, Tree):
        entity = " ".join([token for token, pos in chunk.leaves()])
        entity_type = chunk.label()
        print(f"{entity}: {entity_type}")

# 출력 예시:
# Apple Inc.: ORGANIZATION
# Steve Jobs: PERSON
# Cupertino: GPE (지정학적 개체)
# California: GPE

개체명 인식은 뉴스 기사 분석, 문서 자동 분류, 챗봇 개발 등에서 엄청 유용하게 쓰여.
특히 대량의 문서에서 특정 인물이나 조직에 대한 언급을 추적할 때 개꿀임 ㅋㅋㅋ

⚡ spaCy: 산업용 NLP의 강자

NLTK가 교육용 스위스 아미 나이프라면, spaCy는 실전용 파워툴이라고 할 수 있어.
2015년에 나온 비교적 최신 라이브러리인데, 속도와 정확도 면에서 NLTK를 압도하는 성능을 보여줌 🚀

spaCy의 핵심 특징:

1. 압도적인 속도: Cython으로 작성되어 NLTK보다 수십 배 빠름
2. 딥러닝 기반: 최신 신경망 모델을 활용한 높은 정확도
3. 프로덕션 레디: 실제 서비스에 바로 적용 가능한 안정성
4. 다국어 지원: 60개 이상의 언어 모델 제공
5. 파이프라인 구조: 여러 처리 단계를 효율적으로 연결

실무에서 대용량 텍스트를 처리해야 한다면 spaCy가 거의 필수라고 봐도 됨 💪

# spaCy 설치
pip install spacy

# 영어 모델 다운로드 (크기별로 3가지)
python -m spacy download en_core_web_sm  # 소형 (12MB)
python -m spacy download en_core_web_md  # 중형 (40MB)
python -m spacy download en_core_web_lg  # 대형 (560MB)

# 한국어 모델 (비공식, 성능 제한적)
pip install spacy-korean

1️⃣ 기본 파이프라인 사용법

spaCy의 가장 큰 특징은 한 번의 처리로 토큰화, 품사 태깅, 개체명 인식 등을 모두 수행한다는 거야:

import spacy

# 모델 로드
nlp = spacy.load("en_core_web_sm")

# 텍스트 처리
text = "Apple is looking at buying U.K. startup for $1 billion"
doc = nlp(text)

# 토큰 정보 출력
print("토큰 분석:")
for token in doc:
    print(f"{token.text:12} {token.pos_:8} {token.dep_:10} {token.lemma_}")

# 개체명 인식
print("\n개체명:")
for ent in doc.ents:
    print(f"{ent.text:20} {ent.label_:15} {spacy.explain(ent.label_)}")

이 코드 한 번 실행하면:
• 토큰화 ✅
• 품사 태깅 ✅
• 의존 구문 분석 ✅
• 표제어 추출 ✅
• 개체명 인식 ✅

이 모든 게 동시에 처리됨. NLTK로 하려면 각각 따로 함수 호출해야 하는데 spaCy는 원샷이야 ㅋㅋㅋ

2️⃣ 문장 분리와 토큰 속성

import spacy

nlp = spacy.load("en_core_web_sm")
text = """
spaCy is amazing! It can process text super fast.
Let's see how it handles multiple sentences.
"""

doc = nlp(text)

# 문장 분리
print("문장 분리:")
for i, sent in enumerate(doc.sents, 1):
    print(f"{i}. {sent.text.strip()}")

# 토큰 상세 속성
print("\n토큰 상세 분석:")
for token in doc[:10]:  # 처음 10개만
    print(f"""
    텍스트: {token.text}
    표제어: {token.lemma_}
    품사: {token.pos_} ({spacy.explain(token.pos_)})
    태그: {token.tag_}
    의존관계: {token.dep_}
    불용어 여부: {token.is_stop}
    구두점 여부: {token.is_punct}
    숫자 여부: {token.like_num}
    """)

spaCy의 토큰 객체는 진짜 정보가 풍부함.
각 토큰마다 20개 이상의 속성을 제공해서 웬만한 분석은 다 가능해 👍

3️⃣ 단어 벡터와 유사도 계산

md나 lg 모델을 사용하면 단어를 벡터로 표현해서 의미적 유사도를 계산할 수 있어:

import spacy

# 벡터가 포함된 모델 필요 (md 또는 lg)
nlp = spacy.load("en_core_web_md")

# 단어 유사도
doc1 = nlp("dog")
doc2 = nlp("cat")
doc3 = nlp("banana")

print(f"dog vs cat: {doc1.similarity(doc2):.4f}")
print(f"dog vs banana: {doc1.similarity(doc3):.4f}")
print(f"cat vs banana: {doc2.similarity(doc3):.4f}")

# 문장 유사도
sent1 = nlp("I love programming in Python")
sent2 = nlp("Python is my favorite programming language")
sent3 = nlp("I enjoy eating pizza")

print(f"\n문장 유사도:")
print(f"sent1 vs sent2: {sent1.similarity(sent2):.4f}")
print(f"sent1 vs sent3: {sent1.similarity(sent3):.4f}")

이 기능은 추천 시스템, 문서 분류, 중복 탐지 등에서 엄청 유용하게 쓰여.
예를 들어 고객 문의를 자동으로 분류할 때, 새로운 문의와 기존 카테고리의 유사도를 계산해서 자동 배정할 수 있음!

4️⃣ 커스텀 파이프라인 컴포넌트

spaCy의 진짜 강력한 기능 중 하나는 파이프라인을 커스터마이징할 수 있다는 거야:

import spacy
from spacy.language import Language

nlp = spacy.load("en_core_web_sm")

# 커스텀 컴포넌트 정의
@Language.component("custom_sentiment")
def custom_sentiment_component(doc):
    # 간단한 감성 분석 로직
    positive_words = {"good", "great", "excellent", "amazing", "wonderful"}
    negative_words = {"bad", "terrible", "awful", "horrible", "poor"}
    
    pos_count = sum(1 for token in doc if token.text.lower() in positive_words)
    neg_count = sum(1 for token in doc if token.text.lower() in negative_words)
    
    # 문서에 커스텀 속성 추가
    doc._.sentiment_score = pos_count - neg_count
    doc._.sentiment = "positive" if pos_count > neg_count else "negative" if neg_count > pos_count else "neutral"
    
    return doc

# 커스텀 속성 등록
from spacy.tokens import Doc
Doc.set_extension("sentiment_score", default=0, force=True)
Doc.set_extension("sentiment", default="neutral", force=True)

# 파이프라인에 추가
nlp.add_pipe("custom_sentiment", last=True)

# 테스트
texts = [
    "This product is amazing and wonderful!",
    "Terrible experience, very bad service.",
    "It's okay, nothing special."
]

for text in texts:
    doc = nlp(text)
    print(f"텍스트: {text}")
    print(f"감성: {doc._.sentiment} (점수: {doc._.sentiment_score})\n")

이런 식으로 자기만의 분석 로직을 파이프라인에 끼워넣을 수 있어.
실무에서는 도메인 특화 규칙이나 비즈니스 로직을 이렇게 추가해서 쓰는 경우가 많음 ㅇㅇ

📊 텍스트 마이닝 실전 프로젝트: 영화 리뷰 감성 분석

이론만 배우면 재미없으니까, 이제 실제로 텍스트 마이닝 프로젝트를 처음부터 끝까지 해보자!
영화 리뷰 데이터를 가지고 긍정/부정을 자동으로 분류하는 감성 분석 시스템을 만들어볼 거야 🎬

이 프로젝트를 통해 배울 내용:
• 실제 데이터 수집 및 전처리
• NLTK와 spaCy를 활용한 텍스트 정제
• 특징 추출 (Feature Extraction)
• 머신러닝 모델 학습 및 평가
• 결과 시각화

실습용으로 IMDB 영화 리뷰 데이터셋을 사용할 거야. 이건 50,000개의 리뷰가 있는 유명한 데이터셋임:

import pandas as pd
import numpy as np
from sklearn.model_selection import train_test_split

# 데이터 로드 (실제로는 파일에서 읽어옴)
# 여기서는 예시 데이터 생성
sample_reviews = [
    ("This movie was absolutely amazing! Best film I've seen this year.", "positive"),
    ("Terrible waste of time. I want my money back.", "negative"),
    ("Great acting and wonderful storyline. Highly recommended!", "positive"),
    ("Boring and predictable. Fell asleep halfway through.", "negative"),
    ("Masterpiece! The director outdid himself.", "positive"),
    ("Awful movie. Poor acting and terrible script.", "negative"),
]

# DataFrame 생성
df = pd.DataFrame(sample_reviews, columns=['review', 'sentiment'])

# 실제 프로젝트에서는 이렇게 로드
# df = pd.read_csv('IMDB_Dataset.csv')

print(f"전체 리뷰 수: {len(df)}")
print(f"긍정 리뷰: {len(df[df['sentiment']=='positive'])}")
print(f"부정 리뷰: {len(df[df['sentiment']=='negative'])}")
print("\n샘플 데이터:")
print(df.head())

원시 텍스트를 분석 가능한 형태로 정제하는 단계야. 여기서 NLTK와 spaCy가 활약함:

import re
import spacy
from nltk.corpus import stopwords
from nltk.tokenize import word_tokenize

# spaCy 모델 로드
nlp = spacy.load("en_core_web_sm")

# 불용어 세트
stop_words = set(stopwords.words('english'))

def preprocess_text(text):
    """텍스트 전처리 함수"""
    
    # 1. 소문자 변환
    text = text.lower()
    
    # 2. HTML 태그 제거
    text = re.sub(r'<.*?>', '', text)
    
    # 3. URL 제거
    text = re.sub(r'http\S+|www\S+', '', text)
    
    # 4. 특수문자 제거 (알파벳과 공백만 남김)
    text = re.sub(r'[^a-zA-Z\s]', '', text)
    
    # 5. spaCy로 처리
    doc = nlp(text)
    
    # 6. 표제어 추출 + 불용어 제거
    tokens = [
        token.lemma_ for token in doc 
        if not token.is_stop 
        and not token.is_punct 
        and len(token.text) > 2
    ]
    
    return ' '.join(tokens)

# 전처리 적용
df['cleaned_review'] = df['review'].apply(preprocess_text)

print("전처리 전후 비교:")
for i in range(3):
    print(f"\n원본: {df['review'].iloc[i]}")
    print(f"전처리 후: {df['cleaned_review'].iloc[i]}")

머신러닝 모델은 숫자만 이해할 수 있으니까, 텍스트를 숫자 벡터로 변환해야 해.
대표적인 방법이 TF-IDF야:

from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.model_selection import train_test_split

# TF-IDF 벡터라이저 생성
tfidf = TfidfVectorizer(
    max_features=5000,  # 상위 5000개 단어만 사용
    ngram_range=(1, 2),  # 1-gram과 2-gram 모두 사용
    min_df=2,  # 최소 2번 이상 등장한 단어만
    max_df=0.8  # 80% 이상 문서에 등장하는 단어 제외
)

# 특징 벡터 생성
X = tfidf.fit_transform(df['cleaned_review'])
y = df['sentiment'].map({'positive': 1, 'negative': 0})

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

print(f"학습 데이터: {X_train.shape}")
print(f"테스트 데이터: {X_test.shape}")
print(f"특징 벡터 차원: {X.shape[1]}")

# 가장 중요한 단어들 확인
feature_names = tfidf.get_feature_names_out()
print(f"\n추출된 특징 예시: {feature_names[:20]}")

이제 여러 머신러닝 모델을 학습시켜서 성능을 비교해보자:

from sklearn.naive_bayes import MultinomialNB
from sklearn.linear_model import LogisticRegression
from sklearn.svm import LinearSVC
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import accuracy_score, classification_report, confusion_matrix

# 여러 모델 정의
models = {
    'Naive Bayes': MultinomialNB(),
    'Logistic Regression': LogisticRegression(max_iter=1000),
    'Linear SVM': LinearSVC(max_iter=1000),
    'Random Forest': RandomForestClassifier(n_estimators=100, random_state=42)
}

# 각 모델 학습 및 평가
results = {}

for name, model in models.items():
    print(f"\n{'='*50}")
    print(f"모델: {name}")
    print('='*50)
    
    # 학습
    model.fit(X_train, y_train)
    
    # 예측
    y_pred = model.predict(X_test)
    
    # 평가
    accuracy = accuracy_score(y_test, y_pred)
    results[name] = accuracy
    
    print(f"정확도: {accuracy:.4f}")
    print("\n분류 리포트:")
    print(classification_report(y_test, y_pred, 
                                target_names=['Negative', 'Positive']))
    
    print("\n혼동 행렬:")
    print(confusion_matrix(y_test, y_pred))

# 최고 성능 모델
best_model = max(results, key=results.get)
print(f"\n🏆 최고 성능 모델: {best_model} (정확도: {results[best_model]:.4f})")

모델이 어떤 단어를 중요하게 생각하는지 확인해보자:

import numpy as np
import matplotlib.pyplot as plt

# Logistic Regression 모델의 계수 분석
lr_model = models['Logistic Regression']
feature_names = tfidf.get_feature_names_out()
coefficients = lr_model.coef_[0]

# 긍정적 영향을 주는 단어 Top 20
top_positive_idx = np.argsort(coefficients)[-20:]
top_positive_words = [(feature_names[i], coefficients[i]) for i in top_positive_idx]

print("긍정 감성에 가장 영향을 주는 단어:")
for word, coef in reversed(top_positive_words):
    print(f"{word:20} {coef:.4f}")

# 부정적 영향을 주는 단어 Top 20
top_negative_idx = np.argsort(coefficients)[:20]
top_negative_words = [(feature_names[i], coefficients[i]) for i in top_negative_idx]

print("\n부정 감성에 가장 영향을 주는 단어:")
for word, coef in top_negative_words:
    print(f"{word:20} {coef:.4f}")

이렇게 하면 모델이 "amazing", "excellent" 같은 단어를 긍정으로,
"terrible", "awful" 같은 단어를 부정으로 학습했다는 걸 확인할 수 있어 ㅎㅎ

이제 새로운 리뷰가 들어왔을 때 바로 감성을 예측하는 함수를 만들어보자:

def predict_sentiment(review_text, model, vectorizer, preprocessor):
    """
    새로운 리뷰의 감성을 예측하는 함수
    
    Args:
        review_text: 예측할 리뷰 텍스트
        model: 학습된 모델
        vectorizer: 학습된 TF-IDF 벡터라이저
        preprocessor: 전처리 함수
    
    Returns:
        sentiment: 'Positive' 또는 'Negative'
        probability: 예측 확률
    """
    # 전처리
    cleaned_text = preprocessor(review_text)
    
    # 벡터화
    text_vector = vectorizer.transform([cleaned_text])
    
    # 예측
    prediction = model.predict(text_vector)[0]
    probability = model.predict_proba(text_vector)[0]
    
    sentiment = "Positive" if prediction == 1 else "Negative"
    confidence = probability[prediction]
    
    return sentiment, confidence

# 테스트
test_reviews = [
    "This movie is absolutely fantastic! I loved every minute of it.",
    "Worst movie ever. Complete waste of time and money.",
    "It was okay, nothing special but not terrible either.",
]

best_model_obj = models['Logistic Regression']

print("실시간 예측 테스트:\n")
for review in test_reviews:
    sentiment, confidence = predict_sentiment(
        review, best_model_obj, tfidf, preprocess_text
    )
    print(f"리뷰: {review}")
    print(f"예측: {sentiment} (확신도: {confidence:.2%})\n")

이제 완전히 작동하는 감성 분석 시스템이 완성됐어!
실제 서비스에 적용하려면 Flask나 FastAPI로 API를 만들어서 배포하면 됨 🚀

🎨 텍스트 마이닝 고급 기법들

기본적인 감성 분석을 넘어서, 더 고급 텍스트 마이닝 기법들을 알아보자.
이런 기법들은 실무에서 진짜 많이 쓰이는 것들이야 💡

토픽 모델링은 대량의 문서에서 숨겨진 주제를 자동으로 찾아내는 기술이야.
대표적으로 LDA (Latent Dirichlet Allocation)가 많이 쓰임:

from sklearn.decomposition import LatentDirichletAllocation
from sklearn.feature_extraction.text import CountVectorizer

# 샘플 문서 (실제로는 수백~수천 개)
documents = [
    "Python is a great programming language for data science",
    "Machine learning and deep learning are hot topics",
    "Natural language processing helps understand text data",
    "Data visualization is important for data analysis",
    "Neural networks are used in deep learning models",
]

# CountVectorizer로 문서-단어 행렬 생성
vectorizer = CountVectorizer(max_features=100, stop_words='english')
doc_term_matrix = vectorizer.fit_transform(documents)

# LDA 모델 학습
n_topics = 2
lda = LatentDirichletAllocation(
    n_components=n_topics,
    random_state=42,
    max_iter=10
)
lda.fit(doc_term_matrix)

# 토픽별 주요 단어 출력
feature_names = vectorizer.get_feature_names_out()

print("발견된 토픽들:\n")
for topic_idx, topic in enumerate(lda.components_):
    top_words_idx = topic.argsort()[-10:][::-1]
    top_words = [feature_names[i] for i in top_words_idx]
    print(f"토픽 {topic_idx + 1}: {', '.join(top_words)}")

토픽 모델링은 이런 곳에 활용돼:
• 뉴스 기사 자동 분류
• 고객 리뷰에서 주요 불만사항 파악
• 연구 논문 트렌드 분석
• SNS 대화 주제 추출

Word2Vec은 단어를 벡터 공간에 배치해서 단어 간 의미적 관계를 표현하는 기술이야.
"왕 - 남자 + 여자 = 여왕" 같은 신기한 연산이 가능함 ㅋㅋㅋ

from gensim.models import Word2Vec
from nltk.tokenize import word_tokenize

# 샘플 문장들
sentences = [
    "the king sits on the throne",
    "the queen sits beside the king",
    "the prince is the son of the king",
    "the princess is the daughter of the queen",
]

# 토큰화
tokenized_sentences = [word_tokenize(sent.lower()) for sent in sentences]

# Word2Vec 모델 학습
model = Word2Vec(
    sentences=tokenized_sentences,
    vector_size=100,  # 벡터 차원
    window=5,  # 문맥 윈도우 크기
    min_count=1,  # 최소 등장 횟수
    workers=4
)

# 유사한 단어 찾기
print("'king'과 유사한 단어:")
similar_words = model.wv.most_similar('king', topn=5)
for word, similarity in similar_words:
    print(f"{word}: {similarity:.4f}")

# 단어 간 유사도
similarity = model.wv.similarity('king', 'queen')
print(f"\n'king'과 'queen'의 유사도: {similarity:.4f}")

# 단어 연산
result = model.wv.most_similar(
    positive=['king', 'woman'],
    negative=['man'],
    topn=1
)
print(f"\nking - man + woman = {result[0][0]}")

spaCy의 NER을 커스터마이징해서 도메인 특화 개체를 인식하도록 만들 수 있어:

import spacy
from spacy.training import Example
from spacy.util import minibatch
import random

# 기본 모델 로드
nlp = spacy.blank("en")

# NER 파이프라인 추가
if "ner" not in nlp.pipe_names:
    ner = nlp.add_pipe("ner")
else:
    ner = nlp.get_pipe("ner")

# 커스텀 레이블 추가 (예: 제품명)
ner.add_label("PRODUCT")

# 학습 데이터 (텍스트, {개체 위치와 레이블})
TRAIN_DATA = [
    ("I bought an iPhone 13 yesterday", {"entities": [(14, 23, "PRODUCT")]}),
    ("The new MacBook Pro is amazing", {"entities": [(8, 19, "PRODUCT")]}),
    ("Samsung Galaxy S21 has great camera", {"entities": [(0, 18, "PRODUCT")]}),
]

# 모델 학습
optimizer = nlp.begin_training()
for epoch in range(10):
    random.shuffle(TRAIN_DATA)
    losses = {}
    
    for text, annotations in TRAIN_DATA:
        doc = nlp.make_doc(text)
        example = Example.from_dict(doc, annotations)
        nlp.update([example], drop=0.5, losses=losses)
    
    print(f"Epoch {epoch + 1}, Loss: {losses['ner']:.4f}")

# 테스트
test_text = "I'm thinking about buying the new AirPods Pro"
doc = nlp(test_text)

print("\n인식된 개체:")
for ent in doc.ents:
    print(f"{ent.text}: {ent.label_}")

이런 커스텀 NER은 특히 이런 분야에서 유용해:
• 의료: 질병명, 약물명 추출
• 법률: 법률 용어, 판례 인식
• 금융: 회사명, 금융상품 식별
• 전자상거래: 제품명, 브랜드 추출

텍스트 분류는 문서를 미리 정의된 카테고리로 자동 분류하는 거야.
딥러닝을 활용하면 더 높은 정확도를 얻을 수 있어:

# 간단한 CNN 기반 텍스트 분류 (개념 코드)
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Embedding, Conv1D, GlobalMaxPooling1D, Dense, Dropout
from tensorflow.keras.preprocessing.text import Tokenizer
from tensorflow.keras.preprocessing.sequence import pad_sequences

# 하이퍼파라미터
vocab_size = 10000
embedding_dim = 100
max_length = 200
num_classes = 5

# 모델 구조
model = Sequential([
    Embedding(vocab_size, embedding_dim, input_length=max_length),
    Conv1D(128, 5, activation='relu'),
    GlobalMaxPooling1D(),
    Dense(64, activation='relu'),
    Dropout(0.5),
    Dense(num_classes, activation='softmax')
])

model.compile(
    optimizer='adam',
    loss='categorical_crossentropy',
    metrics=['accuracy']
)

print(model.summary())

실무에서는 BERT, GPT 같은 트랜스포머 모델을 파인튜닝해서 쓰는 경우가 많아.
Hugging Face 라이브러리를 사용하면 쉽게 적용할 수 있음 👍

🎓 학습 로드맵과 추천 리소스

텍스트 마이닝을 제대로 배우고 싶다면 체계적인 학습이 중요해.
내가 추천하는 단계별 로드맵을 공유할게 📚

1️⃣ 기초 단계 (1-2개월)

• Python 기본 문법 완벽히 익히기
• 리스트, 딕셔너리, 함수, 클래스 등
• 정규표현식 마스터 (re 모듈)
• 파일 입출력, 문자열 처리

추천 실습: 간단한 텍스트 파일 읽어서 단어 빈도수 세기, 특정 패턴 찾기 등

2️⃣ NLP 기초 단계 (2-3개월)

• NLTK 라이브러리 전체 기능 학습
• 토큰화, 품사 태깅, 개체명 인식
• 불용어 처리, 어간 추출
• 기본적인 텍스트 전처리 파이프라인 구축

추천 실습: 뉴스 기사 크롤링해서 키워드 추출, 간단한 워드클라우드 생성

3️⃣ 고급 NLP 단계 (2-3개월)

• spaCy로 효율적인 텍스트 처리
• Word2Vec, GloVe 등 단어 임베딩
• TF-IDF, BM25 등 정보 검색 기법
• 의존 구문 분석, 공지시 해소

추천 실습: 유사 문서 찾기 시스템, 간단한 검색 엔진 구현

4️⃣ 머신러닝 단계 (3-4개월)

• scikit-learn으로 텍스트 분류
• Naive Bayes, SVM, Random Forest
• 감성 분석, 스팸 필터링
• 토픽 모델링 (LDA, NMF)

추천 실습: 영화 리뷰 감성 분석, 뉴스 기사 자동 분류

5️⃣ 딥러닝 단계 (4-6개월)

• RNN, LSTM으로 시퀀스 모델링
• Attention 메커니즘 이해
• Transformer, BERT 등 최신 모델
• Hugging Face Transformers 활용

추천 실습: 챗봇 구현, 기계 번역, 문서 요약

6️⃣ 실전 단계 (지속적)

• 실제 비즈니스 문제 해결
• 대용량 데이터 처리 경험
• 모델 배포 및 서빙
• 성능 최적화 및 모니터링

추천 실습: Kaggle 컴피티션 참가, 오픈소스 기여, 포트폴리오 프로젝트

🚀 텍스트 마이닝의 미래와 트렌드

텍스트 마이닝 분야는 정말 빠르게 발전하고 있어.
앞으로 어떤 방향으로 나아갈지, 어떤 기술들이 주목받을지 알아보자 🔮

GPT-3, GPT-4, Claude, Gemini 같은 대규모 언어 모델이 게임 체인저가 되고 있어.
이제는 모델을 처음부터 학습시키는 게 아니라, 사전 학습된 모델을 파인튜닝하는 게 대세야:

# Hugging Face Transformers 예시
from transformers import pipeline

# 감성 분석 파이프라인 (사전 학습 모델 활용)
classifier = pipeline("sentiment-analysis")

results = classifier([
    "I love this product!",
    "This is terrible.",
    "It's okay, nothing special."
])

for result in results:
    print(f"{result['label']}: {result['score']:.4f}")

# 텍스트 생성
generator = pipeline("text-generation", model="gpt2")
output = generator("Natural language processing is", max_length=50)
print(output[0]['generated_text'])

LLM의 장점:
• 별도 학습 없이 바로 사용 가능 (Zero-shot Learning)
• 소량의 예시만으로 학습 (Few-shot Learning)
• 다양한 태스크를 하나의 모델로 처리
• 인간 수준의 텍스트 이해 및 생성

영어 중심에서 벗어나 다양한 언어를 동시에 처리하는 모델들이 나오고 있어:

한국어 NLP도 빠르게 발전 중:
• KoBERT, KoGPT, KoBART 등 한국어 특화 모델
• 네이버, 카카오 등 기업들의 대규모 투자
• 한국어 데이터셋 공개 및 벤치마크 구축

범용 모델에서 특정 분야에 특화된 모델로 진화 중:

의료 NLP
• BioBERT, PubMedBERT: 의학 논문 학습
• 전자의무기록(EMR) 자동 분석
• 약물 상호작용 예측

법률 NLP
• LegalBERT: 법률 문서 특화
• 계약서 자동 검토
• 판례 검색 및 분석

금융 NLP
• FinBERT: 금융 뉴스 감성 분석
• 리스크 평가 자동화
• 사기 탐지 시스템

기술이 발전할수록 윤리적 이슈도 중요해지고 있어:

클라우드가 아닌 디바이스에서 직접 NLP 처리하는 추세:

• 모델 경량화: DistilBERT, TinyBERT 등
• 양자화: 모델 크기 줄이면서 성능 유지
• 프루닝: 불필요한 파라미터 제거
• 지식 증류: 큰 모델의 지식을 작은 모델로 전달

이렇게 하면 스마트폰, IoT 기기에서도 고급 NLP 기능 사용 가능 📱

💼 실무 활용 사례와 비즈니스 가치

이론과 기술도 중요하지만, 결국 실무에서 어떻게 쓰이는지가 가장 중요하지 ㅇㅇ
다양한 산업에서 텍스트 마이닝이 어떻게 활용되는지 살펴보자 💼

문제: 하루에 수천 개씩 쌓이는 상품 리뷰를 일일이 읽을 수 없음
해결: 텍스트 마이닝으로 자동 분석

구현 내용:
• 감성 분석으로 긍정/부정 리뷰 자동 분류
• 토픽 모델링으로 주요 불만사항 추출
• 키워드 분석으로 제품 개선점 도출
• 가짜 리뷰 탐지 시스템

비즈니스 효과:
✅ 제품 개선 사이클 50% 단축
✅ 고객 만족도 15% 향상
✅ 가짜 리뷰 90% 이상 차단

# 리뷰 분석 파이프라인 예시
class ReviewAnalyzer:
    def __init__(self):
        self.sentiment_model = load_sentiment_model()
        self.topic_model = load_topic_model()
        self.fake_detector = load_fake_detector()
    
    def analyze_review(self, review_text):
        """리뷰 종합 분석"""
        results = {
            'sentiment': self.sentiment_model.predict(review_text),
            'topics': self.topic_model.extract_topics(review_text),
            'is_fake': self.fake_detector.predict(review_text),
            'key_phrases': self.extract_key_phrases(review_text)
        }
        return results
    
    def generate_insights(self, reviews):
        """전체 리뷰에서 인사이트 추출"""
        # 감성 분포
        sentiment_dist = self.get_sentiment_distribution(reviews)
        
        # 주요 불만사항
        complaints = self.extract_complaints(reviews)
        
        # 개선 제안
        suggestions = self.generate_suggestions(complaints)
        
        return {
            'sentiment_distribution': sentiment_dist,
            'top_complaints': complaints,
            'improvement_suggestions': suggestions
        }

문제: 실시간으로 쏟아지는 뉴스를 빠르게 분류하고 요약 필요
해결: NLP 기반 자동화 시스템

구현 내용:
• 뉴스 기사 자동 카테고리 분류 (정치, 경제, 사회 등)
• 중요 문장 추출로 3줄 요약 생성
• 개체명 인식으로 주요 인물/장소 태깅
• 유사 기사 클러스터링으로 중복 제거

비즈니스 효과:
✅ 편집 시간 70% 절감
✅ 뉴스 발행 속도 3배 향상
✅ 독자 체류 시간 25% 증가

문제: 의사의 자유 형식 진료 기록에서 정보 추출 어려움
해결: 의료 특화 NLP 시스템

구현 내용:
• 증상, 진단명, 처방약 자동 추출
• 의학 용어 표준화 (SNOMED CT, ICD-10)
• 약물 상호작용 자동 경고
• 유사 사례 검색으로 진단 지원

비즈니스 효과:
✅ 진료 기록 작성 시간 40% 단축
✅ 의료 오류 30% 감소
✅ 연구 데이터 활용도 대폭 향상

문제: 반복적인 고객 문의 처리에 인력 낭비
해결: 지능형 챗봇 시스템

구현 내용:
• 의도 분류(Intent Classification)로 문의 유형 파악
• 개체명 인식으로 주문번호, 제품명 등 추출
• 지식 베이스 검색으로 적절한 답변 제공
• 감성 분석으로 불만 고객 우선 처리

비즈니스 효과:
✅ 단순 문의 80% 자동 처리
✅ 응답 시간 90% 단축
✅ 고객 만족도 20% 향상
✅ 상담사 업무 효율 2배 증가

# 간단한 챗봇 의도 분류 예시
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.svm import LinearSVC

class IntentClassifier:
    def __init__(self):
        self.vectorizer = TfidfVectorizer()
        self.classifier = LinearSVC()
        self.intents = {
            'order_status': '주문 조회',
            'return': '반품/교환',
            'payment': '결제 문의',
            'product_info': '제품 정보',
            'complaint': '불만 접수'
        }
    
    def train(self, training_data):
        """학습 데이터로 모델 훈련"""
        texts = [item['text'] for item in training_data]
        labels = [item['intent'] for item in training_data]
        
        X = self.vectorizer.fit_transform(texts)
        self.classifier.fit(X, labels)
    
    def predict(self, user_message):
        """사용자 메시지의 의도 예측"""
        X = self.vectorizer.transform([user_message])
        intent = self.classifier.predict(X)[0]
        
        return {
            'intent': intent,
            'intent_name': self.intents.get(intent, '기타'),
            'confidence': self.classifier.decision_function(X).max()
        }

# 사용 예시
bot = IntentClassifier()
# bot.train(training_data)  # 실제로는 학습 필요

user_input = "제 주문이 언제 도착하나요?"
result = bot.predict(user_input)
print(f"의도: {result['intent_name']}, 확신도: {result['confidence']:.2f}")

문제: 대출 심사, 사기 거래 탐지에 시간과 비용 과다
해결: 텍스트 기반 리스크 평가 시스템

구현 내용:
• 뉴스, SNS 분석으로 기업 평판 모니터링
• 재무제표 텍스트 분석으로 리스크 요인 추출
• 거래 메모 분석으로 이상 패턴 탐지
• 감성 분석으로 시장 심리 파악

비즈니스 효과:
✅ 대출 심사 시간 60% 단축
✅ 사기 탐지율 45% 향상
✅ 부실 채권 30% 감소

🎯 마무리하며

와... 여기까지 읽느라 수고했어 ㅋㅋㅋ
텍스트 마이닝과 NLTK, spaCy에 대해 정말 많은 내용을 다뤘지?

간단하게 핵심만 정리해보면:

텍스트 마이닝은 이제 선택이 아니라 필수 기술이 됐어.
데이터 분석가, 개발자, 마케터, 연구자 등 다양한 분야에서 활용되고 있고,
앞으로 그 중요성은 더욱 커질 거야 📈

처음엔 어렵게 느껴질 수 있지만, 하나씩 차근차근 따라하다 보면 어느새 전문가가 되어 있을 거임 ㅎㅎ

시작이 반이라고 했잖아?
지금 바로 Python 켜고 NLTK나 spaCy 설치해서 간단한 코드부터 실행해봐.
그게 텍스트 마이닝 전문가로 가는 첫걸음이야 🚀

궁금한 점 있으면 언제든 커뮤니티에 물어보고,
실전 경험 쌓고 싶으면 재능넷 같은 플랫폼에서 프로젝트도 찾아보고,
꾸준히 학습하면서 포트폴리오 만들어가면 돼!

화이팅! 💪💪💪