# pororo는 pytorch 1.6 이 선행되어야 함. 이를 위해 python-3.6 버전으로 가상환경 생성
conda create -n pororo_test python=3.6
conda install pytorch==1.6.0 torchvision==0.7.0 cudatoolkit=10.1 -c pytorch

# pip 유저 옵션 - 권한 문제 해결
python -m pip install -U pip --user
# 여기까지 참고: https://kangaroo-dev.tistory.com/1

# pororo git
git clone https://github.com/kakaobrain/pororo.git
ls
cd pororo
conda install -e .

1. pip install pororo를 했더니 ImportError: cannot import name 'Pororo’ 에러가 떴다.

   • 설치 시 커맨드 창

       Successfully built pororo
       Installing collected packages: pororo
         Attempting uninstall: pororo
           Found existing installation: pororo 0.4.2
           Uninstalling pororo-0.4.2:
             Successfully uninstalled pororo-0.4.2
       Successfully installed pororo-0.4.1

     • 실패

       $python pororo.py
       Traceback (most recent call last):
       File "pororo.py", line 1, in <module>
       from pororo import Pororo
       File "/pororo.py", line 1, in <module>
       from pororo import Pororo
       ImportError: cannot import name 'Pororo'

2. pororo git을 clone하여 직접 conda install -e . 해주어야 한다. 그리고 이때 가상환경을 새로 생성해주어 pytorch 1.6을 꼭! 먼저 설치해 주어야 한다.

   • 설치 시 커맨드 창

       Installing collected packages: pororo
         Attempting uninstall: pororo
           Found existing installation: pororo 0.4.1
           Uninstalling pororo-0.4.1:
             Successfully uninstalled pororo-0.4.1
         Running setup.py develop for pororo
       Successfully installed pororo-0.4.1

   • 성공

       $python
       >>> from pororo import Pororo
       >>> Pororo.available_tasks()
       "Available tasks are ['mrc', 'rc', 'qa', 'question_answering', 'machine_reading_comprehension', 'reading_comprehension', 'sentiment', 'sentiment_analysis', 'nli', 'natural_language_inference', 'inference', 'fill', 'fill_in_blank', 'fib', 'para', 'pi', 'cse', 'contextual_subword_embedding', 'similarity', 'sts', 'semantic_textual_similarity', 'sentence_similarity', 'sentvec', 'sentence_embedding', 'sentence_vector', 'se', 'inflection', 'morphological_inflection', 'g2p', 'grapheme_to_phoneme', 'grapheme_to_phoneme_conversion', 'w2v', 'wordvec', 'word2vec', 'word_vector', 'word_embedding', 'tokenize', 'tokenise', 'tokenization', 'tokenisation', 'tok', 'segmentation', 'seg', 'mt', 'machine_translation', 'translation', 'pos', 'tag', 'pos_tagging', 'tagging', 'const', 'constituency', 'constituency_parsing', 'cp', 'pg', 'collocation', 'collocate', 'col', 'word_translation', 'wt', 'summarization', 'summarisation', 'text_summarization', 'text_summarisation', 'summary', 'gec', 'review', 'review_scoring', 'lemmatization', 'lemmatisation', 'lemma', 'ner', 'named_entity_recognition', 'entity_recognition', 'zero-topic', 'dp', 'dep_parse', 'caption', 'captioning', 'asr', 'speech_recognition', 'st', 'speech_translation', 'tts', 'text_to_speech', 'speech_synthesis', 'ocr', 'srl', 'semantic_role_labeling', 'p2g', 'aes', 'essay', 'qg', 'question_generation', 'age_suitability', 'wsd']"
       >>>

• 어제 읽은 [Improving the Use of Pseudo-Words for Evaluating Selectional Preferences(2010)] 논문은, 선택 선호도(Selectional Preference) 매커니즘의 evaluation 단계의 기법으로 Pseudo-words(유사 어휘) 기법을 활용한 효과적인 평가방법을 제안한 논문이었다.

• 선택 선호도(Selectional Preference)에 대한 개념부터 이해하고 싶어져서 처음 선택 선호도(Selectional Preference)라는 개념을 명명한 Resnik의 1997년도 논문 리뷰 글을 찾아 읽어보았다. (어제 논문은 리뷰 글을 찾아보기가 어려웠다..)

  • 잘 정리된 블로그 글: https://silvercityz.tistory.com/27
  • 논문: https://aclanthology.org/W97-0209.pdf

• 어제 논문에서 많이 등장했던 용어인 backoff model이 n-gram 언어모델과 관련이 있다고 느꼈는데, 해당 논문에서 smothing의 효과가 있다고 하여 추가로 찾아본 smothing 기법에 크게 laplace smoothing 과 back-off smoothing이 있다는 것을 알게 되며 smothing 방법론 중 하나의 접근법이라는 것을 배웠다.

  • smothing 기법: 통계적 언어모델, N-gram 언어모델에서 희소 문제를 해결하기 위한 방법. 확률값이 0이 되지 않도록 하여 문장 생성 확률이 정의되지 않는 문제를 해결하기 위한 방법

• 이러한 선택 선호도(Selectional Preference) 및 선택 제한(selectional constraints/selection restriction) 개념은 우선은 중의성을 해소(WSD)하기 위해 출발한 개념인 것 같다. (좀더 사람과 같이 단어의 의미를 파악할 줄 아는 NLP를 만들기 위해) 그리고 정량적인 수식에는 쿨백-라이블러 발산(KLD)의 개념이 사용된다.(두 확률분포의 차이를 계산하는 함수, 정보이론에서의 상대 엔트로피 개념이 활용됨)

• 하지만 다른 모델과 마찬가지로 학습을 시켜주는 단계가 필요하다. 그리고 이때, 사람이 manually하게 엄청난 대량의 training data를 직접 annotation하여 준비하거나, semantic feature를 추출하는 데에는 한계가 있을 수 있다. 이러한 방향에서 Resnik은 supervised training 없이도 중의성을 해소하는 방안을 고민해본 것 같다.

• 하지만, 저자가 An Unsupervised Method for Sense Disambiguation라고 제안한 argument plausibility judgments(논항 타당성 판단)은 WordNet(워드넷) 기반이다. 즉, 한계가 있을 것이다. (아마 1997년도에는 이러한 제안이 최선이었을 것 같다.)

[selectional preference and sense disambiguation <선택적 선호도와 중의성 해소>(Resnik, 1997)]

• 노션 글: https://utopian-glove-b74.notion.site/selectional-preference-and-sense-disambiguation-Resnik-1997-738f718089bd41a9abf2d15dfb66b7bc

🤔

• 다른targeted aspect-based sentiment analysis (TABSA)주제의 논문([Utilizing BERT for Aspect-Based Sentiment Analysis via Constructing Auxiliary Sentence(2019)]) 에서는 심지어 Aspect(ex. 가격, 안전성, 교통 등)가 문장 시퀀스 내에 등장하지도 않는다.(pre-training 시에는 manual annotation이 구축된 뒤 학습되지만)

• (-> 그리고 이를 토대로 Classification 시, "Location 1(Target) - price(Aspect) - Positive(Sentiment)" 형태의 Auxiliary sentence(보조 문장)을 Origin Sentence에 붙여서 수행함 - "[CLS] Auxiliary Sentence [SEP] Original Sentence [SEP]" 형태로)

• 하지만, 해당 논문에서는 predicate와 arguments가 모두 문장에서 등장해야할 것이다.(그래야지만 워드넷을 활용해 선택 확률의 값을 계산해낼 수 있으니까) 이런 부분에서도 한계가 존재했다고 볼 수 있지 않을까? 사람은 많은 경우에 문장에서 정보를 생략하기 때문에

• argument라는 용어가 많이 나오는데 아직 정확한 뉘앙스가 잘 와닿지 않음 (아마도 predicate(술어)-argument(논항) 관계 ? (ex. 동사-목적어 관계))

[Improving the Use of Pseudo-Words for Evaluating Selectional Preferences(2010) 논문 리뷰]

• 논문: https://aclanthology.org/P10-1046.pdf
• 노션 글: https://utopian-glove-b74.notion.site/Improving-the-Use-of-Pseudo-Words-for-Evaluating-Selectional-Preferences-2010-8723bd9540b045e78c27fadb5fbd36c3

• 가정: 문장 내에 같이 등장하는 단어들은 공통 토픽을 공유한다..!
• 중의성을 갖는 각 단어에 대해 사전(ex. 워드넷 등)을 활용해 사전에서의 의미별 설명 사이의 유사도를 구하는(ex. 겹치는 단어의 개수를 카운팅 등) 알고리즘
• <장점> 워드넷과 같은 잘 분류된 사전이 있다면, 쉽고 빠르게 중의성 해소 문제 해결 가능
• <한계> 사전에 dependency

[5.9. 선택 선호도 (selectional preference)]

• 표제어 용어 ? (Headword (: 표제어 단어 자체) VS. Lemmatization (: 표제어를 문장에서 추출하는 일) 구분 )

• Lemmatization : have to find correct dictionary headword form

• 방법 1) 워드넷 기반의 선택 선호도

• 방법 2) 유사어휘를 통한 선택 선호도 평가

  • 유사어휘를 활용하여 선택 선호도를 잘 평가하는 방법을 더 자세히 알기 위한 논문 읽어보기
  • Improving the Use of Pseudo-Words for Evaluating Selectional Preferences, 2010 (http://web.stanford.edu/~jurafsky/chambers-acl2010-pseudowords.pdf)

• 방법 3) 유사도 기반의 선택 선호도

• “Context” → 사람은 주변 정보(= Context)를 파악하여 각 단어에 숨겨진 의미를 파악하고 이해함

• 용어 단어 중의성 해소(WSD) : 단어가 가지는 모호성을 제거하는 과정 ⇒ 효과: 자연어 처리의 성능 높임

• 단어

• 불연속적인 심볼로써 이산 확률 변수로 나타냄 → 값을 불연속적으로 가짐

1. 원핫 인코딩

• 원핫 인코딩의 벡터의 차원은 보통 Vocab 의 개수 (30,000~100,000)
• <문제점> (1)벡터의 차원이 너무 크다 (2)많은 부분이 0으로 가득찬 sparse vector(희소 벡터) → 벡터 간 유사도 등 연산 시 결과값이 0으로 수렴 → 서로 유사한 경우지만 유사도가 0이 나옴 or 상대적으로 관계가 적어도 유사도가 0이 나옴 (3)차원의 저주에 따라, 차원이 늘어날수록 이와 정보를 표현하는 점(벡터)가 낮은 밀도로 희소하게 퍼져있는 문제가 지수적으로 늘어남

