1. 텍스트 마이닝이 뭐길래? 기초 개념 알아보기 🔍

텍스트 마이닝이 뭔지 모르겠다고요? 걱정 마세요! 쉽게 설명해드릴게요~ 😉

텍스트 마이닝은 비정형 텍스트 데이터에서 유용한 정보와 인사이트를 추출하는 과정이에요. 쉽게 말하면 엄청나게 많은 글들 속에서 의미 있는 패턴이나 트렌드를 찾아내는 거죠! 마치 금광에서 금을 캐내듯이 텍스트 속에서 가치 있는 정보를 '채굴'한다고 생각하면 돼요. ㅋㅋㅋ

요즘 SNS는 트렌드의 바로미터라고 할 수 있죠! 인스타그램, 트위터, 페이스북, 유튜브 댓글까지... 이런 플랫폼에서 사람들이 무슨 이야기를 하는지 분석하면 소비자 트렌드나 여론 동향을 파악할 수 있어요. 이런 분석은 마케팅부터 제품 개발, 정책 결정까지 다양한 분야에서 활용되고 있답니다! 🔥

텍스트 마이닝의 매력은 뭐니뭐니해도 방대한 양의 텍스트를 자동으로 분석할 수 있다는 점이에요! 사람이 일일이 읽고 분석하려면 평생이 걸릴 수도 있는 데이터를 컴퓨터는 몇 분 만에 처리해버리니까요. 진짜 개이득 아니겠어요? 😆

재능넷에서도 텍스트 마이닝 관련 프로젝트를 의뢰하는 경우가 많아지고 있어요. 마케팅 전략을 세우거나 소비자 반응을 분석하는 데 이런 기술이 정말 유용하거든요! 이제 우리도 파이썬으로 직접 텍스트 마이닝을 해볼 차례입니다~ 고고씽! 🚀

2. 파이썬 환경 세팅하기: 필요한 라이브러리 설치 🛠️

텍스트 마이닝을 시작하기 전에 먼저 필요한 도구들을 준비해야겠죠? 파이썬은 데이터 분석에 최적화된 언어라서 텍스트 마이닝에 딱이에요! 다양한 라이브러리들이 우리의 작업을 엄청 편리하게 만들어줄 거예요. 😎

이제 이 라이브러리들을 설치해볼까요? 파이썬 패키지 관리자인 pip를 사용하면 아주 쉽게 설치할 수 있어요!

# 필요한 라이브러리 설치하기
pip install nltk konlpy pandas numpy matplotlib seaborn scikit-learn wordcloud tweepy requests beautifulsoup4
    

혹시 설치가 안 된다면? 걱정 마세요! 아나콘다(Anaconda)를 사용하는 방법도 있어요. 아나콘다는 데이터 과학에 필요한 여러 패키지를 한 번에 설치해주는 배포판이랍니다. 특히 윈도우에서 KoNLPy 설치가 까다로울 수 있는데, 아나콘다를 사용하면 훨씬 수월해요! 👍

# 아나콘다 환경에서 설치하기
conda install -c conda-forge nltk pandas numpy matplotlib seaborn scikit-learn
conda install -c conda-forge wordcloud tweepy requests beautifulsoup4
    

KoNLPy는 한국어 처리를 위한 필수 라이브러리인데, 설치가 좀 복잡할 수 있어요. 특히 Java 환경이 필요하기 때문에 JDK도 설치해야 해요. 윈도우 사용자라면 아래 단계를 따라해보세요!

자, 이제 모든 준비가 끝났어요! 파이썬 환경을 확인해볼까요? 아래 코드를 실행해서 모든 라이브러리가 제대로 설치됐는지 확인해보세요.

# 라이브러리 임포트 테스트
import nltk
import konlpy
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
from sklearn import feature_extraction
from wordcloud import WordCloud
import tweepy
import requests
from bs4 import BeautifulSoup

print("모든 라이브러리가 성공적으로 임포트되었습니다! 🎉")
    

오 대박! 이제 텍스트 마이닝을 위한 모든 준비가 완료됐어요! 다음 단계로 넘어가볼까요? 😄

참고로, 주피터 노트북(Jupyter Notebook)이나 구글 코랩(Google Colab)을 사용하면 코드 작성과 결과 확인이 더 편리해요. 특히 구글 코랩은 무료로 사용할 수 있고 GPU도 지원해서 대용량 데이터 처리에 유리하답니다! 진짜 꿀팁이죠? ㅋㅋㅋ

3. SNS 데이터 수집하기: API 활용법 📱

이제 본격적으로 SNS 데이터를 수집해볼 차례예요! 데이터가 없으면 분석도 못 하니까요~ 😉 SNS 데이터를 가져오는 방법은 크게 두 가지가 있어요.

오늘은 API를 활용한 방법을 중점적으로 알아볼게요! 가장 대표적인 트위터(현 X) API를 예로 들어볼게요. 트위터는 개발자들에게 API를 제공해서 트윗 데이터를 수집할 수 있게 해줘요.

자, 이제 tweepy를 사용해서 특정 키워드가 포함된 트윗을 수집해볼게요!

import tweepy
import pandas as pd
from datetime import datetime

# API 키 설정 (실제 키로 대체해야 함)
consumer_key = "YOUR_CONSUMER_KEY"
consumer_secret = "YOUR_CONSUMER_SECRET"
access_token = "YOUR_ACCESS_TOKEN"
access_token_secret = "YOUR_ACCESS_TOKEN_SECRET"

# tweepy 인증 및 API 객체 생성
auth = tweepy.OAuthHandler(consumer_key, consumer_secret)
auth.set_access_token(access_token, access_token_secret)
api = tweepy.API(auth, wait_on_rate_limit=True)

# 특정 키워드로 트윗 검색
keyword = "파이썬 데이터분석"
tweets = []

for tweet in tweepy.Cursor(api.search_tweets, q=keyword, lang="ko", tweet_mode="extended").items(200):
    tweets.append({
        'created_at': tweet.created_at,
        'id': tweet.id,
        'text': tweet.full_text,
        'username': tweet.user.screen_name,
        'followers_count': tweet.user.followers_count,
        'retweet_count': tweet.retweet_count,
        'favorite_count': tweet.favorite_count
    })

# 데이터프레임으로 변환
df_tweets = pd.DataFrame(tweets)

# 결과 확인
print(f"수집된 트윗 수: {len(df_tweets)}")
print(df_tweets.head())

# CSV 파일로 저장
df_tweets.to_csv(f"tweets_{keyword}_{datetime.now().strftime('%Y%m%d')}.csv", index=False, encoding='utf-8-sig')
    

위 코드를 실행하면 "파이썬 데이터분석" 키워드가 포함된 최근 트윗 200개를 수집해서 CSV 파일로 저장할 수 있어요! 이렇게 저장된 데이터는 나중에 분석에 활용할 수 있죠. 😊

인스타그램이나 페이스북 같은 다른 SNS 플랫폼도 API를 제공하지만, 최근에는 개인정보 보호 강화 때문에 접근할 수 있는 데이터가 제한적이에요. 특히 인스타그램은 비즈니스 계정만 API를 사용할 수 있고, 그마저도 자신의 계정 데이터만 접근 가능해요. ㅠㅠ

