goodjin_55.log https://velog.io/ 열심히 노력하는 학생! Sat, 08 Apr 2023 16:59:03 GMT https://validator.w3.org/feed/docs/rss2.html https://github.com/jpmonette/feed Copyright (C) 2019. goodjin_55.log. All rights reserved. <![CDATA[베스트도전 웹툰의 정식연재 승격 확률 예측 - 5. 모델링]]> https://velog.io/@goodjin_55/%EB%B2%A0%EC%8A%A4%ED%8A%B8%EB%8F%84%EC%A0%84-%EC%9B%B9%ED%88%B0%EC%9D%98-%EC%A0%95%EC%8B%9D%EC%97%B0%EC%9E%AC-%EC%8A%B9%EA%B2%A9-%ED%99%95%EB%A5%A0-%EC%98%88%EC%B8%A1-5.-%EB%AA%A8%EB%8D%B8%EB%A7%81 https://velog.io/@goodjin_55/%EB%B2%A0%EC%8A%A4%ED%8A%B8%EB%8F%84%EC%A0%84-%EC%9B%B9%ED%88%B0%EC%9D%98-%EC%A0%95%EC%8B%9D%EC%97%B0%EC%9E%AC-%EC%8A%B9%EA%B2%A9-%ED%99%95%EB%A5%A0-%EC%98%88%EC%B8%A1-5.-%EB%AA%A8%EB%8D%B8%EB%A7%81 Sat, 08 Apr 2023 16:59:03 GMT 정식연재 웹툰의 수가 비정식연재 웹툰의 수에 비해 매우매우 적어, 정확도만으로는 정확한 분류와 예측이 힘들었다. 따라서 분류의 명확성을 나타내는 AUC를 모델의 성능으로 선택하였다.

import

!pip install imbalanced-learn

import numpy as np
import pandas as pd

import sklearn
from sklearn import metrics
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import train_test_split
from sklearn.metrics import confusion_matrix
from sklearn.metrics import accuracy_score, roc_auc_score, roc_curve
import statsmodels.api as sm
import matplotlib.pyplot as plt
import time

from collections import Counter
from imblearn.under_sampling import RandomUnderSampler

🔎 데이터 확인

# class imbalance 확인
y.sum()/len(y)
## 0.07203389830508475

데이터 불균형이 매우 심한 것을 알 수 있다.

# titleId 칼럼 제거
webtoon.drop(["titleId"], axis=1, inplace = True)

🌏 모델링

원핫인코딩

# contentGenre, typeGenre : one-hot encoding
webtoon = pd.get_dummies(data = webtoon, columns=['contentGenre'], prefix='contGenre')
webtoon = pd.get_dummies(data = webtoon, columns=['typeGenre'], prefix='typeGenre')

언더샘플링 + 랜덤포레스트분류

accList = []
aucList = []

# X,y dataset 분리
X, y = webtoon.iloc[:,:-1], webtoon['isPublic']

# 4:3 언더샘플링
undersample = RandomUnderSampler(sampling_strategy=0.7, random_state=121818)
X_under, y_under = undersample.fit_resample(X, y)

for i in range(50): # 50번 수행
    ## train, test split
    X_train_under, X_test_under, y_train_under, y_test_under = train_test_split(X_under, y_under, stratify=y_under, test_size=0.2, random_state=121818)

    ## 랜덤포레스트분류
    rf = RandomForestClassifier(random_state=121818)
    rf.fit(X_train_under, y_train_under)

    ## 정확도 acc
    accList.append(rf.score(X_test_under,y_test_under))
    ## 오차행렬
    y_pred = rf.predict(X_test_under)
    cfmat = confusion_matrix(y_test_under, y_pred)
    ## auc
    y_pred_proba = rf.predict_proba(X_test_under)[:,1] # -> 정식연재 승격 확률
    auc = roc_auc_score(y_test_under, y_pred_proba)
    aucList5.append(auc)
  • 모델 성능 확인 AUC : 0.9285 ACC : 0.7812 confusion matrix : $\begin{bmatrix}10&8\1&13\ \end{bmatrix}$

  • 정식연재를 정식연재로 판단 10개, 정식연재를 비정식연재로 판단 8개, 비정식연재를 정식연재로 판단 1개, 비정식연재를 비정식연재로 판단 13개

변수 중요도

#변수 중요도 확인
feature_df = pd.DataFrame()
feature_df['feature'] = X.columns
feature_df['importance'] = rf_under.feature_importances_
feature_df

장르 변수들이 중요도가 매우 낮다. 그러나, 장르 변수를 제외하고 모델링한 결과는 성능이 더 안좋았다.

❗ 별점참여자수의 비율과 조회수의 비율이 타 변수들에 비해 중요도가 크게 나왔다. 정식연재로 승격될 확률은 유입독자들을 잘 유지하면 높아질 것으로 예상할 수 있었다.

🥂 느낀점

데이터 수집부터 전처리, 모델링을 직접 하려니 며칠을 밤을 샜는지 모르겠다..ㅠ 많이 부족한 실력으로 욕심은 많아서 고생을 좀 했지만, 모든 과정들을 이해하고 적용하는 것이 큰 공부가 되었다. 스스로 처음부터 끝까지 해냈다는 것이 뿌듯하다.

중간중간 생각만 하고 진행하지 못했던 부분들(ex. 댓글분석에서 단어 선택, 변수의 상관관계 확인)을 더 보완하여 더 멋진 프로젝트를 진행할 것이다!

]]> <![CDATA[베스트도전 웹툰의 정식연재 승격 확률 예측 - 4. 댓글분석]]> https://velog.io/@goodjin_55/%EB%B2%A0%EC%8A%A4%ED%8A%B8%EB%8F%84%EC%A0%84-%EC%9B%B9%ED%88%B0%EC%9D%98-%EC%A0%95%EC%8B%9D%EC%97%B0%EC%9E%AC-%EC%8A%B9%EA%B2%A9-%ED%99%95%EB%A5%A0-%EC%98%88%EC%B8%A1-4.-%EB%8C%93%EA%B8%80%EB%B6%84%EC%84%9D https://velog.io/@goodjin_55/%EB%B2%A0%EC%8A%A4%ED%8A%B8%EB%8F%84%EC%A0%84-%EC%9B%B9%ED%88%B0%EC%9D%98-%EC%A0%95%EC%8B%9D%EC%97%B0%EC%9E%AC-%EC%8A%B9%EA%B2%A9-%ED%99%95%EB%A5%A0-%EC%98%88%EC%B8%A1-4.-%EB%8C%93%EA%B8%80%EB%B6%84%EC%84%9D Sat, 08 Apr 2023 16:23:11 GMT 이전에 수집한 댓글 데이터를 확률 예측의 변수로 만드는 과정에서 많은 고민이 있었다. 그 과정을 간단히 설명하자면, 댓글 내용을 형태소별로 토큰화하여 정식연재와 비정식연재 웹툰의 빈도수가 높은 단어들을 비교하였다. 빈도수가 높은 단어들 중 정식 연재를 판가름할 수 있다고 생각하는 단어들(ex. 재밌, 기대, 응원 등등)을 선택하여 전체 댓글과의 등장 비율을 계산하였다. 최종적으로 정식연재에 2배 많이 나타나는 단어와 비정식연재에 2배 많이 나타나는 단어를 필터링하여 등장 횟수를 변수로 넣었다.

🔎 댓글 데이터 예시

아래는 이전에 수집한 'mycomment_data.csv'의 comment 칼럼의 예시이다.

📄 글자 정리

영어

# 영어 글자 확인
pd.set_option('display.max_rows', None)
## 정규표현식을 이용해 영어 외의 글자들 삭제
tmp = commentData['comment'].replace('[^a-zA-Z]', '', regex=True)
## 영어가 포함된 댓글들 출력
tmp[tmp.str.contains('[a-zA-Z]')]

영어가 들어있는 댓글들의 내용을 확인 후 대부분의 영단어가 큰 의미를 가지고 있지 않다고 판단했다. 몇몇 글자들을 제외한 영어 글자를 삭제하였다.

# bb -> 굿, zz -> ㅋㅋ
commentData['comment'] = commentData['comment'].str.replace("Good","굿")
commentData['comment'] = commentData['comment'].str.replace("bb+","굿")
commentData['comment'] = commentData['comment'].str.replace("zz+","ㅋㅋ")

# 나머지 영어 삭제
commentData['comment'] = commentData['comment'].replace('[a-zA-Z]','',regex=True)

이모티콘

이모티콘의 경우, 종류는 다양하지만 같은 의미를 담고 있는 것들을 묶어 한글로 대체하였다. '❤️'는 한글로 대체하기 애매하다고 생각하여 하나의 이모티콘으로 통일시켰다.

# 이모티콘 대체
commentData['comment'] = commentData['comment'].str.replace('[💟♡♥️❤❤️💓💕💖💗💘💙💚💛💜💝💞😍😘😻🤍🤎🥰🧡😚💋]+','❤️',regex=True)
commentData['comment'] = commentData['comment'].str.replace('[🙃🤣😆😀😊😄🤭😁😂]+','ㅋㅋ',regex=True)
commentData['comment'] = commentData['comment'].str.replace('[😢😭🥺]+','ㅠㅠ',regex=True)
commentData['comment'] = commentData['comment'].str.replace('[🔥👊💪]+','파이팅',regex=True)
commentData['comment'] = commentData['comment'].str.replace('[👍🏻👍]+','굿',regex=True)
commentData['comment'] = commentData['comment'].str.replace('[🎊🎉✨👏🥳💐]+','축하',regex=True)
commentData['comment'] = commentData['comment'].str.replace('[☆★⭐]+','별',regex=True)
commentData['comment'] = commentData['comment'].str.replace('[🍪]+','쿠키',regex=True)
commentData['comment'] = commentData['comment'].str.replace('[🙏]+',"제발",regex=True)