<차원 축소의 필요성으로 등장한 방법>

• Thesaurus(시소러스)를 활용한 단어 의미 파악 :
• ex) Wordnet (1985년)
• <구조> 계층적 구조, 트리 구조가 아닌 유향 비순환 그래프 DAG(directed acyclic graph)
• <장점> 코퍼스(Training set)가 없어도 단어간 유사도를 구할 수 있음
• <한계> (1)사전 구축에 너무 큰 비용과 시간 소요 (2)특정 도메인(수집된 데이터)에 특화된 수치를 계산하고 싶은 경우 어려움 (3)신조어 or 사전에 등록되지 않은 단어 문제 (4)단어의 의미가 과거와 다르게 변화한 경우 문제
• <배운점> : Data-driven 방식의 필요성..!

2. 특징 벡터(Feature Vector)

• ex) TF-IDF
• 출현 빈도를 이용하여 어떤 단어 w가 문서 d 내에서 얼마나 중요한지 나타내는 수치 (수치가 높을수록 해당 단어가 해당 문서를 대표하는 성질을 띈다)
• <가정> 의미가 비슷한 단어라면, 쓰임새/역할 역시 비슷할 것이고 함께 나타나는 단어들이 유사할 것이다.
• <한계> (1)문서가 지나치게 많을 시, 여전히 벡터의 차원이 커지는 문제 (2)여전히 sparse vector(희소 벡터) (3)단순히 문서에서의 ‘출현 횟수’만으로 특징 벡터를 구성하다 보니 많은 정보가 유실됨 (4)단순한 원리로 아주 정확한 특징 벡터를 구성하기에는 무리

3. Context Window로 함께 출현한 단어들의 정보 활용하기

• 동시발생(Co-Occurrence) 단어들을 활용한 방법, 각 단어별로 윈도우 내에 속해 있는 이웃 단어들의 출현 빈도를 세어 행렬로 나타내는 ‘Windowing’ 실행
• <가정> 의미가 비슷한 단어라면, 쓰임새/역할 역시 비슷할 것이고 함께 나타나는 단어들이 유사할 것이다.
• <장점> TF-IDF 보다 더 정확
• <한계> (1)‘윈도우 크기’라는 하이퍼파라미터 추가 → 적절한 크기를 정하는 문제 (2)여전히 sparse vector(희소 벡터)

단어를 벡터로 표현하는 방식의 구분

➕) [딥러닝독학! (5) simple word2vec- 밑바닥부터시작하는딥러닝 2] (https://haystar.tistory.com/27?category=962717)

• 밑바닥부터시작하는딥러닝 2에서는 단어를 벡터로 표현하는 방법을 크게 통계 기반 기법와 추론 기반 기법로 나누고 있음
• 용어 통계 기반 기법(ex. 특이값 분해(Singular Value Decomposition, SVD)) VS. 추론 기반 기법(ex. 신경망)
• 통계 기반 기법이 김기현의 자연어 처리 딥러닝 캠프 에서 [5장. 유사성과 모호성 ()] VS. 추론 기반 기법 이 [6장. 단어 임베딩 (word2vec 계열 - CBOW/Skip-gram, Glove 계열 - FastText)]
• (김기현은 전통적인 방식의 자연어 처리 VS. 딥러닝에서의 자연어 처리 라고 자주 표현함)

단어를 벡터로 표현하는 기법의 발전동향

➕) [word2vec 이해를 위한 개념 정리 part1] (https://sikaleo.tistory.com/11)

1. 희소 표현(Sparse Represents)
2. 밀집 표현(Dense Representation)
3. 워드 임베딩(Word Embedding)
4. 분산 표현(Distributed Representatin)
5. 신경망에서의 단어 처리

(1) 데이터 크롤링/전처리/증강이 관건, 확보한 데이터셋 기반으로 모델 training 실험 계획 수립하자

(2)

• 용어 Counterfactually-augmented data (: 반사실적으로 보강된 데이터)

• 용어 Spurious Correlations (: 허위 상관관계, 상관계수 값이 1에 가깝지만, 실제론 관계가 없는 경우)

• 용어 Casuality-based augmentation (: 학습 시와 동일한 분포에서의 Generalization을 넘어, 변경된 (Casual한) distribution에서 기존의 knowledge를 어떻게 재사용하여 인간처럼 추론/이해하는 모델을 만들지의 문제, 딥러닝 2.0 레벨과 관련) - [Casual Learning과 관련된 연구] (https://brunch.co.kr/@advisor/23)

• 용어 Anchor / Anchoring (NLP 분야에서 앵커링은 “Conditioning” 기준과 유사하다..?)

➕)

• [[자연어처리] 어떻게 텍스트 데이터를 늘릴 것인가? (Text Data Augmentation)] (https://fish-tank.tistory.com/95)
  • 2019년 EMNLP에서 발표된 "Easy Data Augmentation Techniques for Boosting Performance on Text Classification Tasks" 라는 논문
  • 이를 한국어용으로 코드구현을 한 좋은 자료가 있어 아래 깃허브를 함께 올린다 !  github.com/catSirup/KorEDA/blob/master/eda.pygithub.com/catSirup/KorEDA/tree/master
  • 이분께서는 RD, RS 두가지 방식을 먼저 추천하는 것 같다.

➕)

• Grid search / Random search / Bayesian Optimization (: 적절한 하이퍼파라미터를 탐색) (1) [[Machine learning] 쉽게 설명하는 Grid search - 모델 성능을 최고로 만드는 hyper parameter를 찾아서] (200727) (https://huidea.tistory.com/32) (2) 3기법 비교 글 - [[ML] 베이지안 최적화 (Bayesian Optimization)](https://wooono.tistory.com/102)

2. The whys and hows of data augmentation (http://dmqm.korea.ac.kr/activity/seminar/307)

• Data augmentation에서 주의해야 할 점은 semantically invariant transformation(: 의미가 불변하는 변환, 즉, augmentation이 image/text class label을 보존)여야한다는 점이다.

• <텍스트 데이터에서의 augmentation 기법> 1) 사전적 의미가 비슷한 단어로 바꾸는 기법 - Thesaurus-based Substitution 2) Embedding을 통해 벡터 공간에서 거리가 가까운 단어로 바꾸는 기법 - Word Embedding-based Substitution 3) 특정 단어 위치에 Mask를 씌워 미리 학습된 모델의 예측값을 사용하는 기법 - BERT를 이용한 Masked Language Model 4) 문장에서 의미가 크지 않은 단어를 다른 단어로 대체하는 기법 - TF-IDF-based Replacement 5) 기계번역 모델을 증강에 활용하는 기법 - 번역 후 재번역하는 Back Translation 6) 워드 임베딩 피쳐/센텐스 임베딩 피쳐에 믹스업- Word/Sent Mixup

• Data의 특성에 따라 augmentation 하는 방법이 많이 다르다..!

• torchtext 라이브러리 → data.Field() 클래스, data.TabularDataset.split() 클래스, data.BucketIterator.split() 클래스, LanguageModelDataset() 클래스

✅ Flask 프레임워크를 활용해서 API를 만들기 ✅ API를 클라이언트에 연결하기 ✅ 실습에서 적용해보기

* Flask 서버

• templates 폴더는 주로 HTML 파일이 담기는 곳
• static 폴더는 주로 이미지, CSS 파일 등이 담기는 곳
  
  

사전 준비

1. 폴더 및 파일 준비
2. mongoDB 준비
3. 필요한 라이브러리들 임포트
   
   

1-1. 폴더 생성

• 폴더의 구성 (PyCharm)
  

1-2. 파일 준비

• 1. app.py 파일 만들어 놓기 (= 서버 코드)

  • [1] POST 과정 ✨

    • _(app.py 파일 내에서) _POST 요청 API코드 + mongoDB 문법 활용해서 ➡️ 사용자로부터 입력받은 데이터 클라우드DB에 저장..!

    
    
    

  • [2] GET 과정 ✨

    • _(app.py 파일 내에서) _GET 요청 API코드 + mongoDB 문법 활용해서 ➡️ 기존에 클라우드DB에 저장해 놓은 데이터 가져오기..!

    
    
    