API 접근이 어려운 경우에는 웹 스크래핑을 고려해볼 수 있어요. BeautifulSoup이나 Selenium 같은 라이브러리를 사용하면 웹페이지에서 데이터를 추출할 수 있죠. 하지만 웹 스크래핑은 사이트의 이용약관을 확인하고, 서버에 부담을 주지 않도록 적절한 간격을 두고 요청해야 한다는 점! 꼭 기억해주세요! 🙏

# BeautifulSoup을 활용한 간단한 웹 스크래핑 예시
import requests
from bs4 import BeautifulSoup
import time

url = "https://example.com/search?q=파이썬"
headers = {"User-Agent": "Mozilla/5.0"}

response = requests.get(url, headers=headers)
soup = BeautifulSoup(response.text, "html.parser")

# 예: 모든 게시물 제목 추출
titles = soup.select(".post-title")
for title in titles:
    print(title.text.strip())
    # 서버에 부담을 주지 않기 위해 요청 간 간격 두기
    time.sleep(1)
    

데이터 수집은 텍스트 마이닝의 첫 단계이자 가장 중요한 단계예요! 좋은 데이터가 있어야 좋은 분석 결과가 나오니까요. 다음 단계에서는 수집한 데이터를 분석하기 좋은 형태로 가공하는 텍스트 전처리 과정을 알아볼게요! 🧹

참고로, 재능넷에서는 데이터 수집 전문가들이 다양한 SNS 플랫폼에서 데이터를 수집하는 서비스를 제공하고 있어요. 직접 코딩하기 어렵다면 전문가의 도움을 받는 것도 좋은 방법이랍니다! 💪

4. 텍스트 전처리: 깔끔하게 데이터 정리하기 🧹

SNS에서 수집한 데이터는 그대로 분석하기에는 너무 지저분해요! 이모티콘, URL, 해시태그, 불필요한 특수문자 등이 잔뜩 섞여 있거든요. 이런 노이즈를 제거하고 분석하기 좋은 형태로 변환하는 과정을 텍스트 전처리(Text Preprocessing)라고 해요. 이 단계가 분석 결과의 품질을 좌우한다고 해도 과언이 아니에요! 😎

한국어는 영어와 달리 교착어라서 전처리가 더 복잡해요. 영어는 단어 사이에 공백만 있으면 쉽게 토큰화할 수 있지만, 한국어는 조사와 어미가 붙어 있어서 형태소 분석이 필요하죠. 이때 KoNLPy 라이브러리가 큰 도움이 돼요! 👍

자, 이제 실제 코드로 전처리 과정을 살펴볼게요!

import re
import pandas as pd
from konlpy.tag import Okt

# 예시 데이터 (트위터에서 수집한 트윗)
tweets = [
    "오늘 파이썬으로 데이터 분석 너무 재밌다!!! 😍 https://example.com #파이썬 #데이터분석",
    "@friend 나 요즘 텍스트마이닝 공부중... 생각보다 어렵네ㅠㅠ 근데 재밌어!!",
    "요즘 핫한 AI 기술, 텍스트마이닝으로 SNS 트렌드 분석하는 방법 알아보기 https://bit.ly/3xyzabc"
]

# 전처리 함수 정의
def preprocess_text(text):
    # 1. URL 제거
    text = re.sub(r'https?://\S+|www\.\S+', '', text)
    
    # 2. 해시태그 및 멘션 처리 (# 또는 @ 제거하고 단어는 유지)
    text = re.sub(r'#(\w+)', r'\1', text)
    text = re.sub(r'@(\w+)', r'\1', text)
    
    # 3. 특수문자 및 이모티콘 제거
    text = re.sub(r'[^\w\s]', '', text)
    
    # 4. 숫자 제거 (선택사항)
    text = re.sub(r'\d+', '', text)
    
    # 5. 여러 공백을 하나로 치환
    text = re.sub(r'\s+', ' ', text).strip()
    
    return text

# 형태소 분석기 초기화
okt = Okt()

# 불용어 목록 (예시)
stopwords = ['이', '가', '은', '는', '을', '를', '에', '의', '과', '와', '한', '하다', '임', '것']

# 전처리 및 형태소 분석 수행
processed_data = []

for tweet in tweets:
    # 기본 전처리
    clean_text = preprocess_text(tweet)
    
    # 형태소 분석 (명사, 동사, 형용사만 추출)
    tokens = okt.pos(clean_text)
    selected_tokens = [word for word, pos in tokens if pos in ['Noun', 'Verb', 'Adjective']]
    
    # 불용어 제거
    filtered_tokens = [word for word in selected_tokens if word not in stopwords and len(word) > 1]
    
    processed_data.append({
        'original': tweet,
        'cleaned': clean_text,
        'tokens': filtered_tokens
    })

# 결과 확인
df_processed = pd.DataFrame(processed_data)
print(df_processed)
    

위 코드를 실행하면 원본 트윗에서 URL, 특수문자, 이모티콘 등을 제거하고, 형태소 분석을 통해 의미 있는 단어만 추출한 결과를 볼 수 있어요. 이렇게 정제된 데이터는 분석하기 훨씬 수월하답니다! 😄

전처리 과정에서 주의할 점은 목적에 맞는 전처리를 해야 한다는 거예요. 예를 들어, 감성 분석을 할 때는 감정을 나타내는 이모티콘이나 특수문자(!, ?)가 중요한 정보일 수 있어요. 반면, 토픽 모델링을 할 때는 주요 명사만 추출하는 것이 더 효과적일 수 있죠.

또한, 한국어 특성상 신조어나 줄임말이 많이 사용되는데, 이런 단어들은 기존 사전에 없어서 형태소 분석기가 제대로 인식하지 못할 수 있어요. 이런 경우에는 사용자 정의 사전을 추가하거나, 정규표현식을 활용한 패턴 매칭으로 처리할 수 있답니다.

이제 깔끔하게 정리된 데이터가 준비됐으니, 다음 단계에서는 이 데이터를 가지고 실제 분석을 시작해볼게요! 단어 빈도 분석과 워드클라우드 만들기, 기대되지 않나요? 😆

5. 단어 빈도 분석과 워드클라우드 만들기 📊

이제 정제된 텍스트 데이터를 가지고 본격적인 분석을 시작해볼까요? 가장 기본적이면서도 직관적인 분석 방법은 단어 빈도 분석이에요. 말 그대로 어떤 단어가 얼마나 자주 등장하는지 세어보는 거죠! 이를 통해 사람들이 어떤 주제에 관심이 많은지 한눈에 파악할 수 있어요. 👀

먼저 단어 빈도를 계산하는 코드를 살펴볼게요!

from collections import Counter
import pandas as pd
import matplotlib.pyplot as plt
from matplotlib import font_manager
import seaborn as sns
from wordcloud import WordCloud

# 예시 데이터 (전처리된 토큰 리스트)
all_tokens = [
    '파이썬', '데이터', '분석', '텍스트', '마이닝', '파이썬', '코딩', '프로그래밍', 
    '데이터', '시각화', '머신러닝', '인공지능', '파이썬', '데이터', '분석', '재미있다',
    '텍스트', '마이닝', '트렌드', '분석', '인사이트', '도출', '유용하다', '파이썬'
]