자음

자음은 대부분 의미를 가지고 있지만, 후의 토큰화 과정에서는 그 의미를 캐치하지 못했다. 따라서 직접 의미를 풀어서 대체하였다.

# 자음 정리
commentData['comment'] = commentData['comment'].str.replace('ㄷㄷ+','덜덜',regex=True)
commentData['comment'] = commentData['comment'].str.replace('ㅎㅇㅌ','파이팅',regex=True)
commentData['comment'] = commentData['comment'].str.replace('ㅇㅈ','인정',regex=True)
commentData['comment'] = commentData['comment'].str.replace('ㄹㅈ','인정',regex=True)
commentData['comment'] = commentData['comment'].str.replace('ㄹㅈㄷ','레전드',regex=True)
commentData['comment'] = commentData['comment'].str.replace('ㄱㅇㅇ','귀여워',regex=True)
commentData['comment'] = commentData['comment'].str.replace('ㄷㄱ','두근',regex=True)
commentData['comment'] = commentData['comment'].str.replace('ㅊㅎ','축하',regex=True)
commentData['comment'] = commentData['comment'].str.replace('ㅊㅊ','축하',regex=True)
commentData['comment'] = commentData['comment'].str.replace('ㅆㄹㄱ','쓰레기',regex=True)
commentData['comment'] = commentData['comment'].str.replace('ㅁㄹ','몰라',regex=True)
commentData['comment'] = commentData['comment'].str.replace('ㄱㅊ','괜찮',regex=True)
commentData['comment'] = commentData['comment'].str.replace('ㅁㅊ','미친',regex=True)

# ㅎㅎ, ㅋㅋ 는 댓글마다 그 글자수가 달라 통일시킴.
commentData['comment'] = commentData['comment'].str.replace('ㅎㅎ+','ㅎㅎ',regex=True)
commentData['comment'] = commentData['comment'].str.replace('ㅋㅋ+','ㅋㅋ',regex=True)

모음

모음의 경우 'ㅜㅜ'와 'ㅠㅠ' 외에는 대부분 오타로 보였다. 따라서 글자수만 통일시켜 주었다.

# 모음 정리
commentData['comment'] = commentData['comment'].str.replace('ㅜ+','ㅠㅠ',regex=True)
commentData['comment'] = commentData['comment'].str.replace('ㅠㅠ+','ㅠㅠ',regex=True)

최종정리

# 한국어, 숫자, 띄어쓰기, 하트 제외 삭제
commentData['comment'] = commentData['comment'].str.replace('[^0-9ㅋㅎㅠ가-힣❤️ ]','',regex=True)

# 자음과 모음 앞뒤에 띄어쓰기를 넣어 별개의 단어로 판단하도록 함.
commentData['comment'] = commentData['comment'].str.replace('ㅋㅋ',' ㅋㅋ ')
commentData['comment'] = commentData['comment'].str.replace('ㅎㅎ',' ㅎㅎ ')
commentData['comment'] = commentData['comment'].str.replace('ㅠㅠ',' ㅠㅠ ')
commentData['comment'] = commentData['comment'].str.replace(' +',' ', regex=True)

## 의미가 없는 댓글 삭제
noMean = []
for i in range(len(commentData)):
    if commentData.loc[i,'comment'] == '': noMean.append(i)
    elif commentData.loc[i,'comment'] == ' ': noMean.append(i)
commentData.drop(noMean, inplace=True)
commentData.reset_index(drop=True, inplace=True)

✂ 토큰화

한셀 교정

댓글의 경우, 맞춤법이나 띄어쓰기가 정확하게 갖추어지지 않기 때문에 토큰화 전에 교정 과정이 필요했다. 한국어 교정을 해주는 'hanspell' 패키지를 이용하였다.

# hanspell 설치
pip install git+https://github.com/ssut/py-hanspell.git

from hanspell import spell_checker
for i in range(len(commentData)):
  commentData.loc[i,'comment'] = spell_checker.check(commentData.loc[i,'comment']).checked

형태소 분석기 비교

konlpy 의 okt, kkma, komoran, mecab 을 이용해보았다. mecab의 경우 윈도우에서 지원하지 않기 때문에 코랩에 설치 후 확인하였다.

# mecab 설치
!git clone https://github.com/SOMJANG/Mecab-ko-for-Google-Colab.git
%cd Mecab-ko-for-Google-Colab
!bash install_mecab-ko_on_colab190912.sh
## -> 2022년 11월에 코드 실행함. 2023년 4월에 확인 결과 오류가 뜨므로 수정 필요함.

# 원래 문장
original_sentence = commentData.loc[20,'comment']
print(original_sentence) 
## '벌레는 진짜아니지이그래도 짜파게티에 계란과 군만두는 뭐너무 맛있어보이잖아요오나 한입만❤️'

# Okt
from konlpy.tag import Okt
okt = Okt()
print(*okt.morphs(original_sentence, stem=True))
## 벌레 는 진짜 아 니지 이 그래도 짜파게티 에 계란 과 군 만두 는 뭐 너무 맛있다 보이다 오 나 한 입 만 ❤️

# Kkma
from konlpy.tag import Kkma
kkma = Kkma()
print(*kkma.morphs(original_sentence))
## 벌레 는 진짜 알 니 지이 그리하 여도 짜 아 파 게 티 에 계란 과 군만두 는 뭐 너무 맛있 어 보이 잖아요 오 나 한입 만 ❤️ ️

# Komoran -> 코드 진행 시간이 너무 오래 걸려 제외함.
from konlpy.tag import Komoran
komoran = Komoran()
print(*komoran.morphs(original_sentence))
## 벌레 는 진짜 아니 지이 그래도 짜파게티 에 계란 과 군만두 는 뭐 너무 맛있 어 보이 잖아요 오 나 한입 만 ❤️ ️

# Mecab
from konlpy.tag import Mecab
mecab = Mecab()
print(*mecab.morphs(original_sentence))
## 벌레 는 진짜 아니 지이 그래도 짜파게티 에 계란 과 군만두 는 뭐 너무 맛있 어 보이 잖아요 오 나 한입 만 ❤️ ️

# 맞춤법 교정
spelled_sentence = spell_checker.check(original_sentence).checked
print(spelled_sentence)
## '벌레는 진짜 아니지 이 그래도 짜파게티에 계란과 군만두는 뭐 너무 맛있어 보이잖아요 오나 한입만❤️'

# 교정 후 Okt
print(*okt.morphs(spelled_sentence, stem=True))
## 벌레 는 진짜 아니다 이 그래도 짜파게티 에 계란 과 군 만두 는 뭐 너무 맛있다 보이다 오 나 한 입 만 ❤️

# 교정 후 Kkma
print(*kkma.morphs(spelled_sentence))
## 벌레 는 진짜 아니 지 이 그리하 여도 짜 아 파 게 티 에 계란 과 군만두 는 뭐 너무 맛있 어 보이 잖아요 오 나 한입 만 ❤️

# 교정 후 Mecab
print(*kkma.morphs(spelled_sentence))
## 벌레는 진짜 아니지 이 그래도 짜파게티에 계란과 군만두는 뭐 너무 맛있어 보이잖아요 오나 한입만❤️
형태소 분석기 출력 결과
원래 문장 벌레는 진짜아니지이그래도 짜파게티에 계란과 군만두는 뭐너무 맛있어보이잖아요오나 한입만❤️
haspell 교정 벌레는 진짜 아니지 이 그래도 짜파게티에 계란과 군만두는 뭐 너무 맛있어 보이잖아요 오나 한입만❤️
Okt 벌레 는 진짜 아니다 이 그래도 짜파게티 에 계란 과 군 만두 는 뭐 너무 맛있다 보이다 오 나 한 입 만 ❤️
Kkma 벌레 는 진짜 아니 지 이 그리하 여도 짜 아 파 게 티 에 계란 과 군만두 는 뭐 너무 맛있 어 보이 잖아요 오 나 한입 만 ❤️
Mecab 벌레는 진짜 아니지 이 그래도 짜파게티에 계란과 군만두는 뭐 너무 맛있어 보이잖아요 오나 한입만❤️

위 형태소 분석기 중 mecab이 가장 효율적이라고 판단하였다.

Mecab 형태소 분석, 토큰화

Mecab을 이용하여 형태소별로 문장을 쪼갰다. 각 형태소 중 조사, 어미 등 의미없는 단어는 제외하며 토큰화를 진행하였다. 정식연재와 비정식연재의 단어들을 워드 클라우드 형태로 시각화하였다.

# import
!git clone https://github.com/SOMJANG/Mecab-ko-for-Google-Colab.git
%cd Mecab-ko-for-Google-Colab
!bash install_mecab-ko_on_colab190912.sh
from konlpy.tag import Mecab
mecab = Mecab()

from tensorflow.keras.preprocessing.text import Tokenizer

from wordcloud import WordCloud
import matplotlib.pyplot as plt
!apt-get update -qq
!apt-get install fonts-nanum* -qq
import matplotlib.font_manager as fm
sys_font = fm.findSystemFonts()

# 체언, 용언(동사, 형용사), 일반부사, 감탄사, 체언 접두사, 어근, 부호 및 숫자
goodPos = ['NNG','NNP','NNBC','NR','NP','VV','VA','MAG','IC','XPN','XR']

