from nltk import ngrams
sentence1 = 'I can always predict the fortune cookies'
# n-gram모듈에 sentence1을 split한 것을 넣고, 2개씩 묶어서 나눈다.
bigram1 = list(ngrams(sentence1.split(), 2))
print(bigram1)

from textblob import TextBlob
ngram_blob = TextBlob(sentence1)
# TextBlob에 있는 ngrams함수를 사용한다.
# n=2로 넣어서 bigram으로 만든다.(default는 trigram으로 설정되어 있다)
ngram_blob.ngrams(n=2)

ngram_blob.ngrams()

import nltk
nltk.download('punkt')
from nltk import word_tokenize

# 먼저 tokenize해준다.
tokenize_result = word_tokenize(sentence1)
tokenize_result

nltk.download('averaged_perceptron_tagger') # tagger를 다운로드한다.

nltk.pos_tag(tokenize_result) # nltk의 pos_tag이라는 함수를 사용하여 태깅해준다.

# tokenize와 pos tagging을 한번에
nltk.pos_tag(word_tokenize(sentence1))

sentence2 = "I play the violin when I'm thinking and sometimes I don't talk for days on end."

stop_words = "on the" # "on 과 the"를 불용어로 취급한다
# 불용어 사전에 등록한 단어들을 공백을 기준으로 나눠 리스트에 담는다
stop_words = stop_words.split(' ') 

sentence2 = sentence2.split(' ') # 문장을 토큰화한다.

except_stop_words = [] # 불용어를 제거한 문장을 담을 리스트를 준비한다.
for word in sentence2: # 토큰화된 문장의 단어들을 하나씩 방문해서
    if word not in stop_words: # 해당 단어가 불용어 사전에 없으면
        except_stop_words.append(word) # 미리 만든 리스트에 넣어라

except_stop_words
# on과 the가 빠진 것을 확인할 수 있다.

import nltk
nltk.download('stopwords')
from nltk import word_tokenize
from nltk.corpus import stopwords

# nltk에서 불러온 stopwords라는 불용어 사전의 words를 가져온다. 언어는 영어.
stop_words1 = stopwords.words('english') 
print(stop_words1)

sentence2 = "I play the violin when I'm thinking and sometimes I don't talk for days on end."
s2_tokenize = word_tokenize(sentence2)
except_stop_words1 = []
for w in s2_tokenize:
    if w not in stop_words1:
        except_stop_words1.append(w)
except_stop_words1
# the, when, and, do, for, on이 불용어로 처리되어 빠졌다.

# !pip install autocorrect
from autocorrect import Speller # Speller 모듈을 불러온다

spell1 = Speller('en') # 영어 철자를 검사할 수 있게 객체를 생성한다.

print(spell1('spelleerr')) # 철자가 틀린 단어를 넣어본다

wrong_sentence1 = 'I caan alwayss predicta the fortunie cookiess'
s1_tokenize = word_tokenize(wrong_sentence1)

 # s1_tokenize 리스트 안에 있는 단어를 하나씩 돌면서 spell1객체에 통과시켜 철자를 확인하고
# 단어 사이에 공백을 넣어 join한다.
check_spell = ' '.join([spell1(s) for s in s1_tokenize])
print(check_spell)
# caan, alwayss, predicta, fortunie, cookiess 다 잘 고쳐졌다

from textblob import TextBlob

sentence1 = 'I can always predict the fortune cookies'
textblob1 = TextBlob(sentence1) # 문장을 토큰화한다.
print(textblob1.words) # 토큰화 결과
print(textblob1.words.singularize()) # 토큰화한 것을 단수화한 결과
# always에서 s를 빼버렸다... 복수로 인식했나보다...
print(textblob1.words.pluralize())
# 그냥 다 s를 붙여버리네

import nltk

# nltk에서 제공하는 어간추출 라이브러리 중 가장 많이 사용된다.
stemmer = nltk.stem.PorterStemmer() 
stemmer.stem('stemming') # 어간을 추출해보자

import nltk
nltk.download('wordnet')
from nltk.stem.wordnet import WordNetLemmatizer

lemmatizer1 = WordNetLemmatizer()