# 단어 빈도 계산
word_counts = Counter(all_tokens)
print(word_counts.most_common(10))  # 상위 10개 단어 출력

# 데이터프레임으로 변환
df_word_counts = pd.DataFrame(word_counts.most_common(), columns=['word', 'count'])
print(df_word_counts.head(10))

# 한글 폰트 설정 (맥/윈도우 환경에 따라 다름)
plt.rcParams['font.family'] = 'AppleGothic'  # 맥
# plt.rcParams['font.family'] = 'Malgun Gothic'  # 윈도우

# 막대 그래프로 시각화
plt.figure(figsize=(12, 6))
sns.barplot(x='count', y='word', data=df_word_counts.head(15), palette='viridis')
plt.title('단어 빈도 분석 결과', fontsize=16)
plt.xlabel('빈도수', fontsize=14)
plt.ylabel('단어', fontsize=14)
plt.tight_layout()
plt.savefig('word_frequency.png', dpi=300)
plt.show()
    

이 코드를 실행하면 단어별 등장 빈도를 계산하고, 상위 15개 단어를 막대 그래프로 시각화할 수 있어요. 이렇게 하면 어떤 단어가 가장 많이 언급되었는지 한눈에 볼 수 있죠! 😊

하지만 단순히 단어 빈도만 보면 'the', 'is', 'a'와 같은 불용어(stopwords)가 상위에 랭크될 수 있어요. 이런 단어들은 실제 의미 분석에는 큰 도움이 되지 않죠. 그래서 TF-IDF(Term Frequency-Inverse Document Frequency)라는 방법을 사용하기도 해요.

from sklearn.feature_extraction.text import TfidfVectorizer

# 예시 문서 데이터
documents = [
    "파이썬으로 데이터 분석하기",
    "텍스트 마이닝 기법 알아보기",
    "파이썬 라이브러리로 텍스트 분석",
    "데이터 시각화 방법 배우기",
    "파이썬 머신러닝 모델 개발"
]

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

# 단어 목록 가져오기
feature_names = vectorizer.get_feature_names_out()

# 각 문서의 TF-IDF 상위 단어 확인
for i, doc in enumerate(documents):
    # 해당 문서의 TF-IDF 값 가져오기
    tfidf_scores = tfidf_matrix[i].toarray()[0]
    # 단어와 TF-IDF 값을 매핑
    word_scores = [(feature_names[j], tfidf_scores[j]) for j in range(len(feature_names))]
    # TF-IDF 값 기준으로 정렬
    word_scores = sorted(word_scores, key=lambda x: x[1], reverse=True)
    # 상위 3개 단어 출력
    print(f"문서 {i+1}: {doc}")
    print(f"상위 단어: {word_scores[:3]}")
    print()
    

이제 워드클라우드(Word Cloud)를 만들어볼까요? 워드클라우드는 단어의 빈도를 시각적으로 표현하는 방법으로, 빈도가 높은 단어일수록 크게 표시돼요. 직관적이고 시각적으로 멋져서 프레젠테이션이나 보고서에 활용하기 좋답니다! 🌟

from wordcloud import WordCloud
import matplotlib.pyplot as plt
from collections import Counter
import numpy as np
from PIL import Image

# 단어 빈도 딕셔너리 생성
word_freq = dict(word_counts)

# 워드클라우드 생성 (기본)
wordcloud = WordCloud(
    font_path='AppleGothic',  # 맥용 한글 폰트 (윈도우: 'malgun.ttf')
    width=800, 
    height=400, 
    background_color='white',
    max_words=100,
    max_font_size=150,
    random_state=42
).generate_from_frequencies(word_freq)

# 워드클라우드 표시
plt.figure(figsize=(10, 8))
plt.imshow(wordcloud, interpolation='bilinear')
plt.axis('off')
plt.tight_layout()
plt.savefig('wordcloud_basic.png', dpi=300)
plt.show()

# 마스크를 적용한 워드클라우드 (선택사항)
# 마스크 이미지 로드 (예: 파이썬 로고 모양)
# mask = np.array(Image.open('python_logo.png'))
# 
# wordcloud_mask = WordCloud(
#     font_path='AppleGothic',
#     width=800, 
#     height=400, 
#     background_color='white',
#     max_words=100,
#     mask=mask,
#     contour_width=1,
#     contour_color='steelblue',
#     random_state=42
# ).generate_from_frequencies(word_freq)
# 
# plt.figure(figsize=(10, 8))
# plt.imshow(wordcloud_mask, interpolation='bilinear')
# plt.axis('off')
# plt.tight_layout()
# plt.savefig('wordcloud_mask.png', dpi=300)
# plt.show()
    

단어 빈도 분석과 워드클라우드는 텍스트 데이터의 전반적인 특성을 파악하는 데 유용해요. 하지만 단어 간의 관계나 문맥을 파악하기는 어렵다는 한계가 있죠. 그래서 다음 단계에서는 감성 분석과 토픽 모델링 같은 더 심층적인 분석 방법을 알아볼 거예요!

단어 빈도 분석은 텍스트 마이닝의 기초 중의 기초지만, 그만큼 활용도가 높아요. 특히 SNS 트렌드 분석에서는 해시태그 빈도 분석이 자주 활용되는데, 이를 통해 어떤 주제가 인기 있는지 빠르게 파악할 수 있죠!

다음 섹션에서는 텍스트에 담긴 감정을 분석하는 감성 분석(Sentiment Analysis)에 대해 알아볼게요. 사람들이 특정 주제에 대해 긍정적인지 부정적인지 파악할 수 있는 강력한 기법이랍니다! 기대되지 않나요? 😄

6. 감성 분석으로 여론 파악하기 😊😠

단어 빈도만으로는 사람들의 감정이나 태도를 파악하기 어려워요. 예를 들어, "이 제품은 정말 좋아요!"와 "이 제품은 정말 별로예요..."에서 '제품'이라는 단어의 빈도는 같지만, 담긴 감정은 완전히 다르죠! 이런 감정적인 측면을 분석하는 것이 바로 감성 분석(Sentiment Analysis)이에요. 🔍

감성 분석은 텍스트에 담긴 감정이나 의견, 태도를 파악하는 기술로, 주로 긍정/부정/중립으로 분류해요. SNS 트렌드 분석에서는 특정 주제나 제품, 브랜드에 대한 대중의 반응을 파악하는 데 매우 유용하답니다!

먼저 가장 간단한 사전 기반 접근법을 살펴볼게요. 한국어 감성 사전을 활용해 텍스트의 감성 점수를 계산하는 방법이에요.

import pandas as pd
import matplotlib.pyplot as plt
from konlpy.tag import Okt

# 간단한 한국어 감성 사전 예시 (실제로는 더 큰 사전 사용)
sentiment_dict = {
    '좋다': 1, '훌륭하다': 2, '멋지다': 1.5, '아름답다': 1, '행복하다': 1.5,
    '나쁘다': -1, '최악이다': -2, '실망하다': -1.5, '화나다': -1, '슬프다': -1.5,
    '재미있다': 1, '지루하다': -1, '유용하다': 1, '쓸모없다': -1, '추천하다': 1.5,
    '비추하다': -1.5, '만족하다': 1, '불만이다': -1, '사랑하다': 2, '싫어하다': -1.5
}