# 정식연재 토큰화
pubCom = commentData[commentData['isPublic'] == 1]
public_mecab = []
for sentence in pubCom['comment']:
  tokenized_sentence = mecab.pos(sentence)
  token = []
  for i in range(len(tokenized_sentence)):
    if tokenized_sentence[i][1] in goodPos:
      token.append(tokenized_sentence[i][0])
    elif tokenized_sentence[i][1][:2] in ['VV','VA']: # 동사와/형용사 + 어미
      token.append(tokenized_sentence[i][0])
  public_mecab.append(token)


tokenizer = Tokenizer()
tokenizer.fit_on_texts(public_mecab)
wordDict = tokenizer.word_counts
wordDict_sorted = list(sorted(tokenizer.word_counts.items(), key=lambda x: x[1], reverse=True))
len(wordDict_sorted)

wc = WordCloud(font_path='/usr/share/fonts/truetype/nanum/NanumGothic.ttf', background_color='white')
gen = wc.generate_from_frequencies(wordDict)
plt.figure()
plt.imshow(gen)
plt.axis('off')

# 비정식연재 토큰화
notPubCom = commentData[commentData['isPublic'] == 0]
notPublic_mecab = []
for sentence in notPubCom['comment']:
  tokenized_sentence = mecab.pos(sentence)
  token = []
  for i in range(len(tokenized_sentence)):
    if tokenized_sentence[i][1] in goodPos:
      token.append(tokenized_sentence[i][0])
    elif tokenized_sentence[i][1][:2] in ['VV','VA']:
      token.append(tokenized_sentence[i][0])
  notPublic_mecab.append(token)

tokenizer2 = Tokenizer()
tokenizer2.fit_on_texts(notPublic_mecab)
wordDict2 = tokenizer2.word_counts
wordDict_sorted2 = list(sorted(tokenizer2.word_counts.items(), key=lambda x: x[1], reverse=True))
print(len(wordDict_sorted2))
print(wordDict_sorted2)

wc = WordCloud(font_path='/usr/share/fonts/truetype/nanum/NanumGothic.ttf', background_color='white')
gen = wc.generate_from_frequencies(wordDict2)
plt.figure()
plt.imshow(gen)
plt.axis('off')

정식연재와 비정식연재 웹툰의 순위권 단어들이 비슷하게 나온다. 따라서 비율을 고려해 보았다.

🏅 단어 선택 및 변수화

# 전체 댓글 토큰화
commentData2 = commentData.copy()
for i in range(len(commentData)):
  sentence = commentData.loc[i,'comment']
  if type(sentence) == float: continue

  tokenized_sentence = mecab.pos(sentence)
  token = ''
  for j in range(len(tokenized_sentence)):
    if tokenized_sentence[j][1] in goodPos:
      token += ' '+tokenized_sentence[j][0]
    elif tokenized_sentence[j][1][:2] in ['VV','VA']: # 체언접두사와 어근
      token += ' '+tokenized_sentence[j][0]
  commentData2.loc[i,'comment'] = token

# 정식과 비정식을 나눌 수 있다고 판단되는 들
wordsList = ['가', '가셨으면', '가즈아', '감동', '감성', '감정', '갑시다', '개성', '계속', '고침', '고퀄', '공감', '괜찮', '굿', '궁금', '귀여', '귀여우', '귀여운', '귀여움', '귀여워', '귀여워서', '귀염', '귀엽', '그리', '그림', '기다렸', '기다리', '기대', '깜찍', '꾸준히', '나쁜', '네이버', '다음', '담당자', '답답', '대박', '대작', '더', '덜', '데려가', '독특', '두근두근', '드디어', '등록', '디테일', '따뜻', '매력', '매주', '명작', '모셔', '몰입', '무서워', '무섭', '미쳤', '미친', '반갑', '발암', '베스트', '별로', '부들부들', '분량', '분위기', '비슷', '빨리', '사이다', '새로', '새로운', '색감', '생각', '생각나', '설레', '세계관', '소름', '소원', '소재', '스타일', '스토리', '승격', '시키', '신기', '신선', '실화', '싫', '아쉽', '알림', '어서', '얼른', '연재', '연출', '열심히', '옆', '예뻐요', '예쁘', '예쁜', '오랜만', '오지', '올라가', '올려', '올리', '완결', '웃', '웃겨', '웃겨요', '웃기', '원합니다', '위', '응원', '이뻐요', '이쁘', '이상', '이야기', '작품', '작화', '장면', '재미', '재미나', '재미있', '재밌', '잼', '전개', '정식', '좋', '좋아하', '주인공', '주제', '진심', '짧', '쩔', '참신', '처음', '최강', '최고', '추천', '축하', '취향', '친구', '캐릭터', '쿠키', '퀄리티', '탄탄', '파이팅', '팬', '표절', '표정', '피드백', '헉', '현기증', '현실', '흑흑', '흥미', '흥미진진', '힐링', '힘내']

# 같은 의미의 단어들 하나로 통일
commentData2['comment'] = commentData2['comment'].str.replace('가셨으면','가')
commentData2['comment'] = commentData2['comment'].str.replace('갑시다','가')
commentData2['comment'] = commentData2['comment'].str.replace('귀여우','귀엽')
commentData2['comment'] = commentData2['comment'].str.replace('귀여운','귀엽')
commentData2['comment'] = commentData2['comment'].str.replace('귀여움','귀엽')
commentData2['comment'] = commentData2['comment'].str.replace('귀여워서','귀엽')
commentData2['comment'] = commentData2['comment'].str.replace('귀염','귀엽')
commentData2['comment'] = commentData2['comment'].str.replace('귀여워','귀엽')
commentData2['comment'] = commentData2['comment'].str.replace('귀여','귀엽')
commentData2['comment'] = commentData2['comment'].str.replace('그리','그림')
commentData2['comment'] = commentData2['comment'].str.replace('기다렸','기다리')
commentData2['comment'] = commentData2['comment'].str.replace('무서워','무섭')
commentData2['comment'] = commentData2['comment'].str.replace('미친','미쳤')
commentData2['comment'] = commentData2['comment'].str.replace('예뻐요','예쁘')
commentData2['comment'] = commentData2['comment'].str.replace('예쁜','예쁘')
commentData2['comment'] = commentData2['comment'].str.replace('올라가','올려')
commentData2['comment'] = commentData2['comment'].str.replace('올리','올려')
commentData2['comment'] = commentData2['comment'].str.replace('웃','웃겨')
commentData2['comment'] = commentData2['comment'].str.replace('웃겨요','웃겨')
commentData2['comment'] = commentData2['comment'].str.replace('웃기','웃겨')
commentData2['comment'] = commentData2['comment'].str.replace('이뻐요','예쁘')
commentData2['comment'] = commentData2['comment'].str.replace('이쁘','예쁘')
commentData2['comment'] = commentData2['comment'].str.replace('재미나','재미')
commentData2['comment'] = commentData2['comment'].str.replace('재미있','재미')
commentData2['comment'] = commentData2['comment'].str.replace('재밌','재미')
commentData2['comment'] = commentData2['comment'].str.replace('잼','재미')
commentData2['comment'] = commentData2['comment'].str.replace('좋','좋아하')
commentData2['comment'] = commentData2['comment'].str.replace('흥미진진','흥미')

# 한 댓글 내에 중복등장하는 단어 정리
for i in range(len(commentData2)):
    comSet = set(commentData2.loc[i,'comment'].split(' '))
    token = ''
    for j in range(1,len(comSet)):
        token += ' '+list(comSet)[j]
    commentData2.loc[i,'comment'] = token

# 정식연재와 비정식연재 웹툰의 단어들 빈도 비율 비교
token_ratio = pd.DataFrame(arr, columns=['public','notPublic'])
for i in range(len(commentData2)):
    tokenList = commentData2.loc[i,'comment'].split(' ')[1:]
    for word in token_ratio.index:
        if word in tokenList:
            if commentData2.loc[i,'isPublic'] == 1:
                token_ratio.loc[word,'public'] += 1/(len(pubId)*6)
            elif commentData.loc[i,'isPublic'] == 0:
                token_ratio.loc[word,'notPublic'] += 1/(len(notPubId)*6)

# 정식연재가 2배 많은 단어
words1 = token_ratio[token_ratio['public'] > token_ratio['notPublic'] * 2]
print(words1.index)
## '고침', '나쁜', '담당자', '덜', '데려가', '두근두근', '등록', '디테일', '매주', '모셔', '무섭', '미쳤', '발암', '부들부들', '사이다', '새로', '색감', '설레', '소름', '소원', '시키', '얼른', '옆', '오지', '위', '작화', '전개', '쩔', '최강', '친구', '쿠키', '탄탄', '표절', '피드백', '헤어지', '현기증', '현실'

# 비정식연재가 2배 많은 단어
words0 = token_ratio[token_ratio['public'] * 2 < token_ratio['notPublic']]
print(words0.index)
## '감동', '감성', '감정', '개성', '깜찍', '명작', '비슷', '새로운', '소식', '신기', '아쉽', '오랜만', '완결', '원합니다', '이야기', '장면', '짧', '추천', '축하'

최종 단어 선택! 위의 각 단어들 중 더더욱 정식연재 여부를 구별할 수 있는 단어들을 선택하였다.

  • 정식 연재 단어 words1 '나쁜', '데려가', '두근두근', '등록', '디테일', '매주', '무섭', '미쳤', '발암', '부들부들', '사이다', '색감', '소름', '얼른', '옆', '오지', '작화', '전개', '쩔', '쿠키', '탄탄', '현실'
  • 비정식 연재 단어 words0 '감동', '명작', '비슷', '새로운', '소식', '아쉽', '오랜만', '완결', '이야기', '짧', '축하'

이제, 각 웹툰별로 정식연재와 비정연재 단어들이 몇번 나타나는지를 카운트하여 그 숫자를 값으로 넣었다.