lemmatizer1.lemmatize('holds')

import nltk
from nltk import word_tokenize
nltk.download('maxent_ne_chunker') # max named entity chunker를 다운받는다
nltk.download('words')

sentence1 = 'The name\'s Sherlock Holmes and the address is 221B Baker Street.'

s1_pos_tok = nltk.pos_tag(word_tokenize(sentence1)) # tokenize, pos tagging을 해준다

s1_named = nltk.ne_chunk(s1_pos_tok, binary=True)
print(s1_named)

import nltk
from nltk.wsd import lesk

ambiguous_sentence1 = 'I went to the bank of the river'
ambiguous_sentence2 = 'I went to the bank to deposit some money'

print(lesk(word_tokenize(ambiguous_sentence1), 'bank')) # 이건 잘 파악하지 못했지만
print(lesk(word_tokenize(ambiguous_sentence2), 'bank')) # 얘는 잘 파악했다

# 벡터 개수 세는 라이브러리를 불러온다.
from sklearn.feature_extraction.text import CountVectorizer 

bos_sentence = ['betty bought a bit of better butter to make her bitter butter better']

count_words1 = CountVectorizer() # vector 세어줄 라이브러리를 담은 객체를 생성한다
bow1 = count_words1.fit_transform(bos_sentence) # 문장에 fit_transform해준다


print(bow1.toarray()) # 벡터 센 결과를 리스트 형태로 출력한다.
print(count_words1.vocabulary_) # 결과에서 어떤 단어에 대한 카운트가 어느 인덱스에 있는지 출력한다.

# 불용어는 제거하고 카운트를 셀 수 있다.
count_words2 = CountVectorizer(stop_words='english')
bow2 = count_words2.fit_transform(bos_sentence)

print(bow2.toarray())
print(count_words2.vocabulary_)
# of, to, her이 불용어로 처리되어 제거됐다.

# 보기 편하게 DataFrame으로 바꾸자

import pandas as pd
from pandas import DataFrame

bos_index = count_words2.vocabulary_
bos_result = bow2.toarray()
bos_list = [] # column이 될 것들을 추출해서 넣을 리스트를 만든다.(딕셔너리의 key값.)

# 딕셔너리를 정렬 시키고 key값으로는 for문을 돌며 들어온 원소의 인덱스 1, 
# 즉 딕셔너리의 value값을 key로 보고 그것을 기준으로 정렬한다.
# 이렇게하면 index 순으로 정렬된다.
for k, v in sorted(bos_index.items(), key= lambda i : i[1]):
    bos_list.append(k) # 리스트에 순서대로 담는다

# 데이터프레임을 만든다. data는 baw_result, column은 방금 만든 리스트
bos_df = DataFrame(bos_result, columns= bos_list)

bos_df

kor_bos_sentence = ['내가 어제 호떡을 먹고 싶어서 사 온 건데 나를 빼고 다 먹었더라고']

count_words1 = CountVectorizer()
kor_bow = count_words1.fit_transform(kor_bos_sentence)

print(kor_bow.toarray())
print(count_words1.vocabulary_)
# 한국어는 띄어쓰기를 기준으로 나뉜 벡터를 세면 부정확하다.

from konlpy.tag import Mecab

import re
import MeCab
kor_bos_sentence2 = '내가 어제 호떡을 먹고 싶어서 사 온 건데 나를 빼고 다 먹었더라고.'
kor_tagger = Mecab(dicpath=r"C:\mecab\mecab-ko-dic")
# 온점은 없애고 형태소 분석한 결과를 kor_tokens에 넣는다
kor_tokens = kor_tagger.morphs(re.sub('(\.)', "", kor_bos_sentence2))
print(kor_tokens)

kor_vocab = {} # 토큰화된 단어들을 {토큰:인덱스}형태로 저장할 딕셔너리를 만든다
kor_bow2 = [] # bow결과를 저장할 리스트를 만든다