# 예시 리뷰 데이터
reviews = [
    "이 파이썬 책은 정말 좋아요! 초보자도 쉽게 이해할 수 있어서 만족합니다.",
    "텍스트 마이닝 강의가 너무 어려워요. 실망했습니다.",
    "SNS 데이터 분석 도구는 유용하지만 사용법이 복잡해서 아쉬워요.",
    "이 분석 방법은 정말 훌륭해요! 많은 인사이트를 얻을 수 있었습니다.",
    "파이썬 라이브러리 설치가 너무 어렵고 오류가 많이 발생해서 화가 납니다."
]

# 형태소 분석기 초기화
okt = Okt()

# 감성 분석 함수 정의
def analyze_sentiment(text):
    # 형태소 분석
    tokens = okt.pos(text, stem=True)  # stem=True로 기본형 추출
    
    # 감성 점수 계산
    score = 0
    sentiment_words = []
    
    for word, pos in tokens:
        if word in sentiment_dict:
            score += sentiment_dict[word]
            sentiment_words.append((word, sentiment_dict[word]))
    
    # 감성 레이블 결정
    if score > 0:
        sentiment = "긍정"
    elif score < 0:
        sentiment = "부정"
    else:
        sentiment = "중립"
    
    return {
        'text': text,
        'score': score,
        'sentiment': sentiment,
        'sentiment_words': sentiment_words
    }

# 모든 리뷰에 대해 감성 분석 수행
results = []
for review in reviews:
    result = analyze_sentiment(review)
    results.append(result)

# 결과를 데이터프레임으로 변환
df_results = pd.DataFrame(results)
print(df_results[['text', 'score', 'sentiment']])

# 감성 분포 시각화
plt.figure(figsize=(8, 6))
sentiment_counts = df_results['sentiment'].value_counts()
plt.bar(sentiment_counts.index, sentiment_counts.values, color=['green', 'gray', 'red'])
plt.title('리뷰 감성 분포')
plt.ylabel('리뷰 수')
plt.tight_layout()
plt.savefig('sentiment_distribution.png', dpi=300)
plt.show()
    

위 코드는 간단한 감성 사전을 활용해 텍스트의 감성을 분석하는 예시예요. 실제로는 더 큰 규모의 감성 사전이나, KNU 한국어 감성사전 같은 공개된 리소스를 활용하는 것이 좋아요! 😊

하지만 사전 기반 방법은 문맥을 고려하지 못하고, 신조어나 은어를 처리하기 어렵다는 한계가 있어요. 이런 한계를 극복하기 위해 머신러닝 기반 접근법을 사용할 수 있어요.

from sklearn.feature_extraction.text import CountVectorizer
from sklearn.model_selection import train_test_split
from sklearn.naive_bayes import MultinomialNB
from sklearn.metrics import classification_report

# 예시 학습 데이터 (실제로는 더 많은 데이터 필요)
texts = [
    "이 제품 정말 좋아요 만족합니다",
    "최고의 서비스 감사합니다",
    "배송이 빠르고 품질도 좋네요",
    "사용하기 편리하고 디자인도 마음에 들어요",
    "가성비 최고 추천합니다",
    "실망스러운 품질이네요",
    "배송이 너무 늦어서 화가 납니다",
    "사용법이 너무 복잡해요",
    "가격만 비싸고 별로예요",
    "최악의 구매였어요 환불하고 싶네요"
]

# 레이블 (0: 부정, 1: 긍정)
labels = [1, 1, 1, 1, 1, 0, 0, 0, 0, 0]

# 데이터 분할 (학습용/테스트용)
X_train, X_test, y_train, y_test = train_test_split(texts, labels, test_size=0.2, random_state=42)

# 텍스트 벡터화
vectorizer = CountVectorizer()
X_train_vec = vectorizer.fit_transform(X_train)
X_test_vec = vectorizer.transform(X_test)

# 나이브 베이즈 분류기 학습
classifier = MultinomialNB()
classifier.fit(X_train_vec, y_train)

# 테스트 데이터로 예측
y_pred = classifier.predict(X_test_vec)

# 성능 평가
print(classification_report(y_test, y_pred, target_names=['부정', '긍정']))

# 새로운 텍스트에 대한 감성 예측
new_texts = [
    "파이썬으로 텍스트 마이닝하는 방법이 정말 유용해요",
    "이 분석 방법은 너무 복잡하고 어려워요"
]

new_texts_vec = vectorizer.transform(new_texts)
predictions = classifier.predict(new_texts_vec)
probabilities = classifier.predict_proba(new_texts_vec)

for i, text in enumerate(new_texts):
    sentiment = "긍정" if predictions[i] == 1 else "부정"
    pos_prob = probabilities[i][1]
    print(f"텍스트: {text}")
    print(f"감성: {sentiment} (긍정 확률: {pos_prob:.2f})")
    print()
    

더 정확한 감성 분석을 위해서는 딥러닝 기반 접근법을 활용할 수 있어요. 특히 BERT(Bidirectional Encoder Representations from Transformers)와 같은 사전 학습된 언어 모델은 문맥을 고려한 고성능 감성 분석이 가능해요. 한국어의 경우 KoBERT, KoGPT 등의 모델을 활용할 수 있답니다!

감성 분석은 SNS 트렌드 분석의 핵심 요소 중 하나예요. 단순히 어떤 주제가 인기 있는지 뿐만 아니라, 그 주제에 대한 대중의 감정까지 파악할 수 있으니까요! 이를 통해 더 깊이 있는 인사이트를 도출할 수 있답니다. 😊

다음 섹션에서는 텍스트 데이터에서 주요 주제를 자동으로 추출하는 토픽 모델링(Topic Modeling)에 대해 알아볼게요. 대량의 문서에서 숨겨진 주제를 발견하는 마법 같은 기술이랍니다! 기대되지 않나요? 🔮

7. 토픽 모델링으로 주요 이슈 찾아내기 🔍

SNS에서는 매일 수많은 주제에 대한 대화가 오가고 있어요. 이 중에서 주요 이슈나 트렌드를 자동으로 찾아내려면 어떻게 해야 할까요? 바로 토픽 모델링(Topic Modeling)이 해답이 될 수 있어요! 🧩

토픽 모델링은 대량의 문서 집합에서 숨겨진 주제(토픽)를 발견하는 통계적 기법이에요. 쉽게 말해, 비슷한 주제를 다루는 문서들을 자동으로 그룹화하고, 각 그룹의 핵심 키워드를 추출해주는 거죠!

이 중에서 가장 많이 사용되는 LDA(Latent Dirichlet Allocation) 알고리즘을 파이썬으로 구현해볼게요! LDA는 각 문서가 여러 토픽의 혼합으로 구성되어 있고, 각 토픽은 단어의 분포로 표현된다고 가정해요.

import pandas as pd
import numpy as np
from konlpy.tag import Okt
from sklearn.feature_extraction.text import CountVectorizer
from sklearn.decomposition import LatentDirichletAllocation
import matplotlib.pyplot as plt
import pyLDAvis
import pyLDAvis.sklearn