titleId = commentData2.drop_duplicates('titleId')['titleId']
commentData3 = pd.DataFrame(columns= ['titleId','words0','words1'])
commentData3['titleId'] = titleId
commentData3.reset_index(drop=True, inplace=True)

for i in range(len(commentData3)):
  comment_dt = commentData2['comment'][commentData2['titleId'] == commentData3.loc[i,'titleId']]
  w0 = 0; w1 = 0
  for com in comment_dt:
    for word in words0:
      if word in com: w0 += 1
    for word in words1:
      if word in com: w1 += 1
  commentData3.loc[i,'words0'] = w0
  commentData3.loc[i,'words1'] = w1

commentData3.to_csv('comment_words.csv', index=False)
]]> <![CDATA[월간 데이콘 기계 고장 진단 AI 경진대회]]> https://velog.io/@goodjin_55/%EC%9B%94%EA%B0%84-%EB%8D%B0%EC%9D%B4%EC%BD%98-%EA%B8%B0%EA%B3%84-%EA%B3%A0%EC%9E%A5-%EC%A7%84%EB%8B%A8-AI-%EA%B2%BD%EC%A7%84%EB%8C%80%ED%9A%8C https://velog.io/@goodjin_55/%EC%9B%94%EA%B0%84-%EB%8D%B0%EC%9D%B4%EC%BD%98-%EA%B8%B0%EA%B3%84-%EA%B3%A0%EC%9E%A5-%EC%A7%84%EB%8B%A8-AI-%EA%B2%BD%EC%A7%84%EB%8C%80%ED%9A%8C Sun, 12 Feb 2023 15:02:02 GMT 데이콘에서 음향 데이터를 이용해 기계의 고장 여부를 판단하는 대회가 열렸다. 한번도 다뤄본 적 없는 음향데이터를 만져볼 좋은 기회라고 생각되어 대회에 참가하였다.

https://dacon.io/competitions/official/236036/overview/description

데이터 살펴보기

train.csv 에는 아래 사진과 같이 샘플의 고유ID, 음향 파일의 경로, FAN의 종류(0,2), 기계 고장 여부(0:정상, 1:고장)로 구성되어 있다. 이때, train의 LABEL은 모두 정상 샘플만 존재한다. train 폴더에는 SAMPLE_PATH 에 나타나는 소리파일(.wav)이 있다.

패키지 import

import numpy as np
import pandas as pd
from tqdm.auto import tqdm
import warnings
warnings.filterwarnings(action='ignore')

import librosa
import librosa.display
import matplotlib.pyplot as plt

from sklearn.svm import OneClassSVM

librosa를 이용한 시각화

SAMPLE_ID 가 'TRAIN_0000'인 샘플을 load하여 시각화해 보았다. 파라미터 sr을 이용해 sampling rate(주파수 분석의 시간 간격)을 조정할 수 있다. 기본값은 22050 이다.

trainData = pd.read_csv('./train.csv')
train_path = trainData['SAMPLE_PATH'][0]
train_y, sr = librosa.load(train_path)
plt.plot(train_y)

Short Time Fourier Transform (STFT)

시간 단위로 짧게 쪼개서 푸리에 변환을 하는 방법이다.

train_stft = np.abs(librosa.stft(train_y))
librosa.display.specshow(librosa.amplitude_to_db(train_stft, ref= np.mean), 
                         y_axis='log', sr=sr, x_axis='time')
plt.colorbar(format='%+2.0f dB')
plt.title('STFT _train')
plt.tight_layout()
plt.show()

Mel Spectrogram

Mel Scale 변환을 통해 오디오를 분석하여 특징을 추출하는 방법이다.

train_mel = librosa.feature.melspectrogram(y= train_y, sr= sr)
train_mel_dB = librosa.amplitude_to_db(train_mel, ref= np.mean)
librosa.display.specshow(train_mel_dB, y_axis='mel', sr=sr, x_axis='time')
plt.colorbar(format='%+2.0f dB')
plt.title('Mel-Spectrogram _train')
plt.tight_layout()
plt.show()

Mel-Frequency Cepstral Coefficients (MFCC)

사람의 청각구조를 반영하여 음성 정보를 추출하는 방법으로, mel-spectrum에서 Cepstral 분석으로 추출한 값이다. Cepstral 분석이란, 스펙트럼 신호의 로그값에 역푸리에 변환을 하는 것을 말한다.

train_mfccs = librosa.feature.mfcc(train_y, sr= sr, n_mfcc=128)
librosa.display.specshow(train_mfccs, sr=sr, x_axis='time')
plt.colorbar()
plt.title('MFCC _train')
plt.tight_layout()
plt.show()

Chroma Frequencies

인간의 청각이 한 옥타브를 유사음으로 인지한다는 것에 기반하여, 모든 스펙트럼을 12개의 Bin으로 표현한다.

train_chromagram = librosa.feature.chroma_stft(train_y, sr= sr)
train_chromagram.shape # (12, 431)
librosa.display.specshow(train_chromagram, x_axis='time', y_axis= 'chroma')
plt.colorbar()
plt.title('Chroma _train')
plt.show()

Zero Crossing Rate

음파가 양에서 음, 음에서 양으로 바뀌는 비율이다. 0을 많이 지날수록 노이즈가 많음을 뜻한다.

train_zero_crossings = librosa.zero_crossings(train_y, pad=False)
sum(train_zero_crossings) # 결과는 21960

데이터 전처리

위에서 시도했던 여러 방법들 중 mfcc를 선택하고, 파라미터 n_mfcc = 27로 설정하여 소리의 특징을 추출하였다. 

train_df = pd.read_csv('train.csv')
test_df = pd.read_csv('test.csv')

def get_mfcc_feature(df, num):
    features = []
    for path in tqdm(df['SAMPLE_PATH']):
        y, sr = librosa.load(path, sr= 16000)

        mfcc = librosa.feature.mfcc(y= y, sr= sr, n_mfcc= num)

        y_feature = []
        for e in mfcc:
            y_feature.append(np.mean(e))
        features.append(y_feature)
    return features

train_features = get_mfcc_feature(train_df, 27)
test_features = get_mfcc_feature(test_df, 27)

모델 적합

전처리를 통해 얻은 특징의 수치들을 데이터프레임으로 저장하여, 각 특징별 상관관계를 구하여 변수를 선택하는 과정을 추가하였다. 그 중 Col5, Col6, Col7 을 제외하였을 때 점수가 높게 나왔다.

모델로는 OCSVM을 선택하였다. 비지도학습의 머신러닝 모델로는 Isolation Forest, OneClassSVM, LocalOutlierFactor 등이 있다. 주어진 데이터들을 바탕으로 이 데이터에서 많이 떨어져 있는 데이터를 이상치로 판단하는 모델들이다. 그 중 OCSVM은 n차원의 좌표축에서 데이터와 원점 사이의 거리를 기준으로 이상치를 판단하는 방법이다. 파라미터는 kernel='rbf', gamma=0.004, nu=0.03 으로 설정하였다.

# 데이터 프레임으로 변환
train_features_df = pd.DataFrame(train_features, columns = [f'Col{i}' for i in range(1,28)])
test_features_df = pd.DataFrame(test_features, columns = [f'Col{i}' for i in range(1,28)])

# corr 구한 후, 0.7 이상의 값들만 확인
cor = train_features_df.corr()
pd.set_option('display.max_rows',None)
pd.set_option('display.max_columns',None)
cor[abs(cor) > 0.7]

# 변수 선택
train_features_df = pd.DataFrame(train_features, columns = [f'Col{n}' for n in range(1,28)])
train_features_df.drop(['Col6','Col5','Col7'], axis=1, inplace=True)
test_features_df = pd.DataFrame(test_features, columns = [f'Col{n}' for n in range(1,28)])
test_features_df.drop(['Col6','Col5','Col7'], axis=1, inplace=True)

# OCSVM 훈련
svm = OneClassSVM(kernel='rbf', gamma= 0.004, nu=0.03)
svm.fit(train_features_df)

테스트 데이터 예측

test 데이터를 예측하여 1(정상)과 -1(불량)로 표현된 값들을 0(정상)과 1(불량)로 바꿔주고, 파일로 저장하여 제출하였다.

# 0, 1로 변환
def get_pred_label(model_pred):
    # 1: 정상, -1: 불량  => 0: 정상, 1:불량 변환
    model_pred = np.where(model_pred == 1, 0, model_pred)
    model_pred = np.where(model_pred == -1, 1, model_pred)
    return model_pred

# 예측
test_pred = svm.predict(test_features_df)
test_pred = get_pred_label(test_pred)

# 제출
submit = pd.read_csv('./answer/sample_submission.csv')
submit['LABEL'] = test_pred
submit.to_csv('./answer/ans1.csv', index= False)

후기

모델을 선택하는 과정에서 deep SVDD 를 이용해보고 싶었다. 딥러닝까지 시도하기에는 시간이 부족하여 모델링은 하지 못했지만, 더 공부하여 딥러닝을 이용한 모델링도 도전해볼 것이다!

]]> <![CDATA[베스트도전 웹툰의 정식연재 승격 확률 예측 - 3. 데이터 변수화]]> https://velog.io/@goodjin_55/%EB%B2%A0%EC%8A%A4%ED%8A%B8%EB%8F%84%EC%A0%84-%EC%9B%B9%ED%88%B0%EC%9D%98-%EC%A0%95%EC%8B%9D%EC%97%B0%EC%9E%AC-%EC%8A%B9%EA%B2%A9-%ED%99%95%EB%A5%A0-%EC%98%88%EC%B8%A1-3.-%EB%8D%B0%EC%9D%B4%ED%84%B0-%EB%B3%80%EC%88%98%ED%99%94 https://velog.io/@goodjin_55/%EB%B2%A0%EC%8A%A4%ED%8A%B8%EB%8F%84%EC%A0%84-%EC%9B%B9%ED%88%B0%EC%9D%98-%EC%A0%95%EC%8B%9D%EC%97%B0%EC%9E%AC-%EC%8A%B9%EA%B2%A9-%ED%99%95%EB%A5%A0-%EC%98%88%EC%B8%A1-3.-%EB%8D%B0%EC%9D%B4%ED%84%B0-%EB%B3%80%EC%88%98%ED%99%94 Mon, 06 Feb 2023 13:03:01 GMT 이전에 수집한 데이터들을 'mywebtoon_data.csv' 와 'mycomment_data.csv'에 저장하였다.