• 2. index.html 파일 만들어 놓기 (= 클라이언트 코드)

  • [0] Jquery 임포트 (필수 ❗️)

    <br>
    <br>

  • [1] POST 과정 ✨

    • _(index.html 파일 내에서) _POST 요청 확인 Ajax코드를 활용해서 ➡️ 데이터 입력&저장 완료 시 원하는 메시지 띄우기 가능..!
      - (ex. '요청을 잘 받았습니다.', '주문 완료!' 등)
      - code 적용 예시

        function done_bucket(num) {
            $.ajax({
                type: "POST",
                url: "/bucket/done",
                data: {num_give: num},
                success: function (response) {
                    alert(response["msg"]) ### 예시
                    window.location.reload() ### 예시
                }
            });
        }

    
    
    

  • [2] GET 과정 ✨

    • _(index.html 파일 내에서) _GET 요청 확인 Ajax코드 활용해서 ➡️ 가져온 데이터 페이지 상에서 순차적으로 보여주기..!
      - (ex. for문 함께 사용)
      - code 적용 예시 ``` function show_order() { $('#order-box').empty() $.ajax({ type: 'GET', url: '/mars', data: {}, success: function (response) { let rows = response['orders'] for (let i = 0; i < rows.length; i++) { let name = rows[i]['name'] let address = rows[i]['address'] let size = rows[i]['size']

            let temp_html = `<tr>
                                <td>${name}</td>
                                <td>${address}</td>
                                <td>${size}</td>
                              </tr>`
            $('#order-box').append(temp_html)
        }

    }

    }); }

3-1. 서버 사용을 위한 임포트

• Flask
• dnspython
• requests
  

3-2. 몽고DB 사용을 위한 임포트

• pymongo
• dnspython
• ➕) certifi (나는 맥북이라 mongoDB 연결과정에서 추가로 보안설정함)

3-3. 추가 임포트

• ex) beautifulsoup/bs4 (크롤링 시)

➕ 배포

• og title
• image
• description

[실습 1.] 화성 땅 공동구매

[실습 2.] 스파르타피디아 (영화 별점 기록 페이지)

[실습 3.] 버킷리스트

[실습 4.] 팬명록 페이지

💻 [4주차 과제] 웹 페이지에 POST/GET 기능 추가

- 과제 개요

팬명록 페이지 (1주차 과제) 에 두 가지 기능 추가하기

• 1) 응원 남기기(POST): 정보 입력 후 '응원 남기기' 버튼클릭 시 주문목록에 추가
• 2) 응원 보기(GET): 페이지 로딩 후 하단 응원 목록이 자동으로 보이기

- 완성 🌟

• 작성 중 ..

📃 Playing Atari with Deep Reinforcement Learning

• arXiv (Deep Mind)
• 강화학습 (CV)
• https://arxiv.org/pdf/1312.5602.pdf?source=post_page---------------------------
  

📃 A Neural Algorithm of Artistic Style

• arXiv
• 스타일 변환 (CV)
• https://arxiv.org/pdf/1508.06576.pdf?translate=1&translate=1&translate=1&translate=1
  

🤍✨🤍✨🤍

📃 On Measuring Social Biases in Sentence Encoders

• NAACL
• Bias Metrics (차별적 결과를 띌 수 있는 편향)
• https://aclanthology.org/N19-1063.pdf
  

🤍✨🤍✨🤍

📃 Bi-Cross 사전 학습을 통한 자연어 이해 성능 향상

• 제33회 한글 및 한국어 정보처리 학술대회 논문집 (2021년) (네이버 Clova팀)
• BERT 계열에서 [cls] 토큰이 성능이 높지 않은 경향이 있어, => 나머지 토큰의 평균값을 산출해 활용하자는 주장이 최근에 나오고 있음.
• https://www.koreascience.or.kr/article/CFKO202130060669824.pdf
• 아직 구현한 코드는 없음

📃 Enriching Pre-trained Language Model with Entity Information for Relation Classification

• arXiv
• B-BERT Model
• 관계 추출 Task에서 성능을 높이기 위해 개선된 모델
• https://arxiv.org/abs/1905.08284
• 구현 코드 있음
  
  

* Pretrained Model에 Head 붙이기

• ➕) head를 좀더 쌓는 개선 방법들
  • ex. convolution 1d layer를 하나 추가한 개선법 (지엽적 정보를 좀더 활용할 수 있게끔 만들어줌)
  • ex. LSTM ld layer를 하나 추가한 개선법

• ➕)

🤍✨🤍✨🤍

아이디어 1

• 구글 티처블머신 함께 활용해서 게임 사이트? (ex. 이미지 분류 모델학습&내보내기 활용해 -> 고개를 흔들어서 하는 청기백기 게임?)

아이디어 2

• 다양한 AI기술을 연습해볼 수 있는 사이트? (Ex. 자연어 처리 기술 데모 웹사이트(오픈소스) 결과를 크롤링해서 데이터를 보여줌)
  • ex.) 현재 실시간 순위 중 ?위의 노래 제목으로 시작되는 문장을 생성해주는 시스템
  • 멜론 사이트에서 크롤링 을 통해 노래 제목을 가져옴 -> 문장 생성 모델 기반의 오픈소스 API에 이를 인풋 데이터로 넣음 -> 결과로 출력되는 아웃풋 데이터를 사용자에게 보여줌

아이디어 3

• 데이터 Post/Get을 연습해보게 좀더 데이터베이스 구조를 사용하는 사이트? (구상해보기)

아이디어 4

• 일상 생활에서 가깝게 사용할 수 있을만한 웹사이트 (Ex. 작가(친구)는 작품을 올리고 방문자는 방명록을 쓸 수 있는 기능 등)

. . .

1. KcBERT (20년?, SKT브레인 공개)

• 구어체/신조어 반영
• KcBERT는 2019.01-2020.06의 텍스트로, 정제 후 약 9천만개 문장으로 학습을 진행

2. KcELECTRA (21년 4월, Beomi 개인?)

• (https://github.com/Beomi/KcELECTRA)
• 구어체/신조어 반영
• 뉴스 기사 본문 뿐만 아니라, 한국어 댓글/대댓글까지 학습 데이터로 활용
• 데이터 사이즈는 텍스트만 추출시 약 17.3GB이며, 1억8천만개 이상의 문장 (문장 수 2배..!)
  

3. KoGPT-2 (21년 4월, SKT브레인 공개)

• (https://github.com/SKT-AI/KoGPT2)
• 부족한 한국어 성능을 극복하기 위해 40GB 이상의 텍스트로 학습된 한국어 디코더(decoder) 언어모델
• tokenizers 패키지의 Character BPE tokenizer로 학습됨
• ~ 등의 미사용 토큰을 정의
• 한국어 위키 백과 이외, 뉴스, 모두의 말뭉치 v1.0, 청와대 국민청원 등의 다양한 데이터가 모델 학습에 사용됨
  

4. KoBART (21년 12월..!!!, SKT브레인 공개) 👑👑👑

   • (https://github.com/SKT-AI/KoBART)
   • 입력 텍스트 일부에 노이즈를 추가하여 이를 다시 원문으로 복구하는 autoencoder의 형태로 학습이 됩니다.
   • 논문에서 사용된 Text Infilling 노이즈 함수를 사용하여 40GB 이상의 한국어 텍스트에 대해서 학습한 한국어 encoder-decoder 언어 모델

   

   
   
   

2. 주어진 과제(자연어 추론, NLI)에 대한 이해

카카오브레인 기술블로그 글

• [2018-2020 NLU 연구 동향을 소개합니다(2020/02/26)] https://www.kakaobrain.com/blog/118
  

읽고 느낀/배운 인사이트

• 참인 가설을 찾는(= 분류해내는) 자연어 추론 과제에서는 1) "어순"이 중요
  • ➡️ 따라서, "문맥"을 이해하는 모델이 중요
  • ➡️ 좀더 통계 기반의 기법(ex. 카운트 기반/통계 기반 기법과 같은.. CBOW계열과 같은 기법..)은 문장에서 "패턴"을 학습하는 경향이 있으므로 도움이 안 될 것 같다.(ex. 배열된 단어의 유사성 or 등장횟수(Co-occurrence 등?)이 아닐까)
    • 또는, 좀더 패턴을 잘 추출해내는 특징이 있는 CNN계열 도는 CNN과 조합된 모델도 도움이 안 될 것 같다.
    • 따라서, 가장 최신의 SOTA 한국어 언어모델을 쓰자..! ✨
      

• ** 2) "목적어"와 **"주어"가 바뀌는 경우, 모델이 맞는 참/거짓을 잘 만들어내지 못함
  • ➡️ 따라서, "새로운 도전"을 시도해보는 것은 어떨까 ❓ (ex. 품사 태깅 기술 기반으로 주어/목적어/서술어 등을 태깅한 결과를 함께 활용..?) ✨
    

전제(premise)와 가설(hypothesis)로 구성된 한 쌍의 문장이 있을 때 전제가 참이면 가설도 참인지를 추론하는 자연어 추론 과제에서도 비슷한 현상이 발견됩니다. 두 문장에 등장하는 일부 어휘가 겹친다는 이유만([그림 8-1]으로 어순을 바꿔도 참이라고 예측해버리는 거죠. 이렇게 되면 BERT(base)에서의 추론 정확도는 84%에서 20%까지 떨어집니다. 기존 문장에서 목적어를 주어로 바꾸어 사실 관계를 바꾼 상황([그림 8-2], [그림 8-3])에서는 (출력값이 참인 경우는 제외하고는) 정확도가 80%에서 10% 이하로 떨어지는 사례도 종종 있었습니다. 이는 문장을 구성하는 단어 수와는 관계없이 문장 간 관계를 겨우 3개의 범주로만 분류하는 과제 특성에 기인한 것으로 보입니다.

품사태깅(POS, Part-of-speech Tagging)이란?

• 위키독스
  • https://wikidocs.net/33532 (품사 태깅) VS. https://wikidocs.net/30682 (개체명 인식)
    

한국어에서 품사 태깅 "구조"는 어떻게 되는가?

• [Week 44 - 하나의 문장을 언어학적으로 해부해볼까: DP, POS, NER (2021/02/14)] https://jiho-ml.com/weekly-nlp-44/

  
  - 🤔 `의존 구조 분석` VS. `POS Tagging`

  • 1) 딥 러닝을 이용한 한국어 의존 구문 분석 - Korea Science (2014년)

  • (https://www.koreascience.or.kr/article/CFKO201408355727273.pdf)

  • 2) 한국어 품사 태깅 시스템 - Korea Science (1990년대..?)

  • (http://www.koreascience.or.kr/article/CFKO199511920212880.pdf)

  
  
  

• 🤔 하지만, 더 생각해봐야할 점 ? (⚠️)

  의존 구존 분석과 POS Tagging은 문장의 구조와 단어 간의 관계를 파악하는데 중점을 두고 있습니다. 언어학자들이 만든 이론에 따라 NLP 모델을 이용해 문장 분석을 하는 것이죠. 재밌는 사실은 RNN, BERT, GPT 등의 언어 모델에서는 이러한 지식을 직접적으로 가르켜주지 않아도 어느정도 네트워크 안에 파악이 되어있다는 것입니다.

  2020년 발표된 이 논문에서는 여러 언어 데이터가 함께 학습된 다국어 mBERT 모델을 분석한 결과, 문장의 의존 구조를 어느 정도 파악하고 있는 것으로 나타났습니다. 더 재밌는 점은 만국 언어 공통의 구조 역시 존재하고, 비슷한 언어 계열일 경우 이 구조가 공유될 수 있다는 점입니다.

  예를 들어, 영어 데이터만으로 BERT를 학습해도 프랑스 문장 구조에 대한 이해가 있다는 것이죠. 다국어(multilingual) 모델은 또 하나의 재밌는 주제인데, 다음에 한번 다루어보도록 하겠습니다.

  
  

1. 셀프 어텐션 (SDPA(Scaled Dop-Product Attention))

• 수식의 구현 Flow

  • [1] Query벡터와 transpose한 Key벡터의 내적
  • [2] Key벡터의 차원의 루트 값으로 나누어 주어 정규화
  • [3] softmax를 취해주어 도합 1 사이의 확률 벡터로 변환
  • [4] 지금까지 구한 값을 활용해 Value벡터에 가중치 합을 구해줌
    

• code

  class ScaledDotProductAttention(nn.Module):
    def forward(self,Q,K,V,mask=None):
        d_K = K.size()[-1] # key dimension
  
        scores = Q.matmul(K.transpose(-2, -1)) / np.sqrt(d_K) ## ([1] Query벡터와 transpose한 Key벡터의 내적) / ([2] Key벡터의 차원의 루트 값으로 나누어 주어 정규화)
  
  

    if mask is not None: ## option인 Masking 안 했을 경우
        scores = scores.masked_fill(mask==0, -1e9)


    attention = F.softmax(scores,dim=-1) ## ([3] softmax를 취해주어 도합 1 사이의 확률 벡터로 변환)
    out = attention.matmul(V) ## ([4] 지금까지 구한 값을 활용해 Value벡터에 가중치 합을 구해줌)

    return out, attention

<br>

- 특징
  - `SDPA`는 멀티 헤드 어텐션을 support한다.
  - `Key 벡터`와 `Value 벡터`의 크기는 같아야 한다. 


<br>
<br>

# 2. 멀티 헤드 어텐션 (MHA(Multi-Head Attention))

![](https://images.velog.io/images/gromit_dev/post/6a33e00e-b250-46fc-a9a8-85b1cc02f6cf/image.png)

- 특징
  - 멀티헤드의 수로 나눈 크기만큼 배치로 처리가 이뤄진다.
  - dropout 옵션은 논문의 설명에서 포함되어 있지 않지만, 모든 코드에 적용되어 있음
  - 층은 총 4개 (Query/Key/Value 벡터가 곧 하나의 `layer` + `Linear Layer`)
      > - [1] Query 벡터 층
     - [2] Key 벡터 층
    - [3] Value 벡터 층
    - [4] 연산을 output하기위한 Dense 층

  - 셀프 어텐션과 달리 멀티 어텐션에서는 `d_feature`를 전체 멀티헤드의 수로 나눈 크기만큼 입력 임베딩 벡터를 split하여 접근
  - 이들로부터 독립적(independent)으로 각 Attention의 matmul을 통한 `score 값`을 구한 뒤,
  - 멀티헤드 수만큼 구한 각 셀프 어텐션 결과를 다시 `d_feature` 크기로 concat 해준 것이 최종 결과물 !

  <br>
- code

class MultiHeadAttention(nn.Module): def init(self, d_feat=128, n_head=5, actv=F.relu, USE_BIAS=True, dropout_p=0.1, device=None): """ :param d_feat: feature dimension :param n_head: number of heads :param actv: activation after each linear layer :param USE_BIAS: whether to use bias :param dropout_p: dropout rate :device: which device to use (e.g., cuda:0) """

    super(MultiHeadAttention,self).__init__()

    if (d_feat%n_head) != 0: ## feature dimension이 멀티헤드의 수로 나누어지지 않을 경우 에러 던지기
        raise ValueError("d_feat(%d) should be divisible by b_head(%d)"%(d_feat,n_head)) 


    self.d_feat = d_feat
    self.n_head = n_head
    self.d_head = self.d_feat // self.n_head ## 멀티헤드의 수로 나눈 크기만큼 배치 처리
    self.actv = actv
    self.USE_BIAS = USE_BIAS
    self.dropout_p = dropout_p # prob. of zeroed ## dropout 옵션은 논문의 설명에서 포함되어 있지 않지만, 모든 코드에는 적용되어 있음

    self.lin_Q = nn.Linear(self.d_feat,self.d_feat,self.USE_BIAS) ## [1] Query 벡터 층
    self.lin_K = nn.Linear(self.d_feat,self.d_feat,self.USE_BIAS) ## [2] Key 벡터 층
    self.lin_V = nn.Linear(self.d_feat,self.d_feat,self.USE_BIAS) ## [3] Value 벡터 층
    self.lin_O = nn.Linear(self.d_feat,self.d_feat,self.USE_BIAS) ## [4] 연산을 output하기위한 Dense 층

    self.dropout = nn.Dropout(p=self.dropout_p) ## Drop-out 설정



def forward(self,Q,K,V,mask=None):
    """
    :param Q: [n_batch, n_Q, d_feat]
    :param K: [n_batch, n_K, d_feat]
    :param V: [n_batch, n_V, d_feat] <= n_K and n_V must be the same 
    :param mask: 
    """

    n_batch = Q.shape[0]
    Q_feat = self.lin_Q(Q) 
    K_feat = self.lin_K(K) 
    V_feat = self.lin_V(V)
    # Q_feat: [n_batch, n_Q, d_feat]
    # K_feat: [n_batch, n_K, d_feat]
    # V_feat: [n_batch, n_V, d_feat]


    # Multi-head split of Q, K, and V (d_feat = n_head*d_head)
    Q_split = Q_feat.view(n_batch, -1, self.n_head, self.d_head).permute(0, 2, 1, 3)
    K_split = K_feat.view(n_batch, -1, self.n_head, self.d_head).permute(0, 2, 1, 3)
    V_split = V_feat.view(n_batch, -1, self.n_head, self.d_head).permute(0, 2, 1, 3)
    # Q_split: [n_batch, n_head, n_Q, d_head]
    # K_split: [n_batch, n_head, n_K, d_head]
    # V_split: [n_batch, n_head, n_V, d_head]

    # Multi-Head Attention
    d_K = K.size()[-1] # key dimension

    scores = torch.matmul(Q_split, K_split.permute(0, 1, 3, 2)) / np.sqrt(d_K)
    ## 셀프 어텐션과 달리 멀티 어텐션에서는 d_feature를 전체 멀티헤드의 수로 나눈 크기만큼 입력 임베딩 벡터를 split하여 접근
    ## 이들로부터 독립적(independent)으로 각 Attention의 matmul을 통한 score 값을 구한 뒤,
    ## 멀티헤드 수만큼 구한 각 셀프 어텐션 결과를 다시 d_feature 크기로 concat 해준 것이 최종 결과물 !





    if mask is not None:
        scores = scores.masked_fill(mask==0,-1e9)


    attention = torch.softmax(scores,dim=-1)
    x_raw = torch.matmul(self.dropout(attention), V_split) # dropout is NOT mentioned in the paper
    # attention: [n_batch, n_head, n_Q, n_K]
    # x_raw: [n_batch, n_head, n_Q, d_head]



    # Reshape x
    x_rsh1 = x_raw.permute(0,2,1,3).contiguous()  ## (torch.permute()함수로 차원에 순서를 주어 모든 차원을 서로 맞교환(?) 해줌과 동시에 contiguous()함수를 불러주어, contiguous tensor로 안전하게 설정해줌)
    # x_rsh1: [n_batch, n_Q, n_head, d_head]

    x_rsh2 = x_rsh1.view(n_batch,-1,self.d_feat) ## 다시 원래 차원인 d_featur로 view()함수를 통해 차원을 축소시켜 줌.
    # x_rsh2: [n_batch, n_Q, d_feat]



    # Linear
    x = self.lin_O(x_rsh2)
    # x: [n_batch, n_Q, d_feat]

    out = {'Q_feat':Q_feat,'K_feat':K_feat,'V_feat':V_feat,
           'Q_split':Q_split,'K_split':K_split,'V_split':V_split,
           'scores':scores,'attention':attention,
           'x_raw':x_raw,'x_rsh1':x_rsh1,'x_rsh2':x_rsh2,'x':x}
    return out

<br>
<br>




## ❓
#### torch.transpose(input, int dim0, int dim1)
- `Key벡터`와 `transpose된 Key벡터`를 출력해본 결과
![](https://images.velog.io/images/gromit_dev/post/a6e1d10e-feee-44be-93cd-7d45c1dbcc43/%ED%99%94%EB%A9%B4%20%EC%BA%A1%EC%B2%98%202022-02-08%20123312.png)

<br>
<br>

#### torch.matmul()
- 두 텐서 간의 `Matrix product(행렬 곱)`
- 두 텐서의 차원의 크기(`dimension`)에 따라 적용되는 연산이 달라지는데,
> - [5] 두 tensor 모두 1 dimensional이상이고 하나의 tensor가 3이상의 N dimensional이면, batched matrix multiply가 수행된다. 첫번째 tensor가 1 dimensional이면 1차원이 앞에 추가되어 batched matrix multipy를 수행하고, 수행후에 추가된 dimension은 사라진다. non-matrix dimension (batch)는 broadcast된다. 예를 들면 첫번째 tensor가 (j x 1 x n x n) tensor이고, 두번째 tensor가 (k x n x n) tensor일 때, output은 (j x k x n x n) tensor가 된다. broad casting logic은 input이 broadcast 가능할 때에 batch dimension에만 해당된다. 예를 들면 첫번째 tensor가 (j x 1 x n x m) tensor이고, 두번째 tensor가 (k x m x p) tensor일 때 matrix dimension이 달라도 broadcasting이 유효하다. output은 (j x k x n x p) tensor가 된다.
(참고: https://velog.io/@optjyy/torch.matmul)


<br>
<br>

## 📝 회고
- 🙋‍ [1]`Query 벡터`와 transpose한 `Key 벡터` 간의 **"내적"** & [2]`softmax` 함수를 취한 일종의 가중치와 `Value 벡터` 간의 **"가중치 합(Weighted Sum)"
** ➡️ 둘다 구현코드에서는 동일하게 `torch.matmul()` 사용  ❓
  - `Attention` 매커니즘의 이론을 설명할 때에는 "내적"과 "가중치 합" 이라고 표현하지만, 계산은 동일하게    `matmul` 함수를 통해 이뤄질 수 있는 것 같다.

<br>

- 💡 `Attention` 매커니즘에서 각 `Query 벡터`/`Key 벡터`/`Value 벡터` , 그리고 결과로 출력되는 `Attention Value(어텐션 값) 행렬`의 크기에 대한 고찰
>    - ![](https://images.velog.io/images/gromit_dev/post/a1130073-08e1-4aa4-bb7e-d9ce459e1ba3/image.png)
>
> <br>
>
>   - ![](https://images.velog.io/images/gromit_dev/post/c1c26eaa-d1fc-4cba-8d76-c1285221c622/image.png)

  - 각 time-step의 i번째 요소에 대해 representation(재현성 개념?)을 계산한 결과 `Attention Value(어텐션 값)`는 스칼라 값이 아니라 벡터(리스트)이다..! ✨
  - 그리고 전체 `Attention Value(어텐션 값) 행렬`은 이들이 합쳐진 Matrix다..! ✨

<br>
<br>


### 기타 참고 
- 코드 구현 시 사용되는 PyTorch 함수들이 잘 정리된 글 참고 ✨
  - [[PyTorch] view, reshape, transpose, permute함수의 차이와 contiguous] https://sanghyu.tistory.com/3
<br>

- 위키독스
   - https://wikidocs.net/31379

<br>

- `Query 벡터`/`Key 벡터`/`Value 벡터` 행렬 계산해본 예제
   - https://ratsgo.github.io/nlpbook/docs/language_model/tr_self_attention/


<br>
<br>
<br>

• 논문 리뷰 번역글 : https://velog.io/@changdaeoh/Vision-Transformer-Review
• PyTorch 구현 글 : https://hongl.tistory.com/235

• einops 라이브러리 (피어세션 공유)
  • https://einops.rocks/api/rearrange/
  • http://einops.rocks/pytorch-examples.html

2. seq2seq

-

입력된 시퀀스로부터 다른 도메인의 시퀀스를 출력하는 다양한 분야에서 사용되는 모델입니다. 예를 들어 챗봇(Chatbot)과 기계 번역(Machine Translation)이 그러한 대표적인 예인데, 입력 시퀀스와 출력 시퀀스를 각각 질문과 대답으로 구성하면 챗봇으로 만들 수 있고, 입력 시퀀스와 출력 시퀀스를 각각 입력 문장과 번역 문장으로 만들면 번역기로 만들 수 있습니다. 그 외에도 내용 요약(Text Summarization), STT(Speech to Text) 등에서 쓰일 수 있습니다. (https://wikidocs.net/24996)

1. 인코더

2. 디코더

3. 생성자

• 즉, seq2seq의 구조는 2개의 RNN구조의 결합체..! (2개에는 인코더와 디코더가 해당됨)

보완점

3. Attention

• RNN/LSTM/GRU와 같은 시퀀셜 모델링에서는 Hidden State가 모든 정보를 담기 어려운 문제가 계속되었다. (아무리 LSTM에서 장기 의존성 문제(Long Distance에서의 Long Dependency 문제)를 일부 해결했다 할지라도)

• 따라서, Encoder에 쿼리(Query)를 날려 필요한 정보만 찾아서 리턴하게끔 하는 Attention 매커니즘 개념이 도입됨..!

• Attention 은 쿼리를 잘 만드는 과정을 배우는 일련의 과정..! (미분이 가능한 Key-Value Function 이다..!)

4. Input Feeding

효과

• Teacher Forcing으로 인한 학습/추론 사이의 괴리 최소화
• sampling 과정에서 손실되는 정보를 최소화

단점

• 학습 시 속도의 저하 문제 (추론시에는 크게 문제가 되진 않음.)

  • 이전에는 Decoder도 Encoder 와 마찬가지로 모든 time-step에 대해 한번에 계산할 수 있었지만, Input Feeding에서는 Decoder의 RNN 구조에서 입력으로 이전 time-step의 결과가 필요하게 되며 ➡️ 병렬처리를 하지 못하고 순차적 계산(각 time-step 별로 계산)을 해야만 하게 됨.

• Sequence는 뒤에가 잘리는 경우, 중간에 생략되는 경우, 어순이 바뀌는 경우 등이 존재
• 따라서 재귀적으로(recurrersive) 동작하는 RNN 계열의 경우에는, 이런 문제들을 반영해 학습하기가 어려웠음.

Transformer

• 기계번역 외에도 이미지 분류, 문장 조합에서 이미지를 생성하는 모델(DALL·E - 참고: https://openai.com/blog/dall-e/)
• (1)시퀀셜한 데이터를 처리하고 인코딩하는 구조 & (2)멀티 어텐션 헤드 개념은 다른 Task에서도 많이 사용되고 있음

- RNN 계열과 다른 특징

• [1] 입력 시퀀스와 출력 시퀀스의 크기(단어의 수)가 다를 수 있음.
• [2] 입력 시퀀스와 출력 시퀀스는 데이터의 Domain도 다를 수 있다. (예: 기계번역 Task에서 입력은 한국어, 출력은 영어)
• (하지만 모델은 1개)

• 인코딩 시, RNN 처럼 단어의 수만큼 재귀적으로 돌지 않고, 한 번에 해당 단어의 수만큼 시퀀스가 딱 생성된다.
• Encoder/Attention 구조에서는 n(해당 단어의 수, 가변적인 단어 수..!!)만큼 한 번에 처리된다.
• (➕ cf. Generator(생성자) 단계에서는, 1개 단어씩 생성한다..! 따라서, 이때는 Auto-Regressive)

- Transformer의 구조

• 동일한 내부 구조를 갖지만 parameters가 다르게 학습되는 Encoder와 Decoder가 여러 개 stack되어 있는 구조.

• Self-Attention이 핵심 (Transformer에서 인코딩 단계에 해당됨)

• 입력으로 주어진 n개의 단어가 들어갈 때, x_i에서 z_i으로 n개의 벡터(=Feature Vectors)를 변환하는 구조.

• 이때 해당 1개 단어 외, 나머지 (n-1)개의 단어의 정보를 함께 활용한다..!!!

• ➕ Self-Attention VS. Feed Forward
  • word-dependent // word-independent
  • (dependency 가짐 O) // (dependency 가지지 X)
  • paralleized X // parallelized O

• 쿼리를 날리는 과정
• 현재 내가 구하고자 하는 i번째 단어 1개에 해당하는 Query 벡터와 나머지 (n-1)개에 해당하는 Key 벡터 및 Value 벡터의 내적 값을 구하여 => Score 값(유사도, 상호관계성 관련 지표 / type: 스칼라 값)을 구함.
• 즉, 특정 time-step에서 나머지 단어들 중 어떠한 단어가 자신과 corresponding 한지를 찾는 자기할당(self-aligned) 과정

• 이때, Score 값을 계산할 때는, 정규화(Normalization) 개념으로 전체 벡터의 차원(=Query 벡터 의 차원 = Key 벡터 의 차원)의 루트 값으로 나누어줌. (분모 값)
• 이후, softmax() 함수를 취해줌.
• 이후, Value 벡터 와의 weighted sum(가중치 합)이 최종 인코딩 벡터의 결과..!!

• 인코딩 단계의 최종 결과값 : n차원의 인코딩된 벡터..!

➕ Query/Key/Value 벡터의 Dimension

• Query 벡터 의 차원 = Key 벡터 의 차원..!
• 하지만, Value 벡터 의 차원은 이 둘과 다를 수 있다..!
• 🙋‍ 그 이유는 ??

• MLP(다층 퍼셉트론 구조) 나 CNN에서는 인풋이 고정되어 있으면, 출력도 고정되어 있다. (연산에 쓰이는 필터/가중치 등 파라미터가 고정되어 있기 때문에)
• 하지만 Transformer에서는 인풋/네트워크 구조가 고정되어 있더라도, 현재 인코딩하는 단어와 근처에 주어진 다른 단어들과의 관계성에 따라 출력이 달라질 수 있다..!
• 따라서, 표현성이 높은 flexible한 모델 ➕ 하지만, 그만큼 연산량이 증가한 모델
• 이러한 문장의 길이가 길어짐에 따라 증가하는 연산량은 Transformer의 한계가 됨.
  
  

Muti-Head-Attention

• 하나의 임베딩된 벡터에 대해서 Query/Key/Value를 여러 개(m개) 만드는 접근법.
• 총 m개의 인코딩된 벡터 세트가 아웃풋 결과물
• (이 과정에서 차원을 맞춰주기 위해 linear map을 활용해 차원을 축소시켜줌)
• (➕ 이 부분은 구현 시 논문과 살짝 다름..?)

➕ Positional Encodings

• Self-Attention만 가지고는 순서 정보를 알 수 없음. (order-independent)
• 따라서, 주어진 원래 임베딩 벡터 값에 위치를 나타내는 값을 더해줌.
• ➕ 방법론: [1] Attention is all you need 논문의 방식, , [2] 최근 논문(2020년 7월)의 방식

➕ Masking 기법 (Caution Masking)

• 이전 단어들에 대해서만 dependent하고 이후 단어들에 대해서는 independent하지 않게 만드는 방법론
• 이를 통해, 학습 시 해당 단어의 뒤에 있는 정보(미래에 있는 정보)를 활용하지 않도록 방지하는 효과 (정답을 이미 알고 있는 학습 단계에서는 뒤를 참고하게 된다면 제대로된 학습이 이뤄지지 않게 되기 때문에)
• Masking은 train 뿐만 아니라 inference에서도 사용됨

Decoder + Generator 단계

• 입력 시퀀스(문장) uto-regressive 방식으로 생성된다.
• Encoder-Decoder Attention layer : 생성 시, 내가 이전까지만 generate된 데이터만 가지고 Query를 만들고, Key+Value 벡터는 원래 raw 인풋 시퀀스(문장)서 나오는 임베딩 벡터를 활용한다..!

참고 자료

• PyTorch 공식 nn.Transformer 문서 :
  • https://pytorch.org/tutorials/beginner/transformer_tutorial.html
    

• The Illustrated Transformer :

  http://jalammar.github.io/illustrated-transformer/
  
• 번역 글 :
  • https://nlpinkorean.github.io/illustrated-transformer/
    
• 허민석님 발표 영상 :
  • https://www.youtube.com/watch?v=mxGCEWOxfe8
    
• PyTorch nn.Transformer 모듈 공식 문서 :
  • https://pytorch.org/tutorials/beginner/transformer_tutorial.html
    
• positional encoding에 대한 고찰 :
  • https://skyjwoo.tistory.com/entry/positional-encoding%EC%9D%B4%EB%9E%80-%EB%AC%B4%EC%97%87%EC%9D%B8%EA%B0%80

딥러닝의 구분

1. AI (인공지능)
   • Mimic human intelligence, 사람의 지능을 모방

2. ML (기계학습)
   • Data-driven approach, 데이터를 기반으로 무언가를 (기계)학습

3. DL (딥러닝)
   • Neural Networks, 그 안에서 뉴럴 네트워크를 사용하여 데이터를 가지고 무언가를 학습하는 세부 분야

딥러닝의 Key Components

1. data
   • the model can learn from
2. model
   • how to transform the data
3. loss function
   • quantifies the bbadness of the model
4. algorithm
   • to adjust the parameters to minimize the loss
     
     

기타

• loss function을 줄이기만 하는 것이 목적이 아니라, 모델이 학습하지 않았던 테스트 데이터/실제 사용 환경에서 잘 동작하는 것이 목적..! -> 해당 parameter 값(weight, bias)을 찾는 것이 중요할 것
• 모델의 layer를 깊게 쌓으면 문제가 생기는 이유 또한, train error는 적게 나오지만, test data에서 성능이 잘 안 나오기 때문 (+ 이는 ResNet 등장 후 보완이 됨)
  
  

Neural Networks

• 인간의 뇌 구조를 모방한 구조
• 뉴럴 네트워크는 함수를 근사하는 모델( Function Approximator )
• 비선형 변환의 연속

Neural networks are function approximators that stack affine transformations followed by nonlinear transformations.

MLP(다층퍼셉트론) PyTorch로 구현해보기

- Evaluate Function 정의

• Eval 과정은 with torch.no_grad(): 설정해줘야 함
• 전체 Dataset에서 정의한 iterator통해, 돌면서 Batch Size만큼 뽑아내며 eval과정 처리
• .to(device) 이용해 Batch Size만큼의 X 데이터/y 데이터로부터 예측 값/정답 값 정의
• view() 함수 : 필요 시, reshape

def func_eval(model,data_iter,device):
    with torch.no_grad():
        model.eval() # evaluate (affects DropOut and BN)
        n_total,n_correct = 0,0

        for batch_in,batch_out in data_iter:
            y_trgt = batch_out.to(device)
            model_pred = model(batch_in.view(-1, 28*28).to(device))
            _,y_pred = torch.max(model_pred.data,1)
            n_correct += (y_pred == y_trgt).sum().item()
            n_total += batch_in.size(0)
        val_accr = (n_correct/n_total)
        model.train() # back to train mode 
    return val_accr
print ("Done")

- Train 코드

• 전체 Dataset에서 정의한 iterator통해, 돌면서 Batch Size만큼 뽑아내며 train과정 처리

• [1] 포워드 과정

  • (1)위에서 정의한 CustomModel의 forward(self, x) 함수와 (2)선택한loss 함수(크로스엔트로피 등)에 배치를 돌면서 피드포워드
    

• [2] 옵티마이저 및 로스 업데이트 과정 (backpropagation)

  • (1)옵티마이저.zero_grad()로 값 리셋, (2)출력로스.backward()로 미분값 백워드, (3)옵티마이저.step()로 값 업데이트
    

- code

print ("Start training.")
M.init_param() # initialize parameters
M.train()
EPOCHS,print_every = 10,1

for epoch in range(EPOCHS):
    loss_val_sum = 0

    for batch_in,batch_out in train_iter:
        # Forward path
        y_pred = M.forward(batch_in.view(-1, 28*28).to(device))
        loss_out = loss(y_pred,batch_out.to(device))

        # Update
        optm.zero_grad()      # reset gradient 
        loss_out.backward()      # backpropagate
        optm.step()      # optimizer update

        loss_val_sum += loss_out

    loss_val_avg = loss_val_sum/len(train_iter)
    # Print
    if ((epoch%print_every)==0) or (epoch==(EPOCHS-1)):
        train_accr = func_eval(M,train_iter,device)
        test_accr = func_eval(M,test_iter,device)
        print ("epoch:[%d] loss:[%.3f] train_accr:[%.3f] test_accr:[%.3f]."%
               (epoch,loss_val_avg,train_accr,test_accr))
print ("Done")        

2. Optimization

1. Generalization

   • 일반화 성능을 높이자
   • 학습 데이터 - 테스트 데이터 간 성능의 차이(Generalization Gap)가 적을 때를 지향
   • underfitting vs. overfitting 용어와 관련

2. Cross-validations

   • 학습 데이터 / 테스트 데이터를 k개로 나누어서, (k-1)개로 training, 1개로 validation 일부만 학습에 사용
   • • Cross-validations을 이용해 최적의 하이퍼 파라미터 값을 찾고, 이 하이퍼 파라미터 값을 가지고 모델을 학습하는 방법

3. Bias와 Variance

   • 편향과 분산
   • bias와 variance는 Trade-off 관계를 갖는다.
   • Cost를 최소화하는 문제는, 즉, bias, variance, noise 세 가지를 최소화하는 것

4. Bootstrapping
   • 학습 데이터가 고정되어 있을 때, 그 안에서 subsampling을 통해서 학습 데이터를 여러 개로 만들고, 이를 통해 만든 여러 개의 모델/metric을 통해, 전체 모델의 일치성/불확실성을 파악하는 접근법

선형회귀문제(음성신호 데이터) PyTorch로 optimizer 비교해보기

• optimizers 정의
  • torch.optim라이브러리 활용해 선언
  • momentum 옵티마이저는 momentum=(확률값) 옵션 추가
    

- code

### 임포트 : import torch.optim as optim



LEARNING_RATE = 1e-2
# Instantiate models
model_sgd = Model(name='mlp_sgd',xdim=1,hdims=[64,64],ydim=1).to(device)
model_momentum = Model(name='mlp_momentum',xdim=1,hdims=[64,64],ydim=1).to(device)
model_adam = Model(name='mlp_adam',xdim=1,hdims=[64,64],ydim=1).to(device)

# Optimizers
loss = nn.MSELoss()
optm_sgd = optim.SGD(model_sgd.parameters(), lr=LEARNING_RATE)
optm_momentum = optim.SGD(model_momentum.parameters(), lr=LEARNING_RATE, momentum=0.9)
optm_adam = optim.Adam(model_adam.parameters(), lr=LEARNING_RATE)

print ("Done.")

- 💡 인사이트

• Adam

  • Adam은 짧은 학습 시간부터 성능(정확도)이 확보됨
  • Adam에는 adaptive learning 개념이 반영된 접근법. (adaptive learning: 어떠한 파라미터에 대해서는 lr을 높이고, 다른 어떠한 파라미터에 대해서는 lr을 줄여나감)
  • 따라서, 똑같은 lr을 선언해주어도 더 빠르게 성능이 확보될 수 있다..! ✨

• Momentum

  • Momentum은 학습 시간이 조금 길어지면 성능 확보됨. 반면, SGD는 같은 시간까지도 성능이 확보되지 않음
  • Momentum은 이전 배치의 gradient 정보를 활용해 현재 배치 턴에서 사용하겠다는 접근법
  • 이러한 점에서 미니배치일 때, SGD보다 좋다..! ✨

• SGD

  • SGD는 데이터에서 큰 특징이 되는 파트 위주로 학습이 잘되고, 세부적으로는 잘 놓치는 모양새를 보임
  • 하지만, SGD는 오랜 학습 시간이 흘렀을 때에는 더 좋은 성능을 보일 순 있다.

• 결론: Adam/rAdam을 초기에 사용하면 어느정도의 성능을 짧은 시간에 효율적으로 확보할 수 있다..! ✨

13. 서브워드 토크나이저(Subword Tokenizer)

• 현재 통상적으로 많이 사용하고 있는 Hugging Face의 WordPiece Tokenizer(구글의 BERT모델)나 센텐스피스(Sentencepiece)(구글) 이전에 등장했던 전통적 기법부터 순차적으로 살펴볼 수 있었다.

  
  

  • 바이트 페어 인코딩(Byte Pair Encoding, BPE)

  • Unigram Language Model Tokenizer

  • 센텐스피스(SentencePiece)

  • 서브워드텍스트인코더(SubwordTextEncoder)

  • BERT의 워드피스 토크나이저(BertWordPieceTokenizer)

  • 기타 토크나이저

    • BertWordPieceTokenizer : BERT에서 사용된 워드피스 토크나이저(WordPiece Tokenizer)
      • CharBPETokenizer : 오리지널 BPE
      • ByteLevelBPETokenizer : BPE의 바이트 레벨 버전
      • SentencePieceBPETokenizer : 앞서 본 패키지 센텐스피스(SentencePiece)와 호환되는 BPE 구현체

14. RNN을 이용한 인코더-디코더

• 기계번역 과제에서 모델의 성능을 평가하기 위한 지표인 BELU 또한, 이전에 카운터 기반/n-gram 등과 같은 수학/통계 기반의 지표들이 존재했다. 그리고 점차 정규화/패널티 등을 수학적으로 반영할 수 있는 평가지표로 발전해왔음을 느낄 수 있었다.

  
  

  • 시퀀스-투-시퀀스(Sequence-to-Sequence, seq2seq)

    • Teacher Forcing(교사 강요) 개념
    • seq2seq 기계번역기 TensorFlow로 구현하기 실습 (= LSTM 기반)

       - 참고: [케라스 개발자 프랑수아 숄레의 블로그의 'sequence-to-sequence 10분만에 이해하기'] https://blog.keras.io/a-ten-minute-introduction-to-sequence-to-sequence-learning-in-keras.html

  • 평가지표 BLEU Score(Bilingual Evaluation Understudy Score)

  
  - 💡 - 인코더 모델/디코더 모델(LSTM)에서의 `output, hidden_state, cell_state` (3가지 세트) - `` 토큰('\t', 인코더)과 `` 토큰('\n, 디코더)
  
  

Seq2seq 코드를 PyTorch로 구현한 링크

• https://deep-learning-study.tistory.com/686
• https://github.com/ndb796/Deep-Learning-Paper-Review-and-Practice/blob/master/code_practices/Sequence_to_Sequence_with_LSTM_Tutorial.ipynb

📝3주차 회고

• 이번 주는 설 연휴가 포함되어 있어 2일만 진행되어서 색달랐다.
• 이번 주부터 피어 분들과 3주 동안 스터디를 진행하기로 했었기에, 금요일에 피어세션 시간 외 2시간 가량 스터디를 진행했다. (위키독스(딥 러닝을 이용한 자연어 처리 입문) 13장 & 14장) 발표를 통해 직접 적용한 코드를 들으며 의논하고 이해하는 시간을 가질 수 있어서 좋았다.
• 데이터 시각화를 Web으로 연계하는 공부도 개인적으로 해봐야지..! ([데이터 시각화 웹 페이지 만들기] https://velog.io/@dhelee/TIL-Day22-%EB%8D%B0%EC%9D%B4%ED%84%B0-%EC%8B%9C%EA%B0%81%ED%99%94-%EC%9B%B9-%ED%8E%98%EC%9D%B4%EC%A7%80-%EB%A7%8C%EB%93%A4%EA%B8%B0 ✨)

• 중복은 제거하는 DISTINCT 사용 필수!!

  select count(DISTINCT NAME) as "count" from (ANIMAL_INS)
  where NAME is not null

  
  

조건에 해당하는 col 기준으로 group by col 하기

• group by 와 having 은 세트

  select NAME, count(NAME) as 'count' from ANIMAL_INS
  where NAME is not null
  

group by NAME having count(NAME) >= 2

order by NAME ASC

<br>


## null(값이 없는) col은 'No name'으로 표현하기
- ifnull(col 이름, 변경할 값) 함수

select ANIMAL_TYPE, ifnull(NAME, 'No name'), SEX_UPON_INTAKE from (ANIMAL_INS)

<br>


## 주어진 글자를 포함하는 조건
- like + '~~%'

select A.ANIMAL_ID, A.ANIMAL_TYPE, A.NAME from ANIMAL_INS as A, ANIMAL_OUTS as B where A.ANIMAL_ID = B.ANIMAL_ID and A.SEX_UPON_INTAKE like 'Intact%' and B.SEX_UPON_OUTCOME not like 'Intact%'

order by A.ANIMAL_ID

<br>


## col 값의 조건에 따라 다른 값으로 표현하기
- CASE WHEN    /  col이름 / 조건 /  THEN  / 변경할 값1  / ELSE  / 변경할 값2 /  END

select ANIMAL_ID, NAME, (CASE WHEN SEX_UPON_INTAKE like '%Neutered%' or SEX_UPON_INTAKE like '%Spayed%' THEN 'O' ELSE 'X' END) as '중성화' from ANIMAL_INS

<br>


## 날짜 정보를 다른 포맷으로 바꾸기
- date_format() 함수 : 날짜를 지정해주는 포맷으로 변경 적용

select ANIMAL_ID, NAME, date_format(DATETIME, '%Y-%m-%d') as '날짜' from ANIMAL_INS

<br>


## ❓ 잘 모르겠는 문제
- https://programmers.co.kr/learn/courses/30/lessons/59413

select A.HOUR, ifnull(B.COUNT, 0) as 'COUNT' from( select 0 as 'HOUR' union select 1 union select 2 union select 3 union select 4 union select 5 union select 6 union select 7 union select 8 union select 9 union select 10 union select 11 union select 12 union select 13 union select 14 union select 15 union select 16 union select 17 union select 18 union select 19 union select 20 union select 21 union select 22 union select 23 ) as A

LEFT JOIN( select hour(DATETIME) as 'HOUR', count(ANIMAL_ID) as 'COUNT' from ANIMAL_OUTS group by HOUR ) as B

ON A.HOUR = B.HOUR order by A.HOUR

```