# 예시 데이터 (SNS 게시물)
posts = [
    "파이썬으로 데이터 분석하는 방법 공유합니다. 판다스와 넘파이 라이브러리 활용하면 편리해요.",
    "오늘 새로 산 스마트폰 카메라 성능이 정말 좋네요. 사진 화질이 너무 선명해요.",
    "주식 시장 분석을 위한 데이터 시각화 도구 추천해주세요. 파이썬 라이브러리 중에 좋은 것 있나요?",
    "요즘 인기있는 넷플릭스 드라마 추천 부탁드려요. 주말에 몰아보려고 합니다.",
    "데이터 사이언스 공부 시작했어요. 파이썬부터 배우고 있는데 재미있네요.",
    "새로 출시된 스마트폰 배터리 성능이 좋다고 해서 구매했어요. 하루 종일 써도 배터리가 오래 가요.",
    "주식 투자 초보인데 어떤 종목부터 시작하면 좋을까요? 안전한 ETF 추천해주세요.",
    "데이터 분석 결과를 효과적으로 시각화하는 방법 알려주세요. 대시보드 만들고 싶어요.",
    "요즘 핫한 OTT 서비스 비교해보았어요. 넷플릭스, 디즈니플러스, 왓챠 중 어떤 것이 좋을까요?",
    "인공지능 관련 온라인 강의 추천해주세요. 파이썬 기초는 알고 있습니다."
]

# 형태소 분석기 초기화
okt = Okt()

# 명사만 추출하는 전처리 함수
def preprocess(text):
    nouns = okt.nouns(text)
    return ' '.join([noun for noun in nouns if len(noun) > 1])  # 1글자 명사 제외

# 전처리 적용
processed_posts = [preprocess(post) for post in posts]

# 단어 벡터화
vectorizer = CountVectorizer(max_df=0.9, min_df=2, max_features=1000)
X = vectorizer.fit_transform(processed_posts)
feature_names = vectorizer.get_feature_names_out()

# LDA 모델 학습 (토픽 수는 3개로 설정)
n_topics = 3
lda = LatentDirichletAllocation(
    n_components=n_topics,
    max_iter=10,
    learning_method='online',
    random_state=42
)
lda.fit(X)

# 각 토픽의 주요 단어 출력
def print_top_words(model, feature_names, n_top_words):
    for topic_idx, topic in enumerate(model.components_):
        print(f"토픽 #{topic_idx+1}:")
        top_words = [feature_names[i] for i in topic.argsort()[:-n_top_words - 1:-1]]
        print(f"  {', '.join(top_words)}")
    print()

print_top_words(lda, feature_names, 5)

# 각 문서의 토픽 분포 확인
doc_topic_dist = lda.transform(X)

# 각 문서의 주요 토픽 할당
doc_topics = np.argmax(doc_topic_dist, axis=1)
for i, (post, topic) in enumerate(zip(posts, doc_topics)):
    print(f"문서 {i+1}의 주요 토픽: {topic+1}")
    print(f"  {post[:50]}...")
    print()

# 토픽 시각화 (pyLDAvis)
# pyLDAvis.enable_notebook()  # 주피터 노트북에서 실행 시 활성화
# vis = pyLDAvis.sklearn.prepare(lda, X, vectorizer)
# pyLDAvis.display(vis)
    

위 코드는 SNS 게시물에서 주요 토픽을 추출하는 예시예요. 실행하면 각 토픽의 주요 키워드와 각 문서가 어떤 토픽에 속하는지 확인할 수 있어요. 이를 통해 SNS에서 어떤 주제가 많이 논의되고 있는지 파악할 수 있죠! 😊

토픽 모델링 결과를 시각화하는 데는 pyLDAvis 라이브러리가 유용해요. 각 토픽 간의 관계와 주요 키워드를 직관적으로 보여주기 때문이죠!

토픽 모델링에서 가장 중요한 것은 적절한 토픽 수를 결정하는 것이에요. 토픽 수가 너무 적으면 다양한 주제가 하나로 뭉뚱그려지고, 너무 많으면 비슷한 주제가 여러 토픽으로 분산될 수 있어요. 일반적으로 토픽 일관성(Topic Coherence) 점수를 계산해 최적의 토픽 수를 결정해요.

# 최적의 토픽 수 찾기
from sklearn.decomposition import LatentDirichletAllocation
import matplotlib.pyplot as plt

def compute_coherence_values(dictionary, corpus, texts, limit, start=2, step=1):
    coherence_values = []
    model_list = []
    for num_topics in range(start, limit, step):
        model = LatentDirichletAllocation(
            n_components=num_topics, 
            max_iter=10, 
            learning_method='online',
            random_state=42
        )
        model.fit(X)
        model_list.append(model)
        
        # 여기서는 간단히 로그 우도값을 사용
        # 실제로는 coherence_model_lda = CoherenceModel(model=model, texts=texts, dictionary=dictionary, coherence='c_v')
        # coherence = coherence_model_lda.get_coherence()
        coherence = model.score(X)
        coherence_values.append(coherence)
    
    return model_list, coherence_values

# 토픽 수 범위 설정
start, limit, step = 2, 11, 1

# 토픽 일관성 계산
model_list, coherence_values = compute_coherence_values(
    dictionary=None, corpus=None, texts=processed_posts, 
    start=start, limit=limit, step=step
)

# 결과 시각화
x = range(start, limit, step)
plt.figure(figsize=(10, 6))
plt.plot(x, coherence_values)
plt.xlabel("토픽 수")
plt.ylabel("로그 우도 점수")
plt.title("토픽 수에 따른 모델 성능")
plt.xticks(x)
plt.grid(True)
plt.tight_layout()
plt.savefig('topic_coherence.png', dpi=300)
plt.show()

# 최적의 토픽 수 찾기
optimal_num_topics = x[coherence_values.index(max(coherence_values))]
print(f"최적의 토픽 수: {optimal_num_topics}")
    

토픽 모델링은 SNS 트렌드 분석에 강력한 도구예요. 수많은 게시물에서 자동으로 주요 주제를 추출하고, 각 주제의 비중을 파악할 수 있으니까요! 이를 통해 소비자들이 어떤 주제에 관심이 있는지, 시간에 따라 관심사가 어떻게 변화하는지 등을 분석할 수 있답니다. 🔍

다음 섹션에서는 지금까지 분석한 결과를 시각적으로 멋지게 표현하는 방법에 대해 알아볼게요! 데이터 시각화는 복잡한 분석 결과를 직관적으로 전달하는 데 매우 중요하답니다. 어떤 시각화 방법이 있는지 함께 살펴볼까요? 📊

8. 시각화로 분석 결과 멋지게 표현하기 📊

아무리 뛰어난 분석 결과도 효과적으로 전달되지 않으면 의미가 반감되죠! 데이터 시각화는 복잡한 분석 결과를 직관적이고 이해하기 쉽게 전달하는 강력한 도구예요. 특히 SNS 트렌드 분석 결과를 경영진이나 마케팅팀에 보고할 때 시각화는 필수랍니다! 👀

파이썬에는 다양한 시각화 라이브러리가 있어요. 가장 기본적인 matplotlib부터 seaborn, plotly, Bokeh 등 목적에 맞게 선택할 수 있죠. 이번에는 SNS 트렌드 분석 결과를 시각화하는 다양한 방법을 알아볼게요!

