<jupyter_start><jupyter_text><jupyter_code>!git clone https://github.com/SOMJANG/Mecab-ko-for-Google-Colab.git
ls    # 현재 폴더의 리스트 보여주세요
cd Mecab-ko-for-Google-Colab/    # cd: change directory
!bash install_mecab-ko_on_colab190912.sh
!pip install konlpy
from konlpy.tag import Mecab
mecab = Mecab()
print(mecab.morphs('자연어처리가너무재밌어서밥먹는것도가끔까먹어요'))
import os
import matplotlib.pyplot as plt
import tensorflow as tf
import numpy as np
pwd       # 현재 위치
cd ../    # 상위폴더로 이동
pwd
path_to_file = '/content/drive/MyDrive/백_data/korean-english-park.train.ko'
with open(path_to_file, 'r', encoding='utf-8') as f:
  raw = f.read().splitlines()    # 라인별로 split

print('Data Size', len(raw))
print('Example')
for sen in raw[0:100][::20]:    # 인덱스 0, 20, 40, 60, 80에 해당하는 데이터  -  raw[0:100:20]와 같다
  print('>>', sen)
print(len(raw[3]))
print(type(raw))
print(type(raw[3]))
min_len = 999
max_len = 0
sum_len = 0

for sen in raw:
  length = len(sen)
  if min_len > length:
    min_len = length
  if max_len < length:
    max_len = length
  sum_len += length

print('문장의 최단 길이:', min_len)
print('문장의 최장 길이:', max_len)
print('문장의 평균 길이:', sum_len//len(raw))
sentence_length = np.zeros((max_len), dtype=np.int)    # 최장 길이로 0 배열 만들기

for sen in raw:
  sentence_length[len(sen)-1] += 1                     # 길이에 따른 문장 개수 세기

plt.bar(range(max_len), sentence_length, width=1.0)
plt.title('Sentence Length Distribution')              # 해당 문장 길이(x)인 문장 개수(y)
def check_sentence_with_length(raw, length):
  count = 0
  for sen in raw:
    if len(sen) == length:
      print(sen)
      count += 1
      if count > 100: return
check_sentence_with_length(raw, 3)
for idx, _sum in enumerate(sentence_length):
  if _sum > 1500:
    print('Outlier index:', idx+1)
# 문장길이가 11
check_sentence_with_length(raw, 11)    # 중복 문장이 많다.
min_len = 999
max_len = 0
sum_len = 0

cleaned_corpus = list(set(raw))                # set을 통해 문장 중복 없애기
print('Data Size:', len(cleaned_corpus))

for sen in cleaned_corpus:
  length = len(sen)
  if min_len > length: min_len = length
  if max_len < length: max_len = length
  sum_len += length

print('문장의 최단 길이:', min_len)
print('문장의 최장 길이:', max_len)
print('문장의 평균 길이:', sum_len//len(cleaned_corpus))
check_sentence_with_length(cleaned_corpus, 11)    # 문장 중복이 사라진 것을 확인할 수 있다.
max_len = 150
min_len = 10

# 10 ~ 150 사이의 문장분포
filtered_corpus = [s for s in cleaned_corpus if (len(s) < max_len) & (len(s) >= min_len)]

sentence_length = np.zeros((max_len), dtype=np.int)

for sen in filtered_corpus:
  sentence_length[len(sen)-1] += 1

plt.bar(range(max_len), sentence_length, width=1.0)
plt.title('Sentence Length Distribution')
plt.show()
# 삐쭉삐쭉한 부분을 다 정제하고 범위도 정해주었더니 이전보다 안정된 그래프를 그린다.<jupyter_output><empty_output><jupyter_text>공백 기반 토큰화<jupyter_code>def tokenize(corpus):
  tokenizer = tf.keras.preprocessing.text.Tokenizer(filters='')                       # 토크나이징
  tokenizer.fit_on_texts(corpus)

  tensor = tokenizer.texts_to_sequences(corpus)                                       # 벡터화(숫자화)
  tensor = tf.keras.preprocessing.sequence.pad_sequences(tensor, padding='post')      # 뒤쪽으로 패딩 (앞쪽: padding='pre')
  return tensor, tokenizer
# 정제된 데이터를 공백 기반으로 토큰화하여 저장하는 코드를 직접 작성해보세요~
split_corpus = []

for kor in filtered_corpus:
  # 코드를 작성하세요.
  split_corpus.append(kor.split())

print(split_corpus[0])    # 공백을 기준으로 문장을 잘 잘라주고 있다.
split_tensor, split_tokenizer = tokenize(split_corpus)
print('Split Vocab Size:', len(split_tokenizer.index_word))
split_tensor, split_tokenizer = tokenize(filtered_corpus)
print('Split Vocab Size:', len(split_tokenizer.index_word))
for idx, word in enumerate(split_tokenizer.word_index):
  print(idx, ':', word)

  if idx > 10: break
# 밝혔다 → 밝 + 혔다 / 원형이 밝히다 or 밝다 로 다양하게 해석될 수 있다.(중의성)
# 따라서 의미로 토큰화하는 mecab의 형태소 분석 이용해보자<jupyter_output><empty_output><jupyter_text>형태소 토큰화<jupyter_code># 위에서 사용한 코드를 활용해 MeCab 단어 사전을 만들어 보세요.
# Hint: mecab.morphs()를 사용해서 형태소 분석을 합니다.

def mecab_split(sentence):
  ## 코드를 작성하세요
  return mecab.morphs(sentence)

mecab_corpus = []
for kor in filtered_corpus:
  ## 코드를 작성하세요
  mecab_corpus.append(mecab_split(kor))
print(mecab_corpus[0])    # 형태소 단위로 분리하고 있다.
mecab_tensor, mecab_tokenizer = tokenize(mecab_corpus)
print('MeCab Vocab Size:', len(mecab_tokenizer.index_word))
print(mecab_tokenizer.index_word)    # 형태소와 인덱스가 딕셔너리 형태로 짝지어져 있다
# 위의 이러한 과정을 인코딩이라고 부른다.
# 이제 다시 복구하는 디코딩<jupyter_output><empty_output><jupyter_text>Decoding(Detokenizer) 1. tokenizer.sequences_to_texts() 함수를 사용하여 Decoding2. tokenizer.index_word를 사용하여 Decoding    두 가지 방법을 사용하여 mecab_tensor[100]을 원문으로 되돌려 봅시다.  (여기서는 띄어쓰기는 고려하지 않습니다!)<jupyter_code># Case 1: tokenizer.sequences_to_texts()
texts = mecab_tokenizer.sequences_to_texts([mecab_tensor[100]])[0]
print(texts)
# Case 2: tokenizer.index_word()
sentence = ''
for w in mecab_tensor[100]:
  if w == 0: continue
  sentence += mecab_tokenizer.index_word[w] + ' '
print(sentence)<jupyter_output><empty_output>
{'fraction_non_alphanumeric': 0.12263190059075169, 'fraction_numerical': 0.019352210226115298, 'mean_word_length': 4.279569892473118, 'pattern_counts': {'":': 0, '<': 20, '<?xml version=': 0, '>': 25, 'https://': 1, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 2, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
{'chain_length': '4', 'dir': 'jupyter-structured-clean-dedup', 'id': '491341', 'license': 'Apache-2.0', 'n_tokens_mistral': 2493, 'n_tokens_neox': 2726, 'n_words': 474, 'path': '210707_NLP_Encoding+Decoding.ipynb', 'repo_name': 'rhapis97/Practice_AI', 'size': '4909'}