4.TEXT_CLASSIFICATION/4.1.2.EDA&preprocessing.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4.1.2 데이터 분석 및 전처리"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 데이터 불러오기 및 분석하기\n",
    "\n",
    "4.1 장에서 사용할 데이터인 영화 리뷰 데이터를 불러온 후 탐색적 데이터 분석 과정을 진행한다.  \n",
    "데이터 분석은 다음의 순서로 진행한다.\n",
    "\n",
    "* 데이터 크기\n",
    "* 데이터의 개수\n",
    "* 각 리뷰의 문자 길이 분포\n",
    "* 많이 사용된 단어\n",
    "* 긍, 부정 데이터의 분포\n",
    "* 각 리뷰의 단어 개수 분포\n",
    "* 특수문자 및 대, 소문자 비율 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import zipfile"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "DATA_IN_PATH = './data_in/'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "file_list = ['labeledTrainData.tsv.zip', 'unlabeledTrainData.tsv.zip', 'testData.tsv.zip']\n",
    "\n",
    "for file in file_list:\n",
    "    zipRef = zipfile.ZipFile(DATA_IN_PATH + file, 'r')\n",
    "    zipRef.extractall(DATA_IN_PATH)\n",
    "    zipRef.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np \n",
    "import pandas as pd\n",
    "import os\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 데이터 크기"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"파일 크기 : \")\n",
    "for file in os.listdir(DATA_IN_PATH):\n",
    "    if 'tsv' in file and 'zip' not in file:\n",
    "        print(file.ljust(30) + str(round(os.path.getsize(DATA_IN_PATH + file) / 1000000, 2)) + 'MB')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_data = pd.read_csv( DATA_IN_PATH + 'labeledTrainData.tsv', header = 0, delimiter = '\\t', quoting = 3)\n",
    "train_data.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 데이터 개수"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print('전체 학습데이터의 개수: {}'.format(len(train_data)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 각 리뷰의 문자 길이 분포"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_length = train_data['review'].apply(len)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_length.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 그래프에 대한 이미지 사이즈 선언\n",
    "# figsize: (가로, 세로) 형태의 튜플로 입력\n",
    "plt.figure(figsize=(12, 5))\n",
    "# 히스토그램 선언\n",
    "# bins: 히스토그램 값들에 대한 버켓 범위\n",
    "# range: x축 값의 범위\n",
    "# alpha: 그래프 색상 투명도\n",
    "# color: 그래프 색상\n",
    "# label: 그래프에 대한 라벨\n",
    "plt.hist(train_length, bins=200, alpha=0.5, color= 'r', label='word')\n",
    "plt.yscale('log', nonposy='clip')\n",
    "# 그래프 제목\n",
    "plt.title('Log-Histogram of length of review')\n",
    "# 그래프 x 축 라벨\n",
    "plt.xlabel('Length of review')\n",
    "# 그래프 y 축 라벨\n",
    "plt.ylabel('Number of review')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print('리뷰 길이 최대 값: {}'.format(np.max(train_length)))\n",
    "print('리뷰 길이 최소 값: {}'.format(np.min(train_length)))\n",
    "print('리뷰 길이 평균 값: {:.2f}'.format(np.mean(train_length)))\n",
    "print('리뷰 길이 표준편차: {:.2f}'.format(np.std(train_length)))\n",
    "print('리뷰 길이 중간 값: {}'.format(np.median(train_length)))\n",
    "# 사분위의 대한 경우는 0~100 스케일로 되어있음\n",
    "print('리뷰 길이 제 1 사분위: {}'.format(np.percentile(train_length, 25)))\n",
    "print('리뷰 길이 제 3 사분위: {}'.format(np.percentile(train_length, 75)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.figure(figsize=(12, 5))\n",
    "# 박스플롯 생성\n",
    "# 첫번째 파라메터: 여러 분포에 대한 데이터 리스트를 입력\n",
    "# labels: 입력한 데이터에 대한 라벨\n",
    "# showmeans: 평균값을 마크함\n",
    "\n",
    "plt.boxplot(train_length,\n",
    "             labels=['counts'],\n",
    "             showmeans=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 많이 사용된 단어"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from wordcloud import WordCloud\n",
    "cloud = WordCloud(width=800, height=600).generate(\" \".join(train_data['review']))\n",
    "plt.figure(figsize=(20, 15))\n",
    "plt.imshow(cloud)\n",
    "plt.axis('off')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 긍, 부정 데이터의 분포"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig, axe = plt.subplots(ncols=1)\n",
    "fig.set_size_inches(6, 3)\n",
    "sns.countplot(train_data['sentiment'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"긍정 리뷰 개수: {}\".format(train_data['sentiment'].value_counts()[1]))\n",
    "print(\"부정 리뷰 개수: {}\".format(train_data['sentiment'].value_counts()[0]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 각 리뷰의 단어 개수 분포"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_word_counts = train_data['review'].apply(lambda x:len(x.split(' ')))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.figure(figsize=(15, 10))\n",
    "plt.hist(train_word_counts, bins=50, facecolor='r',label='train')\n",
    "plt.title('Log-Histogram of word count in review', fontsize=15)\n",
    "plt.yscale('log', nonposy='clip')\n",
    "plt.legend()\n",
    "plt.xlabel('Number of words', fontsize=15)\n",
    "plt.ylabel('Number of reviews', fontsize=15)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print('리뷰 단어 개수 최대 값: {}'.format(np.max(train_word_counts)))\n",
    "print('리뷰 단어 개수 최소 값: {}'.format(np.min(train_word_counts)))\n",
    "print('리뷰 단어 개수 평균 값: {:.2f}'.format(np.mean(train_word_counts)))\n",
    "print('리뷰 단어 개수 표준편차: {:.2f}'.format(np.std(train_word_counts)))\n",
    "print('리뷰 단어 개수 중간 값: {}'.format(np.median(train_word_counts)))\n",
    "# 사분위의 대한 경우는 0~100 스케일로 되어있음\n",
    "print('리뷰 단어 개수 제 1 사분위: {}'.format(np.percentile(train_word_counts, 25)))\n",
    "print('리뷰 단어 개수 제 3 사분위: {}'.format(np.percentile(train_word_counts, 75)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 특수문자 및 대, 소문자 비율"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "qmarks = np.mean(train_data['review'].apply(lambda x: '?' in x)) # 물음표가 구두점으로 쓰임\n",
    "fullstop = np.mean(train_data['review'].apply(lambda x: '.' in x)) # 마침표\n",
    "capital_first = np.mean(train_data['review'].apply(lambda x: x[0].isupper())) #  첫번째 대문자\n",
    "capitals = np.mean(train_data['review'].apply(lambda x: max([y.isupper() for y in x]))) # 대문자가 몇개\n",
    "numbers = np.mean(train_data['review'].apply(lambda x: max([y.isdigit() for y in x]))) # 숫자가 몇개\n",
    "                  \n",
    "print('물음표가있는 질문: {:.2f}%'.format(qmarks * 100))\n",
    "print('마침표가 있는 질문: {:.2f}%'.format(fullstop * 100))\n",
    "print('첫 글자가 대문자 인 질문: {:.2f}%'.format(capital_first * 100))\n",
    "print('대문자가있는 질문: {:.2f}%'.format(capitals * 100))\n",
    "print('숫자가있는 질문: {:.2f}%'.format(numbers * 100))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 데이터 전처리\n",
    "\n",
    "데이터 분석과정을 바탕으로 데이터를 모델에 적용시키기 위해 전처리 과정을 진행한다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import re\n",
    "import json\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "from bs4 import BeautifulSoup\n",
    "from nltk.corpus import stopwords\n",
    "from tensorflow.python.keras.preprocessing.sequence import pad_sequences\n",
    "from tensorflow.python.keras.preprocessing.text import Tokenizer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "DATA_IN_PATH = './data_in/'\n",
    "\n",
    "train_data = pd.read_csv( DATA_IN_PATH + 'labeledTrainData.tsv', header = 0, delimiter = '\\t', quoting = 3)\n",
    "print(train_data['review'][0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "review = train_data['review'][0] # 리뷰 중 하나를 가져온다.\n",
    "review_text = BeautifulSoup(review,\"html5lib\").get_text() # HTML 태그 제거\n",
    "review_text = re.sub(\"[^a-zA-Z]\", \" \", review_text ) # 영어 문자를 제외한 나머지는 모두 공백으로 바꾼다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(review_text)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "stop_words = set(stopwords.words('english')) # 영어 불용어들의 set을 만든다.\n",
    "\n",
    "review_text = review_text.lower()\n",
    "words = review_text.split() # 소문자 변환 후 단어마다 나눠서 단어 리스트로 만든다.\n",
    "words = [w for w in words if not w in stop_words] # 불용어 제거한 리스트를 만든다"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(words)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "clean_review = ' '.join(words) # 단어 리스트들을 다시 하나의 글로 합친다.\n",
    "print(clean_review)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def preprocessing( review, remove_stopwords = False ): \n",
    "    # 불용어 제거는 옵션으로 선택 가능하다.\n",
    "    \n",
    "    # 1. HTML 태그 제거\n",
    "    review_text = BeautifulSoup(review, \"html5lib\").get_text()\t\n",
    "\n",
    "    # 2. 영어가 아닌 특수문자들을 공백(\" \")으로 바꾸기\n",
    "    review_text = re.sub(\"[^a-zA-Z]\", \" \", review_text)\n",
    "\n",
    "    # 3. 대문자들을 소문자로 바꾸고 공백단위로 텍스트들 나눠서 리스트로 만든다.\n",
    "    words = review_text.lower().split()\n",
    "\n",
    "    if remove_stopwords: \n",
    "        # 4. 불용어들을 제거\n",
    "    \n",
    "        #영어에 관련된 불용어 불러오기\n",
    "        stops = set(stopwords.words(\"english\"))\n",
    "        # 불용어가 아닌 단어들로 이루어진 새로운 리스트 생성\n",
    "        words = [w for w in words if not w in stops]\n",
    "        # 5. 단어 리스트를 공백을 넣어서 하나의 글로 합친다.\t\n",
    "        clean_review = ' '.join(words)\n",
    "\n",
    "    else: # 불용어 제거하지 않을 때\n",
    "        clean_review = ' '.join(words)\n",
    "\n",
    "    return clean_review"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "clean_train_reviews = []\n",
    "for review in train_data['review']:\n",
    "    clean_train_reviews.append(preprocessing(review, remove_stopwords = True))\n",
    "\n",
    "# 전처리한 데이터 출력\n",
    "clean_train_reviews[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "clean_train_df = pd.DataFrame({'review': clean_train_reviews, 'sentiment': train_data['sentiment']})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "tokenizer = Tokenizer()\n",
    "tokenizer.fit_on_texts(clean_train_reviews)\n",
    "text_sequences = tokenizer.texts_to_sequences(clean_train_reviews)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(text_sequences[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "word_vocab = tokenizer.word_index\n",
    "# print(word_vocab)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"전체 단어 개수: \", len(word_vocab) + 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "tokenizer.word_index"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "data_configs = {}\n",
    "\n",
    "data_configs['vocab'] = word_vocab\n",
    "data_configs['vocab_size'] = len(word_vocab)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "MAX_SEQUENCE_LENGTH = 174 \n",
    "\n",
    "train_inputs = pad_sequences(text_sequences, maxlen=MAX_SEQUENCE_LENGTH, padding='post')\n",
    "\n",
    "print('Shape of train data: ', train_inputs.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_labels = np.array(train_data['sentiment'])\n",
    "print('Shape of label tensor:', train_labels.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "TRAIN_INPUT_DATA = 'train_input.npy'\n",
    "TRAIN_LABEL_DATA = 'train_label.npy'\n",
    "TRAIN_CLEAN_DATA = 'train_clean.csv'\n",
    "DATA_CONFIGS = 'data_configs.json'\n",
    "\n",
    "import os\n",
    "# 저장하는 디렉토리가 존재하지 않으면 생성\n",
    "if not os.path.exists(DATA_IN_PATH):\n",
    "    os.makedirs(DATA_IN_PATH)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 전처리 된 데이터를 넘파이 형태로 저장\n",
    "np.save(open(DATA_IN_PATH + TRAIN_INPUT_DATA, 'wb'), train_inputs)\n",
    "np.save(open(DATA_IN_PATH + TRAIN_LABEL_DATA, 'wb'), train_labels)\n",
    "\n",
    "# 정제된 텍스트를 csv 형태로 저장\n",
    "clean_train_df.to_csv(DATA_IN_PATH + TRAIN_CLEAN_DATA, index = False)\n",
    "\n",
    "\n",
    "# 데이터 사전을 json 형태로 저장\n",
    "json.dump(data_configs, open(DATA_IN_PATH + DATA_CONFIGS, 'w'), ensure_ascii=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_data = pd.read_csv(DATA_IN_PATH + \"testData.tsv\", header=0, delimiter=\"\\t\", quoting=3)\n",
    "\n",
    "clean_test_reviews = []\n",
    "for review in test_data['review']:\n",
    "    clean_test_reviews.append(preprocessing(review, remove_stopwords = True))\n",
    "\n",
    "\n",
    "clean_test_df = pd.DataFrame({'review': clean_test_reviews, 'id': test_data['id']})\n",
    "test_id = np.array(test_data['id'])\n",
    "\n",
    "text_sequences = tokenizer.texts_to_sequences(clean_test_reviews)\n",
    "test_inputs = pad_sequences(text_sequences, maxlen=MAX_SEQUENCE_LENGTH, padding='post')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "TEST_INPUT_DATA = 'test_input.npy'\n",
    "TEST_CLEAN_DATA = 'test_clean.csv'\n",
    "TEST_ID_DATA = 'test_id.npy'\n",
    "\n",
    "np.save(open(DATA_IN_PATH + TEST_INPUT_DATA, 'wb'), test_inputs)\n",
    "np.save(open(DATA_IN_PATH + TEST_ID_DATA, 'wb'), test_id)\n",
    "clean_test_df.to_csv(DATA_IN_PATH + TEST_CLEAN_DATA, index = False)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}