for tok in kor_tokens: # 토큰화된 것을 하나씩 돌면서
    if tok not in kor_vocab.keys(): # kor_vocab이라는 딕셔너리의 key값에 tok이 없으면
         # 딕셔너리 key값으로 tok을 하나 넣고 그의 value값은 딕셔너리의 길이, 즉 원소 개수
        kor_vocab[tok] = len(kor_vocab)
        # 그리고 리스트 kor_bow에는 '딕셔너리 길이 -1'인덱스 자리에 1을 넣는다
        kor_bow2.insert(len(kor_vocab)-1, 1)
    else: # kor_vocab이라는 딕셔너리의 key값에 tok이 있으면
        index1 = kor_vocab.get(tok) # 딕셔너리에서 key값으로 tok을 가지는 것의 value값을 index1에 넣는다.
        # 리스트에서 가져온 인덱스 값에 해당하는 것에 1을 더한다. 
        kor_bow2[index1] = kor_bow2[index1] + 1
print(kor_bow2)
print(kor_vocab)

import pandas as pd
from pandas import DataFrame

kor_bow2_1 = [kor_bow2]

kor_bow_list = [] # column이 될 것들을 추출해서 넣을 리스트를 만든다.(딕셔너리의 key값.)

# 딕셔너리를 정렬 시키고 key값으로는 for문을 돌며 들어온 원소의 인덱스 1, 
# 즉 딕셔너리의 value값을 key로 보고 그것을 기준으로 정렬한다.
# 이렇게하면 index 순으로 정렬된다.
for k, v in sorted(kor_vocab.items(), key= lambda i : i[1]):
    kor_bow_list.append(k)

kor_dtm_df = DataFrame(kor_bow2_1, columns= kor_bow_list)

#kor_dtm_df = DataFrame(kor_bow2, index= kor_bow_list)

kor_dtm_df

from sklearn.feature_extraction.text import CountVectorizer 

doc1 = ["Crime is common.", " Logic is rare.", "Therefore it is upon the logic rather than upon the crime that you should dwell."]

count_words1 = CountVectorizer()
doc_bow = count_words1.fit_transform(doc1)

print(doc_bow.toarray()) # 각 행은 문서 하나, 열은 해당 문서의 단어를 나타낸다.
print(count_words1.vocabulary_) # 인덱스

# 보기 편하게 DataFrame으로 바꾸자

import pandas as pd
from pandas import DataFrame

index2 = count_words1.vocabulary_
bow_result = doc_bow.toarray()
dtm_list = [] # column이 될 것들을 추출해서 넣을 리스트를 만든다.(딕셔너리의 key값.)

# 딕셔너리를 정렬 시키고 key값으로는 for문을 돌며 들어온 원소의 인덱스 1, 
# 즉 딕셔너리의 value값을 key로 보고 그것을 기준으로 정렬한다.
# 이렇게하면 index 순으로 정렬된다.
for k, v in sorted(index2.items(), key= lambda i : i[1]):
    dtm_list.append(k) # 리스트에 순서대로 담는다

# 데이터프레임을 만든다. data는 baw_result, column은 방금 만든 리스트
dtm_df = DataFrame(bow_result, columns= dtm_list)

dtm_df

from sklearn.feature_extraction.text import TfidfVectorizer

tfidf1 = TfidfVectorizer().fit(doc1) # doc1에 대해 tf-idf를 fit시킨다.

print(tfidf1.transform(doc1).toarray())
print(tfidf1.vocabulary_)

import pandas as pd 

tfidf_index = tfidf1.vocabulary_
tfidf_result = tfidf1.transform(doc1).toarray()
tfidf_list = [] # column이 될 것들을 추출해서 넣을 리스트를 만든다.(딕셔너리의 key값.)

# 딕셔너리를 정렬 시키고 key값으로는 for문을 돌며 들어온 원소의 인덱스 1, 
# 즉 딕셔너리의 value값을 key로 보고 그것을 기준으로 정렬한다.
# 이렇게하면 index 순으로 정렬된다.
for k, v in sorted(tfidf_index.items(), key= lambda i : i[1]):
    tfidf_list.append(k) # 리스트에 순서대로 담는다

# 데이터프레임을 만든다. data는 baw_result, column은 방금 만든 리스트
tfidf_df = DataFrame(tfidf_result, columns= tfidf_list)

tfidf_df