먼저, 시간에 따른 토픽 트렌드 변화를 시각화하는 코드를 살펴볼게요!

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
from datetime import datetime, timedelta

# 예시 데이터 생성 (날짜별 토픽 분포)
np.random.seed(42)
dates = [datetime(2023, 1, 1) + timedelta(days=i) for i in range(30)]
topic1_trend = np.random.normal(loc=30, scale=5, size=30) + np.linspace(0, 15, 30)  # 상승 트렌드
topic2_trend = np.random.normal(loc=40, scale=4, size=30) - np.linspace(0, 10, 30)  # 하락 트렌드
topic3_trend = np.random.normal(loc=25, scale=6, size=30) + 5 * np.sin(np.linspace(0, 2*np.pi, 30))  # 주기적 트렌드

# 데이터프레임 생성
df_trends = pd.DataFrame({
    'date': dates,
    '데이터 분석': topic1_trend,
    '스마트폰/기기': topic2_trend,
    '엔터테인먼트': topic3_trend
})

# 시계열 그래프 그리기
plt.figure(figsize=(12, 6))
sns.lineplot(data=df_trends, x='date', y='데이터 분석', marker='o', label='데이터 분석')
sns.lineplot(data=df_trends, x='date', y='스마트폰/기기', marker='s', label='스마트폰/기기')
sns.lineplot(data=df_trends, x='date', y='엔터테인먼트', marker='^', label='엔터테인먼트')

plt.title('시간에 따른 토픽 트렌드 변화', fontsize=16)
plt.xlabel('날짜', fontsize=14)
plt.ylabel('언급 빈도', fontsize=14)
plt.grid(True, linestyle='--', alpha=0.7)
plt.xticks(rotation=45)
plt.tight_layout()
plt.savefig('topic_trends_over_time.png', dpi=300)
plt.show()

# 스택 영역 그래프로 토픽 비율 변화 시각화
plt.figure(figsize=(12, 6))
plt.stackplot(df_trends['date'], 
              df_trends['데이터 분석'], 
              df_trends['스마트폰/기기'], 
              df_trends['엔터테인먼트'],
              labels=['데이터 분석', '스마트폰/기기', '엔터테인먼트'],
              alpha=0.8)

plt.title('시간에 따른 토픽 비율 변화', fontsize=16)
plt.xlabel('날짜', fontsize=14)
plt.ylabel('상대적 비율', fontsize=14)
plt.grid(True, linestyle='--', alpha=0.7)
plt.xticks(rotation=45)
plt.legend(loc='upper left')
plt.tight_layout()
plt.savefig('topic_proportions_over_time.png', dpi=300)
plt.show()
    

다음으로, 감성 분석 결과를 시각화하는 코드를 살펴볼게요!

# 감성 분석 결과 시각화 (예시 데이터)
sentiment_data = {
    '토픽': ['데이터 분석', '스마트폰/기기', '엔터테인먼트', '데이터 분석', '스마트폰/기기', '엔터테인먼트'],
    '감성': ['긍정', '긍정', '긍정', '부정', '부정', '부정'],
    '비율': [65, 70, 80, 35, 30, 20]
}
df_sentiment = pd.DataFrame(sentiment_data)

# 그룹화된 막대 그래프로 토픽별 감성 비율 시각화
plt.figure(figsize=(10, 6))
sns.barplot(x='토픽', y='비율', hue='감성', data=df_sentiment, palette={'긍정': '#4CAF50', '부정': '#F44336'})

plt.title('토픽별 감성 분석 결과', fontsize=16)
plt.xlabel('토픽', fontsize=14)
plt.ylabel('비율 (%)', fontsize=14)
plt.ylim(0, 100)
plt.legend(title='감성')
plt.tight_layout()
plt.savefig('sentiment_by_topic.png', dpi=300)
plt.show()

# 도넛 차트로 전체 감성 비율 시각화
plt.figure(figsize=(8, 8))
sentiment_overall = df_sentiment.groupby('감성')['비율'].mean().reset_index()
plt.pie(sentiment_overall['비율'], labels=sentiment_overall['감성'], autopct='%1.1f%%', 
        colors=['#4CAF50', '#F44336'], startangle=90, wedgeprops=dict(width=0.4))
plt.title('전체 감성 분포', fontsize=16)
plt.axis('equal')
plt.tight_layout()
plt.savefig('overall_sentiment_donut.png', dpi=300)
plt.show()
    

단어 간의 관계를 네트워크 그래프로 시각화하는 것도 매우 유용해요! 함께 자주 등장하는 단어들을 연결해 시각화하면 단어 간의 연관성을 한눈에 파악할 수 있죠.

import networkx as nx
import matplotlib.pyplot as plt
from sklearn.feature_extraction.text import CountVectorizer
import numpy as np

# 예시 데이터
texts = [
    "파이썬 데이터 분석 라이브러리",
    "파이썬 머신러닝 알고리즘",
    "데이터 시각화 도구 추천",
    "텍스트 마이닝 파이썬 코드",
    "머신러닝 모델 성능 평가",
    "데이터 전처리 방법 파이썬"
]

# 단어 동시 출현 행렬 계산
vectorizer = CountVectorizer()
X = vectorizer.fit_transform(texts)
words = vectorizer.get_feature_names_out()

# 동시 출현 행렬 계산 (X^T * X)
word_cooccurrence = (X.T * X).toarray()
np.fill_diagonal(word_cooccurrence, 0)  # 대각선(자기 자신과의 관계) 제거

# 네트워크 그래프 생성
G = nx.Graph()

# 노드 추가
for word in words:
    G.add_node(word)

# 엣지 추가 (동시 출현 빈도가 1 이상인 경우)
for i, word1 in enumerate(words):
    for j, word2 in enumerate(words):
        if i < j and word_cooccurrence[i, j] >= 1:
            G.add_edge(word1, word2, weight=word_cooccurrence[i, j])

# 네트워크 그래프 시각화
plt.figure(figsize=(12, 10))
pos = nx.spring_layout(G, seed=42)  # 노드 위치 결정

# 노드 크기 계산 (단어 빈도에 비례)
word_freq = np.sum(X.toarray(), axis=0)
node_size = [100 * (freq + 1) for freq in word_freq]

# 엣지 두께 계산 (동시 출현 빈도에 비례)
edge_width = [0.5 * G[u][v]['weight'] for u, v in G.edges()]

# 그래프 그리기
nx.draw_networkx_nodes(G, pos, node_size=node_size, node_color='skyblue', alpha=0.8)
nx.draw_networkx_edges(G, pos, width=edge_width, alpha=0.5, edge_color='gray')
nx.draw_networkx_labels(G, pos, font_size=12, font_family='sans-serif')

plt.title('단어 동시 출현 네트워크', fontsize=16)
plt.axis('off')
plt.tight_layout()
plt.savefig('word_cooccurrence_network.png', dpi=300, bbox_inches='tight')
plt.show()
    

더 고급 시각화를 위해서는 인터랙티브 라이브러리를 활용할 수 있어요. plotly나 Bokeh 같은 라이브러리를 사용하면 마우스 오버 시 추가 정보를 보여주거나, 확대/축소, 필터링 등의 기능을 추가할 수 있답니다!