• PyTorch의 다양한 함수들을 직접 과제에서 nn.Module 클래스를 활용한 Custom Model 정의하고, torch.utils.data 라이브러리 및 DataLoader 함수를 활용한 Custom Dataset을 정의하며, 적용해보며 성장한 한 주였다.

• 이전에는 TensorFlow가 좀 더 익숙하기도 했었고, 늘 클래스 단위로 구현하는 PyTorch를 사용해 직접 모델을 수정하며 구현할 줄 알고 싶었기에 과제가 어렵고 시간이 부족하기도 했었지만 너무 좋았다.

• 평소에 부족했던 Official Documentation을 보는 습관을 만들 수 있었고, 딥러닝 적용의 Flow를 익힐 수 있었다.

• 이번 주에는 팀원들과 피어세션 시간(4시~5시)가 아닌 시간에 줌을 켜놓고 질문/의논 시간 또는 모각공(모여서 각자 공부) 시간을 가졌는데 성공적이었다.

• 마스터클래스를 통해서는 빅데이터 과제에서 앞으로 가져야하는 자세/생각/접근 방향성 등을 배울 수 있었다. 개인적으로는 최근에 Web을 공부하고 있었는데 결국에는 사용자에게 접접에서 서비스를 제공할 수 있어야 된다는 생각이 들었고 이전 AI퀴즈 서비스 프로젝트를 진행하면서 많이 느끼기도 했기 때문에 시작했다. (+ BERT/ELECTRA를 써보며 모델은 잘 학습된 Pre-trained 모델이나 API화 되어있는 모델을 선택하면 현재 Domain Task에 더 대용량 데이터&파라미터 튜닝이 된 모델을 활용할 수 있을 것이란 생각도 있었다.) 그렇지만 문득 방향성에 대한 고민?이 들기도 했었는데 이러한 방향이 맞다는 생각을 가질 수 있었고 더욱 부스팅하자고 다짐할 수 있었다.

