336x280(권장), 300x250(권장), 250x250, 200x200 크기의 광고 코드만 넣을 수 있습니다.

다섯 번째 프로젝트

 

1. 추천 시스템에 대한 생각

2. 추천시스템(TFIDF, Word2Vec)

3. GUI로 앱처럼 사용할 수 있게 (PyQt5)

 


드디어 마무리 단계에 왔다 ㅠㅠㅠ 티스토리 블로그 글을 작성하면서 파이널 프로젝트를 하는데 아직도 모르는게 태산이다. 파이널 프로젝트는 자연어(NLP)로 진행중인데, 왜 국문학과를 찾는지 알것 같다.

 

이번 프로젝트를 할 때, 후기 개수 자체가 부족하고, 과마다 특성 있는 키워드가 영화 리뷰처럼 다양하지 않아서(ex. OOO 원장님 너무 친절하고 좋아요. 아프지 않게 잘해주시고 병원이 깔끔해요. 등등) 힘들 것이라 예상을 했다. 결과는 예상대로 워드클라우드로 돌렸을 때 불용어처리할 것이 엄청 많았다. 그래서 추가적으로 팀원들이 후기를 one sentence로 만들 때 진료과목도 집어넣기는 했는데, 이게 얼마나 효과가 있을지는 잘 모르겠다.

 

이번에는 Django 대신에 PyQt5를 이용해서 GUI 앱을 만들었다. 저번에 해보자고 했는데 드디어.. 완성!

 

 

 

 

 

위키독스

온라인 책을 제작 공유하는 플랫폼 서비스

wikidocs.net

 

위키독스

온라인 책을 제작 공유하는 플랫폼 서비스

wikidocs.net

PyQt5 내용은 위키독스를 통해서 잘 배울 수 있다. 모르는 기능들을 하나하나 찾아서 구현이 됐다. 물론 심각한 노가다가 필요한 작업이라고 생각한다. Django, 안드로이드스튜디오 많은 시간이 필요하다.

 

 

 

 

우선 제일 첫번째 안 (다른 팀원)

- 검색기능 / 진료과목 카테고리 / 지역을 클릭하면 => 추천 병원과 병원 정보가 나오게 하는 것이다. 

 

 

 

 

두번째 안 (나)

- 검색기능 / 진료과목을 라디오버튼으로 클릭 => 추천 병원과 나에게 맞는 병원 리스트 담기 병원 정보 나오게 하기 

 

 

 

세번째 안 (절충안)

- 병원을 모를 수도 있기 때문에, 우선 진료과목과 지역을 먼저 선택하게 했다. 그후에 나오는 병원과 유사한 병원을 추가로 검색하고 싶으면 검색하게 만들었다. 그리고 홈페이지의 경우 url을 직접 복사붙여넣기 하는 것보다 바로가기로 만드는 것이 좋다고 생각하여 따로 뺐다.

 

 

 

 

우선 터미널에서 designer를 입력하여 Qt Designer를 실행시켜 ui를 만든다. 안드로이드스튜디오처럼 자신이 원하는 버튼이나 위젯을 끌어다 쓰고, 클래스 옆에 파이참에서 호출하기 쉬운 objectName을 지정해준다. 

 

우리가 구현했던 기능은 자동완성기능, 필터링 기능(지역 진료과목), url클릭시 바로 웹으로 넘어가기, 리스트내 요소를 클릭하여 정보 받아오는 기능, 추천기능, 리셋기능,  등이다. 간단해 보여도 간단하지 않고 시간이 꽤 걸렸다.

 

 

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
import sys
from PyQt5.QtWidgets import *
from PyQt5.QtCore import QStringListModel
from PyQt5 import uic
import pandas as pd
from sklearn.metrics.pairwise import linear_kernel
from gensim.models import Word2Vec
from scipy.io import mmwrite, mmread
import pickle
import webbrowser
 
form_window = uic.loadUiType('plz_Yes_button_edit_3.ui')[0]
 
class Exam(QWidget, form_window):
    def __init__(self):
        super().__init__()
        self.setupUi(self)
 
###########################################
 
if __name__ == "__main__":
    app = QApplication(sys.argv)
    w = Exam()
    w.show()
    sys.exit(app.exec_())
 
cs