시각화는 분석 결과를 효과적으로 전달하는 핵심 단계예요. 아무리 뛰어난 분석 결과도 이해하기 어렵게 표현되면 그 가치가 반감되죠. 특히 의사 결정권자나 비기술적 배경을 가진 사람들에게 결과를 설명할 때는 더욱 중요해요!

이제 지금까지 배운 내용을 종합해서 실전 프로젝트를 진행해볼까요? 다음 섹션에서는 인스타그램 해시태그 트렌드를 분석하는 실제 프로젝트를 단계별로 살펴볼 거예요! 기대되지 않나요? 😄

9. 실전 프로젝트: 인스타그램 해시태그 트렌드 분석 🔍

이제 지금까지 배운 내용을 종합해서 실전 프로젝트를 진행해볼게요! 인스타그램은 해시태그를 통해 콘텐츠를 분류하고 검색하는 플랫폼이라 해시태그 트렌드를 분석하면 소비자들의 관심사를 파악하는 데 큰 도움이 돼요. 특히 마케팅이나 콘텐츠 전략을 수립할 때 매우 유용하답니다! 🚀

인스타그램은 API 접근이 제한적이라 공식 API로는 자신의 비즈니스 계정 데이터만 접근할 수 있어요. 이번 프로젝트에서는 웹 스크래핑 방식으로 데이터를 수집해볼게요. (단, 인스타그램의 이용약관을 준수하고 공개된 데이터만 수집해야 한다는 점 기억해주세요!)

import time
import random
import pandas as pd
from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.chrome.service import Service
from selenium.webdriver.chrome.options import Options
from webdriver_manager.chrome import ChromeDriverManager
from bs4 import BeautifulSoup
import re
from collections import Counter
import matplotlib.pyplot as plt
import seaborn as sns
import networkx as nx
from wordcloud import WordCloud

# 크롬 드라이버 설정
chrome_options = Options()
chrome_options.add_argument("--headless")  # 브라우저 창 숨기기
chrome_options.add_argument("--no-sandbox")
chrome_options.add_argument("--disable-dev-shm-usage")

driver = webdriver.Chrome(service=Service(ChromeDriverManager().install()), options=chrome_options)

# 검색할 해시태그
search_tag = "뷰티"
url = f"https://www.instagram.com/explore/tags/{search_tag}/"

# 인스타그램 접속
driver.get(url)
time.sleep(5)  # 페이지 로딩 대기

# 스크롤 다운하여 더 많은 게시물 로드
for _ in range(5):
    driver.execute_script("window.scrollTo(0, document.body.scrollHeight);")
    time.sleep(2)

# 페이지 소스 가져오기
page_source = driver.page_source
soup = BeautifulSoup(page_source, 'html.parser')

# 게시물 링크 추출
post_links = []
for link in soup.find_all('a'):
    href = link.get('href')
    if href and '/p/' in href:
        post_links.append('https://www.instagram.com' + href)

# 중복 제거
post_links = list(set(post_links))
print(f"수집된 게시물 수: {len(post_links)}")

# 각 게시물에서 해시태그 추출
all_hashtags = []
post_data = []

for i, link in enumerate(post_links[:20]):  # 예시로 20개만 수집
    try:
        driver.get(link)
        time.sleep(random.uniform(2, 4))  # 랜덤 대기 시간
        
        # 게시물 내용 가져오기
        post_html = driver.page_source
        post_soup = BeautifulSoup(post_html, 'html.parser')
        
        # 텍스트 내용 추출 (실제로는 더 정교한 선택자 필요)
        text_elements = post_soup.select('div._a9zs')
        post_text = ' '.join([elem.text for elem in text_elements])
        
        # 해시태그 추출
        hashtags = re.findall(r'#(\w+)', post_text)
        
        # 게시 시간 추출 (예시)
        time_elements = post_soup.select('time._aaqe')
        post_time = time_elements[0]['datetime'] if time_elements else None
        
        # 데이터 저장
        post_data.append({
            'link': link,
            'text': post_text,
            'hashtags': hashtags,
            'time': post_time
        })
        
        all_hashtags.extend(hashtags)
        
        print(f"게시물 {i+1}/{len(post_links[:20])} 처리 완료")
    except Exception as e:
        print(f"게시물 처리 중 오류 발생: {e}")
    
    # 서버 부하 방지를 위한 대기
    time.sleep(random.uniform(1, 3))

# 드라이버 종료
driver.quit()

# 데이터프레임으로 변환
df_posts = pd.DataFrame(post_data)
print(df_posts.head())

# 해시태그 빈도 분석
hashtag_counts = Counter(all_hashtags)
top_hashtags = hashtag_counts.most_common(20)
df_top_hashtags = pd.DataFrame(top_hashtags, columns=['hashtag', 'count'])

# 상위 해시태그 시각화
plt.figure(figsize=(12, 8))
sns.barplot(x='count', y='hashtag', data=df_top_hashtags)
plt.title(f'#{search_tag} 관련 상위 20개 해시태그', fontsize=16)
plt.xlabel('빈도수', fontsize=14)
plt.ylabel('해시태그', fontsize=14)
plt.tight_layout()
plt.savefig('top_hashtags.png', dpi=300)
plt.show()

# 워드클라우드 생성
wordcloud = WordCloud(
    font_path='AppleGothic',  # 맥용 한글 폰트 (윈도우: 'malgun.ttf')
    width=800, 
    height=400, 
    background_color='white',
    colormap='viridis',
    max_words=100,
    max_font_size=150,
    random_state=42
).generate_from_frequencies(hashtag_counts)

plt.figure(figsize=(10, 8))
plt.imshow(wordcloud, interpolation='bilinear')
plt.axis('off')
plt.tight_layout()
plt.savefig('hashtag_wordcloud.png', dpi=300)
plt.show()
    