🔎 수집한 데이터

아래는 'mywebtoon_data.csv' 의 columns 정보이다.

  • titleId : 각 웹툰의 고유번호
  • isPublic : 정식연재 승격 여부
  • totalStar : 전체별점
  • heart : 하트수
  • contentGenre : 내용장르 10개 중 n개 daily/comic/fantasy/action/drama/pure/sensibility/thrill/historical/sports
  • typeGenre : 형식장르 3개 중 1개 에피소드/옴니버스/스토리
  • star(i) : i번째 회차의 별점 *(i = 1,2,3,-3,-2,-1)
  • starPar(i) : i번째 회차의 별점참여수
  • day(i) : i번째 회차의 등록일
  • views(i) : i번째 회차의 조회수

아래는 'mycomment_data.csv' 의 columns 정보이다.

  • titleId : 각 웹툰의 고유번호
  • isPublic : 정식연재 승격 여부
  • comment : 댓글 내용
  • like : 해당 댓글의 좋아요 수
  • hate : 해당 댓글의 싫어요 수

📄 데이터 정리

연재 시작 날짜로 웹툰 선택

지금까지는 모든 웹툰을 수집하였다. 급격히 바뀌는 트렌드를 반영하여 너무 오래된 웹툰들은 분석 데이터에서 제외하자는 판 단을 하였다.

webtoon['day1'] = pd.to_datetime(webtoon['day1'])
webtoon['day1'].dt.year.value_counts().plot.bar()

2012년에 베스트도전 웹툰의 수가 급격히 늘었다. 따라서 2012년 전의 웹툰들은 삭제하였다.

webtoon = webtoon[webtoon['day1'].dt.year >= 2012]
webtoon.reset_index(drop= True, inplace= True)

# 댓글 데이터에서도 제외
titleId = webtoon['titleId'].unique()
for id in comment['titleId']:
    if id not in titleId:
        comment.drop(comment[comment['titleId'] == id].index, inplace=True)
comment.reset_index(drop= True, inplace= True)

그 결과, 전체 웹툰의 수는 2623개, 공식연재(isPublic == 1) 웹툰의 수는 153개였다.

4화, 5화밖에 없는 웹툰 정리

회차의 등록일을 기준으로 4개 또는 5개의 회차만 존재하는 웹툰을 정리하였다. 예를 들어, 4개의 회차만 존재한다면, 데이터 수집 순서가 (-1) -> (-2) -> (-3) -> 1 -> 2 -> 3 이므로, 2와 3은 비어있어야 한다. 5개의 회차만 존재한다면, 3이 비어있는 데이터여야 한다.

# 4화만 있는 웹툰 : 2,3 삭제
only4 = data[data['day2'] == data['day(-2)']].index
data.loc[only4, ['star2','starPar2','views2','day2']] = np.NaN
data.loc[only4, ['star3','starPar3','views3','day3']] = np.NaN
only4 = data[data['day2'].isnull()].index
# 5화만 있는 웹툰 : 3 삭제
only5 = data[data['day3'] == data['day(-3)']].index
data.loc[only5, ['star3','starPar3','views3','day3']] = np.NaN
only5 = data[data['day3'].isnull()].index

📊 데이터 eda 및 변수화

---고려해본 것!---

  1. 초반 회차 데이터와 후반 회차 데이터를 하나의 변수로 나타내기
  2. 분포가 편향된 변수들에 로그변환, 역변환, Box-cox 변환 등 반영하기

패키지 import

import numpy as np
import pandas as pd
from scipy import stats
import matplotlib.pyplot as plt
import seaborn as sns
import warnings
warnings.filterwarnings(action='ignore')
from datetime import datetime
import time

data = pd.read_csv('mywebtoon_data.csv')

종속변수 isPublic

print(data['isPublic'].value_counts())
plt.figure(figsize= (5,4))
data['isPublic'].value_counts().plot(kind = 'bar')
plt.show()

정식연재 웹툰(isPublic == 1)이 매우 적으므로 (약 5%) 이를 고려하여 모델링에 참고하였다.

totalStar

plt.figure(figsize= (6,3))
sns.distplot(data['totalStar'])

대부분의 별점이 9점대에 몰려있다. 이렇게 한쪽으로 몰려있는 데이터는 이후 모델링의 성능에 악영향을 끼칠 수 있다. 따라서 다양한 변환을 이용해 정규분포에 가까운 모양을 나타내거나 데이터를 분산시키는 방법을 선택하였다.

fig, ax = plt.subplots(ncols=2)
# 로그변환
sns.distplot(np.log(data['totalStar']), ax=ax[0], color='red')
# boxcox 변환
y, lambda_optimal = stats.boxcox(data['totalStar'])
sns.distplot(y, ax=ax[1], color='red')

왼쪽은 로그변환, 오른쪽은 Box-cox 변환 후 분포이다. totalStar 변수는 box-cox 변환이 데이터를 잘 분산시켰지만, 값이 너무 커지는 이유로 선택하지 않았다. 그러나 다른 변수들의 변환 및 변수화 결과, 값이 0 근처에서 그게 벗어나지 않아 각 데이터에 최솟값을 빼준 값을 새 데이터로 설정하였다.

heart

data['heart'] = data['heart'].str.replace(',','') # 천단위 콤마 제거
data['heart'] = data['heart'].astype(int)

plt.figure(figsize= (6,3))
sns.distplot(data['heart'])

로그변환!

sns.displot(np.log(data['heart']), color='red')

star

star1, star2, star3와 star(-3), star(-2), star(-1)의 평균으로 초반, 후반 별점을 구하여 분포를 확인하였다. 이때, 4개 또는 5개 회차밖에 존재하지 않는 웹툰은 존재하지 않는 데이터를 제외하고 평균을 구하였다.

# 3개 화의 평균을 이용해 초반, 후반으로 나눔.
data['starEarly'] = (data['star1'] + data['star2'] + data['star3'])/3
data['starLater'] = (data['star(-1)'] + data['star(-2)'] + data['star(-3)'])/3
data.loc[only5,'starEarly'] = (data['star1'] + data['star2'])/2
data.loc[only4,'starEarly'] = data['star1']

# 초반과 후반 분포
fig, ax = plt.subplots(ncols=2)
sns.distplot(data['starEarly'], ax=ax[0])
sns.distplot(data['starLater'], ax=ax[1])

변환 후 파생변수를 만들고자 하였으나, 변환 후 데이터의 분포에서 크게 효과를 보지 못하였다. 따라서 초반과 후반 별점의 차이(후반별점 - 초반별점) 또는 비율(후반별점 / 초반별점)을 구하여 파생변수로 만들었다.

data['starDif'] = data['starLater'] - data['starEarly'] # 차이
data['starRatio'] = data['starLater'] / data['starEarly'] # 비율

fig, ax = plt.subplots(ncols=2)
sns.distplot(data['starDif'], ax=ax[0])
sns.distplot(data['starRatio'], ax=ax[1])

왼쪽은 차이, 오른쪽은 비율의 분포 그래프이다. 둘 중 isPublic 변수와 상관관계가 높은 '차이' 를 이용하였다. (차이 : 0.061, 비율 : 0.055, 상관관계로 변수를 선택한 것이 옳은 방법인지는 더 공부해볼 것.)

starPar

별점에서와 같은 방법으로, 초반 회차와 후반 회차의 별점참여수 평균의 로그변환 후, 비율을 파생변수로 만들었다.

data['starParEarly'] = (data['starPar1'] + data['starPar2'] + data['starPar3'])/3
data['starParLater'] = (data['starPar(-1)'] + data['starPar(-2)'] + data['starPar(-3)'])/3
data.loc[only5,'starParEarly'] = (data['starPar1'] + data['starPar2'])/2
data.loc[only4,'starParEarly'] = data['starPar1']

# 초반과 후반 분포
fig, ax = plt.subplots(ncols=2)
sns.distplot(data['starParEarly'], ax=ax[0])
sns.distplot(data['starParLater'], ax=ax[1])

# 로그변환
fig, ax = plt.subplots(ncols=2)
sns.distplot(np.log(data['starParEarly']), ax=ax[0], color='red')
sns.distplot(np.log(data['starParLater']), ax=ax[1], color='red')

# 초반과 후반 로그변환의 비율 분포
data['starParRatio'] = np.log(data['starParLater']) / np.log(data['starParEarly'])
sns.distplot(data['starParRatio'])

views

마찬가지로, 초반 회차와 후반 회차의 조회수 평균의 로그변환 후, 비율을 파생변수로 만들었다.

data['viewsEarly'] = (data['views1'] + data['views2'] + data['views3'])/3
data['viewsLater'] = (data['views(-1)'] + data['views(-2)'] + data['views(-3)'])/3
data.loc[only5,'viewsEarly'] = (data['views1'] + data['views2'])/2
data.loc[only4,'viewsEarly'] = data['views1']

# 초반과 후반의 분포
fig, ax = plt.subplots(ncols=2)
sns.distplot(data['viewsEarly'], ax=ax[0])
sns.distplot(data['viewsLater'], ax=ax[1])