[과제 1.] Custom Model 개발하기

- 실습과제를 풀며 생겼던 궁금증 / 느낀점

• ❓ torch.Tensor.scatter_() 함수와 torch.Tensor.scatter() 함수의 차이점 ?
  • 도움이 된 글: https://aigong.tistory.com/35

• ❓ torch.gather() 함수의 존재 및 사용법 ?
  • 해설강의 자료

• ❓ 3차원 텐서에서 dims 인자값으로 들어가는 0, 1, 2 축의 의미 & torch.swapdims() 함수의 사용법 ?

  
  

• Pytorch의 Math operations (특히, Reduction Ops 연산자들 읽어보기)

  • https://pytorch.org/docs/stable/torch.html#math-operations
  • "reduction"의 의미

    : 함수들이 조건에 따라 tensor에서 특정 값만을 가져오거나, 연산을 통해서 크기를 줄이는 등 주어진 tensor의 크기를 줄여서 출력하기 때문

  
  

• ❓ 딥러닝 모델에서 Hook(훅) 이란..? 훅의 의미는? ✨

  
  

• torch.nn 관련 함수 공부하기

  • https://pytorch.org/docs/stable/nn.html

• nn.Linear 함수

  • 적용 예

    import torch
    from torch import nn
    

  X = torch.Tensor([[1, 2],

              [3, 4]])

  m = nn.Linear(2, 5) ## nn.Linear() : Applies a linear transformation to the incoming data: y = xA^T + by output = m(X)

  print(output) print(output.size())

  
  <br>
  
  - 출력 결과

  tensor([[-0.7835, 1.1883, -0.5315, 0.1118, -0.2081],

    [-1.0765,  2.0393, -1.5225,  0.6674, -0.7737]],
   grad_fn=<AddmmBackward0>)

  torch.Size([2, 5])