위 코드는 인스타그램에서 특정 해시태그(예: #뷰티)로 검색한 결과에서 게시물을 수집하고, 각 게시물에 포함된 해시태그를 추출하는 과정이에요. 이렇게 수집한 데이터를 바탕으로 해시태그 간의 연관성을 분석해볼게요!

# 해시태그 동시 출현 분석
hashtag_cooccurrence = {}

for post in post_data:
    hashtags = post['hashtags']
    for i, tag1 in enumerate(hashtags):
        for tag2 in hashtags[i+1:]:
            if tag1 != tag2:
                pair = tuple(sorted([tag1, tag2]))
                hashtag_cooccurrence[pair] = hashtag_cooccurrence.get(pair, 0) + 1

# 상위 연관 해시태그 쌍
top_cooccurrences = sorted(hashtag_cooccurrence.items(), key=lambda x: x[1], reverse=True)[:30]
print("상위 연관 해시태그:")
for (tag1, tag2), count in top_cooccurrences[:10]:
    print(f"#{tag1} - #{tag2}: {count}회")

# 네트워크 그래프 생성
G = nx.Graph()

# 상위 해시태그만 노드로 추가
top_tags = [tag for tag, _ in top_hashtags[:15]]
for tag in top_tags:
    G.add_node(tag)

# 엣지 추가
for (tag1, tag2), weight in top_cooccurrences:
    if tag1 in top_tags and tag2 in top_tags:
        G.add_edge(tag1, tag2, weight=weight)

# 네트워크 그래프 시각화
plt.figure(figsize=(12, 10))
pos = nx.spring_layout(G, seed=42)

# 노드 크기 계산 (해시태그 빈도에 비례)
node_size = [100 * hashtag_counts[tag] for tag in G.nodes()]

# 엣지 두께 계산 (동시 출현 빈도에 비례)
edge_width = [0.5 * G[u][v]['weight'] for u, v in G.edges()]

# 그래프 그리기
nx.draw_networkx_nodes(G, pos, node_size=node_size, node_color='skyblue', alpha=0.8)
nx.draw_networkx_edges(G, pos, width=edge_width, alpha=0.5, edge_color='gray')
nx.draw_networkx_labels(G, pos, font_size=12, font_family='sans-serif')

plt.title('해시태그 연관성 네트워크', fontsize=16)
plt.axis('off')
plt.tight_layout()
plt.savefig('hashtag_network.png', dpi=300, bbox_inches='tight')
plt.show()
    

마지막으로, 시간에 따른 해시태그 트렌드 변화를 분석해볼게요. 이를 통해 특정 해시태그의 인기가 상승하는지 하락하는지 파악할 수 있어요!

# 게시물 시간 정보를 datetime 형식으로 변환
df_posts['time'] = pd.to_datetime(df_posts['time'])
df_posts['date'] = df_posts['time'].dt.date

# 날짜별 해시태그 빈도 계산
date_hashtag_counts = {}
for _, row in df_posts.iterrows():
    date = row['date']
    if date not in date_hashtag_counts:
        date_hashtag_counts[date] = Counter()
    
    date_hashtag_counts[date].update(row['hashtags'])

# 상위 5개 해시태그 선택
top5_hashtags = [tag for tag, _ in top_hashtags[:5]]

# 시계열 데이터 생성
time_series_data = []
for date, counts in sorted(date_hashtag_counts.items()):
    for tag in top5_hashtags:
        time_series_data.append({
            'date': date,
            'hashtag': tag,
            'count': counts.get(tag, 0)
        })

df_time_series = pd.DataFrame(time_series_data)

# 시계열 그래프 그리기
plt.figure(figsize=(12, 6))
for tag in top5_hashtags:
    tag_data = df_time_series[df_time_series['hashtag'] == tag]
    plt.plot(tag_data['date'], tag_data['count'], marker='o', label=f'#{tag}')

plt.title('시간에 따른 해시태그 트렌드 변화', fontsize=16)
plt.xlabel('날짜', fontsize=14)
plt.ylabel('빈도수', fontsize=14)
plt.legend()
plt.grid(True, linestyle='--', alpha=0.7)
plt.xticks(rotation=45)
plt.tight_layout()
plt.savefig('hashtag_trend_over_time.png', dpi=300)
plt.show()

# 인사이트 도출
print("\n=== 인스타그램 해시태그 트렌드 분석 인사이트 ===")
print(f"1. 가장 인기 있는 해시태그: #{top_hashtags[0][0]} ({top_hashtags[0][1]}회)")
print(f"2. 가장 강한 연관성을 보이는 해시태그 쌍: #{top_cooccurrences[0][0][0]} - #{top_cooccurrences[0][0][1]} ({top_cooccurrences[0][1]}회)")

# 상승 트렌드 해시태그 찾기 (간단한 예시)
trend_changes = {}
for tag in top5_hashtags:
    tag_data = df_time_series[df_time_series['hashtag'] == tag].sort_values('date')
    if len(tag_data) >= 2:
        first_count = tag_data.iloc[0]['count']
        last_count = tag_data.iloc[-1]['count']
        change_pct = (last_count - first_count) / max(1, first_count) * 100
        trend_changes[tag] = change_pct

# 상승/하락 트렌드 출력
rising_tags = [tag for tag, change in trend_changes.items() if change > 0]
falling_tags = [tag for tag, change in trend_changes.items() if change < 0]

print(f"3. 상승 트렌드 해시태그: {', '.join([f'#{tag}' for tag in rising_tags])}")
print(f"4. 하락 트렌드 해시태그: {', '.join([f'#{tag}' for tag in falling_tags])}")
print(f"5. 마케팅 제안: 상승 트렌드인 {', '.join([f'#{tag}' for tag in rising_tags[:2]])} 해시태그를 활용한 콘텐츠 전략 수립 권장")
    

이 프로젝트를 통해 인스타그램 해시태그 트렌드를 분석하는 방법을 배웠어요! 실제 비즈니스에서는 이런 분석을 정기적으로 수행하여 소비자 트렌드 변화를 지속적으로 모니터링하는 것이 중요해요. 특히 시즌별 트렌드 변화나 특정 이벤트 전후의 해시태그 사용 패턴 변화를 분석하면 더 깊은 인사이트를 얻을 수 있답니다! 😊

재능넷에서도 이런 SNS 트렌드 분석 서비스를 의뢰하는 경우가 많아지고 있어요. 특히 마케팅 전략을 수립하거나 콘텐츠 방향을 결정할 때 데이터 기반의 의사결정이 중요해지고 있거든요! 💪

다음 섹션에서는 텍스트 마이닝의 실무 활용 사례와 팁에 대해 알아볼게요. 실제 비즈니스에서 어떻게 텍스트 마이닝을 활용하는지, 그리고 효과적인 분석을 위한 팁은 무엇인지 함께 살펴보겠습니다! 🚀

10. 텍스트 마이닝 실무 활용 사례와 팁 💼

지금까지 파이썬으로 텍스트 마이닝을 수행하는 방법에 대해 알아봤어요. 이제 실제 비즈니스 환경에서 텍스트 마이닝이 어떻게 활용되는지, 그리고 효과적인 분석을 위한 팁을 알아볼게요! 실무에서는 단순한 기술적 구현을 넘어 비즈니스 가치를 창출하는 것이 중요하니까요! 🔍

이런 활용 사례들을 보면 텍스트 마이닝이 비즈니스 의사결정에 얼마나 중요한 역할을 하는지 알 수 있어요! 이제 실무에서 텍스트 마이닝을 효과적으로 수행하기 위한 팁을 알아볼게요. 🧠

마지막으로, 텍스트 마이닝 프로젝트를 성공적으로 수행하기 위한 체크리스트를 공유할게요! 이 체크리스트를 따라가면 체계적으로 프로젝트를 진행할 수 있을 거예요. 😊

텍스트 마이닝은 데이터 과학과 비즈니스 인사이트의 교차점에 있는 강력한 도구예요. 특히 SNS가 마케팅과 소비자 소통의 중심이 된 지금, 텍스트 마이닝을 통한 트렌드 분석은 기업의 경쟁력을 좌우하는 핵심 역량이 되고 있어요! 🚀

재능넷에서도 텍스트 마이닝 관련 프로젝트가 꾸준히 증가하고 있어요. 데이터 분석 전문가들이 기업의 SNS 데이터를 분석하여 마케팅 전략 수립이나 제품 개발에 도움이 되는 인사이트를 제공하고 있답니다. 여러분도 이 글을 통해 배운 내용을 활용해 직접 텍스트 마이닝 프로젝트를 진행해보세요! 😄