# 로그변환
fig, ax = plt.subplots(ncols=2)
sns.distplot(np.log(data['viewsEarly']), ax=ax[0], color='red')
sns.distplot(np.log(data['viewsLater']), ax=ax[1], color='red')

# 초반과 후반 로그변환의 비율 분포
data['viewsRatio'] = np.log(data['viewsLater']) / np.log(data['viewsEarly'])
sns.distplot(data['viewsRatio'])

day

회차별 등록일 데이터는 각 회차의 날짜의 차이를 계산하여, 얼마나 자주 연재하였나를 변수로 넣고자 하였다.

# 날짜 데이터로 변환
data['day1'] = pd.to_datetime(data['day1'])
data['day2'] = pd.to_datetime(data['day2'])
data['day3'] = pd.to_datetime(data['day3'])
data['day(-3)'] = pd.to_datetime(data['day(-3)'])
data['day(-2)'] = pd.to_datetime(data['day(-2)'])
data['day(-1)'] = pd.to_datetime(data['day(-1)'])

# 등록일 차이 계산
dateInterval1 = data['day2'] - data['day1']
dateInterval2 = data['day3'] - data['day2']
dateInterval3 = data['day(-2)'] - data['day(-3)']
dateInterval4 = data['day(-1)'] - data['day(-2)']

data['dateInterval'] = (dateInterval1+dateInterval2+dateInterval3+dateInterval4)/4
data.loc[only5, 'dateInterval'] = (dateInterval1+dateInterval3+dateInterval4)/3
data.loc[only4, 'dateInterval'] = (dateInterval3+dateInterval4)/2
data['dateInterval'] = data['dateInterval'].dt.days

# 분포
sns.distplot(data['dateInterval'])

상당히 큰 값을 가진 데이터들이 존재하여 로그변환을 수행하였다. 값이 0인 데이터는 로그를 취할 수 없어 -1로 정의하였다.

# 로그변환
data['dateInterval'] = np.log(data['dateInterval'][data['dateInterval'] != 0.0])
data['dateInterval'][data['dateInterval'] == 0] = -1
sns.distplot(data['dateInterval'])

typeGenre

스토리, 에피소드, 옴니버스의 type장르는 원핫인코딩을 하였다. type_스토리 변수의 해당 웹툰이 스토리 장르이면 1, 아니면 0의 값을 갖는다.

pd.get_dummies(data['typeGenre'], prefix = 'type')

contentGenre

daily, comic, fantasy, action, drama, pure, sensibility, thrill, historical, sports의 content장르도 마찬가지로 변환하였다.

+) 실제 프로젝트에서는 R에서 glm(일반화 선형모델)을 돌려 중요도 기준으로 장르를 하나씩만 선택하였다. 아래는 R 코드이다. (이부분은 아직 공부가 더 필요하다.) 결과만 말하자면, 장르의 중요도는 thrill > daily > fantasy > comic > drama > pure > action > sensibility > sports > historical 이었다.

library(data.table)
library(dplyr)
library(MASS)
library(stringr)

webtoon = read.csv('./mywebtoon_data.csv', header=T, fileEncoding='utf-8')
webtoon$isPublic <- as.factor(webtoon$isPublic)

# 장르 개수 입력
webtoon$numGenre <- 1
for (i in 1:length(webtoon$contentGenre)) {
  genre = strsplit(webtoon$contentGenre, split=",")[i][[1]]
  while (length(genre) > webtoon$numGenre[i]) {
    webtoon$numGenre[i] <- webtoon$numGenre[i] + 1
  }
}

# 중요도 계산
cont_list = c('action','comic','daily','drama','fantasy','historical','pure','sensibility','sports','thrill')
fit_genre_thrill <- glm(isPublic ~ factor(webtoon$contentGenre[webtoon$numGenre==1], levels=cont_list[c(10,1:9)]),
                        family=binomial, data=webtoon[webtoon$numGenre==1,])
fit_genre_thrill %>% summary()

# p-value 가 작은 순서대로 지정
webtoon$oneGenre <- webtoon$contentGenre
cont_pval_list = c('thrill','daily','fantasy','comic','drama', 'pure','action','sensibility','sports','historical')
for (i in 1:length(webtoon$oneGenre)){
  for (cont in cont_pval_list) {
    genre = str_detect(webtoon$contentGenre[i], cont)
    if (genre) {
      webtoon$oneGenre[i] <- cont
      break
    }
  }
}

❓초반과 후반 데이터의 파생변수를 고려한 이유

초반과 후반 회차 데이터을 그대로 변수로 사용하지 않고, 차이 혹은 비율의 파생변수를 고려한 이유는 다음과 같다. 첫번째 이유는, 후반 회차의 데이터의 수집 목적이 뒤늦게 인기를 얻는 웹툰과 타 웹툰의 차이를 줄이고자 하는 것이었기 때문이다. 즉, 초반 회차의 데이터 그 자체보다 후반에 비해 초반에 얼마나 큰 주목을 끌었나를 변수화시키고 싶었다. 두번째 이유는 아래 그래프(초반과 후반의 조회수 산점도)를 통해 '조회수가 높은 것보다, 조회수를 후반까지 유지하는 것이 더 중요함'을 발견했기 때문이다.

# viewsEarly vs. viewsLater
dt1 = data[data['isPublic'] == 0][['viewsEarly','viewsLater']]
dt2 = data[data['isPublic'] == 1][['viewsEarly','viewsLater']]
plt.scatter(dt1['viewsEarly'], dt1['viewsLater'], c='green')
plt.scatter(dt2['viewsEarly'], dt2['viewsLater'], c='red')
plt.xlabel('viewsEarly')
plt.ylabel('viewsLater')
plt.show()

그래프에서 빨간색은 정식연재, 초록색은 정식연재가 아닌 웹툰이다. 빨간색 점들은 y=x 그래프꼴로 선형관계를 보이는 반면, 초록색 점들은 아래로 처지는 점들이 많이 보인다. 이를 통해 조회수가 초반이 높고 후반은 낮은 웹툰들은 정식연재로 승격되지 않는 것을 알 수 있다.

]]> <![CDATA[베스트도전 웹툰의 정식연재 승격 확률 예측 - 2. 회차 크롤링]]> https://velog.io/@goodjin_55/%ED%94%84%EB%A1%9C%EC%A0%9D%ED%8A%B8-%EB%B2%A0%EC%8A%A4%ED%8A%B8%EB%8F%84%EC%A0%84-%EC%9B%B9%ED%88%B0%EC%9D%98-%EC%A0%95%EC%8B%9D%EC%97%B0%EC%9E%AC-%EC%8A%B9%EA%B2%A9-%ED%99%95%EB%A5%A0-%EC%98%88%EC%B8%A1-2.-%ED%9A%8C%EC%B0%A8-%ED%81%AC%EB%A1%A4%EB%A7%81 https://velog.io/@goodjin_55/%ED%94%84%EB%A1%9C%EC%A0%9D%ED%8A%B8-%EB%B2%A0%EC%8A%A4%ED%8A%B8%EB%8F%84%EC%A0%84-%EC%9B%B9%ED%88%B0%EC%9D%98-%EC%A0%95%EC%8B%9D%EC%97%B0%EC%9E%AC-%EC%8A%B9%EA%B2%A9-%ED%99%95%EB%A5%A0-%EC%98%88%EC%B8%A1-2.-%ED%9A%8C%EC%B0%A8-%ED%81%AC%EB%A1%A4%EB%A7%81 Sun, 05 Feb 2023 05:01:34 GMT 이전에 수집한 웹툰들의 리스트를 바탕으로 각 초반 3화, 후반 3화의 정보를 크롤링할 것이다.

패키지 import

import pandas as pd
import time

from selenium import webdriver
from selenium.webdriver.common.keys import Keys
from selenium.webdriver.common.by import By
from selenium.webdriver.common.alert import Alert
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC

수집을 진행하기 전에, webdriver에 url을 넣어주어야 한다.

wd = webdriver.Chrome('C:/chromedriver.exe')
url = "https://comic.naver.com/bestChallenge/list?titleId=" + str(webtoon.loc[i,'titleId'])
wd.get(url)

❤️ 하트수

하트수가 나와있는 버튼을 우클릭 -> 검사 하여 개발자도구를 연다.

'9,210'에서 우클릭 -> Copy -> Copy selector 하여 find_element 함수의 인자로 넣을 것이다.

예외) 시리즈 작품

위 웹툰처럼, 시리즈 작품은 기존 하트수가 있는 버튼이 '시리즈에서 보기' 버튼에 의해 한 칸 오른쪽에 있었다. 따라서 기존의 방법처럼 Copy selector 를 진행하여 따로 입력하였다. 시리즈 작품의 여부는 개발자 도구에서 '시리즈에서 보기' 버튼의 유무로 판단하였다.

try: # 시리즈 작품의 하트수 추출
    series = '시리즈' in wd.find_element(By.CSS_SELECTOR, '#content > div.comicinfo > div.detail > ul > li:nth-child(4) > a > span').text
    heart = wd.find_element(By.CSS_SELECTOR,'#content > div.comicinfo > div.detail > ul > li:nth-child(6) > div > a > em').text
except: # 시리즈가 아닌 작품의 하트수 추출
    heart = wd.find_element(By.CSS_SELECTOR,'#content > div.comicinfo > div.detail > ul > li:nth-child(5) > div > a > em').text

📚 type장르

에피소드/옴니버스/스토리 의 type 장르는 class = "on" 인 클래스로 확인할 수 있다. 마찬가지로 find_element를 통해 정보를 추출하였다.

typeGenre = wd.find_element(By.CSS_SELECTOR,'#content > div.snb > ul > li.on').text