• ❓ nn.Identity 를 사용하는 이유?

  • https://pytorch.org/docs/stable/generated/torch.nn.Identity.html#torch.nn.Identity https://stackoverflow.com/questions/64229717/what-is-the-idea-behind-using-nn-identity-for-residual-learning

• 잔차를 학습시킬 때 사용한다..? element-wise fashion(요소 별)

  
  

• nn.Module 클래스 ✨

  • 중첩 및 재사용 가능

    • nn.Module이라는 상자에 기능들을 가득 모아놓은 경우 basic building block
      • nn.Module이라는 상자에 basic building block인 nn.Module들을 가득 모아놓은 경우 딥러닝 모델
      • nn.Module이라는 상자에 딥러닝 모델인 nn.Module들을 가득 모아놓은 경우 더욱 큰 딥러닝 모델

    
    

  • function / layer / model

    • 최소의 기능 단위인 function
      • function들로 이루어진 layer
      • layer로 이루어진 model

• Pytorch에서 동적 계산 그래프의 장점 ? ✨

  • https://www.reddit.com/r/pytorch/comments/8kpsjy/can_someone_explain_the_use_of_a_dynamic_graph/

    동적 그래프의 주요 장점은 시퀀스 길이가 가변적인 순환 신경망에 있습니다. 정적 그래프는 이를 깔끔하게 처리할 수 없습니다. 가장 큰 시퀀스를 먼저 배치해야 하기 때문에 텍스트에 대해서는 작동하지 않는다는 점을 제외하고는 문장을 전환할 수 없으므로 가능한 가장 긴 문장을 위한 공간을 예약해야 합니다.

    또 다른 장점은 autograd입니다. 사용자 지정 레이어를 생성할 때 동적 프레임워크는 모두 자동 미분 기능을 가지고 있으므로 역방향 패스를 작성할 필요가 없습니다. LSTM 또는 GRU의 역방향 패스를 작성하는 것은 매우 까다롭고 잘못되기 쉽습니다.

    이제 모든 프레임워크에는 autograd가 있으므로 관련이 없습니다.

    마지막이자 가장 큰 것은 동적 프레임워크를 사용하여 Python을 작성하고 Python과 같은 기능/제어 흐름을 작성한다는 것입니다. 일반적인 예는 다음과 같습니다.

    for 루프를 사용할 수 있으므로 "스캔"을 강제로 사용할 필요가 없습니다(Python for 루프는 컴파일 타임에 알려져 있지 않기 때문입니다).

    if/then/else와 같은 일반적인 제어 흐름을 사용하고 여전히 역전파할 수 있습니다.