가장 기본적인 구성 - 본인이 만든 ui를 불러오는 코드부터 GUI를 실행시키는 코드까지

 

 

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
        #데이터 불러오기
        self.df_review = pd.read_csv('./datasets/model_data_Hospital_and_info2.csv',index_col=0)
        self.df_review.info()
        self.Tfidf_matrix = mmread('./models/tfidf_hospital_review_l.mtx').tocsr()
        self.embedding_model = Word2Vec.load('./models/word2VecModel_hospital_l2.model')
        with open('./models/tfidf_l.pickle''rb'as f:
            self.Tfidf = pickle.load(f)
 
        # 카테고리 목록 리스트화
        self.cmb_title_2.addItem('과를 선택하세요')
        category = list(self.df_review.category.unique()) #카테고리 중복 없이
        category = sorted(category)
 
        for c in category :
            self.cmb_title_2.addItem(c)
 
        # 지역 목록 리스트화
        self.cmb_title.addItem('지역을 선택하세요')
        add_list = []
        for i in self.df_review.addresses:
            a = i.split(' ')[0#지역이름만
            add_list.append(a)
 
        add_set = set(add_list) #중복 제거 위해 set
        address = list(add_set) #다시 list
        address = sorted(address)
        address.pop(0#지역 아닌 다른 단어가 있어서 pop
 
 
        for add in address:
            self.cmb_title.addItem(add) #지역 목록
 
        # 병원 목록과 진료과목 리스트로 만들기
        total = ''
        for c in self.df_review.clinics:
            total += c
 
        totals = total.split(', ')
        total_set = set(totals)
        total = list(total_set)  #진료 과목
        total = sorted(total)
 
        titles = list(self.df_review.names) # 병원 이름
        titles = sorted(titles) # 따로 정렬하는 이유는 병원 이름이 먼저 나오게 하기 위해서
 
        key_title = titles + total      #병원 + 진료 과목
 
cs

데이터, Tfidf, Word2Vec 모델을 불러오고 카테고리 리스트, 지역 목록 리스트, 병원 이름과 진료과목을 리스트로 만들었다. 공간을 크게 차지하지 않고 옵션을 선택할 수 있는 QComboBox에 리스트를 추가했다. 카테고리와 병원 목록은 쉽게 만들 수 있었으나, 지역의 경우 통일이 되지 않아서 따로 전처리를 하였다.

 

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#주소 통일
add_dic = {'강원도' : '강원','경기도':'경기','경상남도':'경남','경상북도':'경북','광주광역시':'광주','대구광역시':'대구','대전광역시''대전',
           '부산광역시''부산''서울시' :'서울','서울특별시':'서울','서초구':'서울시 서초구','수원시':'경기','인천광역시':'인천','전라북도':'전북','제주특별자치도':'제주','충청북도':'충북'}
add_list = list(add_dic)
 
list = []
for i in df_review.addresses :
    a = i.split(' ')
    if a[0in add_list :
        a[0= add_dic[a[0]]
    #print(a)
    a = ' '.join(a)
    list.append(a)
df_review.addresses = list
print(df_review.addresses.head(100))
df_review.to_csv('./model_data_Hospital_and_info2.csv')
cs

지역의 경우 17개 시도별로 나누려고 split으로 주소를 나눠 가장 첫번째 글자를 가져왔다. 그렇기 때문에 서울시, 서울, 서울특별시처럼 같은 지역인데 이름이 다를 경우 통일하였다. 다행히 크게 수작업을 해도 되지 않아서 안도의 한숨이...

 

 

 

1
2
3
4
5
        #자동완성
        model = QStringListModel()
        model.setStringList(list(key_title))
        completer = QCompleter()
        completer.setModel(model)
cs

자동완성 기능 생각보다 어렵지 않았다. from PyQt5.QtCore import QStringListModel 불러오고 QCompleter로 자동완성을 시켜주고 이걸 QLineEdit으로 받아줬다.

 

 

 

1
2
3
4
5
6
7
8
9
        # 버튼 함수
        self.le_title.setCompleter(completer)
        self.le_title.returnPressed.connect(self.btn_recommend_slot)
        self.btn_recommend.clicked.connect(self.btn_recommend_slot) # 엔터 또는 버튼 클릭시
        self.cmb_title_2.currentIndexChanged.connect(self.cmb_title_slot_2)
        self.cmb_title.currentIndexChanged.connect(self.cmb_title_slot)
        self.listWidget.itemClicked.connect(self.hospital_info)
        self.btn_html.clicked.connect(self.open_web)
        self.btn_recommend_5.clicked.connect(self.btn_clicked)
cs

버튼을 클릭하거나, 엔터를 누르거나, index가 변할 때 어떤 식으로 작동할지를 구현하는 준비단계?

 

 

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
    # 병원 지역별로 필터링
    def cmb_title_slot(self):
        print('지역 선택 클릭')
        self.le_title.clear() # 먼저 병원을 클릭 했을 때
        title = self.cmb_title_2.currentText()
        address = self.cmb_title.currentText()
 
        region = self.df_review[(self.df_review.category == title) &(self.df_review.region == address)].iloc[:101# 자체 추천 순위로 출력
        recommend = list(region)
        #print(recommend)
 
        self.listWidget.clear()
        self.listWidget.insertItems(0, recommend)
 
 
    # 카테고리 탑10 병원
    def cmb_title_slot_2(self):
        print('과 선택 클릭')
        title = self.cmb_title_2.currentText()
 
        top = self.df_review[self.df_review.category == title].iloc[:10,1]
        #recommend = '\n'.join(list(top)) # 이거는 lbl_result에
        recommend = list(top)
 
        self.listWidget.clear()
        self.listWidget.insertItems(0, recommend)
cs

지역 필터링, 병원 필터링 currentIndexChanged, index가 바뀌면 함수가 실행이 된다. 원래 cmb_title_slot1과 2를 바꿔야 하는데 처음에 설정을 그렇게 해서 지나갔다. 

 

현재 QComboBox에서 선택한 텍스트를 가져와야 필터링이 되기 때문에, currentText로 현재 텍스트를 가져왔다.  그리고 선택한  진료과목과 일치하는 탑10 병원을 listWidget에 출력하였다. QLineEdit으로 해도 되지만 나중에 병원 정보를 클릭해야 하기 때문에 안 된다. 그리고 list로 받아와서 0 번째 부터 다시 보여주는 코드를 실행했다. 마찬가지로 지역 설정을 바꿨을 경우, 우선 진료과목과 지역을 동시에 만족하는 병원을 추천하였다.

 

 

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
    # 병원을 클릭 했을 때, 병원 정보 보여주기
    def hospital_info(self):
        print('병원 정보 클릭')
        title = self.listWidget.currentItem().text()
 
        try :
            a = self.df_review[self.df_review.names == title].iloc[03].split(',')[:10# 주요 진료 과목 10개만
            a = ','.join(a)
            b = self.df_review[self.df_review.names == title].iloc[04# 주소
            c = self.df_review[self.df_review.names == title].iloc[06# 전화번호
            #d = self.df_review[self.df_review.names == title].iloc[0, 5] # 홈페이지 url / 홈페이지 오픈 버튼으로 대체
            recommend = '[ 주요 진료 과목 ]\n{0}\n\n[ 주소 ]\n{1}\n\n[ 전화번호 ]\n{2}'.format(a, b, c)
            self.infotext.setText(recommend)
            recommend = '홈페이지 바로가기 클릭!'
            self.btn_html.setText(recommend)
        except :
            pass
 
cs

어떻게 listWidget에 있는 아이템을 가져오나 했더니, 텍스트를 가져오는 것과 비슷하게 currentItem()으로 텍스트를 불러올 수 있었다.  크롤링을 할 때 조금 멍청하게 가져와서 전처리 과정을 한 번 더 거쳤다. 진료과목을 리스트 안에 집어넣었는데 이것을 그대로 csv에 집어넣어서 '[' 리스트가 문자가 됐다. 

 

a는 진료과목, b는 주소,  c는 전화번호, d는 홈페이지 url을 보여주려고 했으나 사용자가 따로 긁어야하는 불편함이 있어서 바로 홈페이지 오픈을 시켜주기로 했다. 

 

 

 

 

1
2
3
4
5
6
    # 홈페이지 오픈
    def open_web(self):
        print('홈페이지 바로가기 클릭')
        title = self.listWidget.currentItem().text()
        html = self.df_review[self.df_review.names == title].iloc[05]
        webbrowser.open(html) # 홈페이지 연동
cs

검색을 해보니 엄청 복잡하게 url을 오픈 하는 경우가 있는데, import webbroser를 하고 html을 open 하면 바로 url로 넘어가진다코딩을 하다보면 어떻게 하면 더 코드를 간단하게 짤까 고민을 하면서, 다른 사람이 짜놓은 코드와 비교를 하다보면 가끔 감탄을 할 때가 온다. 나도 누가 코드를 보고 감탄했으면 좋겠다는 마음이.. 

 

 

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
    def btn_recommend_slot(self):
        print('추천 시스템 클릭')
        title = self.le_title.text()
 
        try:
            if title in list(self.df_review['names']):
                h_idx = self.df_review[
                    self.df_review['names']==title].index[0]
                cosine_sim = linear_kernel(
                    self.Tfidf_matrix[h_idx],
                    self.Tfidf_matrix)
                # recommend = '\n'.join(
                #     list(self.getRecommendation(cosine_sim))[1:])
                recommend = list(self.getRecommendation2(cosine_sim))[:-1]
 
            #elif title in total :
 
 
            else:
                print(title, '예외 키워드')
                sentence = [title] * 10
 
                sim_word = self.embedding_model.wv.most_similar(title, topn=10)
                labels = []
                for label, _ in sim_word:
                    labels.append(label)
                print(labels)
 
                for i, word in enumerate(labels):
                    sentence += [word] * (9 - i)
 
                sentence = ' '.join(sentence)
                sentence_vec = self.Tfidf.transform([sentence])
                cosine_sim = linear_kernel(sentence_vec,
                                           self.Tfidf_matrix)
                # recommend = '\n'.join(
                #     list(self.getRecommendation(cosine_sim))[:-1])
 
                recommend = list(self.getRecommendation2(cosine_sim))[:-1]
        except:
            if title :
                recommend =['검색어를 다시 확인해주세요']
                self.infotext.clear()
 
                default_text = '[ 주요 진료 과목 ]\n\n[ 주소 ]\n\n[ 전화번호 ]'
                self.infotext.setText(default_text)
 
            else:
                pass
        self.listWidget.clear()
        self.listWidget.insertItems(0, recommend)
cs

병원명을 정확히 입력했을 때와 진료과목 또는 다른 키워드를 입력했을 때, 그리고 검색어를 입력하지 않았을 때를 나눠서 진행했다. 

 

 

 

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
    #키워드 기반 추천 시스템
    def getRecommendation2(self, cosine_sim):
        title = self.cmb_title_2.currentText()
        address = self.cmb_title.currentText()
        print(title, address)
        simScores = list(enumerate(cosine_sim[-1]))
        simScores = sorted(simScores, key=lambda x: x[1], reverse=True)
 
        if title == '과를 선택하세요' and address =='지역을 선택하세요':
            pass
        else :
            simlist = []
            for i in simScores :
                add = self.df_review.iloc[i[0],7# 지역
                tit = self.df_review.iloc[i[0],0# 카테고리
 
                if add == address and tit == title : # 지역, 카테고리 동시에 일치할 때만 추가
                    #print(add)
                    simlist.append(i)
 
            h_idx = [i[0for i in simlist[0:10]]
 
            if len(h_idx) == 0:
                RecHosptiallist = [f'{address} 지역에는 관련된 키워드가 없습니다.']
                return RecHosptiallist.names
            else :
                RecHosptiallist = self.df_review.iloc[h_idx]
                print(RecHosptiallist, '출력')
                return RecHosptiallist.names
 
        simScores = simScores[0:11]
        h_idx = [i[0for i in simScores]
        RecHosptiallist = self.df_review.iloc[h_idx]
        return RecHosptiallist.names
cs

검색을 했을 경우 유사한 병원을 추천하긴 하는데, 전혀 다른 진료과목이나 지역이 나오면 안 되기 때문에 여기서도 필터링 기능을 사용하였다. 모델의 아쉬운 점은 지방으로 갈 수록 후기도 많지 않고, 대부분 큰 병원들은 수도권에 몰려서 지방으로 갈수록 추천해줄만한 병원이 많지 않았다. 

 

 

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
    #리셋 기능
    def btn_clicked(self):
        print('리셋 버튼 클릭')
        self.cmb_title_2.clear()
        self.cmb_title.clear()
        self.le_title.clear()
        self.infotext.clear()
 
        #병원 정보 처음에 나오는 내용
        default_text = '[ 주요 진료 과목 ]\n\n[ 주소 ]\n\n[ 전화번호 ]'
        self.infotext.setText(default_text)
 
        category = list(self.df_review.category.unique())
        category = sorted(category)
        self.cmb_title_2.addItem('과를 선택하세요')
        self.cmb_title.addItem('지역을 선택하세요')
 
        add_list = []
        for i in self.df_review.addresses:
            a = i.split(' ')[0]
            add_list.append(a)
 
        add_set = set(add_list)
        address = list(add_set)
        address = sorted(address)
        address.pop(0)
 
        for add in address:
            self.cmb_title.addItem(add)  # 지역 목록
 
        for c in category:
            self.cmb_title_2.addItem(c)  # 카테고리 목록
cs

리셋버튼을 누르면 모든 것이 리셋이 되게 하려고 했다. 찾아보니 그런 코드가 있긴 있는데, 지금 GUI의 경우 지역 목록과 카테고리 목록은 남아야 해서 리셋을 누르는 동시에 다시 지역목록과 카테고리 목록이 뜨게 했다. 여기서 특히 오류가 많이 났는데, 어디서 호출을 해주느냐에 따라서 이게 중복 노출이 되는지, 부분 노출이 되는지 갈렸다.

 

아무튼 GUI 완성 ㅠㅠ

 

336x280(권장), 300x250(권장), 250x250, 200x200 크기의 광고 코드만 넣을 수 있습니다.

다섯 번째 프로젝트

 

1. 추천 시스템에 대한 생각

2. 추천시스템(TFIDF, Word2Vec)

3. GUI로 앱처럼 사용할 수 있게 (PyQt5)


항상 과정이 비슷해서 앞에 부분은 코드는 생략합니다.

 

우선 로그인이 필요한 서비스라서 동적 크롤링으로 후기를 긁어왔다. 그리고 추가로 병원 이름, 클리닉명, 주소, 링크, 전화번호는 로그인 없이도 크롤링이 가능해서 BS4로 긁어왔다. 과정은 크롤링한 데이터를 전처리하고, 워드클라우드를 생성해서 불용어를 처리하고(중요), 하나의 문장으로 합쳤다.  

 

 

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
import pandas as pd
from sklearn.feature_extraction.text import TfidfVectorizer
from scipy.io import mmwrite, mmread #매트릭스 저장할 때 mmwrite, 읽을 땐 mmread
import pickle #변수 타입 그대로 저장
 
df_review_one_sentence = pd.read_csv('./preprocess/total_hospital_review_one_sentence.csv', index_col=0)
print(df_review_one_sentence.info())
 
Tfidf = TfidfVectorizer(sublinear_tf=True)      # sublinear_tf는 값의 스무딩 여부를 결정하는 파라미터
Tfidf_matrix = Tfidf.fit_transform(df_review_one_sentence['reviews'])       # fit_transform 된 Tfidf를 갖고 있으면 추후 데이터 추가 가능하므로 따로 저장
 
with open('./models/tfidf.pickle''wb'as f:
    pickle.dump(Tfidf, f)       # Tfidf 저장
 
mmwrite('./models/tfidf_hospital_review.mtx', Tfidf_matrix)        # 유사도 점수 매트릭스 저장
cs

TfidfVectorizer로 문서 내에서 단어 토큰을 생성하고, 각 단어의 수와 가중치를 조정하여 문자를 순서 벡터로 변환했다. 이 과정은 따로 건드리는 부분이 없다. 다만 데이터 전처리가 중요하다.

 

 

 

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
import pandas as pd
from sklearn.metrics.pairwise import linear_kernel
from scipy.io import mmwrite, mmread
import pickle
from gensim.models import Word2Vec
 
df_hospital_review_one_sentence = pd.read_csv('./preprocess/total_hospital_review_one_sentence.csv', index_col=0)       # 리뷰 읽어 df 생성
 
Tfidf_matrix = mmread('./models/tfidf_hospital_review.mtx').tocsr()        # matrix 불러오기
with open('./models/tfidf.pickle''rb'as f:      # tfidf 불러오기
    Tfidf = pickle.load(f)
 
def getRecommendation(cosine_sim):      # 코사인 유사도롤 활용하여 유사한 병원 추천하는 함수
    simScore = list(enumerate(cosine_sim[-1]))      # 각 코사인 유사도 값에 인덱스 붙임
    simScore = sorted(simScore, key=lambda x:x[1], reverse=True)        # simScore(코사인 유사도, x[1])가 큰 것부터 정렬. reverse=True 내림차순 정렬.
    simScore = simScore[1:11]       # 유사한 병원 10개 리스트. 0번 값은 자기 자신이므로 배제.
    hospital_idx = [i[0for i in simScore]     # 인덱스(i[0]) 뽑아서 리스트 생성
   recHospitalList = df_hospital_review_one_sentence.iloc[hospital_idx]        # df에서 해당 병원 리스트 추출
    return recHospitalList
 
 
#병원명 검색
hospital_idx = df_hospital_review_one_sentence[df_hospital_review_one_sentence['names']=='김이비인후과의원'].index[0]      # 병원 이름으로 인덱스 값 찾기
# hospital_idx = 127
# print(df_review_one_sentence.iloc[hospital, 0])
 
cosine_sim = linear_kernel(Tfidf_matrix[hospital_idx], Tfidf_matrix)      # linear_kernel은 각 Tfidf 값을 다차원 공간에 벡터(방향과 거리를 가짐)로 배치한 뒤, 코사인 유사도를 구해줌. cosine = 삼각형의 밑변 / 윗변
                                                                       # 비슷한 영화는 유사한 위치에 배치됨. 유사할수록 각이 줄어드므로 코사인 값이 1에 가까워짐. -1에 가까울수록 반대, 0에 가까울수록 무관
recommendation = getRecommendation(cosine_sim)
# print(recommendation)
print(recommendation.iloc[:, 1])
cs

pickle에 저장한 Tfidf를 불러와서 코사인 유사도를 활용하여 유사한 병원을 추천해준다. 우선 병원의 idx 값을 구한다. 그리고 추천시스템에 이와 유사한 병원들의 리스트를 반환 받아서 출력한다.

 

 

 

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
import pandas as pd
from gensim.models import Word2Vec
 
review_word = pd.read_csv('./preprocess/total_cleaned_review.csv', index_col=0)
print(review_word.info())
cleaned_token_review = list(review_word['cleaned_sentences'])
print(len(cleaned_token_review))
cleaned_tokens = []
count = 0
for sentence in cleaned_token_review:
    token = sentence.split(' ')     # 띄어쓰기 기준으로 각 단어 토큰화
    cleaned_tokens.append(token)
# print(len(cleaned_tokens))
# print(cleaned_token_review[0])
# print(cleaned_tokens[0])
embedding_model = Word2Vec(cleaned_tokens, vector_size=100, window=4,
                           min_count=20, workers=4, epochs=100, sg=1)   # vector_size는 몇차원으로 줄일지 지정, window는 CNN의 kernel_size 개념, 앞뒤로 고려하는 단어의 개수를 나타냄
                                                                        # min_count는 출현 빈도가 20번 이상인 경우만 word track에 추가하라는 의미(즉, 자주 안 나오는 단어는 제외)
                                                                        # workers는 cpu 스레드 몇개 써서 작업할 건지 지정, sg는 어떤 알고리즘 쓸건지 지정
embedding_model.save('./models/word2VecModel_hospital.model')
print(embedding_model.wv.vocab.keys())
print(len(embedding_model.wv.vocab.keys()))
cs

Word2Vec 단어의 의미를 다차원에 분산시켜 표현하여, 단어간 위치를 파악해서 유사도를 분석해준다. Skip-Gram의 경우 중심 단어를 보고 주변에 어떤 단어가 있을지 예측. CBoW는 주변에 있는 단어들로 중간에 있는 단어를 예측한다.

 

 

 

 

 

 

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#리뷰 기반 키워드 검색
embedding_model = Word2Vec.load('./models/word2VecModel_hospital.model')
key_word = '친절'
 
sim_word = embedding_model.wv.most_similar(key_word, topn=10)
labels = []
sentence = []
for label, _ in sim_word:
    labels.append(label)
print(labels)
for i, word in enumerate(labels):
    sentence += [word] * (9-i)
sentence = ' '.join(sentence)
#sentence = [key_word] * 10      # tf에서 높은 값을 가지도록 리스트 복사
print(sentence)
 
sentence_vec = Tfidf.transform([sentence])
cosine_sim = linear_kernel(sentence_vec, Tfidf_matrix)
recommendation = getRecommendation(cosine_sim)
print(recommendation)
cs

키워드를 기반으로 하여 병원을 추천해주는 시스템이다.

 

 

336x280(권장), 300x250(권장), 250x250, 200x200 크기의 광고 코드만 넣을 수 있습니다.

다섯 번째 프로젝트

 

1. 추천 시스템에 대한 생각

2. 추천시스템(TFIDF, Word2Vec)

3. GUI로 앱처럼 사용할 수 있게 (PyQt5)

 


기간 : 2021.07.02 ~ 2021.07.09

 

언어 : Python

패키지 : Scikit-learn, GENSIM(Word2Vec, TF-IDF), Selenium, Pandas, Maplotlib, WordCloud

툴 : PyCharm, Jupyter Notebook

 

 

 

영화 리뷰 기반으로 추천시스템을 같이 진행을 했다. 새로운 프로젝트를 하려고 했으나 생각보다 자료 모으기가 쉽지 않았다. 원래는 보드게임 후기를 모으려고 했으나 데이터가 너무 정제되지 않았다. 인터파크나 티켓팅하는 사이트에서 뮤지컬 후기를 긁어오려고 했으나  도배도 많았고, 알바들이 너무 많아서 포기했다. 네이버 검색을 하려고 했으나 뮤지컬의 경우 책 제목이 중간중간 있어서 일일이 또 처리를 해야 해서 병원 후기를 기반으로 한 병원 추천시스템을 진행하기로 했다.

 

데이터 크롤링 -> 데이터 전처리 -> 추천 시스템 -> GUI 순으로 프로젝트가 진행 됐으나 앞에 부분은 계속 반복되는 것 같아서 이번에 추천시스템에 대한 생각을 정리해보고자 한다.

 

 

 

출처 : 공부합시다 티스토리

협업 필터링

- 취향이 비슷한 사람끼리 그룹화해서 추천하는 방식이다. (예를 들어서 20~30대 남성, 서울 중구 지역에 사는 사람들)

- 단점은 처음 사용하는 이용자거나 새로 나온 상품을 추천하기 어렵다.

 

콘텐츠 기반 필터링

- 이용자가 소비한 콘텐츠를 기준으로 유사한 특성을 가진 콘텐츠를 추천한다.

- 단점은 다양성이 떨어진다. (이전에 진중권 교수가 얘기했던 확증편향 문제가 생긴다.)

 

 

 

분명 콘텐츠는 많은 것 같은데 또 막상 뒤적거려보면 볼게 없는 넷플릭스. 예전에 넷플릭스 추천시스템을 검색해봤을 때 수천개의 데이터를 가지고 카테고리를 나누고 각각 가중치를 곱해서 복잡하게 만들어졌다고 하는데 잘 모르겠다...

 

우선 플랫폼은 유저가 더욱 오래 사용해야 돈을 버는 구조인데, 이런 식으로 갑자기 볼 콘텐츠가 사라지면 이탈률이 커져서 플랫폼 자체적으로 손해다. 그래서 이들을 붙잡으려고 콘텐츠를 추천한다. 하지만 너무 유사한 콘텐츠를 추천하게 되면 확증편향 문제는 물론, 사람들이 질리게 되는 단점이 있는 것 같다.

 

 

 

 

유튜브의 알 수 없는 알고리즘. 내가 평상시에 보고 있던 콘텐츠도 아니고, 관심을 가지고 있던 콘텐츠도 아닌데 왜 갑자기 뜨는 것일까? 심지어 오늘 어제 영상도 아닌 몇 개월, 몇 년 전 영상이 추천이 된다?

 

나도 마케팅을 하려고 하는 사람이다 보니, 유튜브 알고리즘을 이해하려고 많은 분석과 시도를 해봤다. 조회수 100만, 200만, 300만 넘는 영상을 여러 개 보유하고 있어서 탐색기능에 대해서는 어느정도 이해를 했다. 하지만 아직도 나를 한 번도 보지 않았던 영상으로 이끄는 알고리즘에 대해서는 분석이 조금 필요하다.

 

우선 구글과 유튜브는 어느정도 연동(?)이 되어있어서, 구글에서 트래픽이 증가하면 유튜브에서도 어느정도 추천되는 모양이다. 예전에 빅맥송 오디션이 있었는데, 구글에서 검색량이 많아지자 유튜브에서도 이전 영상들이 다시 노출되는 현상이 있었다.

 

 

 

 

 

유튜브 알고리즘을 따라가려면 이용자의 개인 데이터, 노출 클릭률, 영상시청지속시간, 다음 화면의 클릭 유무 등 엄청나게 다양한 데이터가 필요하겠지만 이는 불가능하기 때문에, 간이 추천시스템을 만드려고 생각을 했다.

 

우선 우리가 했던 프로젝트는, 후기를 기반으로 TF-IDF로 각 단어의 가중치를 줘서 얼마나 자주 나오는지를 비교하여 코사인 유사도를 활용하여 영화를 추천했다. 그렇다면 코사인 유사도를 구하는 식에서 reverse = False를 할 경우에 정 반대의 영화를 추천하겠다는 생각이 들었다.

 

정반대의 영화의 경우 사용자가 관심이 없던 영화일 수도 있고, 아니면 한 번도 보지 않았던 장르의 영화일 수도 있다. 총 9개의 영화를 보여줄 때 6개는 관련성 있고, 2개는 중간 정도, 1개는 전혀 관련 없는 영화를 보여주면서 노출클릭률을 살펴본다. log.txt 파일에 데이터를 담아서 관련성 있는 영화를 클릭했을 때는 영향을 주지 않고, 총 9개의 영화를 다시 새로고침했을 때에만 점차 관련 없는 영화가 나오는 값을 줄여나간다. (-1 ~1 사이면 , -0.9 -0.8 -0.7 이런 식으로...)

 

랜덤으로 계속 영화가 나오기 때문에 이것도 정확하지는 않지만, 어떻게 하면 편향성을 줄이면서 플랫폼에 이용자를 더 오래 잡게 할 수 있을지에 대해서 계속 고민해야 할 것 같다.

 

 

 

336x280(권장), 300x250(권장), 250x250, 200x200 크기의 광고 코드만 넣을 수 있습니다.

네 번째 프로젝트

 

1. 간단한 intro

2. 웹 크롤링 및 전처리

3. 모델 학습 및 평가


프로젝트를 하면서 느낀 보완사항은 :

-데이터의 길이가 너무 짧으면 단어를 추출하는데 한계가 있고, 과적합이 발생한다.

-유의미한 단어가 존재해야 정확도가 더 개선된다. 모델을 계속 만져봐도 정확도는 크게 개선되지 않는다.

-각 사이트마다 카테고리 분류가 다르게 되어있어서 소비자가 불편할 수도 있을 것이다.

 

 

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
# 모듈 임포트
import pandas as pd
import numpy as np
from tensorflow.keras.utils import to_categorical
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import LabelEncoder
from tensorflow.keras.preprocessing.text import *
from tensorflow.keras.preprocessing.sequence import pad_sequences
import pickle # pickle을 이용하면 int 값을 그대로 저장하고 그대로 불러옴
from konlpy.tag import Okt # 형태소 분리기 임포트
 
pd.set_option('display.unicode.east_asian_width',True)
 
df = pd.read_csv('/content/10x10(kor2).csv', index_col=0)
 
print(df.head())
print(df.info())
 
# 중복 행 확인
col_dup = df['title'].duplicated()
print(col_dup)
 
sum_dup = df.title.duplicated().sum()
print(sum_dup)
 
 
# title 컬럼 기준으로 중복 제거 (row 통째로 제거)
df = df.drop_duplicates(subset=['title'])
 
sum_dup = df.title.duplicated().sum()
print(sum_dup)
 
 
# 인덱스 새로 고침
df.reset_index(drop=True# False로 줄 시 기존 인덱스를 colum으로 올림
               inplace=True)
 
print(df.head())
print(df.tail())
cs

이 과정만 잘 따라와도 누구나 쉽게 카테고리 분류가 가능하다.

 

 

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
# 데이터 나누기
= df['title']
= df['category']
 
 
# 원핫인코딩 위해 라벨로 변경
encoder = LabelEncoder()
labeled_Y = encoder.fit_transform(Y)
label = encoder.classes_
 
# 지정한 라벨 저장
# 이미 학습한 라벨들을 이용해야 학습된 결과들과 똑같이 도출
with open('/content/10x10_category_encoder.pickle''wb'as f:
    pickle.dump(encoder, f)   
 
# 원핫인코딩 => 정답데이터 원핫인코딩(희소벡터처리)
onehot_Y = to_categorical(labeled_Y)
 
# 첫번째 데이터 형태소로 분리
okt = Okt()
okt_X = okt.morphs(X[0])
 
 
# 모든 row를 형태소로 분리
for i in range(len(X)):
    X[i] = okt.morphs(X[i])
cs

추후에 데이터들을 불러서 모델 성능이 얼마나 좋은지 평가를 하기 위해서 라벨들을 통일시켜야 한다.

 

 

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
# stopwords 불러오기
stopwords = pd.read_csv('/content/stopwords2.csv')
 
# stopwords에 있는 단어를 제거하고 리스트에 담기
words = [] # 빈 리스트 생성
 
for word in okt_X:
    if word not in list(stopwords['stopword']):
        words.append(word)
 
#한 행씩 모든 데이터 처리
for i in range(len(X)): # X=df['title']
    result = []
    for j in range(len(X[i])):
        if len(X[i][j]) > 1:
            if X[i][j] not in list(stopwords['stopword']):
                result.append(X[i][j])
    X[i] = ' '.join(result)
cs

불용어 제거 단계

 

 

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
#단어를 컴퓨터에서 인식시키기 위해 각 단어마다 숫자(라벨링) 부여 => 토큰화
# 수치적인 의미는 없음
token = Tokenizer()
token.fit_on_texts(X)
tokened_X = token.texts_to_sequences(X)
print(tokened_X[0])
 
#읽고 쓰는 과정에서 데이터의 자료형을 따로 인코딩할 필요 없이 그대로 저장
import pickle
 
with open('/content/10x10_token3.pickle''wb'as f:
    pickle.dump(token, f)
 
wordsize = len(token.word_index) + 1
 
max = 0
for i in range(len(tokened_X)):
    if max < len(tokened_X[i]):
        max = len(tokened_X[i])
 
#LSTM모델 사용을 위해 데이터 크기가 다른 것들을 0을 채워넣어 max사이즈로 통일시킴
X_pad = pad_sequences(tokened_X, max)
 
X_train, X_test, Y_train, Y_test = train_test_split(
    X_pad, onehot_Y, test_size=0.1)
print(X_train.shape)
print(X_test.shape)
print(Y_train.shape)
print(Y_test.shape)
 
xy = X_train, X_test, Y_train, Y_test
np.save('/content/10x10_data_max_{}_size_{}_2'.format(max, wordsize), xy)
cs

언어를 컴퓨터가 이해하기 위해서 토크나이징 과정을 거친다.

 

 

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import *
from keras.callbacks import EarlyStopping
 
 
X_train, X_test, Y_train, Y_test = np.load(
    '/content/datasets/10x10_data_max_13_size_20320_2.npy',
    allow_pickle=True)
#max: 한 행의(리스트 글자의) 최대 길이
#size: 차원 수
 
##모델 생성
model = Sequential()
#X_pad로 사이즈 통일시킨 데이터를 embedding layer가 원핫인코딩+벡터라이징 처리해줌
#벡터라이징: 각 인덱스별 의미부여를 벡터공간이라는 개념을 도입해 처리
 
model.add(Embedding(20320300, input_length=13))
#차원수 20320를 차원수 300으로 낮추고 input_length는 max최대값인 13으로 입력
 
model.add(Conv1D(512, kernel_size=5
            padding='same', activation='relu'))#1차원 컨볼루션=> conv1d, 2차원 컨볼루션=>conv2d
model.add(MaxPool1D(pool_size=1))
#conv다음에는 maxpool함께 감
 
model.add(LSTM(128, activation='tanh',
               return_sequences=True))
model.add(Dropout(0.2))
model.add(LSTM(64, activation='tanh',
               return_sequences=True))
model.add(Dropout(0.1))
model.add(Flatten())
model.add(Dense(128, activation='relu'))
model.add(Dense(10, activation='softmax'))#y값개수: 10(카테고리개수)
early_stopping = EarlyStopping(monitor='val_accuracy', patience=3)  
# 5 에포크 동안 해당 값이 좋아지지 않으면 학습을 중단.
 
print(model.summary())
cs

모델 구조

 

 

 

모델 정확도는 높게 나오지만 지속적으로 val_loss 값이 증가하는 것으로 보아, 약간의 과적합이 발생함을 확인했다.

 

제목 자체가 길지 않기 때문에 okt로 형태소 분석을 끝내고, stopwords로 불용어를 제거, 기타 전처리 과정을 끝냈을 때, 제목 최대 길이가 13밖에 나오지 않아서 그렇지 않을까 하는 추측을 해본다.

 

 

 

학습한 모델을 가지고 신상품순, 판매량순으로 새로 데이터를 크롤링해서 성능을 평가해보았다. 지속적으로 학습을 시키고, 더 많은 데이터를 학습시켰다면 신상품이 들어온다고 해도 정확도가 많이 떨어지지 않을 것으로 보인다.

 

 

 

 

 

10x10으로 학습시킨 모델을 쿠팡, 지마켓에 적용하려고 하니까 성능이 확실히 떨어지는 것을 확인할 수 있다. 제목도 각 사이트마다 짓는 방법도 다를 것이며, 같은 제품이라도 다른 카테고리에 있음을 확인했다.

 

예를 들어, 비타민C 고려은단은 당연히 건강식에 있을거라고 생각했는데... 쿠팡에서 아이 유아쪽 카테고리에 있었다.

 

336x280(권장), 300x250(권장), 250x250, 200x200 크기의 광고 코드만 넣을 수 있습니다.

네 번째 프로젝트 순서

 

1. 간단한 intro

2. 웹 크롤링 및 전처리

3. 모델 학습 및 평가


팀프로젝트로 진행했기 때문에 각각 팀원들이 직접 크롤링을 해볼 수 있게, 카테고리를 정해서 각자 코드를 만들어서 공유하자고 얘기를 했다. 이전에 했던 네이버 기사랑 비슷한 느낌이라서 우선 빠르게 진행을 하고, 팀원들이 질문을 하면 피드백을 해주는 형식으로 진행했다.

 

 

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
import requests
import pandas as pd
from bs4 import BeautifulSoup
 
# 카테고리 설정 및 카테고리 별 url 숫자 지정
Category = ['Furniture','Life','Deco','Kitchen','Food','Baby,Kids','FasihonClothing','FasionGoods','Beauty','Jewelry']
Category_num = ['121','120','122','112','119','115','117','116','118','125']               
 
# 빈 데이터프레임 생성
df_section_title = pd.DataFrame()
 
for j in range(0,10):
    category = Category[j]
    print(category, ' 카테고리 크롤링 시작')
    category_num = Category_num[j]
    key_list = []
    
    #150페이지 크롤링
    for i in range(1,151):
        
        # 제목 추출  
        url = f'https://www.10x10.co.kr/shopping/category_main.asp?rect=&prvtxt=&rstxt=&extxt=&sflag=n&disp={category_num}&cpg={i}&chkr=False&chke=False&mkr=&sscp=Y&psz=40&srm=ne&iccd=0&styleCd=&attribCd=&icoSize=S&arrCate=&deliType=&minPrc=&maxPrc=&lstDiv=list&ab='
        headers = {'user-agent''Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/90.0.4430.85 Safari/537.36'}
        html = requests.get(url, headers=headers)
        title = BeautifulSoup(html.text, 'html.parser')        
        keywords = title.select('p.pdtName.tPad07')        
        
        
        #6개는 행사 상품
        for k in keywords[6:78]:
            keyword = k.text
            key_list.append(keyword)        
        if i % 50 == 0:
            print(i,'페이지 완료')
cs

 

 

 

 

제목이 안 그래도 짧은데, 제목에 과적합을 야기할 수 있는 불필요한 단어들이 많이 포함되어 있어서 전처리가 필요했다. 특히 [무료배송], (1+1), ★특가할인★ 등과 같이 특정 문구[],{},()와 그 안에 들어있는 단어들을 제거해야했다.

 

 

 

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
# [] / () 지우기
key_list2 = []
    
for key in key_list :
    if '[' and '(' in key :
        key = re.sub(r'\[[^)]*\]''', key)
        key_re = re.sub(r'\([^)]*\)''', key)
        key_list2.append(key_re)        
    elif '[' in key :
        key_re = re.sub(r'\[[^)]*\]''', key)
        key_list2.append(key_re)
    elif '(' in key :
        key_re = re.sub(r'\([^)]*\)''', key)
        key_list2.append(key_re)
    elif '★' in key :
        key_re = re.sub(r'\★[^)]*\★''', key)
        key_list2.append(key_re)
    else :
        key_list2.append(key)
print('(),[]삭제 완료')    
cs

이를 제거할 수 있는 코드 

 

 

 

re.sub(r'\([^)]*\)', '', key)

붉은 색 글씨 속에 있는 것들이 제거 됨을 알 수 있다.

개발자에게 쉬는 날은 없다. - 기억하자

 

 

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
    #형태소 분류
    titles =[]
    for key in key_list2 :
        titles.append(re.compile('[^가-힣]').sub(' ',key))
        # '가'부터 '힣'빼고 나머지 제외(한글모두)
        # ^:뒤에 붙은 것 제외하고 모두
        #정규표현식 or 점프투파이썬 정규표현식 찾아보기
 
    df_title = pd.DataFrame(titles, columns=['title'])
    df_title['category'= category
    df = pd.concat([df, df_title], axis = 0, ignore_index=True)
    
    print(f'{category} 추가')
    print('-'*30)
 
if 'Unnamed: 0' in df.columns :
    df = df.drop(['Unnamed: 0'], axis=1)   
    df = df.dropna(axis=0)
    
# ' ' 스페이스 공백 지우기 
index_list = []
for i in range(len(df)):
    if df['title'][i].isspace() == True :
        index_list.append(i)
 
df = df.drop(index= index_list, axis = 0)
    
df.to_csv('test_data.csv', encoding='utf-8-sig')    
cs

다른 팀의 경우 조금 더 장문의 글을 형태소 분석을 해야 해서 mecab을 이용했다. 하지만 우리의 경우 제목이 길지 않아서 간단하게 okt로 형태소 분류를 진행했다. 영어의 경우, 대부분 브랜드 네임이라서 따로 카테고리 분류를 진행하지 않았다.

하지만 문제가 생긴 부분은 영어가 사라진 부분이 NaN 값이 아닌 공백으로 존재하고 있었다. 그래서 공백으로만 존재하는 행을 제거했다. isspace()일 경우 따로 리스트를 생성해서 drop하는 방식을 택했다. 

 

 

 

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
import sys
from konlpy.tag import Okt
from collections import Counter
from wordcloud import WordCloud
 
def get_noun(category):
    
    okt=Okt()
    noun = okt.nouns(category)
    for i,v in enumerate(noun):
        if len(v) < 2:
            noun.pop(i)
            
    count = Counter(noun)
    noun_list = count.most_common(100)
    
    return noun_list
 
def visualize(noun_list):
    
    wc = WordCloud(font_path='Jalnan.ttf',\
              background_color = "white", \
              width = 1000, \
              height=1000, \
              max_words=100, \
              max_font_size=300)
    
    wc.generate_from_frequencies(dict(noun_list))
    wc.to_file('10x10_WordCloud.png')
    
if __name__=='__main__':
    filename = sys.argv[1]
    
    f= open('10x10(kor2).csv''r', encoding='utf-8')
    category = f.read()
    noun_list = get_noun(category)
    visualize(noun_list)
 
 
print('저장완료')
cs

추가로 모델 학습을 하는데 있어 불필요한 용어들이 너무 많아서 워드클라우딩을 사용하여, 불용어 리스트를 만들어서 제거하였다.  

 

 

336x280(권장), 300x250(권장), 250x250, 200x200 크기의 광고 코드만 넣을 수 있습니다.

네 번째 프로젝트 순서

 

1. 간단한 intro

2. 웹 크롤링 및 전처리

3. 모델 학습 및 평가

 


기간 : 21.06.17 ~ 21.06.24

 

언어 : Python

패키지 : Tensorflow, Scikit-learn, Okt, Beautiful Soup, Pandas, Maplotlib

툴 : Colab, PyCharm, Jupyter Notebook

 

주제 선정 이유 : 보고 있는 카테고리에서, 불필요한 상품까지 노출되는 경우 필터링. 카테고리 분류를 조금 더 깔끔하게 하기 위함.

 

 

 

 

팀원 전체가 프로젝트에 치이고 있는 상태라서 이번에는 지금까지 했던 것을 정리하는 시간을 갖기로 했다. 도서, 영화 등 다른 것도 분류를 할 수 있었으나 이미 다른 팀에서 주제를 선정해서 넘어가게 됐다. 

 

새로운 팀원들이 코드를 다루거나 이해하는 것이 쉽지 않다는 의견이 있어서, 함께 기초부터 같이 하기로 했다. 학원에서 배운 크롤링 기법은 대부분 Selenium을 사용해서 시간이 오래 걸렸다. 그래서 웬만하면 시간이 적게 드는 bs4로 해결하기 위한 코드를 새로 만들었다. 동적인 크롤링을 요하는 상황에서는 어쩔 수 없이 사용하긴 했지만.. 

 

동적 크롤링 : Selenium정적 크롤링 : Beautiful Soup

 

 

 

 

 

GitHub - kes76963/asia_project: NLP - Word2Vec, TFIDF / CNN - Category Classify

NLP - Word2Vec, TFIDF / CNN - Category Classify. Contribute to kes76963/asia_project development by creating an account on GitHub.

github.com

셀레니움보다 bs4가 더 확실하게 긁어오긴 하지만, 처음에 코드를 짜는데 은근히 시간이 걸린다. 셀레니움은 그냥 순서대로 가고 xpath 붙여넣기를 하면 되는데, bs4는 정적이다 보니 각 페이지별 url이나 num_id 값을 구해야하해서 고려할 요소들이 많다. 그리고 코드를 새로 만들면서 느낀 것이 홈페이지 개발자분들께서 가끔씩 특이한 이벤트를 집어넣으셔서 오류가 생긴다. try except 문을 반드시 써주도록 하자 ㅠㅠ

 

 

 

 

시간이 있는 김에 저번에 designer로 만들었던 gui로 앱 느낌의 구현을 하려고 했으나 실패하여, 다섯번째 프로젝트에 적용을 했다. 이 부분은 기대하셔도 좋다. 엄청난 발전이 있었다고 장담한다. (안드로이드 스튜디오로 앱을 만들 때처럼 노가다 느낌이 강하게 느껴진다.)

 

 

 

 

 

 

336x280(권장), 300x250(권장), 250x250, 200x200 크기의 광고 코드만 넣을 수 있습니다.

세 번째 프로젝트 순서 

 

1. 식물 병충해 자료 파일분류

2. CNN 모델링

3. 이미지화

4. CNN, AlexNet, VGG-16 모델 평가

 


프로젝트 발표 준비 전 모델 평가 및 성능 테스트? 단계

 

참고로 그린라이트로 정하게 된 배경에는.. 예전에 마녀사냥에서 자주 사용했던 그린라이트, 불빛이 들어온다는 느낌에서 약간의 언어유희를 사용했다. 식물이 아픈지 안 아픈지 제대로 정의해준다(right)와 밝혀준다(light)의 조합이랄까..

 

 

 

 

이미지 인식 모델에서 자주 사용 되는 모델 AlexNet, VGG-16, GoogleNet(2012~2014), ResNet, InceptionV3 (2014 이후) 매년  ImageNet Large Scale Visual Recognition Challenge( ILSVRV ) 대회에서 성능 비교를 한다. 요즘은 점차 정확도에 차이가 줄어서 0.01% 차이로도 순위가 갈린다고 수업시간에 들었다.

 

 

 

 

 

AlexNet

2012AlexNet 은 이전의 모든 경쟁자를 압도할 정도로, 상위 5개 오류를 26%에서 15.3%로 줄였다고 한다. 총 8개의 layer로 구성 됐고, 5개는 convolutional layer로 구성이 됐다.  11x11, 5x5, 3x3, 컨볼루션, 최대 풀링, 드롭아웃, 데이터 증대, ReLU 활성화 등으로 구성이 됐다. 

 

입력 크기 256x256x3

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
def Alexnet_model():
    inputs = Input(shape=(64643))
 
    conv1 = Conv2D(filters=48, kernel_size=(1010), strides=1, padding="valid", activation='relu')(inputs)
    pool1 = MaxPooling2D(pool_size=(33), strides=2, padding="valid")(conv1)
    nor1 = tf.nn.local_response_normalization(pool1, depth_radius=4, bias=1.0, alpha=0.001/9.0, beta=0.75)
 
    conv2 = Conv2D(filters=128, kernel_size=(33), strides=1, padding="same", groups=2, activation='relu')(nor1)
    pool2 = MaxPooling2D(pool_size=(33), strides=2, padding="valid")(conv2)
    nor2 = tf.nn.local_response_normalization(pool2, depth_radius=4, bias=1.0, alpha=0.001 / 9.0, beta=0.75)
 
    conv3 = Conv2D(filters=192, kernel_size=(33), strides=1, padding="same", activation='relu')(nor2)
    conv4 = Conv2D(filters=192, kernel_size=(33), strides=1, padding="same", activation='relu')(conv3)
    conv5 = Conv2D(filters=128, kernel_size=(33), strides=1, padding="same", activation='relu')(conv4)
    pool3 = MaxPooling2D(pool_size=(33), strides=2, padding="valid")(conv5)
    drop1 = Dropout(0.5)(pool3)
    nor3 = tf.nn.local_response_normalization(drop1, depth_radius=4, bias=1.0, alpha=0.001 / 9.0, beta=0.75)
 
    flat = Flatten()(nor3)
    dense1 = Dense(units=2048, activation='relu')(flat)
    dense2 = Dense(units=1024, activation='relu')(dense1)
    logits = Dense(units=20, activation='softmax')(dense2)
 
    return Model(inputs=inputs, outputs=logits)
 
 
model=Alexnet_model()
model.summary()
model.compile(loss='binary_crossentropy', optimizer=otm, metrics=["accuracy"])
cs

 

 

 

 

 

GoogleNet

ILSVRC 2014 대회의 우승자는 Google의 GoogLeNet(Inception V1이라고도 함)이다. 6.67%의 상위 5위 오류율을 달성. 인간 수준의 성과에 매우 가까웠다고 한다. 27개의 pooling layer가 포함된 22개의 layer로 구성된다. 

 

 

 

 

EarlyStopping을 했을 때 이미지 사이즈에 맞게 변형해서 만든 저희 모델들의 결과

 

 

 

 

 

VGG-16

ILSVRC 2014 대회의 준우승은 커뮤니티에서 VGGNet이다. VGGNet은 16개의 컨볼루션 레이어로 구성되며 매우 균일한 아키텍처로 구성됐다. AlexNet과 유사한 3x3 회선만 있지만 필터가 더 많다. 이미지에서 특징을 추출하기 위해 커뮤니티에서 선호되고 있다. 단점은 훈련에 많은 시간이 걸리고, 네트워크 아키텍처 가중치가 크다.

 

이미지 크기 244x244

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
def vgg_16():
    inputs = Input(shape=(64643))
    conv1_1 = Conv2D(filters=32, kernel_size=(33), strides=1, padding="same", activation='relu')(inputs)
    conv1_2 = Conv2D(filters=32, kernel_size=(33), strides=1, padding="same", activation='relu')(conv1_1)
    pool1 = MaxPooling2D(pool_size=(22), strides=2, padding="valid")(conv1_2)
    nor1 = BatchNormalization()(pool1)
 
    conv2_1 = Conv2D(filters=64, kernel_size=(33), strides=1, padding="same", activation='relu')(nor1)
    conv2_2 = Conv2D(filters=64, kernel_size=(33), strides=1, padding="same", activation='relu')(conv2_1)
    pool2 = MaxPooling2D(pool_size=(22), strides=2, padding="valid")(conv2_2) # 16
    nor2 = BatchNormalization()(pool2)
 
    conv3_1 = Conv2D(filters=128, kernel_size=(33), strides=1, padding="same", activation='relu')(nor2)
    conv3_2 = Conv2D(filters=128, kernel_size=(33), strides=1, padding="same", activation='relu')(conv3_1)
    conv3_3 = Conv2D(filters=128, kernel_size=(33), strides=1, padding="same", activation='relu')(conv3_2)
    pool3 = MaxPooling2D(pool_size=(22), strides=2, padding="valid")(conv3_3)
    nor3 = BatchNormalization()(pool3)
 
    # 4 layers
    conv4_1 = Conv2D(filters=128, kernel_size=(33), strides=1, padding="same", activation='relu')(nor3)
    conv4_2 = Conv2D(filters=128, kernel_size=(33), strides=1, padding="same", activation='relu')(conv4_1)
    conv4_3 = Conv2D(filters=128, kernel_size=(33), strides=1, padding="same", activation='relu')(conv4_2)
    pool4 = MaxPooling2D(pool_size=(22), strides=2, padding="valid")(conv4_3) # 4
    nor4 = BatchNormalization()(pool4)
 
    # 5 layers
    conv5_1 = Conv2D(filters=128, kernel_size=(33), strides=1, padding="same", activation='relu')(nor4)
    conv5_2 = Conv2D(filters=128, kernel_size=(33), strides=1, padding="same", activation='relu')(conv5_1)
    conv5_3 = Conv2D(filters=128, kernel_size=(33), strides=1, padding="same", activation='relu')(conv5_2)
    pool5 = MaxPooling2D(pool_size=(22), strides=2, padding="valid")(conv5_3)
    nor5 = BatchNormalization()(pool5)
    drop5 = Dropout(0.5)(nor5)
 
    flatten1 = Flatten()(drop5)
    dense1 = Dense(units=2048, activation=tf.nn.relu)(flatten1)
    dense2 = Dense(units=1024, activation=tf.nn.relu)(dense1)
 
    logits = Dense(units=20, activation='softmax')(dense2)
    return Model(inputs=inputs, outputs=logits)
 
model=vgg_16()
model.compile(loss='categorical_crossentropy', optimizer=otm, metrics=["accuracy"])
model.summary()
cs

 

 

 

모델 성능 평가

외부 데이터를 수집하려고 직접 찾아보면서 고생을 하다가, 관련 자료를 깃허브에 친절하게 올려주신 분이 있어서 감사히 썼습니다.

 

https://github.com/spMohanty/PlantVillage-Dataset/tree/master/raw/color

 

GitHub - spMohanty/PlantVillage-Dataset: Dataset of diseased plant leaf images and corresponding labels

Dataset of diseased plant leaf images and corresponding labels - GitHub - spMohanty/PlantVillage-Dataset: Dataset of diseased plant leaf images and corresponding labels

github.com

 

 

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
##########################
# 테스트 데이터 50개 랜덤으로 평가
##########################
 
 
########################################
#class name으로 변경
from os import rename, listdir
 
path2 = "./tests"  #TEST_DATA => tests로 수정함
 
list3 = list(str(i) for i in range(20))
dict3 = dict(zip(combined_labels,list3))
 
for fname in os.listdir(path2):
    newname = dict3.get(fname)
    try:
        if newname not in os.listdir(path2) :    
            os.rename(os.path.join(path2, fname), os.path.join(path2,newname))
    except:
        counter = True
 
if counter :        
    print("이미 변경 완료")
else :
    print("class name으로 변경완료")
 
 
########################################
### 필수 아님 #####
 
#labeled_name으로 되돌리고 싶을 때
list3 = list(str(i) for i in range(20))
dict3 = dict(zip(list3, combined_labels))
 
for fname in os.listdir(path2):
    newname = dict3.get(fname)
    try :
        if newname not in os.listdir(path2) :    
            os.rename(os.path.join(path2, fname), os.path.join(path2,newname))
    except:
        counter = True
 
if counter :        
    print("이미 변경 완료")
else :
    print("labeled name으로 변경완료")
 
 
########################################
import os, re, glob
import cv2
import numpy as np
from sklearn.model_selection import train_test_split
from tensorflow.keras.preprocessing.image import img_to_array
import random
 
# class에 따른 본래 label
t_list = list(str(i) for i in range(20))
t_dict = dict(zip(t_list, combined_labels))
 
 
 
########################################
#테스트 데이터 list
tests ='./tests'
tests_list = os.listdir(tests)
 
model = load_model('model1.h5')     # 자신의 model load
 
def convert_image_to_array(image_dir):
    try:
        image = cv2.imread(image_dir)
        if image is not None :
            image = cv2.resize(image, dsize=(64,64))
            return img_to_array(image)
        else :
            return np.array([])
    except Exception as e:
        print(f"Error : {e}")
        return None
 
def predict_disease(image_path, num):
    global count
    image_array = convert_image_to_array(image_path)
    np_image = np.array(image_array, dtype=np.float32) / 225.0
    np_image = np.expand_dims(np_image,0)
    result = model.predict_classes(np_image)
    c = result.astype(str)[0]
    if c == num : 
        count += 1
    return count
 
for i in range(20):
    num = str(i)
    tests_file = os.listdir(f'tests/{num}')
    count = 0
    max = len(tests_file)
    
    for j in range(50):
        ran_num = random.randint(0,max) # 임의의 숫자 추출
        tests_path =  f'tests/{num}/' + os.listdir(f'./tests/{num}')[ran_num]
        predict_disease(tests_path, num)
 
    print(f'###### 테스트 데이터 {t_dict.get(num)} 의 정확도 입니다 #######' )
    print('accuracy: {:0.5f}'.format(count/50))
 
print('테스트 완료')
cs

 

###### 테스트 데이터 Corn_(maize)_Common_rust_ 의 정확도 입니다 #######
accuracy: 1.00000
###### 테스트 데이터 Corn_(maize)_healthy 의 정확도 입니다 #######
accuracy: 1.00000
###### 테스트 데이터 Grape_Black_rot 의 정확도 입니다 #######
accuracy: 0.96000
###### 테스트 데이터 Grape_Esca_(Black_Measles) 의 정확도 입니다 #######
accuracy: 0.94000
###### 테스트 데이터 Grape_Leaf_blight_(lsariopsis_Leaf_Spot) 의 정확도 입니다 #######
accuracy: 0.98000
###### 테스트 데이터 Orange_Haunglongbing_(Citrus_greening) 의 정확도 입니다 #######
accuracy: 0.98000
###### 테스트 데이터 Pepper,_bell_Bacterial_spot 의 정확도 입니다 #######
accuracy: 0.94000
###### 테스트 데이터 Pepper,_bell_healthy 의 정확도 입니다 #######
accuracy: 0.98000
###### 테스트 데이터 Potato_Early_blight 의 정확도 입니다 #######
accuracy: 1.00000
###### 테스트 데이터 Potato_Late_blight 의 정확도 입니다 #######
accuracy: 0.98000
###### 테스트 데이터 Soybean_healthy 의 정확도 입니다 #######
accuracy: 0.96000
###### 테스트 데이터 Squash_Powdery_mildew 의 정확도 입니다 #######
accuracy: 0.94000
###### 테스트 데이터 Tomato_Bacterial_spot 의 정확도 입니다 #######
accuracy: 0.90000
###### 테스트 데이터 Tomato_Early_blight 의 정확도 입니다 #######
accuracy: 0.90000
###### 테스트 데이터 Tomato_Late_blight 의 정확도 입니다 #######
accuracy: 0.84000
###### 테스트 데이터 Tomato_Septoria_leaf_spot 의 정확도 입니다 #######
accuracy: 0.96000
###### 테스트 데이터 Tomato_Spider_mites_Two-spotted_spider_mite 의 정확도 입니다 #######
accuracy: 0.96000
###### 테스트 데이터 Tomato_Target_Spot 의 정확도 입니다 #######
accuracy: 0.96000
###### 테스트 데이터 Tomato_Tomato_Yellow_Leaf_Curl_Virus 의 정확도 입니다 #######
accuracy: 0.98000
###### 테스트 데이터 Tomato_healthy 의 정확도 입니다 #######
accuracy: 0.98000
테스트 완료
----------------------------------------------------------------------------------------------------
테스트 정확도 :  0.957

 

 

 

 

 

 

이건 팀원이 정확도와 loss 값 그래프를 보고 그린 그래프

수고하셨습니다

336x280(권장), 300x250(권장), 250x250, 200x200 크기의 광고 코드만 넣을 수 있습니다.

세 번째 프로젝트 순서

1. 식물 병충해 자료 파일분류
2. CNN 모델링
3. 이미지화
4. CNN, AlexNet, VGG-16 모델 평가


예전에 네이버 블로그를 하듯이 글을 자유롭게 쓰고 싶은데, 혹시나 틀릴까 하는 마음에 쉽게 글이 작성이 되지 않는다. 너무나 쉽게 생각을 한 것이 아닌가 싶기도 하지만.. 그래도 팀프로젝트 5개 + 현재하고 있는 파이널 프로젝트 관련된 글을 작성하려고 한다.

이번에는 실패했던 시각화에 대한 내용이라 너무 관심 있게 보지는 말아주셨으면 한다. (부끄러우니까)

CNN 모델링을 했을 때 정확도가 90퍼센트 이상이 나왔지만 이를 어떻게 하면 더 개선시킬 수 있을까에 대한 고민을 많이 했다. 그러다가 생각한 것이 학습에 필요한 데이터는 전체 사진이 아닌 식물의 사진만 중요하지 않을까? 그래서 배경을 제외하고 학습을 해보기로 했다.

-배경과 식물 분리하는 mask
-sharpen 값을 줘서 병충해가 있는 데이터는 조금 더 부각이 되게


여러 예제들을 찾아보다가 이거다! 하는 예제가 있어서 처음에 단순히 따라하는 식으로 해봤다! 이건 그냥 너무 쉽게 되겠는 걸?






결과는 참담했다.



1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
#배경과 분리하기 위해서 hsv 값 조정
def create_mask_for_plant(image):
    image_hsv = cv2.cvtColor(image, cv2.COLOR_BGR2HSV)
 
    sensitivity = 30
    lower_hsv = np.array([60 - sensitivity, 10050])
    upper_hsv = np.array([60 + sensitivity, 255255])
 
    mask = cv2.inRange(image_hsv, lower_hsv, upper_hsv)
    kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (11,11))
    mask = cv2.morphologyEx(mask, cv2.MORPH_CLOSE, kernel)
    
    return mask
 
#비트연산 and 모든 색이 같을 때만 색 표현
def segment_plant(image):
    mask = create_mask_for_plant(image)
    output = cv2.bitwise_and(image, image, mask = mask)
    return output
 
#샤픈, 특징을 조금더 부각시키게
def sharpen_image(image):
    image_blurred = cv2.GaussianBlur(image, (00), 3)
    image_sharp = cv2.addWeighted(image, 1.5, image_blurred, -0.50)
    return image_sharp
cs

sensitivity를 어떻게 하느냐에 따라서 결과값이 많이 차이가 났다. 위의 경우가 1을 뒀을 때고, 아래의 경우가 30일 때 실행을 했는데 단점이 배경 없이 잎만 찍은 데이터의 경우 분간이 제대로 되지가 않았다.



1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
%matplotlib inline
import os
import matplotlib
import matplotlib.pyplot as plt
import pandas as pd
import cv2
import numpy as np
from glob import glob
import seaborn as sns
 
image = cv2.imread('8_9_2.jpg')
 
image_mask = create_mask_for_plant(image)
image_segmented = segment_plant(image)
image_sharpen = sharpen_image(image_segmented)
 
fig, axs = plt.subplots(14, figsize=(2020))
axs[0].imshow(image)
axs[1].imshow(image_mask)
axs[2].imshow(image_segmented)
axs[3].imshow(image_sharpen)
cs

그래도 이전보다는 배경과 잎의 경계가 뚜렷하게 나눠지는 것을 확인할 수 있었다. 그런데도 문제가 되는 부분은 잎을 나눈데 있어서 hsv 값을 비슷하게 판단해서인지? 식물의 잎도 같이 사라지는 마술을 보여줬다. 병충해가 있어서 저렇게 빵꾸가 뚤렸다고 생각하면 좋겠지만, 병충해가 있는 부분은 중간 아래부분이다.

라이트룸이나 사진 편집을 할 때, 어떤 식으로 특정 색만 색깔을 남길까 생각을 해봤을 때.. hsv 전체 색 공간이 아닌 말 그대로 특정색만 추출하면 되는데 왜 이생각을 못 했을까 하고 무릎을 탁 쳤다. 그래서 초록색을 가장 잘 나타낼 수 있는 값들을 조절해봤다.


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
import numpy as np 
import cv2 
img_color = cv2.imread('4_7_5.jpg'
 
img_hsv = cv2.cvtColor(img_color, cv2.COLOR_BGR2HSV) # cvtColor 함수를 이용하여 hsv 색공간으로 변환 
lower_green = (03030)
upper_green = (80255255
img_mask = cv2.inRange(img_hsv, lower_green, upper_green) #hsv 색공간 전체가 아닌 지정한 범위 내의 
img_result = cv2.bitwise_and(img_color, img_color, mask = img_mask) # 바이너리 이미지를 마스크로 사용하여 원본이미지에서 범위값에 해당하는 부분을 획득 
 
 
fig, axs = plt.subplots(13, figsize=(2020))
axs[0].imshow(img_color) 
axs[1].imshow(img_mask) 
axs[2].imshow(img_result) 
cs

이정도면 나름 선방한 결과였다. 하지만 이 이미지들을 다 다시 저장시키고, 식물마다 톤이 다르고, 사진 찍은 곳 조명이 달라서 lower_green과 upper_green을 일일이 다 조정해야 한다는 치명적인 단점이 있어서 실패를 했다.

그래도 어떤 식으로 사진과 배경을 분리하고, 샤픈을 줘서 CNN이 사진의 특징을 학습할 때 조금 더 도움을 줄 수 있지 않을까 하는 생각이 든다.

336x280(권장), 300x250(권장), 250x250, 200x200 크기의 광고 코드만 넣을 수 있습니다.

세 번째 프로젝트 순서 

 

1. 식물 병충해 자료 파일분류

2. CNN 모델링

3. 이미지화

4. CNN, AlexNet, VGG-16 모델 평가




쉼호흡부터 한 번 후~ 하~ 파이썬 팀프로젝트 당시에도 내용이 어려웠는데, 지금 다시 봐도 내용이 어렵다. 그래도 블로그로 글을 쓰면서 다시 정리한다는 생각으로 일단 간단하게 정리를 해봤다. 

 

 

인공지능 : 인간의 지능을 기계로 구현한 것

머신러닝 : 인간이 개발한 알고리즘을 컴퓨터 언어를 통해 기계에게 학습. 데이터로부터 스스로 학습을 통해 데이터를 가장 잘 표현하는 규칙, 패턴을 찾는 것(함수로 정의하는 과정 - x와 y관계)

딥러닝 : 인간의 뇌 신경망을 모방한 인공 신경망, 분류 예측 등의 머신러닝 수행  (입력층과 출력층 사이에 여러 층을 거쳐서 학습)

 

지도학습 : 입력 데이터(feature, 독립변수)와 출력데이터(class, target, 종속변수)를 이용해서 학습 – 분류, 회귀

비지도학습 : 입력 데이터를(feature)를 이용한 학습 – 군집

강화 학습 : 학습 결과에 대한 보상이 주는 방식으로 학습

 

train data : 모델 구축시 사용되는 데이터 (학습)

test data  : 구축된 모델 검증하는데 사용 (검증)

 

케라스(keras) ㅡ 저차원의 딥러닝 라이브러리를 래핑한 고차원의 라이브러리

sequential – 딥러닝의 구조를 한 층 한층 순차적으로 층을 쌓은 신경망 모델

dense – 신경망 모델에 포함된 완전 연결층 (각 층이 각각 어떤특성을 가질지 옵션을 설정)

activation – 다음 층으로 어떻게 값을 넘길지 결정하는 부분(relu, sigmoid, softmax 등)

loss – 한 번 신경망이 실행될 때마다 오차 값을 추적하는 함수 (mse, rmse 등)

optimizer – 오차를 어떻게 줄여 나갈지 정하는 함수 (adam, 경사하강법, 확률적 경사하강법)

input_shape – 입력 데이터의 형태

epoch - 주어진 데이터를 신경망 모델에서 한 번 훈련하는 단위

 

 

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
from keras.models import Sequential
from keras.callbacks import EarlyStopping, ModelCheckpoint
from keras.layers import Dropout, Activation, Dense
from keras.layers import Flatten, MaxPooling2D
from keras.layers import Conv2D
from keras.models import load_model
from keras.optimizers import Adam
from tensorflow.keras.layers import BatchNormalization
import os
import numpy as np
 
# dataset 불러오기
if not os.path.exists("./model/"):
    os.mkdir('./model/')
X_train, X_test, Y_train, Y_test = np.load('./data/img_data.npy', allow_pickle=True)
 
# 기본 설정
categories = list(str(i) for i in range(20))
EPOCHS = 30
BS = 32
INIT_LR = 1e-3
n_classes = len(categories)
 
 
# CNN 모델
model = Sequential()
model.add(Conv2D(32, (33), padding="same", input_shape=X_train.shape[1:], activation='relu'))
model.add(MaxPooling2D(pool_size=(22)))
model.add(Dropout(0.2))
 
model.add(Conv2D(64, (33), padding="same", activation='relu'))
model.add(MaxPooling2D(pool_size=(22)))
model.add(Dropout(0.2))
 
model.add(Conv2D(64, (33), padding="same", activation='relu'))
model.add(MaxPooling2D(pool_size=(22)))
model.add(Dropout(0.25))
 
model.add(Flatten())
model.add(Dense(256, activation='relu'))
model.add(Dropout(0.5))
 
model.add(Dense(n_classes, activation='softmax'))
 
model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy'])
 
 
# 모델 요약
print(model.summary())
 
# 모델 학습
# opt = Adam(lr=INIT_LR, decay=INIT_LR / EPOCHS)
# model.compile(loss="binary_crossentropy", optimizer=opt,metrics=["accuracy"])
# print("트레이닝 ")
 
#EarlyStopping
model_dir = './model'
model_filepath = "model/se_cnn.h5"
if os.path.exists(model_filepath):
    model.load_weights(model_filepath)
else:
    model_path = model_dir + '/multi_img_classification.model'
    checkpoint = ModelCheckpoint(filepath=model_path, monitor='val_loss', verbose=1, save_best_only=True)
    early_stopping = EarlyStopping(monitor='val_loss', patience=6)
 
    model.fit(
        X_train,
        Y_train,
        batch_size=BS,
        validation_data=(X_test, Y_test),
        steps_per_epoch=len(X_train) // BS,
        epochs=EPOCHS, verbose=1,
        callbacks=[checkpoint, early_stopping]
    )
    model.save_weights(model_filepath)
 
cs

지속적으로 층을 바꿔가면서 모델링을 진행했다. 솔직히 어떤 부분에서 무엇을 바꿔야 하는지 이해는 쉽지 않았다. 같은 모델을 돌린다고 해도 train, test 데이터가 바뀌어서 학습이 진행되기 때문에, 데이터 중에 인간도 판별하기 힘든 데이터가 많이 섞여 있으면 정확도가 계속 떨어졌다.

 

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#모델 시각화
acc = history.history['accuracy']
val_acc = history.history['val_accuracy']
loss = history.history['loss']
val_loss = history.history['val_loss']
epochs = range(1, len(acc) + 1)

#모델 정확도
plt.rc('font',family='Malgun Gothic')
plt.plot(epochs, acc, 'b', label='Training accurarcy')
plt.plot(epochs, val_acc, 'r', label='Testing accurarcy')
plt.title('학습과 훈련 정확도')
plt.legend()
plt.figure()
 
#모델 손실
plt.plot(epochs, loss, 'b', label='Training loss')
plt.plot(epochs, val_loss, 'r', label='Testing loss')
plt.title('학습과 훈련 손실')
plt.legend()
plt.show()
cs

신기한 부분은 모델을 돌리게 되면 정확도가 90%가 넘는게 쉽지 않은데... 데이터 자체가 양질의 데이터고 분류가 잘 돼서 더 잘 학습이 되는 것으로 보인다. 다음에는 시각화와 어떻게 하면 정확도를 높일 수 있을지에 대한 고민이 담긴 글이다. 실패는 했지만 그래도 어떻게 하면 계선을 할 수 있을까 많은 고민을 했다.

336x280(권장), 300x250(권장), 250x250, 200x200 크기의 광고 코드만 넣을 수 있습니다.

세 번째 프로젝트 순서 

 

1. 식물 병충해 자료 파일분류

2. CNN 모델링

3. 이미지화

4. CNN, AlexNet, VGG-16 모델 평가


언어 : Python

패키지 : Tensorflow, Keras, NumPy, Maplotlib

툴 : Colab, PyCharm, Jupyter Notebook

 

여러가지 주제를 가지고 고민을 하다가 딥러닝을 제대로 배우지도 않은 상태에서 진행을 하려고 해서 쉽지 않았다. 그래서 이런 저런 자료들을 찾아보다가 '정보통신산업진흥원 주최  2020 인공지능 문제해결 경진대회 예선 문제' 데이터셋이 있어서 배운 것을 적용해보는 시간을 가지려고 했다.

 

 

 

train 데이터가 16000개, test 데이터가 3997개로 구성되어 있었다. 하지만 test 데이터는 라벨링이 되어있지 않아서, 모델을 학습시킨다고 해서 딥러닝 모델이 얼마나 좋은지 성능을 평가할 수 없었다. 대회 자체가 워낙 폐쇄적이라서 현재 데이터도 이미 가지고 있던 팀원이 있어서 구할 수 있었다. 직접 전화도 해봤지만 정답을 알려주긴 어렵다는 말을 들었다. 그래서 추후에 데이터를 따로 수집을 했다.

 

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
plant_label = ["Apple""Blueberry""Cherry_(including_sour)""Corn_(maize)",
              "Grape""Orange""Peach""Pepper,_bell""Potato""Raspberry",
              "Soybean""Squash""Strawberry""Tomato"]
 
disease_label = ["Apple_scab""Bacterial_spot""Black_rot""Cedar_apple_rust",
                 "Cercospora_leaf_spot_Gray_leaf_spot""Common_rust_",
                 "Early_blight""Esca_(Black_Measles)""Haunglongbing_(Citrus_greening)",
                 "Late_blight""Leaf_Mold""Leaf_blight_(lsariopsis_Leaf_Spot)",
                 "Leaf_scorch""Northem_Leaf_Blight""Powdery_mildew""Septoria_leaf_spot",
                 "Spider_mites_Two-spotted_spider_mite""Target_Spot",
                 "Tomato_Yellow_Leaf_Curl_Virus""Tomato_mosaic_virus""healthy"]
 
combined_labels = ["Corn_(maize)_Common_rust_""Corn_(maize)_healthy""Grape_Black_rot",
                   "Grape_Esca_(Black_Measles)""Grape_Leaf_blight_(lsariopsis_Leaf_Spot)",
                   "Orange_Haunglongbing_(Citrus_greening)""Pepper,_bell_Bacterial_spot",
                   "Pepper,_bell_healthy""Potato_Early_blight""Potato_Late_blight",
                   "Soybean_healthy""Squash_Powdery_mildew""Tomato_Bacterial_spot",
                   "Tomato_Early_blight""Tomato_Late_blight""Tomato_Septoria_leaf_spot",
                   "Tomato_Spider_mites_Two-spotted_spider_mite""Tomato_Target_Spot",
                   "Tomato_Tomato_Yellow_Leaf_Curl_Virus""Tomato_healthy"]
len(combined_labels)


####################################################################################
#라벨 폴더 생성
import shutil, glob, os
path = "./train"
if not os.path.isdir(path):                                                           
    os.mkdir(path)
 
for i in range(len(combined_labels)):
    path2 = f"./train/{combined_labels[i]}"
    if not os.path.isdir(path2):                                                           
        os.mkdir(path2)
 
 
####################################################################################
#사진 폴더별로 복사붙여넣기 
path_data = './eda/식물병충해data/train'
file_list = os.listdir(path_data)
 
#plant_label 딕셔너리
list1 = list(range(14))
dict1 = dict(zip(list1,plant_label))
 
#disease_label 딕셔너리
list2 = list(range(21))
dict2 = dict(zip(list2,disease_label))
 
#
for i in range(16000):
    cl_list = file_list[i][:-4].split('_'#이름을 나누기 plant + disease + 번호
    find_name = dict1.get(int(cl_list[0])) + '_' + dict2.get(int(cl_list[1])) #Combined Labels 이름 찾기
    if file_list[i] not in path_data :
        shutil.copy(f'{path_data}/{file_list[i]}', f'{path}/{find_name}')
    #print('복사완료')
cs

폴더명이 숫자 클래스로 필요할 수도 있고 combined_labels로 필요할 수도 있어서 폴더명을 바꾸기 쉽게 수정하는 코드를 추가했다. 

 

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
#class name으로 변경
from os import rename, listdir
 
path = "./train"
 
list3 = list(str(i) for i in range(20))
dict3 = dict(zip(combined_labels,list3))
 
for fname in os.listdir(path):
    newname = dict3.get(fname)
    if newname not in os.listdir(path) :    
        os.rename(os.path.join(path, fname), os.path.join(path,newname))
print("class name으로 변경완료")
 
 
 
#labeled_name으로 되돌리고 싶을 때
list3 = list(str(i) for i in range(20))
dict3 = dict(zip(list3, combined_labels))
 
for fname in os.listdir(path):
    newname = dict3.get(fname)
    if newname not in os.listdir(path) :    
        os.rename(os.path.join(path, fname), os.path.join(path,newname))
print("labeled name으로 변경완료")
cs

 

 

 

 

반복해서 학습을 위해서 numpy 배열을 npy 파일로 저장을 하려고 했다. 하지만 모든 팀원들 컴퓨터 사양이 좋지 않아서 이미지 사이즈를 128x128로 하려다가 다들 맛이 가서 64x64로 어쩔 수 없이 저장했다.. ㅠㅠㅠ

 

 

 

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
import os, re, glob
import cv2
import numpy as np
from sklearn.model_selection import train_test_split
  
groups_folder_path = './train/'
categories = list(str(i) for i in range(20))
 
num_classes = len(categories)
  
image_w = 64
image_h = 64
  
= []
= []
  
for idex, categorie in enumerate(categories):
    label = [0 for i in range(num_classes)]
    label[idex] = 1
    image_dir = groups_folder_path + categorie + '/'
  
    for top, dir, f in os.walk(image_dir):
        for filename in f:
            print(image_dir+filename)
            img = cv2.imread(image_dir+filename)
            img = cv2.resize(img, dsize=(image_w, image_h))
            X.append(img/256)
            Y.append(label)
 
= np.array(X)
= np.array(Y)
 
X_train, X_test, Y_train, Y_test = train_test_split(X,Y)
xy = (X_train, X_test, Y_train, Y_test)
 
np.save("./img_data.npy", xy)
cs

#NumPy 배열을 npy 외부 파일로 저장

+ Recent posts