✔️ 회차별 별점, 별점참여수, 등록일, 조회수

위 사진에서 find_element를 이용해 별점, 별점참여수, 등록일, 조회수를 수집하였다.

star = wd.find_element(By.CSS_SELECTOR, '#topPointTotalNumber').text
starPar = wd.find_element(By.CSS_SELECTOR, '#topTotalStarPoint > span.pointTotalPerson > em').text
views(-1) = wd.find_element(By.CSS_SELECTOR, '#sectionContWide > div.tit_area > div.vote_lst > dl.rt > dd:nth-child(4)').text
day(-1) = wd.find_element(By.CSS_SELECTOR, '#sectionContWide > div.tit_area > div.vote_lst > dl.rt > dd:nth-child(2)').text

💬 회차별 댓글

전체 댓글을 가져오기 힘들 것 같아 'BEST댓글'을 최대 5개로 수집하였다. 각 댓글의 좋아요수, 싫어요수도 중요한 변수가 될 것 같아 같이 수집하였다.

comment = pd.DataFrame(columns= ['titleId','isPublic','comment','like','hate'])
# 댓글창 열기
wd.switch_to.frame('commentIframe') 
# 'BEST댓글'이 없는 경우 == '전체댓글'로 설정되어 있는 경우
if wd.find_element(By.CSS_SELECTOR,'#cbox_module > div > div.u_cbox_sort > div.u_cbox_sort_option > div > ul > li.u_cbox_sort_option_wrap.u_cbox_sort_option_on').text == '전체댓글':
    wd.switch_to.default_content(); wd.back(); continue
# 'BEST댓글' 수집
commentNum = min(len(wd.find_elements(By.CLASS_NAME, 'u_cbox_contents')),5)
for j in range(commentNum): #댓글수가 5개 미만인 경우 고려
    comment.loc[len(comment)] = [titleId, isPublic, 
                                wd.find_elements(By.CLASS_NAME, 'u_cbox_contents')[j].text,
                                wd.find_elements(By.CLASS_NAME, 'u_cbox_cnt_recomm')[j].text,
                                wd.find_elements(By.CLASS_NAME, 'u_cbox_cnt_unrecomm')[j].text]
wd.switch_to.default_content(); wd.back()

💻 전체코드

변수에서 숫자는 각 회차의 정보를 의미한다. 예를 들어 star1은 1화, star2는 2화, ..., star(-1)은 가장 최신화 이다. 제목에 '공지'가 있는 회차는 수집 목적에 맞지 않다고 판단하여 해당 회차는 건너뛰었다. 수집 순서는 가장 최신화 -> 두번째 최신화 -> 세번째 최신화 -> '첫화보기'를 클릭하여 첫화 -> 두번째 화 -> 세번째 화 이다. 코드의 중간중간에(url 이동 후, 댓글창 이동 후 등) time.sleep() 함수를 이용하여, 에러를 줄일 수 있다. 

# import
import pandas as pd
import time

from selenium import webdriver
from selenium.webdriver.common.keys import Keys
from selenium.webdriver.common.by import By
from selenium.webdriver.common.alert import Alert
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC

# 각 웹툰별 정보 크롤링
comment = pd.DataFrame(columns= ['titleId','isPublic','comment','like','hate'])
alertList = [] # 경고창 때문에 첫번째 회차가 안 열리는 경우 : 따로 크롤링 진행!
wd = webdriver.Chrome('C:/chromedriver.exe')