• torch.nn.parameter.Parameter(data=None, requires_grad=True)

  • nn.Module안에 미리 만들어진 tensor들을 Parameter로서 보관 가능..!

    A kind of Tensor that is to be considered a module parameter. Parameters are Tensor subclasses, that have a very special property when used with Module s - when they’re assigned as Module attributes they are automatic.

    • https://pytorch.org/docs/stable/generated/torch.nn.parameter.Parameter.html?highlight=parameter

    • (즉, parameter는 iterator이며, 임시저장하는 캐시메모리 역할을 한다..?) ✨
      

해설 강의

• 주요 개념

  • torch.tensor와 torch.Tensor의 차이 ✨
  • 사칙연산 관련 torch의 함수들 ✨
  • 인덱싱 ✨
  • gather 함수의 2D/3D 적용 ✨

    • gather란, 주어진 텐서에서, 대각선 값만 가져올 때 사용하는 함수..!
      • 대각 행렬을 만들 수 있다.
      • List에서 인덱싱 하던 것처럼 한번에 여러 요소를 선택할 수 없다..!
      • 따라서 원하는 요소의 갯수만큼 인덱싱을 만들어줘야 한다
      • gather(input, k차원 방향으로 인덱싱하겠다, )
      • k차원의 값이 2개면, input의 k차원에서, 2개의 값을 가져올 수 있음 (?)
    • 직관적으로 생각하는 것이 도움됨

  
  

  • nn.Module 분석하기

    • 깃허브 등 오픈소스로 모델을 가져와 사용할 때, pre-trained된 모델을 transfer-learning할 때 weight 값 등 변경하고 싶을 때 / 다른 사람이 작성한 모델의 코드를 이해할 때 등을 위한 문제들 (named_children vs named_modules / get_submodule / Parameter / buffer / docstring)

    • hook

    • 모델에서 특정 조건을 만족하는 일부만 출력(디버깅) / 모델의 일부만 수정할 때 사용

  
  

• apply 함수 ✨

이건 제가 설명드릴 수 있을 것 같아요! 공부를 열심히 했죠!

우리는 PyTorch의 nn.Module은 상자라는 것을 같이 배웠어요! 그래서 module은 module를 포함할 수 있고 다른 module 속에 들어갈 수도 있죠!

하나의 module에 다른 모든 module들이 담기면 우리는 이 거대한 module들의 집합을 모델이라고 부르죠!

모델은 수많은 module과 module들이 서로 복잡하게 얽혀있는 트리(Tree) 혹은 그래프(Graph)라고 볼 수 있어요!

모델에 무언가를 적용하면 단지 맨 꼭대기의 module 하나가 아니라 모델을 구성하는 전체 module에 모두 적용이 되어야 하고 nn.Module의 method들은 대부분 내부적으로 이를 지원해요!

예로 ".cpu()"를 맨 위 module에 적용하면 우리는 신경쓰지 않아도 module이 그 아래에 존재하는 모든 module에 ".cpu()"를 적용해요!

그러면 nn.Module에 이미 구현되어있는 method가 아닌 저희만의 custom 함수를 모델에 적용하고 싶다면 어떻게 하면 좋을까요? 모델에 속하는 모든 module에 일일이 함수를 적용해야할까요?