for i in range(len(webtoon)):
    # url이동
    url = "https://comic.naver.com/bestChallenge/list?titleId=" + str(webtoon.loc[i,'titleId'])
    wd.get(url)

    # 하트수
    try: # 시리즈 작품
        series = '시리즈' in wd.find_element(By.CSS_SELECTOR, '#content > div.comicinfo > div.detail > ul > li:nth-child(4) > a > span').text
        while True: 
            # url 이동 후 바로 버튼이 생성되지 않아 반복문 이용. time.sleep()을 이용해도 좋다.
            try: 
                webtoon.loc[i,'heart'] = wd.find_element(By.CSS_SELECTOR,'#content > div.comicinfo > div.detail > ul > li:nth-child(6) > div > a > em').text
                break
            except: pass
    except: # 시리즈 작품이 아닌 작품
        while True:
            try: 
                webtoon.loc[i,'heart'] = wd.find_element(By.CSS_SELECTOR,'#content > div.comicinfo > div.detail > ul > li:nth-child(5) > div > a > em').text
                break
            except: pass

    # 에피소드/옴니버스/스토리
    webtoon.loc[i,'typeGenre'] = wd.find_element(By.CSS_SELECTOR,'#content > div.snb > ul > li.on').text

    pageCnt = len(wd.find_elements(By.CSS_SELECTOR, '#content > table > tbody > tr > td.title > a')) # 첫 화면에서의 회차 수 <= 10
    ## 3화 이하인 웹툰은 정보가 너무 적다고 판단하여 수집하지 않음.
    if pageCnt <= 3: continue 

    tryCnt = 0 # 수집을 도전한 회차 수
    dataCnt = 0 # 수집한 회차 수
    isalert = False # 경고창 팝업 여부

    for no in range(0,pageCnt):
        if (dataCnt == 3) or (tryCnt == pageCnt): break
        tryCnt += 1

        ## 최근 날짜 맞추기위해 실행 
        if (no == 0) and (pd.to_datetime(wd.find_elements(By.CSS_SELECTOR, '#content > table > tbody > tr > td.num')[0].text) > pd.to_datetime('2022.12.02')): continue 

        ## '공지' 글자가 있는 회차 스킵
        title = wd.find_elements(By.CSS_SELECTOR,'#content > table > tbody > tr > td.title > a')[no].text
        if '공지' in title: continue

        ## 가장 최신 화 클릭
        wd.find_elements(By.CSS_SELECTOR,'#content > table > tbody > tr > td.title > a')[no].click()
        dataCnt += 1

        if dataCnt == 1: ## 최근 1화
            webtoon.loc[i,'star(-1)'] = wd.find_element(By.CSS_SELECTOR, '#topPointTotalNumber').text
            webtoon.loc[i,'starPar(-1)'] = wd.find_element(By.CSS_SELECTOR, '#topTotalStarPoint > span.pointTotalPerson > em').text
            webtoon.loc[i,'views(-1)'] = wd.find_element(By.CSS_SELECTOR, '#sectionContWide > div.tit_area > div.vote_lst > dl.rt > dd:nth-child(4)').text
            webtoon.loc[i,'day(-1)'] = wd.find_element(By.CSS_SELECTOR, '#sectionContWide > div.tit_area > div.vote_lst > dl.rt > dd:nth-child(2)').text

            ## 댓글
            wd.switch_to.frame('commentIframe')
            if wd.find_element(By.CSS_SELECTOR,'#cbox_module > div > div.u_cbox_sort > div.u_cbox_sort_option > div > ul > li.u_cbox_sort_option_wrap.u_cbox_sort_option_on').text == '전체댓글':
                wd.switch_to.default_content(); wd.back(); continue
            commentNum = min(len(wd.find_elements(By.CLASS_NAME, 'u_cbox_contents')),5) #댓글수가 5개 미만인 경우 고려
            for j in range(min(len(wd.find_elements(By.CLASS_NAME, 'u_cbox_contents')),5)): 
                comment.loc[len(comment)] = [webtoon.loc[i,'titleId'],webtoon.loc[i,'isPublic'],
                                             wd.find_elements(By.CLASS_NAME, 'u_cbox_contents')[j].text,
                                             wd.find_elements(By.CLASS_NAME, 'u_cbox_cnt_recomm')[j].text,
                                             wd.find_elements(By.CLASS_NAME, 'u_cbox_cnt_unrecomm')[j].text]
            wd.switch_to.default_content(); wd.back()

        elif dataCnt == 2: ## 최근 2화
            webtoon.loc[i,'star(-2)'] = wd.find_element(By.CSS_SELECTOR, '#topPointTotalNumber').text
            webtoon.loc[i,'starPar(-2)'] = wd.find_element(By.CSS_SELECTOR, '#topTotalStarPoint > span.pointTotalPerson > em').text
            webtoon.loc[i,'views(-2)'] = wd.find_element(By.CSS_SELECTOR, '#sectionContWide > div.tit_area > div.vote_lst > dl.rt > dd:nth-child(4)').text
            webtoon.loc[i,'day(-2)'] = wd.find_element(By.CSS_SELECTOR, '#sectionContWide > div.tit_area > div.vote_lst > dl.rt > dd:nth-child(2)').text

            wd.switch_to.frame('commentIframe') # 댓글 크롤링
            if wd.find_element(By.CSS_SELECTOR,'#cbox_module > div > div.u_cbox_sort > div.u_cbox_sort_option > div > ul > li.u_cbox_sort_option_wrap.u_cbox_sort_option_on').text == '전체댓글':
                wd.switch_to.default_content(); wd.back(); continue
            commentNum = min(len(wd.find_elements(By.CLASS_NAME, 'u_cbox_contents')),5) #댓글수가 5개 미만인 경우 고려
            for j in range(min(len(wd.find_elements(By.CLASS_NAME, 'u_cbox_contents')),5)): 
                comment.loc[len(comment)] = [webtoon.loc[i,'titleId'],webtoon.loc[i,'isPublic'],
                                             wd.find_elements(By.CLASS_NAME, 'u_cbox_contents')[j].text,
                                             wd.find_elements(By.CLASS_NAME, 'u_cbox_cnt_recomm')[j].text,
                                             wd.find_elements(By.CLASS_NAME, 'u_cbox_cnt_unrecomm')[j].text]
            wd.switch_to.default_content(); wd.back()

        elif dataCnt == 3: ## 최근 3화
            webtoon.loc[i,'star(-3)'] = wd.find_element(By.CSS_SELECTOR, '#topPointTotalNumber').text
            webtoon.loc[i,'starPar(-3)'] = wd.find_element(By.CSS_SELECTOR, '#topTotalStarPoint > span.pointTotalPerson > em').text
            webtoon.loc[i,'views(-3)'] = wd.find_element(By.CSS_SELECTOR, '#sectionContWide > div.tit_area > div.vote_lst > dl.rt > dd:nth-child(4)').text
            webtoon.loc[i,'day(-3)'] = wd.find_element(By.CSS_SELECTOR, '#sectionContWide > div.tit_area > div.vote_lst > dl.rt > dd:nth-child(2)').text

            wd.switch_to.frame('commentIframe') # 댓글 크롤링
            if wd.find_element(By.CSS_SELECTOR,'#cbox_module > div > div.u_cbox_sort > div.u_cbox_sort_option > div > ul > li.u_cbox_sort_option_wrap.u_cbox_sort_option_on').text == '전체댓글':
                wd.switch_to.default_content(); continue
            commentNum = min(len(wd.find_elements(By.CLASS_NAME, 'u_cbox_contents')),5) #댓글수가 5개 미만인 경우 고려
            for j in range(min(len(wd.find_elements(By.CLASS_NAME, 'u_cbox_contents')),5)): 
                comment.loc[len(comment)] = [webtoon.loc[i,'titleId'],webtoon.loc[i,'isPublic'],
                                             wd.find_elements(By.CLASS_NAME, 'u_cbox_contents')[j].text,
                                             wd.find_elements(By.CLASS_NAME, 'u_cbox_cnt_recomm')[j].text,
                                             wd.find_elements(By.CLASS_NAME, 'u_cbox_cnt_unrecomm')[j].text]
            wd.switch_to.default_content()

    if (tryCnt == pageCnt): continue

    ## 1화
    try:
        tryCnt += 1
        wd.find_element(By.CSS_SELECTOR, '#sectionContWide > div.comicinfo > div.detail > ul > li:nth-child(2) > a').click()
        alert = Alert(wd); alert.accept()
        alertList += [i]
        continue
    except: pass

    title = wd.find_element(By.CSS_SELECTOR, '#sectionContWide > div.tit_area > div.view > h3').text
    while ('공지' in title) and (tryCnt < pageCnt):
        tryCnt += 1
        wd.find_element(By.CSS_SELECTOR, '#sectionContWide > div.tit_area > div.view > div > span.next > a').click()
        title = wd.find_element(By.CSS_SELECTOR, '#sectionContWide > div.tit_area > div.view > h3').text

    webtoon.loc[i,'star1'] = wd.find_element(By.CSS_SELECTOR, '#topPointTotalNumber').text
    webtoon.loc[i,'starPar1'] = wd.find_element(By.CSS_SELECTOR, '#topTotalStarPoint > span.pointTotalPerson > em').text
    webtoon.loc[i,'views1'] = wd.find_element(By.CSS_SELECTOR, '#sectionContWide > div.tit_area > div.vote_lst > dl.rt > dd:nth-child(4)').text
    webtoon.loc[i,'day1'] = wd.find_element(By.CSS_SELECTOR, '#sectionContWide > div.tit_area > div.vote_lst > dl.rt > dd:nth-child(2)').text

    wd.switch_to.frame('commentIframe') # 댓글 크롤링
    time.sleep(1.5)
    if wd.find_element(By.CSS_SELECTOR,'#cbox_module > div > div.u_cbox_sort > div.u_cbox_sort_option > div > ul > li.u_cbox_sort_option_wrap.u_cbox_sort_option_on').text == '전체댓글':
        wd.switch_to.default_content(); continue
    commentNum = min(len(wd.find_elements(By.CLASS_NAME, 'u_cbox_contents')),5) #댓글수가 5개 미만인 경우 고려
    for j in range(min(len(wd.find_elements(By.CLASS_NAME, 'u_cbox_contents')),5)): 
        comment.loc[len(comment)] = [webtoon.loc[i,'titleId'],webtoon.loc[i,'isPublic'],
                                     wd.find_elements(By.CLASS_NAME, 'u_cbox_contents')[j].text,
                                     wd.find_elements(By.CLASS_NAME, 'u_cbox_cnt_recomm')[j].text,
                                     wd.find_elements(By.CLASS_NAME, 'u_cbox_cnt_unrecomm')[j].text]
    wd.switch_to.default_content()
    if tryCnt == pageCnt: continue

    ## 2화 
    tryCnt += 1
    wd.find_element(By.CSS_SELECTOR, '#sectionContWide > div.tit_area > div.view > div > span.next > a').click()
    title = wd.find_element(By.CSS_SELECTOR, '#sectionContWide > div.tit_area > div.view > h3').text
    while ('공지' in title) and (tryCnt < pageCnt):
        tryCnt += 1
        wd.find_element(By.CSS_SELECTOR, '#sectionContWide > div.tit_area > div.view > div > span.next > a').click()
        title = wd.find_element(By.CSS_SELECTOR, '#sectionContWide > div.tit_area > div.view > h3').text

    webtoon.loc[i,'star2'] = wd.find_element(By.CSS_SELECTOR, '#topPointTotalNumber').text
    webtoon.loc[i,'starPar2'] = wd.find_element(By.CSS_SELECTOR, '#topTotalStarPoint > span.pointTotalPerson > em').text
    webtoon.loc[i,'views2'] = wd.find_element(By.CSS_SELECTOR, '#sectionContWide > div.tit_area > div.vote_lst > dl.rt > dd:nth-child(4)').text
    webtoon.loc[i,'day2'] = wd.find_element(By.CSS_SELECTOR, '#sectionContWide > div.tit_area > div.vote_lst > dl.rt > dd:nth-child(2)').text

    wd.switch_to.frame('commentIframe') # 댓글 크롤링
    time.sleep(0.5)
    if wd.find_element(By.CSS_SELECTOR,'#cbox_module > div > div.u_cbox_sort > div.u_cbox_sort_option > div > ul > li.u_cbox_sort_option_wrap.u_cbox_sort_option_on').text == '전체댓글':
        wd.switch_to.default_content(); continue
    commentNum = min(len(wd.find_elements(By.CLASS_NAME, 'u_cbox_contents')),5) #댓글수가 5개 미만인 경우 고려
    for j in range(min(len(wd.find_elements(By.CLASS_NAME, 'u_cbox_contents')),5)): 
        comment.loc[len(comment)] = [webtoon.loc[i,'titleId'],webtoon.loc[i,'isPublic'],
                                     wd.find_elements(By.CLASS_NAME, 'u_cbox_contents')[j].text,
                                     wd.find_elements(By.CLASS_NAME, 'u_cbox_cnt_recomm')[j].text,
                                     wd.find_elements(By.CLASS_NAME, 'u_cbox_cnt_unrecomm')[j].text]
    wd.switch_to.default_content()
    if tryCnt == pageCnt: continue

    ## 3화
    tryCnt += 1
    wd.find_element(By.CSS_SELECTOR, '#sectionContWide > div.tit_area > div.view > div > span.next > a').click()
    title = wd.find_element(By.CSS_SELECTOR, '#sectionContWide > div.tit_area > div.view > h3').text
    while ('공지' in title) and (tryCnt < pageCnt):
        tryCnt += 1
        wd.find_element(By.CSS_SELECTOR, '#sectionContWide > div.tit_area > div.view > div > span.next > a').click()
        title = wd.find_element(By.CSS_SELECTOR, '#sectionContWide > div.tit_area > div.view > h3').text

    webtoon.loc[i,'star3'] = wd.find_element(By.CSS_SELECTOR, '#topPointTotalNumber').text
    webtoon.loc[i,'starPar3'] = wd.find_element(By.CSS_SELECTOR, '#topTotalStarPoint > span.pointTotalPerson > em').text
    webtoon.loc[i,'views3'] = wd.find_element(By.CSS_SELECTOR, '#sectionContWide > div.tit_area > div.vote_lst > dl.rt > dd:nth-child(4)').text
    webtoon.loc[i,'day3'] = wd.find_element(By.CSS_SELECTOR, '#sectionContWide > div.tit_area > div.vote_lst > dl.rt > dd:nth-child(2)').text

    wd.switch_to.frame('commentIframe') # 댓글 크롤링
    if wd.find_element(By.CSS_SELECTOR,'#cbox_module > div > div.u_cbox_sort > div.u_cbox_sort_option > div > ul > li.u_cbox_sort_option_wrap.u_cbox_sort_option_on').text == '전체댓글':
        wd.switch_to.default_content(); continue
    commentNum = min(len(wd.find_elements(By.CLASS_NAME, 'u_cbox_contents')),5) #댓글수가 5개 미만인 경우 고려
    for j in range(min(len(wd.find_elements(By.CLASS_NAME, 'u_cbox_contents')),5)): 
        comment.loc[len(comment)] = [webtoon.loc[i,'titleId'],webtoon.loc[i,'isPublic'],
                                     wd.find_elements(By.CLASS_NAME, 'u_cbox_contents')[j].text,
                                     wd.find_elements(By.CLASS_NAME, 'u_cbox_cnt_recomm')[j].text,
                                     wd.find_elements(By.CLASS_NAME, 'u_cbox_cnt_unrecomm')[j].text]
    wd.switch_to.default_content()

# 웹툰 데이터 csv 파일로 저장
webtoon.to_csv('mywebtoon_data.csv', index= False)
comment.to_csv('mycomment_data.csv', index= False)

코딩 실력이 부족하여 코드가 상당히 길지만, 잘 정리하여 간략한 코드를 만들어보고 싶다..

]]>