이때 사용하는게 바로 "apply"에요! 함수를 적용한다는 문구가 잘 와닿지 않으시죠? 함께 사용해봐요!

[과제 2.] Custom Dataset 개발하기

- PyTorch 의 Dataset

• = TORCH.UTILS.DATA 라이브러리

  • 데이터 셋에는 (1) Map-Style datasets와, (2) Iterable-style datasets이 있다.

    • Map-style datasets

    A map-style dataset is one that implements the getitem() and len() protocols, and represents a map from (possibly non-integral) indices/keys to data samples.

    For example, such a dataset, when accessed with dataset[idx], could read the idx-th image and its corresponding label from a folder on the disk.

    See Dataset for more details.

    • Iterable-style datasets

    An iterable-style dataset is an instance of a subclass of IterableDataset that implements the iter() protocol, and represents an iterable over data samples. This type of datasets is particularly suitable for cases where random reads are expensive or even improbable, and where the batch size depends on the fetched data.

    For example, such a dataset, when called iter(dataset), could return a stream of data reading from a database, a remote server, or even logs generated in real time.

  
  
  

- PyTorch의 DataLoader

• 불균형 데이터셋의 경우, 클래스의 비율에 맞게끔 데이터를 제공해야할 필요가 있음. 이럴 때 사용하는 옵션이 sampler..! ✨

  
  

• 🙋‍ Dictionary 타입으로 단어사전(Vocab)을 만들어 사용하는 이유? (정수 인덱싱)

  • https://wikidocs.net/31766
    

• CountVectorizer 더 찾아보기

  • 1. https://wikidocs.net/33661
  • 2. https://wiserloner.tistory.com/917
       
       

- 모델 불러오기

• checkpoint 저장하기

  torch.save({
  'epoch': e,
  'model_state_dict': model.state_dict(),
  'optimizer_state_dict': optimizer.state_dict(),
  'loss': epoch_loss,
  },
  f"saved/checkpoint_model_{e}_{epoch_loss/len(dataloader)}_{epoch_acc/len(dataloader)}.pt")
  모델의 정보를 epoch과 함께 저장
  checkpoint = torch.load(PATH)
  model.load_state_dict(checkpoint['model_state_dict'])
  optimizer.load_state_dict(checkpoint['optimizer_state_dict'])
  epoch = checkpoint['epoch']
  loss = checkpoint['loss']

[과제 3.] Transfer Learning

• Source Tasks과 Target Tasks에 정답(Label)의 유무에 따라 다양한 Transfer Learning 방법론 존재

  • (실습 과제는 Source Tasks와 Target Tasks에 모두 정답이 있는 상황에서의 Fine-Tuning)
  • ❓ 어떤 종류의 방법론들이 있을까?

• PyTorch에서 모델 Weight/Bias 초기화하는 방법

  • Refence: https://stackoverflow.com/questions/49433936/how-to-initialize-weights-in-pytorch ✨

• 초기화 방법 2가지

  • [1] nn.sequential 함수 사용하기
    - [2] `torch.nn.Module.apply` 함수 사용하기 > - Custom Model에서 초기화 함수를 선언하여, `torch.nn.Module.apply`를 사용해 전달해주어 사용 > - 이는 `nn.Module`에 재귀적으로 전체 가중치를 초기화한다..! ✨

  
  
  

과제 해설

• 딥러닝 과제 Common Flow ✨

  1. 데이터 전처리
  2. 데이터 불러오는 함수 생성
  3. 신경망 구성
  4. 오차 함수 및 최적화 기법 선택하기
  5. 학습 및 추론 설정
  6. 학습 및 추론 실행

• *torch.utils.data.DataLoader 내 다양한 함수들 *

  
  

• sampler() 함수 설정 ✨

• 인덱스 중 짝수만 가져오거나 / 홀수만 가져오거나 / 3의 배수만 가져오도록 추가 설정도 할 수 있음.

  • 불균형한 데이터셋에서도 많이 쓰임...! (예: 암 환자 데이터)
  • shuffle()은 단순히 섞는 설정 함수이지만, sampler()는 섞으면서 더 세밀한 설정이 함께 가능한 함수..! ✨
  
  

• collate_fn 함수 ✨

  • 1. X는 X끼리, y는 y끼리 묶어주고 싶을 때 사용 (like 프린터기의 묶음 인쇄)
  • 2. 길이가 가변적인 데이터의 경우 사용 - zero-padding 관련됨. (같은 size로 맞춰줘야 모델이 학습할 수 있기 때문에)
  • 자연어처리(NLP)에서는 활용도 더 높다..!
  • (ex: 데이터마다 target(y)의 길이가 다른 경우에, collate_fn을 사용해서, 길이를 맞춰줄 필요가 있기 때문)
  
  

• drop_last 옵션

  • batch_size에 따라 마지막 batch가 남는 경우가 간혹 있음. 이때 귀찮은 일이 발생하여 문제가 되는데, drop_last 설정 넣어주어서 미연에 방지 가능

    • batch 단위로 데이터를 불러온다면, batch_size에 따라 마지막 batch의 길이가 달라질 수 있습니다. 예를 들어 data의 개수는 27개인데, batch_size가 5라면 마지막 batch의 크기는 2가 되겠죠.

    • batch의 길이가 다른 경우에 따라 loss를 구하기 귀찮은 경우가 생기고, batch의 크기에 따른 의존도 높은 함수를 사용할 때 걱정이 되는 경우 마지막 batch를 사용하지 않을 수 있습니다.
      (https://subinium.github.io/pytorch-dataloader/)

  • drop_last 인자의 경우, 배치 크기를 채우지 못한 마지막 불완전 배치를 사용할 것인지, 사용하지 않을 것인지를 결정하는 Boolean 인자

[멘토링] Colab과 연결하는 프로그램/사이트

• 1. 💡 VSC 코드 (from 강의)
• 2. 💡 Ainize ✨ (from 멘토링) : 터미널/주피터/VS 코드를 바로 작성 가능

✏️ 1. 타겟 넘버 (Level 2)

from collections import deque


def solution(numbers, target):
    answer = 0


    q = deque()
    q.append([0, -1])


    while q:
        sumi, pre_idx = q.popleft()
        ####print(sumi, pre_idx)


        # 1. 종료 조건
        if pre_idx+1 == len(numbers):
            # (정답에 해당되는 조건)
            if sumi == target:
                answer += 1



        # 2. 다음 큐 방문 진행
        else:
            q.append([sumi + numbers[pre_idx+1], pre_idx+1])
            q.append([sumi - numbers[pre_idx+1], pre_idx+1])




    return answer

✏️ 2. 네트워크 (Level 3)

from collections import deque


def solution(n, computers):
    answer = 0

    # 1. 인접 리스트 구하기
    a =  []

    for i in range(n):
        for j in range(n):
            if i == j:
                continue


            if computers[i][j] == 1:
                u, v = i+1, j+1
                a.append([u, v])


    ###print(a)


    # 2. BFS 수행
    q = deque()
    check = [False] * (n+1)


    while False in check:
        idx = check.index(False)
        check[idx] = True

        q = deque() # 큐 리셋
        q.append(idx)
        answer += 1 # 큐를 새로 생성할 때마다 네트워크의 개수(cnt)를 1 증가시켜주면 됨 !


        while q:
            x = q.popleft()

            for case in a:
                u, v = case

                if u == x and check[v] == False:
                    q.append(v)
                    check[v] = True



    ###print(check)




    return answer -1

✏️ 3. 단어 변환 (Level 3)

from collections import deque



def change(x, y):
    cnt = 0
    n = len(x)

    for i in range(n):
        if x[i] != y[i]:
            cnt += 1


    if cnt == 1:
        return True
    else:
        return False


def solution(begin, target, words):
    answer = []

    if target not in words:
        return 0



    m = len(words)

    for idx in range(m):
        if change(begin, words[idx]) == True:
            # 큐 생성 및 BFS 탐색 시작 !
            q = deque()
            q.append((words[idx], 1))

            check = [False] * m
            check[idx] = True




            while q:
                pre_word, depth = q.popleft()


                # 종료 조건
                if pre_word == target:
                    answer.append(depth)
                    break


                for j in range(m):
                    if check[j] == False and change(pre_word, words[j]) == True:
                        q.append((words[j], depth+1))





    return min(answer)

✏️ 4. 여행 경로 (Level 3)

• 문제 해결과정 및 코드 : https://github.com/sallyy1/Algorithm/issues/137
• 가장 처음에 가능한 경우의 수가 여러 개라는 점에서 브루트포스 문제로 접근해 permutations을 활용해 풀어보았으나 4개 중 1번에서 시간초과로 역부족이었다.
• 그래서 역시 deque를 활용해 접근을 했는데, 다양한 예제 테스트케이스에 Global하게 맞는 해답을 찾기까지 여러 시행착오를 겪었다.
• 개선점: 풀이들을 찾아보니 stack를 활용하면 간단하게 문제를 풀 수 있는 방법이 있다고 한다..! ✨

  from collections import deque
  
  

def solution(tickets): answer = []

## 1. 주어진 항공권은 모두 사용해야 합니다. (키 조건)  
## 2. 만일 가능한 경로가 2개 이상일 경우 알파벳 순서가 앞서는 경로를 return 합니다.

m = len(tickets)

tickets.sort() ## 1번만 틀렸습니다. 나오다가 알파벳 순서를 미리 반영하기 위해 정렬 한 줄을 추가해 주었더니 바로 통과..!


for i in range(m):
    u, v = tickets[i]

    if u == "ICN": ## 항상 "ICN" 공항에서 출발합니다.
        check = [False] * m
        check[i] = True

        q = deque() 
        q.append(([u, v], check)) # 시작 공항(2개 짝), 어느 항공권을 사용했는지 표시 배열
        ####print('--시작-- ', i, q)



        while q:
            pre_q, pre_c = q.popleft()
            ####print(q)


            if False not in pre_c: ## 종료 조건
                if pre_q not in answer:
                    answer.append(pre_q)
                    break


            for idx in range(m):
                if pre_c[idx] == False and pre_q[-1] == tickets[idx][0]:
                    ###q.append((pre_q, pre_c)) (디버깅) 1번. 현재 항공권 이용 안 하는 경우 빼주어야 5번에서 무한루프 해결됨..?

                    # 2번.
                    copy = pre_c[:] ## (디버깅) 이전 방문표시 배열(항공권에 대한)을 복사해주고 사용해야 함
                    copy[idx] = True

                    c = pre_q[:]
                    c.append(tickets[idx][1])

                    q.append((c, copy))


answer.sort()
return answer[0]

```