mios.velog

뱅크샐러드는 왜 돈 안되는 ‘유전자 검사’를 할까?

Tue, 07 Mar 2023 06:38:06 GMT

링크: https://outstanding.kr/banksaladdna20220523

뱅크샐러드의 유전자 검사

핀테크 회사인 뱅크샐러드에서는 현재 무료로 유전자 검사를 할 수 있는 서비스를 운영 중이다. 2021년 10월부터 2022년 5월까지 누적 12만명이 무료로 유전자 검사를 받았다. 매일 선착순으로 오전 10시에 700명을 신청받고 있다.

2021년 유전자 검사를 시작으로 마이데이터 전문업체로의 도약을 비전으로 삼고, 10대 질병 발병률 예측 서비스인 ‘내 위험 질병 찾기’ 런칭하며 건강 마이데이터 사업으로 확장중이다.

뱅크샐러드는 건강 사업을 왜 하나요?

핀테크 회사인 뱅크샐러드가 건강 관련 서비스 하는 이유?

궁극적으로 지향하는 바는 ‘데이터’ 영역에서 전문성을 가진 회사
마이데이터라는 큰 틀에서 금융을 넘어 건강까지 아우르는 서비스
개인이 만들 수 있는 가장 근본적인 데이터는 ‘건강’ 이라고 생각

왜 유전자 검사로 시작했나요?

우선, 자신의 건강에 대한 기본적인 이해가 필요하다고 생각했음
이 부분을 소비자에게 어떻게 이해시키고 전달할지 고민하다 보니 유전자 검사로 결정
마이데이터에 맞게 유전자 검사는 일반적인 정보가 아닌 개인 맞춤형 정보
일반적 유전자 검사 비용은 10~30만원인데, 이 서비스를 무료로 운영하는 이유
- 유저를 모으기 위한 투자, 고객에게 건강 데이터에 대한 경험 제공

유전자 검사를 보여주는 방식

만들어진 전문적인 의학 데이터에 대한 의미를 이해를 알기 쉽게 ‘보이는 형태’로 전달
실제 나의 행동과 인과관계가 느껴져야 이 데이터와 시너지를 만들어낼 것이라고 생각
유전자 검사 결과 카드

유전자 검사를 통해 사람들이 내 행동과 습관을 연결하게 되어
유전자 검사를 보고 고민 될 때, 바로 진료나 검사를 해보는 것에 활용하는 것을 의도하고 있음

‘내 위험 질병 찾기’는 어떤 서비스?

고객의 성별, 나이, 건강검진 정보 등 건강 데이터를 활용해서, 특정 질병에 걸릴 통계적 발병률을 알려주는 내용
유전자 검사가 ‘선천적 내 건강’을 알려줬다면, 내 위험 질병 찾기는 ‘후천적 건강 관리’에 초점을 맞춘 서비스
이 역시, 전문 의학 지식이 실제로 나에게 어떤 의미이고, 어떻게 해석해야하는 건지를 쉬운 메시지로 전달하는데 의의를 둠

이걸로 돈을 벌 수 있을까요?

솔직히 어렵다.
마이데이터로 건강 부분에 적용한 사업이 얼마 안되어, 수익까지 가려면 건강 관련된 비전을 많이 만들어놔야 함
건강과 관련된 많은 데이터가 쌓이면 구상해 볼 수 있을 듯

파이썬 머신러닝 완벽 가이드 - 9. Text Analytics(1) (Encoding, Vectorize)

Wed, 26 Oct 2022 03:41:34 GMT

Text Analytics 텍스트 분석

TA(Text Analytics or Text Mining)
- 비정형 텍스트에서 의미있는 정보를 추출하는 것에 좀 더 중점을 두고 발전
- 머신러닝, 언어 이해, 통계 등을 활용해 모델을 수립하고 정보를 추출해 비즈니스 인텔리전스나 예측 분석 등의 분석 작업을 주로 수행한다.
  - 텍스트 분류 : 문서가 특정 분류/카테고리에 속하는 것을 예측하는 기법 ← 지도학습
  - 감성 분석 : 텍스트에서 나타나는 감정/판단/믿음/의견/기분 등의 주관적인 요소들을 분석하는 기법 ← 지도&비지도학습
  - 텍스트 요약 : 텍스트 내에서 중요한 주제나 중심 사상을 추출하는 기법 ex) 토픽 모델링 (Topic Modeling)
  - 텍스트 군집화와 유사도 측정 : 비슷한 유형의 문서에 대해 군집화를 수행하는 기법 ← 비지도학습
NLP(Nature Language Processing)
- 머신이 인간의 언어를 이해하고 해석하는 데에 더 중점을 두고 발전
- 기계번역, 질의응답 시스템 등의 영역에서 텍스트 분석과 차별점 존재

1. 텍스트 분석의 이해

: 비정형 데이터인 텍스트를 분석하는 것. 머신러닝 알고리즘은 숫자형의 피처 기반 데이터만 입력받을 수 있기 때문에 비정형 텍스트 데이터를 피처 형태로 추출하고, 추출된 피처에 의미있는 값을 부여하는 게 중요하다.

피처 벡터화(Feature Vectorization), 피처 추출(Feature Extraction)

: 텍스트를 word(or word의 일부분) 기반의 다수의 피처로 추출하고, 이 피처에 단어 빈도수와 같은 숫자값을 부여하면 텍스트는 단어의 조함인 벡터값으로 표현될 수 있는데, 이렇게 텍스트를 변환하는 것
- 방법: BOW(Bag of Words), Word2Vec (책에서는 BOW만 설명)
과정
1. 텍스트 전처리
  1. 클렌징 : 대소문자 변경, 특수문자, 기호 삭제 등
  2. 토큰화 : 문장/단어
  3. 불용어, 필터링, 철자수정 : 의미없는 단어(stop word) 등 제거
  4. 어간/표제어 추출 : 단어에서 어간 및 표제어 추출
2. 피처 추출 / 벡터화 (Encoding) : 피처를 추출하고 벡터값 할당
  1. BOW(Bag of Words) : Count 기반, TF-IDF 기반
  2. Word2Vec
3. ML 모델 수립 및 학습/예측/평가
파이썬 기반의 NLP, 텍스트 분석 패키지
- NLTK(Natural Language Toolkit for Python): 가장 대표적인 NLP 패키지. 수행 성능, 속도, 신기술, 엔터프라이즈한 기능 지원 등에서 아쉬워 실제 업무에서는 잘 안쓰임
- Gensim: 토픽 모델링 분야에서 가장 두각을 나타내는 패키지
- SpaCy: 뛰어난 수행 성능으로 최근 가장 주목을 받는 NLP 패키지
  
  ⇒ 사이킷런과 더불어 이러한 NLP 전용 패키지와 결합해 애플리케이션을 작성하는 경우가 많다.

2. 텍스트 전처리

텍스트 정규화 : 텍스트를 머신러닝 알고리즘이나 NLP 애플리케이션에 입력 데이터로 사용하기 위해 클렌징, 정제, 토큰화, 어근화 등의 다양한 텍스트 데이터의 사전작업을 수행하는 것

→ 클렌징, 토큰화, 필터링 | 스톱워드 제거 | 철자 수정, Stemming, Lemmatization
클렌징(Cleansing) : 대소문자 변경, 특수문자, 기호 삭제 등
토큰화(Tokenization)
- 문장 토큰화
  - 문서에서 문장을 분리
  - 문장의 마침표(.), 개행문자(\n) 등 문장의 마지막을 뜻하는 기호에 따라 분리하는 게 일반적
  - 정규 표현식에 따른 문장 토큰화도 가능
  - 각 문장이 가지는 시맨틱적 의미가 중요한 요소로 사용될 때 사용
  - NLTK의 경우 단어 사전과 같이 참조가 필요한 데이터 세트의 경우 인터넷으로 다운 받을 수 있다.
```
  nltk.download('punkt')
  ---
  from nltk import sent_tokenize

  sent_tokenize(text=텍스트 파일) # 각각의 문장으로 구성된 list 객체 반환
```
- 단어 토큰화
  - 문장을 단어로 토큰화 하는 것
  - 공백, 콤마(,), 마침표(.), 개행문자 등으로 단어를 분리하지만, 정규표현식으로 다양한 유형으로 토큰화 수행 가능
```
from nltk import word_tokenize

word_tokenize(문장) # 각각의 단어로 구성된 list 객체 반환
```
  - 단점 : 문맥적 의미가 무시된다.
  - n-gram
    - 위의 단점을 보완하기 위해 도입됨
    - 연속된 n개의 단어를 하나의 토큰화 단위로 분리하는 것
    - n개 단어 크기 윈도우를 만들어 문장의 처음부터 오른쪽으로 움직이면서 토큰화 수행
    - 예) Agent Smith knocks the door 를 2-gram(bigram)으로 만들면, (Agent, Smith), (Smith, knocks), (knocks, the), (the, door)로 토큰화
불용어(Stop Word) 제거
- 불용어 : 분석에 큰 의미가 없는 단어 (예: 영어에서 is, the, a, will 등)
- 제거하는 이유 : 스톱워드는 문법적인 특성으로 인해 빈번하게 텍스트에 나타나므로 제거하지 않으면 빈번함으로 인해 중요 단어로 인식된다.
- 언어별로 불용어가 목록화 되어 있다.
```
nltk.download('stopword')

nltk.corpus.stopwords.words('english')
# 이후 for, if문을 이용하여 스톱워드를 제거한다.
```
추출(Stemming, Lemmatization) : 문법적, 의미적으로 변화하는 단어의 원형을 찾는 것
- 어간 추출(Stemming): 원형 단어로 변환 시 일반적인 방법을 적용하거나 더 단순화된 방법을 적용해 원래 단어에서 일부 철자가 훼손된 어근 단어를 추출하는 경향이 있음
  - 어간 추출은 품사 정보를 갖고 있지 않음 : 단어의 뜻이 분명한 경우
```
from nltk.stem import LancasterStemmer

stemmer = LancasterStemmer()
stemmer.stem('working') # -> work 로 변환
```
- 표제어 추출(Lemmatization) : 표제어 추출은 Stemming보다 정교하며 의미론적인 기반에서 단어의 원형을 찾음, 단어의 [품사 정보]를 포함하고 있음
  - 정확한 원형 단어 추출을 위해 단어의 품사를 입력해줘야 한다. 동사=’v’, 형용사=’a’
  - 명사 / 동사로 쓰일 때 반어의 뜻이 완전히 달라지는 경우 ex) bear, taxi,
  - 시간은 좀 더 걸린다.
```
from nltk.stem import WordNetLemmatizer

lemma = WordNetLemmatizer()
lemma.lemmatize('amusing', 'v') # -> amuse로 변환
```

3. 피처 추출 / 피처 벡터화 (Encoding) - BOW(Bag of Words) & Word2Vec

피처 벡터화(Encoding) : ML알고리즘에 입력할 수 있도록, 텍스트를 특정 의미를 갖는 숫자형인 벡터값으로 변환하는 것
1. 각 문서의 텍스트를 단어로 추출해 피처로 할당
2. 각 단어의 발생빈도와 같은 값을 피처 값으로 부여
  
  ⇒ 각 문서를 단어 피처의 발생 빈도값으로 구성된 벡터로 만드는 기법
  
  : 기존 텍스트 데이터를 또 다른 형태의 피처의 조합으로 변경하는 것이기 때문에 피처 추출에 포함하기도 한다. (TA에서는 피처 벡터화와 피처 추출을 같은 의미로 사용하곤 한다.)
BOW : 문서가 갖는 모든 단어(words)를 문맥이나 순서를 무시하고 일괄적으로 단어의 빈도 값을 부여해 피처값을 추출하는 모델

![](https://velog.velcdn.com/images/mios_leo/post/3520db12-42fe-4bb0-a735-19738c8859ff/image.png)


- 방식
    1. 문장 1과 문장 2에 있는 모든 단어에서 중복을 제거하고, 각 단어(feature or term)를 컬럼 형태로 나열
    2. 각 단어에 고유의 index를 부과 ex) ‘I’ : 0, ‘love’ : 1, ‘dogs’ : 3, ‘hate’ : 4 …
    3. 개별 문장을 로우로 잡고, 해당 단어가 나타나는 횟수(Occurrence)를 각 단어(단어 인덱스)에 기재합니다.
    4. 즉 M 개의 문장과 N 개의 단어 피처들로 이뤄진 MxN행렬이 구성되게 됨
- 장점 : 쉽고 빠른 구축
- 단점
    - 문맥의미(Semantic context) 반영 부족: 단어의 순서를 고려하지 않기 때문에 n-gram 기법 활용 가능하나 제한적이다.
    - 희소행렬 문제(희소성, 희소행렬): BOW로 피처 벡터화를 수행하면 희소행렬 형태의 데이터 세트가 만들어지기 쉽다. 희소행렬은 일반적으로 ML알고리즘의 수행시간과 예측 성능을 떨어뜨린다. (그래서 희소행렬을 위한 기법 마련되어 있음)

CountVectorizer : 단어에 피처 값을 부여 할 때, 각 문서에 해당 단어가 등장하는 횟수 Count로 Vector화
- CountVectorizer에서는 카운트 값이 높을 수록 중요한 단어로 인식
- 그러나 카운트만 부여할 경우, 그 문서의 특징을 나타내기 보다, 언어 특성상 자주 사용될 수 밖에 없는 단어까지 높은 값을 부여받게 됨
- 이러한 문제를 보완하기 위해 TF-IDF (Term Frequency Inverse Document Frequency) Vectorizer를 사용 함
TF-IDFVectorizer : 개별 문서에서 자주 나타나는 단어에 높은 가중치를 주되, 모든 문서에 전반적으로 자주 나타나는 단어에 대해서는 패널티를 주는 방식으로 값을 부여
- 문서마다 텍스트 길이가 길고, 문서의 갯수가 많은 경우에는, Count보다 TF-IDF 방식을 사용하느 것이 더 좋은 성능을 낼 가능성이 높음

3.1. CountVectorizer (카운트 기반 벡터화)

: 단어 피처에 값을 부여할 때 각 문서에서 해당 단어가 나타나는 횟수를 부여하는 경우

카운트 값이 높을 수록 중요한 단어로 인식한다.
사이킷런 - CountVectorizer 클래스 제공
```
  from sklearn.feature_extraction.text import CountVectorizer
```
- 소문자 일괄 변환, 토큰화, 스톱워드 필터링 등 텍스트 전처리도 함께 수행해줌
- 파라미터 (TF-IDF도 동일)

    | 파라미터 | 설명 |
    | --- | --- |
    | max_df | 전체 문서에 걸쳐서 너무 높은 빈도수를 가지는 단어 피처를 제외하기 위한 파라미터, int 입력: 주어진 값 이하로 나타나는 단어만 피처로 추출, float 입력: 빈도가 0~주어진 값% 까지만 피처로 추출 |
    | min_df | 전체 문서에 걸쳐서 너무 낮은 빈도수를 가진 단어 피처를 제외하기 위한 파라미터, int 입력: 주어진 값 이하로 나타나는 단어는 피처로 추출하지 않음, float 입력: 하위 주어진 값% 이하의 빈도를 가지는 단어는 피처로 추출하지 않음 |
    | max_features | int 입력 : 추출하는 피처의 개수를 제한, 가장 높은 빈도수를 가지는 단어순으로 정렬해 주어진 값 개수까지만 피처로 추출 |
    | stop_words | ‘english’로 지정하면 영어의 스톱워드로 지정된 단어는 추출에서 제외 |
    | n_gram_range | 단어 순서를 어느 정도 보강하기 위한 n_gram 범위 설정, 튜플 형태 (범위 최소값, 범위 최대값) |
    | analyzer | default = ‘word’, 피처 추출을 수행할 단위 지정, character의 특정 범위를 피처로 만드는 특정 경우에 사용 |
    | token_pattern | default = ‘\b\w\w+\b’ 공백 또는 개행 문자 등으로 구분된 단어 분리자(\b) 사이의 두 문자(영숫자) 이상의 단어를 토큰으로 분리, 정규 표현식 패턴 지정, analyzer=’word’일때만 변경 가능 (거의 변경X) |
    | tokenizer | 토큰화를 별도의 커스텀 함수로 이용시 적용, 일반적으로 CountTokenizer 클래스에서 어근 변화시 이를 수행하는 별도의 함수를 tokenizer 파라미터 적용하면 된다. |
- fit(), transform()을 통해 피처 벡터화된 객체 반환
    - 반드시 학습 데이터를 이용해 fit()이 수행된 객체를 이용해 테스트 데이터를 변환(transform)해야 한다.
    - 그래야만 학습시 설정된 CountVectorizer의 피처 개수와 테스트 데이터를 CountVectorizer로 변환한 피처 개수가 같아진다.
    - 테스트 데이터의 피처 벡터와 시 fit_transform() 사용 X

    ```python
    cnt_vect = CountVectorizer()
    cnt_vect.fit(X_train)
    X_train_cnt_vect = cnt_vect.transform(X_train)
    X_text_cnt_vect = cnt_vect.transform(X_test)
    ```

- Process
    1. 사전 데이터 가공(전처리): 모든 문자를 소문자로 변경 등
    2. 토큰화: 디폴트는 단어기준(analyzer = True), n_gram_range를 반영하여 토큰화 수행
    3. 텍스트 정규화
        1. stop words 필터링 수행
        2. Stemmer, Lemmatizer는 지원 X

            이를 위한 함수를 만들어 tokenizer 파라미터에 적용하거나 외부 패키지로 미리 텍스트 정규화 수행 필요

        3. 피처 벡터화: 토큰화 된 단어 피처로 추출, 단어 빈도수 벡터 값을 적용

단점: 문서의 특징을 나타내기 보다는 언어 특성상 문장에서 자주 사용될 수 밖에 없는 단어까지 높은 값을 부여 받는다.

3.2. TF-IDF (Term Frequency-Inverse Document Frequency) Vectorizer

: 개별 문서에서 자주 나타나는 단어에 높은 가중치를 주되, 모든 문서에서 전반적으로 자주 나타나는 단어에 대해서는 패털티를 주는 방식으로 값을 부여한다.

문서마다 텍스트가 길고 문서의 개수가 많을 경우 카운트 방식보다 TF-IDF 방식을 사용하는 게 좋다.

$$ TFIDF_i = TF_i \times log{N\over DF_i} $$

$TF_i$: 개별 문서에서 단어 i 빈도, $DF_i$: 단어 i를 가지고 있는 문서 개수, N: 전체 문서 개수
사이킷런 - TfidfVectorizer 클래스 제공
- 파라미터와 변환 방법은 CountVectorizer와 동일
```
from sklearn.feature_extraction.text import TfidfVectorizer
```

3.3. 희소행렬

: 희소행렬(Sparse Matrix)은 행렬의 값이 대부분 0인 경우를 가리키는 표현 ↔ 밀집행렬(Dense Matrix) : 모든 문서로 피처 벡터화를 수행하면 + n-gram (1,2) , (1,3) 등 주면 칼럼 수가 더욱 증가 : 희소행렬은 일반적으로 ML알고리즘의 수행시간과 예측 성능을 떨어뜨림 → 메모리 공간이 많이 필요하고, 연산 시간이 오래 걸린다. 따라서, 물리적으로 적은 메모리 공간을 차지할 수 있도록 변환해야 한다. $\therefore$ 희소행렬을 COO, CSR 형태의 희소행렬로 압축해줘야 함 (CSR을 더 많이 사용함)

: CountVectorizer, TfidfVectorizer 은 희소행렬을 반환(CSR 형태)

3.3.1. COO(Coordinate : 좌표) 형식

: 0이 아닌 데이터만 별도의 데이터 배열에 저장하고, 그 데이터가 가르키는 행과 열의 위치를 별도의 배열에 저장하는 방식

예) [ [3, 0, 1], [0, 2, 0] ] → (row, col): (0, 0), (0, 2), (1, 1) → row: [0, 0, 1], col: [0, 2, 1]

희소행렬 변환은 주로 Scipy의 sparse 패키지 사용

  import numpy as np

  # BOW에서 좌표 기반으로 밀집행렬 추출
  dense = np.array( [ [ 3, 0, 1 ], [0, 2, 0 ] ] )

  from scipy import sparse

  # 0 이 아닌 데이터 추출
  data = np.array([3,1,2])

  # 행 위치와 열 위치를 각각 array로 생성 
  row_pos = np.array([0,0,1])
  col_pos = np.array([0,2,1])

  # sparse 패키지의 coo_matrix를 이용하여 COO 형식으로 희소 행렬 생성
  # 매개변수로 채워넣을 숫자인 순차적 data와, (row_pos, col_pos)의 좌표 정보를 tuple 형태로 주는 듯
  sparse_coo = sparse.coo_matrix((data, (row_pos,col_pos)))
  sparse_coo.toarray()

  > array([3, 0, 1], [0, 2, 0])

단점: 행과 열의 위치를 나타내기 위해서, 반복적인 위치 데이터를 사용해야 한다.

3.3.2. CSR(Compressed Sparse Row) 형식

: 행 위치 배열 내에 있는 고유한 값의 시작 위치만 다시 별도의 위치 배열로 가지는 변환 방식

from scipy import sparse

dense2 = np.array([[0,0,1,0,0,5],
                         [1,4,0,3,2,5],
                         [0,6,0,3,0,0],
                         [2,0,0,0,0,0],
                         [0,0,0,7,0,8],
                         [1,0,0,0,0,0]])

# 0 이 아닌 데이터 값 배열
data2 = np.array([1, 5, 1, 4, 3, 2, 5, 6, 3, 2, 7, 8, 1])

# 열 위치와 행 위치를 각각 array로 생성 
col_pos = np.array([2, 5, 0, 1, 3, 4, 5, 1, 3, 0, 3, 5, 0])

row_pos = np.array([0, 0, 1, 1, 1, 1, 1, 2, 2, 3, 4, 4, 5])

# 행 위치 배열의 고유한 값들의 시작 위치 index를 배열로 생성
row_pos_ind = np.array([0, 2, 7, 9, 10, 12, 13])

# sparse 패키지의 csr_matrix를 이용하여 CSR 형식으로 희소 행렬 생성
# 매개변수로 채워넣을 숫자인 순차적 (data, row_pos_ind인 좌표의 위치 정보, col_pos인 좌표 정보) 를 tuple로
sparse_csr = sparse.csr_matrix((data2, col_pos, row_pos_ind))

print('COO 변환된 데이터가 제대로 되었는지 다시 Dense로 출력 확인')
print(sparse_coo.toarray())
print('CSR 변환된 데이터가 제대로 되었는지 다시 Dense로 출력 확인')
print(sparse_csr.toarray())

> COO 변환된 데이터가 제대로 되었는지 다시 Dense로 출력 확인
> [[0 0 1 0 0 5]
>  [1 4 0 3 2 5]
>  [0 6 0 3 0 0]
>  [2 0 0 0 0 0]
>  [0 0 0 7 0 8]
>  [1 0 0 0 0 0]]
> CSR 변환된 데이터가 제대로 되었는지 다시 Dense로 출력 확인
> [[0 0 1 0 0 5]
>  [1 4 0 3 2 5]
>  [0 6 0 3 0 0]
>  [2 0 0 0 0 0]
>  [0 0 0 7 0 8]
>  [1 0 0 0 0 0]]

실제 사용로 사용할 때 ⇒ 밀집 행렬을 매개변수(생성 파라미터)로 입력하면 COO나 CSR 희소 행렬로 생성한다.

파이썬 머신러닝 완벽 가이드 - 8. Clustering(2) (평균 이동, GMM, DBSCAN, 예제 실습)

Tue, 18 Oct 2022 03:59:55 GMT

4. 평균 이동 Mean shift

: K-평균과 유사하게, 군집의 중심을 지속적으로 움직이면서 군집화를 수행함 : 그러나, K-평균이 중심에 소속된 데이터의 평균 거리 중심으로 이동하는데 반해, : 평균 이동은 데이터가 모여있는 밀도가 가장 높은 곳으로 이동시키면서 군집화하는 방법

평균 이동 군집화는 데이터의 분포도를 이용해 군집 중심점을 찾음
- 군집 중심점은 데이터 포인트가 모여있는 곳이라는 생각에서 착안
- 이를 위해 확률 밀도 함수를 이용 함
- 확률 밀도 함수가 피크인 점(가장 집중적으로 데이터가 모여 있을)을 군집 중심점으로 선정하며
- 주어진 모델의 확률 밀도 함수를 찾기 위해서 KDE(Kernel Density Estimation)을 이용
- 주변 데이터와의 거리 값을 KDE 함수 값으로 입력한 뒤, 그 반환 값을 현재 위치에서 업데이트하면서 이동하는 방식

KDE(Kernel Density Estimation)

: 커널 함수를 통해 어떤 변수의 확률 밀도 함수를 추정하는 대표적인 방법

: 개별 데이터 각각에, 커널 함수를 적용한 값을 모두 더한 뒤 데이터 건수로 나눠 확률 밀도 함수를 추정한다.
- 확률 밀도 함수 PDF(Probability Density Function)
  
  : 확률 변수의 분포를 나타내는 함수 (정규 분포, 감마 분포, t-분포 등)
  - 확률 밀도 함수를 알면 특정 변수가 어떤 값을 갖게 될지에 대한 확률을 알게 되므로, 이를 통해 변수의 특성, 확률 분포 등 변수의 많은 요소를 알 수 있다.
- 커널 함수의 예시) 가우시안 커널 함수 적용

    ![](https://velog.velcdn.com/images/mios_leo/post/eb818ea7-9888-4ab4-b213-8d8f05bf1add/image.png)


- 수식

    $$
    KDE = {1\over n}\sum_{i=1}^nK_h(x-x_i) = {1\over nh}\sum_{i=1}^nK({x-x_i\over h})
    $$

    - $K$ : 커널 함수, $x$ : 확률 변수 값, $x_i$ : 관측값, $h$ : 대역폭(bandwidth)
    - 대역폭 $h$ : KDE 형태를 부드럽거나 뾰족한 형태로 평활화(smoothing)하는데 적용
        - 작은 $h$ 값: 좁고 뾰족한 KDE를 가짐. 과적합 되기 쉬움. 많은 수의 군집 중심점을 가짐
        - 큰 $h$ 값: 과도하게 평활화된 KDE를 가짐. 과소적합 되기 쉬움. 적은 수의 군집 중심점을 가짐

        ⇒ 적절한 h를 계산하는 것이 KDE 기반의 평균 이동에서 매우 중요하다.


    ![](https://velog.velcdn.com/images/mios_leo/post/c334ceb0-4755-4ccf-a10a-a1a40e330e66/image.png)


    ![](https://velog.velcdn.com/images/mios_leo/post/0989675b-902d-49da-a208-bdfcdcdff7e7/image.png)

사용

  import numpy as np
  from sklearn.datasets import make_blobs
  from sklearn.cluster import MeanShift

  X, y = make_blobs(n_samples=200, n_features=2, centers=3, 
                    cluster_std=0.7, random_state=0)

  meanshift= MeanShift(bandwidth=0.8)
  cluster_labels = meanshift.fit_predict(X)
  print('cluster labels 유형:', np.unique(cluster_labels))

  > cluster labels 유형: [0 1 2 3 4 5]

  meanshift= MeanShift(bandwidth=1) # bandwidth 변경
  cluster_labels = meanshift.fit_predict(X)
  print('cluster labels 유형:', np.unique(cluster_labels))

  > cluster labels 유형: [0 1 2]

bandwidth (=KDE의 h) 값을 작게 할수록 군집 개수가 많아진다.

⭐️ estimate_bandwidth(X) ⭐️ : 최적의 대역폭 $h$ 찾아줌. 파라미터로 피처 데이터 세트(X) 입력

  from sklearn.cluster import estimate_bandwidth

  # estimate_bandwidth()로 최적의 bandwidth 계산
  bandwidth = estimate_bandwidth(X)
  print('bandwidth 값:', round(bandwidth,3))

  > bandwidth 값: 1.816

  ------------------------------------------------------------
  import pandas as pd

  clusterDF = pd.DataFrame(data=X, columns=['ftr1', 'ftr2'])
  clusterDF['target'] = y

  # estimate_bandwidth()로 최적의 bandwidth 계산
  best_bandwidth = estimate_bandwidth(X)

  meanshift= MeanShift(bandwidth=best_bandwidth)
  cluster_labels = meanshift.fit_predict(X)
  print('cluster labels 유형:',np.unique(cluster_labels))

  > cluster labels 유형: [0 1 2]

평균 이동의 장점
- 데이터 세트의 형태를 특정 형태로 가정한다든가, 특정 분포 기반의 모델로 가정하지 않기 때문에 유연한 군집화 가능
- 이상치의 영향력도 크지 않으며, 미리 군집의 개수를 정하지 않아도 된다.
평균 이동의 단점
- 수행 시간이 오래 걸리고, bandwidth의 크기에 따른 군집화 영향도가 크다.
활용
- 컴퓨터 비전 영역에서 많이 사용
- 이미지나 영상 데이터에서, 특정 개체를 구분하거나 움직임을 추적하는데 뛰어난 역할

5. GMM(Gaussian Mixture Model) (확률 기반 군집화)

: 군집화를 적용하고자 하는 데이터가, 여러 개의 가우시안 분포를 가진 데이터 집합들이 섞여서 생성된 것이라는 가정하에, 군집화를 수행하는 방식

정규분포: 평균 $\mu$를 중심으로 높은 데이터 분포도를 가지고 있으며, 좌우 표준편차 1에 전체 데이터의 68.27%, 좌우 표준편차 2에 전체 데이터의 95.45%를 갖고 있다.
표준 정규 분포: 평균이 0, 표준편차가 1인 정규분포
섞인 데이터 분포에서 개별 유형의 가우시간 분포 추출, 개별 데이터가 이 중 어떤 정규분포에 속하는지 결정하는 방식

모수 추정 : 개별 정규 분포의 평균과 분산 추정, 각 데이터가 어떤 정규분포에 해당되는지의 확률 추정
- 가령 1,000개의 데이터 세특 있다면, 이를 구성하는 여러 개의 정규 분포 곡선을 추출
- 개별 데이터가 이 중 어떤 정규 분포에 속하는지 결정하는 방식

사용

  from sklearn.mixture import GaussianMixture

  gmm = GaussianMixture(n_components=3, random_state=0).fit(iris.data)
  gmm_cluster_labels = gmm.predict(iris.data)

  # 클러스터링 결과를 irisDF 의 'gmm_cluster' 컬럼명으로 저장
  irisDF['gmm_cluster'] = gmm_cluster_labels
  irisDF['target'] = iris.target

  # target 값에 따라서 gmm_cluster 값이 어떻게 매핑되었는지 확인. 
  iris_result = irisDF.groupby(['target'])['gmm_cluster'].value_counts()
  print(iris_result)

  > target  gmm_cluster
  > 0       0              50
  > 1       2              45
  >         1               5
  > 2       1              50
  > Name: gmm_cluster, dtype: int64

n_components: 모델의 총 개수. 군집의 개수를 정하는데 중요한 역할 수행
fit(피처 데이터 세트), predict(피처 데이터 세트)를 수행해 군집을 결정

장점 : KMeans보다 유연하게 다양한 데이터 세트에 잘 적용될 수 있다. (Not 원형 범위여도 작동 잘 함)

- 성능이 더 좋다는 뜻이 아니라, K-평균은 평균 거리 중심을 이동하면서 군집화를 수행하여,
개별 군집 내의 데이터가 원형으로 흩어져 있는 경우에 매우 효과적으로 군집화가 수행될 수 있음
⇒ 데이터 세트 구성에 따라 성능 달라짐
    - 따라서 K-평균은 길쭉한 타원형으로 늘어선 경우에는 군집화를 잘 수행하지 못함

단점 : 수행시간이 오래 걸린다.

6. DBSCAN(Density Based Spatial Clustering of Applications with Noise) (밀도 기반 군집화)

: 입실론 주변 영역의 최소 데이터 갯수를 포함하는 밀도 기준을 충족시키는 데이터인, 핵심 포인트를 연결하면서 군집화를 구성하는 방식 : 데이터의 분포가 기하학적으로 복잡한 데이터 세트에도 효과적으로 군집화 가능

수행 방법
1. P1 데이터 기준으로 입실론 반경(eps=0.6)내에 포함한 데이터(min_samples=6)가 7개 (자신 P1 포함하여, 이웃 데이터 P2, P6, P7, P9, P11)로 최소 6개 이상을 만족하므로 P1은 핵심 포인트(Core Point)
2. 다음으로 P2 데이터를 보면, P2 역시 반경 내에 6개 (자신 P2, P1, P3, P4, P9, P10) 데이터를 갖고 있으므로 핵심 포인트
3. 핵심 포인트 P1의 이웃 ↔ 데이터 포인트 P2 역시 핵심 포인트일 경우 ⇒ P1에서 P2를 연결하여 [직접 접근]
4. 특정 핵심 포인트에서 *[직접 접근]*이 가능한 다른 핵심 포인트들을 서로 연결하면서 군집화를 구성 ⇒ 이런 군집화 영역을 확장해나가는 것이 DBSCAN의 군집화 방식
5. P3 데이터의 경우, 이웃 데이터로 P2, P4 2개이므로 군집을 구분할 수 있는 핵심포인트는 될 수 없음
  1. 하지만 이웃 데이터 중에 핵심 포인트인 P2를 가지고 있음
  2. 이렇게, 자신은 핵심 포인트가 아니지만, 이웃 데이터로 핵심 포인트를 가지고 있는 데이터를 경계 포인트(Border Point)라고 부름
  3. 경계 포인트는 군집의 외곽을 형성
6. P5와 같이 반경내 최소 데이터를 갖고 있지도 않고, 핵심 포인트를 이웃 데이터로 가지고 있지 않은 데이터를 잡음 포인트(Noise Point)라고 함
- 핵심 포인트(core point) : 주변 영역 내 최소 데이터 갯수 이상의 타 데이터를 가지고 있을 경우
- 이웃 포인트(neighbor point): 주변 영역 내에 위치한 타 데이터
- 경계 포인트(border point): 주변 영역 내에 최소 데이터 개수 이상의 이웃 포인트를 가지고 있지 않지만 핵심 포인트를 갖고 있는 데이터
- 잡음 포인트(noise point): 최소 데이터 개수 이상의 이웃 포인트를 가지고 있지 않으며, 핵심 포인트도 갖고 있지 않은 데이터

사용

  from sklearn.cluster import DBSCAN

  dbscan = DBSCAN(eps=0.6, min_samples=8, metric='euclidean')
  dbscan_labels = dbscan.fit_predict(iris.data)

  irisDF['dbscan_cluster'] = dbscan_labels
  irisDF['target'] = iris.target

  iris_result = irisDF.groupby(['target'])['dbscan_cluster'].value_counts()
  print(iris_result)

  > target  dbscan_cluster
  > 0        0                49
  >         -1                 1
  > 1        1                46
  >         -1                 4
  > 2        1                42
  >         -1                 8
  > Name: dbscan_cluster, dtype: int64

  # 군집 레이블이 -1인 것은 노이즈에 속하는 군집을 의미

군집 레이블이 -1인 것은 노이즈에 속하는 군집을 의미
Target 유형이 3가지 인데, 군집이 2개가 됐다고 군집화 효율이 떨어진다는 의미는 아님
- DBSCAN은 군집의 갯수를 알고리즘에 따라 자동으로 지정하므로, DBSCAN에서 군집의 갯수를 지정하는 것은 무의미
- 원래 iris 데이터의 경우는 군집을 3개로 하는 것 보다, 2개로 하는 것이 군집화의 효율로서 더 좋은 면도 실제로 있음

파라미터

| 파라미터 | 설명 |
| --- | --- |
| eps | 입실론(epsilon)
개별 데이터를 중심으로 입실론 반경을 가지는 원형의 영역
일반적으로 1 이하의 값 설정 |
| min_samples | 최소 데이터 개수(min points)
개별 데이터의 입실론 주변 영역에 포함되는 타 데이터의 개수 (자기 자신 포함) |
- eps 값을 크게 하면, 반경이 커져 포함하는 데이터가 많아지므로 노이즈 데이터 개수가 작아진다.
- min_samples를 크게 하면, 주어진 반경 내에서 더 많은 데이터를 포함시켜야 하므로 노이즈 데이터 개수가 커진다.

DBSCAN 적용하기 - make_circles() 데이터 세트 +- 비교하기

make_circles() 원본

- make_circles는 내부 원과 외부 원으로 구분되는 데이트 세트를 생성해줌

Kmeans (거리기반 군집화)

- 거리를 기반으로, 위, 아래 군집 중심을 기반으로 군집화 됨

GMM (확률 기반 군집화)

- 일렬로 늘어선 데이터 세트(타원형)에서는 효과적으로 군집화 적용이 가능했으나,
- 내부와 외부의 원형으로 구성된 더 복잡한 형태의 데이터 세트에서는 군집화가 원하는 방향으로 되지 않았음

DBSCAN

- 는 정확히 군집화가 됐음

7. 실습

군집화 실습 : 고객 세그먼테이션

비지도학습 알고리즘의 하나인 군집화의 기능적 의미 ⇒ 숨어 있는 새로운 집단을 발견하는 것
- 새로운 군집 내의 데이터 값을 분석하고 이해함으로써, 집단에 새로운 의미를 부여하고
- 전체 데이터를 다른 각도로 바라볼 수 있게 만들어줌

8. 정리

: 각 군집화 기법은 나름의 장/단점을 가지고 있으며, 군집화 하려는 데이터의 특성에 맞게 선택해야 한다.

KMeans: 거리 기반으로 군집 중심점을 이동시키며 군집화 수행. 평가는 실루엣 계수 이용
MeanShift: 거리 중심X, 데이터가 모여 있는 밀도가 가장 높은 쪽으로 군집 중심점을 이동하며 군집화 수행
GMM: 전체 데이터 세트에서 서로 다른 정규 분포 형태를 추출해 다른 정규 분포를 가진 데이터 세트를 각각 군집화
DBSCAN: 밀도 기반. 입실론 주변 영역 내에 포함되는 최소 데이터 개수의 충족 여부에 따라 데이터 포인트를 핵심 포인트, 이웃 포인트, 경계 포인트, 잡음 포인트로 구분하고 특정 핵심 포인트에서 직접 접근이 가능한 다른 핵심 포인트를 서로 연결하면서 군집화를 구성하는 방식

파이썬 머신러닝 완벽 가이드 - 8. Clustering(1) (K-Mean, Cluster Evaluation)

Thu, 13 Oct 2022 02:57:52 GMT

Clustering 군집화

분류와 유사해보일 수 있지만 성격이 다르다. 데이터 내에 숨어있는 별도의 그룹을 찾아서 의미를 부여하거나, 동일한 분류값에 속하더라도 그 안에서 더 세분화된 군집화를 추구하거나, 서로 다른 분류값의 데이터도 더 넓은 군집화 레벨화 등의 영역을 가진다.

1. K-Mean(K평균)

(거리기반 군집화)

: 군집 중심점(centroid)이라는 특정한 임의의 지점을 선택해 해당 중심에 가장 가까운 포인트들을 선택해 군집화하는 방식

수행
1. 군집 중심점을 임의의 위치에 놓는다. (일반적으로는 초기화 알고리즘으로 적합한 위치에 놓음)
2. 각 데이터는 가장 가까운 곳에 위치한 중심점에 소속된다.
3. 군집 중심점을 소속된 데이터의 평균 중심으로 이동
4. 각 데이터는 기존에 속한 중심점보다 더 가까운 중심점이 있다면 해당 중심점으로 다시 소속을 변경
5. 다시 중심을 소속된 데이터의 평균으로 이동
6. 중심점을 이동했는데 데이터의 중심점 소속 변경이 없으면 군집화를 종료
장점
- 일반적으로 가장 많이 사용되는 알고리즘으로 쉽고 간결하다.
단점
- 속성의 개수가 많을 경우 군집화 정확도가 떨어진다. (PCA가 필요할 수도)
- 반복이 많을수록 수행시간이 느려진다.
- 몇 개의 군집을 선택해야 할지 가이드하기 어렵다.
- 개별 군집 내의 데이터가 원형으로 흩어져 있는 경우에 효과적으로 군집화가 수행될 수 있지만, 데이터가 길쭉한 타원형으로 늘어선 경우와 같을 때는 군집화를 잘 수행하지 못한다.

하이퍼 파라미터	설명
n_clusters	군집화할 개수(군집 중심점의 개수)
init	초기에 군집 중심점의 좌표를 설정할 방식. 보통은 임의로 설정하지 않고 K-Means++ 방식으로 설정
- 임의로 설정하고 싶으면 init=’random’
- K-means++ 방식
1. 데이터 포인트 중에서 무작위로 1개를 선택하여 중심점으로 지정
2. 나머지 데이터 포인트들에 대해 첫 번째 중심점까지의 거리 계산
3. 지정된 중심점으로부터 가장 멀리 있는 데이터 포인트를 다음 중심점으로 지정
4. 중심점이 K개가 될 때까지 2, 3번 반복
max_iter	최대 반복 횟수. 이 횟수 이전에 모든 데이터의 중심점 이동이 없으면 종료
- 속성
- labels_: 각 데이터 포인트가 속한 군집중심점 레이블
- cluster_centers_: 각 군집 중심점 좌표(shape=[군집개수, 피처개수]). 이를 이용해 시각화 가능
- 사용

```python
from sklearn.preprocessing import scale
from sklearn.datasets import load_iris
from sklearn.cluster import KMeans
import matplotlib.pyplot as plt
import numpy as np
import pandas as pd
%matplotlib inline

iris = load_iris()
# 보다 편리한 데이터 Handling을 위해 DataFrame으로 변환
irisDF = pd.DataFrame(data=iris.data, columns=['sepal_length','sepal_width','petal_length','petal_width'])
irisDF.head(3)

# 개정판 소스 코드 수정(2019.12.24)
kmeans = KMeans(n_clusters=3, init='k-means++', max_iter=300,random_state=0)
kmeans.fit(irisDF)

# irisDF['cluster']=kmeans.labels_ 개정 소스코드 변경(2019.12.24)
irisDF['target'] = iris.target
irisDF['cluster']=kmeans.labels_
iris_result = irisDF.groupby(['target','cluster'])['sepal_length'].count()
print(iris_result)

# iris 4개의 속성을 2차원 평면에 그리기 위해 PCA로 2개로 차원 축소
from sklearn.decomposition import PCA
pca = PCA(n_components=2)
pca_transformed = pca.fit_transform(iris.data)

irisDF['pca_x'] = pca_transformed[:,0]
irisDF['pca_y'] = pca_transformed[:,1]

# cluster 값이 0, 1, 2 인 경우마다 별도의 Index로 추출
marker0_ind = irisDF[irisDF['cluster']==0].index
marker1_ind = irisDF[irisDF['cluster']==1].index
marker2_ind = irisDF[irisDF['cluster']==2].index

# cluster값 0, 1, 2에 해당하는 Index로 각 cluster 레벨의 pca_x, pca_y 값 추출. o, s, ^ 로 marker 표시
plt.scatter(x=irisDF.loc[marker0_ind,'pca_x'], y=irisDF.loc[marker0_ind,'pca_y'], marker='o') 
plt.scatter(x=irisDF.loc[marker1_ind,'pca_x'], y=irisDF.loc[marker1_ind,'pca_y'], marker='s')
plt.scatter(x=irisDF.loc[marker2_ind,'pca_x'], y=irisDF.loc[marker2_ind,'pca_y'], marker='^')

plt.xlabel('PCA 1')
plt.ylabel('PCA 2')
plt.title('3 Clusters Visualization by 2 PCA Components')
plt.show()
```

2. 군집화 알고리즘 테스트를 위한 데이터 생성

사이킷런의 데이터 생성기: 여러 개의 클래스에 해당하는 데이터 세트를 만드는데, 하나의 클래스에 여러 개의 군집이 분포될 수 있게 데이터를 생성한다.
- make_blobs(): 개별 군집의 중심점과 표준 편차 제어 기능이 추가되어 있다. 피처 데이터 세트, 타깃 데이터 세트가 튜플로 잔환

    | 파라미터 | 설명 |
    | --- | --- |
    | n_samples | 디폴트 = 100
    생성할 총 데이터의 개수 |
    | n_features | 데이터의 피처 개수 |
    | centers | int로 입력: 군집의 개수
    ndarray로 입력: 개별 군집 중심점의 좌표 |
    | cluster_std | 생성될 군집 데이터의 표준편차
    float로 입력: 군집 내 데이터의 표준 편차
    [float, …]로 입력: 각 군집의 순서대로 각각의 표준편차가 만들어짐.
    ⇒ 군집별로 서로 다른 표준편차를 가진 데이터 세트를 만들 때 사용 |
- `make_classification()`: 노이즈를 포함한 데이터를 만든다.
- `make_circle(), make_moon()`: 중심기반의 군집화로 해결하기 어려운 데이터 세트를 만듦

```python
import numpy as np
import matplotlib.pyplot as plt
from sklearn.cluster import KMeans
from sklearn.datasets import make_blobs
%matplotlib inline

# 테스트 데이터 생성
X, y = make_blobs(n_samples=200, n_features=2, centers=3, cluster_std=0.8, random_state=0)
print(X.shape, y.shape)

# y target 값의 분포를 확인
unique, counts = np.unique(y, return_counts=True)
print(unique,counts)

> (200, 2) (200,)
> [0 1 2] [67 67 66]

# DataFrame에 적용
import pandas as pd
clusterDF = pd.DataFrame(data=X, columns=['ftr1', 'ftr2'])
clusterDF['target'] = y

target_list = np.unique(y)
# 각 target별 scatter plot 의 marker 값들. 
markers=['o', 's', '^', 'P','D','H','x']
# 3개의 cluster 영역으로 구분한 데이터 셋을 생성했으므로 target_list는 [0,1,2]
# target==0, target==1, target==2 로 scatter plot을 marker별로 생성. 
for target in target_list:
    target_cluster = clusterDF[clusterDF['target']==target]
    plt.scatter(x=target_cluster['ftr1'], y=target_cluster['ftr2'], edgecolor='k', marker=markers[target] )

plt.show()
```

KMeans 객체를 이용하여 X 데이터를 K-Means 클러스터링 수행 후, 시각화

  # KMeans 객체를 이용하여 X 데이터를 K-Means 클러스터링 수행 
  kmeans = KMeans(n_clusters=3, init='k-means++', max_iter=200, random_state=0)
  cluster_labels = kmeans.fit_predict(X)
  clusterDF['kmeans_label']  = cluster_labels

  #cluster_centers_ 는 개별 클러스터의 중심 위치 좌표 시각화를 위해 추출
  centers = kmeans.cluster_centers_
  unique_labels = np.unique(cluster_labels)
  markers=['o', 's', '^', 'P','D','H','x']

  # 군집된 label 유형별로 iteration 하면서 marker 별로 scatter plot 수행. 
  for label in unique_labels:
      label_cluster = clusterDF[clusterDF['kmeans_label']==label]
      center_x_y = centers[label]
      plt.scatter(x=label_cluster['ftr1'], y=label_cluster['ftr2'], edgecolor='k', 
                  marker=markers[label] )

      # 군집별 중심 위치 좌표 시각화 
      plt.scatter(x=center_x_y[0], y=center_x_y[1], s=200, color='white',
                  alpha=0.9, edgecolor='k', marker=markers[label])
      plt.scatter(x=center_x_y[0], y=center_x_y[1], s=70, color='k', edgecolor='k', 
                  marker='$%d$' % label)

  plt.show()

  print(clusterDF.groupby('target')['kmeans_label'].value_counts())

  > target  kmeans_label
  > 0       0               66
  >         1                1
  > 1       2               67
  > 2       1               65
  >         2                1

3. 군집 평가 Cluster Evaluation - 실루엣 분석 silhouette analysis

: 대부분의 군집화 데이터 세트는 타깃 레이블을 가지고 있지 않다. : 그래서 비지도 학습의 특성상 정확한 성능 평가는 어렵지만 군집화의 성능을 평가하는 방법으로는 실루엣 분석이 있다.

실루엣 분석: 각 군집 간의 거리가 얼마나 효율적으로 분리되어 있는지 나타냄
- 효율적 분리 ⇒ 다른 군집과는 떨어져 있고, 동일 군집끼리의 데이터는 서로 가깝게 잘 뭉쳐 있는것.
- 군집화가 잘 될수록 개별 군집은 비슷한 정도의 여유공간을 가지고 떨어져 있다.
실루엣 계수(silhouette coefficient) : 개별 데이터가 가지는 군집화 지표
- 해당 데이터가 같은 군집 내의 데이터와 얼마나 가깝게 군집화 돼있고, 다른 군집에 있는 데이터와는 얼마나 멀리 분리되어 있는지 나타내는 지표

- aij: i번째 데이터에서 [자신이 속한 클러스터 내]의 [다른 데이터 포인트]까지의 거리
- a(i): i번째 데이터에서 [자신이 속한 클러스터 내]의 [다른 데이터 포인트]들의 [평균] 거리 ⇒ a(1) = avg(a12, a13…)
- b(i): i번째 데이터에서 [가장 가까운 타 클러스터 내]의 [다른 데이터 포인트]들의 [평균] 거리 ⇒ b(1) = avg(b14, b15…)

    $$
    실루엣 계수S \> (i)={b(i)-a(i)\over max(a(i), b(i))}
    $$

- 실루엣 계수는 -1~1 사이의 값을 가짐
    - 1로 가까울 수록, 근처의 군집과 더 멀리 떨여지 있다는 것
        - $b(i)$가 압도적으로 크면 → $\frac{b(i) - a(i)}{b(i)}$ → $\frac{1- \frac{a(i)}{b(i)}}{1}$ → $\frac{1 - 0.00…}{1}$ → 1에 가까워짐
    - 0에 가까울 수록, 근처의 군집과 가까워진다는 것
        - $b(i) - a(i) = 0$ →  $b(i) = a(i)$ : 클러스터내 거리랑, 타 클러스트내 거리랑 차이가 없다는 거니깐
    - - 값이면 다른 군집에 데이터 포인트가 할당되었다는 것
        - $b(i) < a(i)$ → 클러스터내 거리가 타 클러스트내 거리보다 크다 → 다른 군집 데이터가 할당됐다고 볼 수 있음

사이킷런의 실루엣 분석 메소드

silhouette_sample(X, labels, metric='euclidean', **kwds)
- 인자로 X_feature 데이터 세트, 군집 레이블 값(labels) ⇒ 각 데이터의 실루엣 계수를 계산하여 반환
silhouette_score(X, labels, metric='euclidean', sample_size=None, **kwds)
- 인자로 X feature 데이터 세트, 군집 레이블 값(labels) ⇒ 전체 데이터의 실루엣계수 값을 평균하여 반환
- np.mean(silhouette_samples()) 랑 같음
- 일반적으로 이 값이 높을수록 군집화가 어느정도 잘 됐다고 판단할 수 있지만, 무조건 그런건 아니다.

사용

  from sklearn.preprocessing import scale
  from sklearn.datasets import load_iris
  from sklearn.cluster import KMeans
  # 실루엣 분석 metric 값을 구하기 위한 API 추가
  from sklearn.metrics import silhouette_samples, silhouette_score
  import matplotlib.pyplot as plt
  import numpy as np
  import pandas as pd

  %matplotlib inline

  iris = load_iris()
  feature_names = ['sepal_length','sepal_width','petal_length','petal_width']
  irisDF = pd.DataFrame(data=iris.data, columns=feature_names)
  kmeans = KMeans(n_clusters=3, init='k-means++', max_iter=300,random_state=0).fit(irisDF)

  irisDF['cluster'] = kmeans.labels_

  # iris 의 모든 개별 데이터에 실루엣 계수값을 구함. 
  score_samples = silhouette_samples(iris.data, irisDF['cluster'])
  print('silhouette_samples( ) return 값의 shape' , score_samples.shape)
  print(np.mean(silhouette_samples(iris.data, irisDF['cluster'])))
  print(silhouette_score(iris.data, irisDF['cluster']))

  > silhouette_samples( ) return 값의 shape (150,)
  > 0.5528190123564095
  > 0.5528190123564095

  # irisDF에 실루엣 계수 컬럼 추가
  irisDF['silhouette_coeff'] = score_samples

  # 모든 데이터의 평균 실루엣 계수값을 구함. 
  average_score = silhouette_score(iris.data, irisDF['cluster'])
  print('붓꽃 데이터셋 Silhouette Analysis Score:{0:.3f}'.format(average_score))

  > 붓꽃 데이터셋 Silhouette Analysis Score:0.553

  # 군집별 평균 실루엣 계수
  print(irisDF.groupby('cluster')['silhouette_coeff'].mean())

  > cluster
  > 0    0.417320
  > 1    0.798140
  > 2    0.451105
  > Name: silhouette_coeff, dtype: float64

군집별 평균 실루엣 계수의 시각화를 통한 군집 갯수 최적화 방법

전체 데이터의 평균 실루엣 계수 값이 높다고 해서, 반드시 최적의 군집 개수로 군집화가 잘 됐다고 볼 수 없음
- 특정 군집만 실루엣 계수가 엄청 높고 나머지 군집들은 낮아도, 평균 실루엣 계수 자체는 높게 나올 수 있기 때문
따라서, 좋은 군집의 조건으로
1. 전체 실루엣 계수의 평균값(silhouette_score())은 0~1 사이의 값을 가지며, 1에 가까울 수록 좋다.
2. 하지만 전체 실루엣 계수의 평균값과 더불어, 개별 군집의 평균값의 편차가 크지 않아야 한다.
3. 즉, 개별 군집의 실루엣 계수 평균값이 전체 실루엣 계수 평균값에서 크게 벗어나지 않는 것이 중요하다.

visualize_silhouette( [군집 갯수 list], X_feature )을 통한 실루엣 시각화 분석

  ### 여러개의 클러스터링 갯수를 List로 입력 받아 각각의 실루엣 계수를 면적으로 시각화한 함수 작성
  def visualize_silhouette(cluster_lists, X_features): 

      from sklearn.datasets import make_blobs
      from sklearn.cluster import KMeans
      from sklearn.metrics import silhouette_samples, silhouette_score

      import matplotlib.pyplot as plt
      import matplotlib.cm as cm
      import math

      # 입력값으로 클러스터링 갯수들을 리스트로 받아서, 각 갯수별로 클러스터링을 적용하고 실루엣 개수를 구함
      n_cols = len(cluster_lists)

      # plt.subplots()으로 리스트에 기재된 클러스터링 수만큼의 sub figures를 가지는 axs 생성 
      fig, axs = plt.subplots(figsize=(4*n_cols, 10), nrows=2, ncols=n_cols)

      # 리스트에 기재된 클러스터링 갯수들을 차례로 iteration 수행하면서 실루엣 개수 시각화
      for ind, n_cluster in enumerate(cluster_lists):

          # KMeans 클러스터링 수행하고, 실루엣 스코어와 개별 데이터의 실루엣 값 계산. 
          clusterer = KMeans(n_clusters = n_cluster, max_iter=500, random_state=0)
          cluster_labels = clusterer.fit_predict(X_features)
          centers = clusterer.cluster_centers_

          sil_avg = silhouette_score(X_features, cluster_labels)
          sil_values = silhouette_samples(X_features, cluster_labels)

          y_lower = 10
          axs[0,ind].set_title('Number of Cluster : '+ str(n_cluster)+'\n' \
                            'Silhouette Score :' + str(round(sil_avg,3)) )
          axs[0,ind].set_xlabel("The silhouette coefficient values")
          axs[0,ind].set_ylabel("Cluster label")
          axs[0,ind].set_xlim([-0.1, 1])
          axs[0,ind].set_ylim([0, len(X_features) + (n_cluster + 1) * 10])
          axs[0,ind].set_yticks([])  # Clear the yaxis labels / ticks
          axs[0,ind].set_xticks([0, 0.2, 0.4, 0.6, 0.8, 1])

          # 클러스터링 갯수별로 fill_betweenx( )형태의 막대 그래프 표현. 
          for i in range(n_cluster):
              ith_cluster_sil_values = sil_values[cluster_labels==i]
              ith_cluster_sil_values.sort()

              size_cluster_i = ith_cluster_sil_values.shape[0]
              y_upper = y_lower + size_cluster_i

              color = cm.nipy_spectral(float(i) / n_cluster)
              axs[0,ind].fill_betweenx(np.arange(y_lower, y_upper), 0, ith_cluster_sil_values, \
                                  facecolor=color, edgecolor=color, alpha=0.7)
              axs[0,ind].text(-0.05, y_lower + 0.5 * size_cluster_i, str(i))
              y_lower = y_upper + 10

              # 클러스터링된 데이터 시각화
              axs[1,ind].scatter(X_features[:, 0], X_features[:, 1], marker='.', s=30, lw=0, alpha=0.7, \
                  c=cluster_labels)
              axs[1,ind].set_title("Clustered data")
              axs[1,ind].set_xlabel("Feature space for the 1st feature")
              axs[1,ind].set_ylabel("Feature space for the 2nd feature")  

          # 군집별 중심 위치 좌표 시각화 
          unique_labels = np.unique(cluster_labels)
          for label in unique_labels:
              center_x_y = centers[label]
              axs[1,ind].scatter(x=center_x_y[0], y=center_x_y[1], s=70, color='k', edgecolor='k', 
                          marker='$%d$' % label)

          axs[0,ind].axvline(x=sil_avg, color="red", linestyle="--")

  # make_blobs 을 통해 clustering 을 위한 4개의 클러스터 중심의 500개 2차원 데이터 셋 생성  
  from sklearn.datasets import make_blobs
  X, y = make_blobs(n_samples=500, n_features=2, centers=4, cluster_std=1, \
                    center_box=(-10.0, 10.0), shuffle=True, random_state=1)  

  # cluster 개수를 2개, 3개, 4개, 5개 일때의 클러스터별 실루엣 계수 평균값을 시각화 
  visualize_silhouette([ 2, 3, 4, 5], X)

iris 데이터로 실루엣 시각화 분석

  from sklearn.datasets import load_iris

  iris=load_iris()
  visualize_silhouette([ 2, 3, 4,5 ], iris.data)

단점
- (직관적으로 이해하기 쉽지만) 각 데이터별로 다른 데이터와의 거리를 반복적으로 계산해야 하므로, 데이터 양이 늘어나면 수행시간이 크게 늘어난다.
- 또한 메모리 부족 등의 에러가 발생하기 쉬우며, 이 경우 군집별로 임의의 데이터를 샘플링 해 실루엣 계수를 평가하는 방안을 고민해야 한다.

파이썬 머신러닝 완벽 가이드 - 7. Dimension Reduction(2) (SVD, NMF)

Wed, 12 Oct 2022 01:42:36 GMT

3. SVD(Singular Value Decomposition, 특이 값 분해)

: PCA와 유사. 정방 행렬뿐만 아니라 행과 열의 크기가 다른 행렬에도 적용 가능

Full SVD
- $A = U \sum V^T$
- $A$ : 행렬, $U$, $V$: 특이벡터(Singular vector)로 된 행렬, $\sum$ : 대각행렬
- $\sum$ : 대각행렬 : 행렬의 대각에 위치한 값만 0이 아니고 나머지 위치의 값은 모두 0인 행렬. 여기서 0이 아닌 값이 행렬 A의 특이값

- $A$ : MxN 행렬일 때   —분해→  $U$: MxM 행렬,  $\sum$ : MxN 행렬,  $V^T$: NxN 행렬

Compact SVD (일반적)
- $U$ : MxP 행렬, $\sum$ : PxP 행렬, $V^T$: PxN 행렬
- $\sum$ 의 비대각인 부분과 대각원소 중에 특이값이 0인 부분도 모두 제거되고, 제거된 $\sum$에 대응되는 $U$와 $V$원소도 함께 제거해 차원을 줄인 형태로 SVD를 적용한다.
Truncated SVD
- 특이값 중 상위 일부 데이터만 추출해 분해하는 방식.
- 인위적으로 더 작은 차원의 행렬들로 분해하기 때문에 원본행렬을 정확하게는 복원할 수 없다.

SVD 사용: 보통 넘파이나 사이파이 라이브러리를 이용

  from numpy.linalg import svd
  # or
  from scipy.linalg import svd

  # numpy의 svd 모듈 import
  import numpy as np
  from numpy.linalg import svd

  # 4X4 Random 행렬 a 생성 
  np.random.seed(121)
  a = np.random.randn(4,4)
  print(np.round(a, 3))

  > [[-0.212 -0.285 -0.574 -0.44 ]
  > [-0.33   1.184  1.615  0.367]
  > [-0.014  0.63   1.71  -1.327]
  > [ 0.402 -0.191  1.404 -1.969]]

  U, Sigma, Vt = svd(a) # a = 원본 행렬
  print(U.shape, Sigma.shape, Vt.shape)
  print('U matrix:\n',np.round(U, 3))
  print('Sigma Value:\n',np.round(Sigma, 3)) # 대각행렬 => 대각에 위치한 값 == 1,  외에 나머지 값 0
  print('V transpose matrix:\n',np.round(Vt, 3))

  > (4, 4) (4,) (4, 4)
  > U matrix:
  >  [[-0.079 -0.318  0.867  0.376]
  >  [ 0.383  0.787  0.12   0.469]
  >  [ 0.656  0.022  0.357 -0.664]
  >  [ 0.645 -0.529 -0.328  0.444]]

  > Sigma Value:
  >  [3.423 2.023 0.463 0.079]

  > V transpose matrix:
  >  [[ 0.041  0.224  0.786 -0.574]
  >  [-0.2    0.562  0.37   0.712]
  >  [-0.778  0.395 -0.333 -0.357]
  >  [-0.593 -0.692  0.366  0.189]]

다시 행렬 A로 복원해보기 ⇒ $U > * > \sum > * > V^T > = A$

단, $\sum$ 의 경우 0이 아닌 값만 1차원으로 추출했으므로, 다시 0을 포함한 대칭행렬로 변환 뒤 내적($*$) 수행

# Sima를 다시 0 을 포함한 대칭행렬로 변환
Sigma_mat = np.diag(Sigma)
a_ = np.dot(np.dot(U, Sigma_mat), Vt)
print(np.round(a_, 3))

데이터 세트가 로 우간 의존성이 있을 경우, 어떻게 $\sum$ 값이 변하고, 이에 따른 차원 축소 진행되는지 알아보기

$A$ 행렬 ⇒ 3번째 로우 = 1번째 로우 + 2번째 로우 & 4번째 로우 = 1번째 로우

  a[2] = a[0] + a[1]
  a[3] = a[0]
  print(np.round(a,3))

  > [[-0.212 -0.285 -0.574 -0.44 ]
  >  [-0.33   1.184  1.615  0.367]
  >  [-0.542  0.899  1.041 -0.073]
  >  [-0.212 -0.285 -0.574 -0.44 ]]

이 $A$ 행렬을 다시 SVD 분해

  # 다시 SVD를 수행하여 Sigma 값 확인 
  U, Sigma, Vt = svd(a)
  print(U.shape, Sigma.shape, Vt.shape)
  print('Sigma Value:\n',np.round(Sigma,3))

  > (4, 4) (4,) (4, 4)
  > Sigma Value:
  >  [2.663 0.807 0.    0.   ]

이전과 차원은 같지만, $\sum$ 값 중 2개가 0으로 변함 ⇒ 선형 독립의 로우 벡터의 수가 2개라는 의미 (행렬의 랭크가 2)

이제 다시 행렬 A를 복원해볼 것 ⇒ $U, \sum, V^T$ 전체 데이터 사용하지 않고, $\sum$ 의 0에 대응되는 $U, \sum, V^T$ 를 제외하고 복원해보겠음 ⇒ 즉, $U$ 행렬 중 선행 두 개의 열만 추출 하고, $V^T$의 경우는 선행 두 개의 행만 추출 복원해보는 것

  # U 행렬의 경우는 Sigma와 내적을 수행하므로 Sigma의 앞 2행에 대응되는 앞 2열만 추출
  U_ = U[:, :2]
  Sigma_ = np.diag(Sigma[:2])

  # V 전치 행렬의 경우는 앞 2행만 추출
  Vt_ = Vt[:2]
  print(U_.shape, Sigma_.shape, Vt_.shape)

  # U, Sigma, Vt의 내적을 수행하며, 다시 원본 행렬 복원
  a_ = np.dot(np.dot(U_,Sigma_), Vt_)
  print(np.round(a_, 3))

  > (4, 2) (2, 2) (2, 4)
  > [[-0.212 -0.285 -0.574 -0.44 ]
  >  [-0.33   1.184  1.615  0.367]
  >  [-0.542  0.899  1.041 -0.073]
  >  [-0.212 -0.285 -0.574 -0.44 ]]

Truncated SVD : $\sum$ 행렬에 있는 대각원소, 즉 특이값 중 상위 일부 데이터만 추출해 분해하는 방식
- 이렇게 분해하면, 인위적으로 더 작은 차원의 $U, \sum, V^T$ 로 분해하기에, 원본 행렬을 정확히 원복할 수는 없음
- 그러나, 데이터 정보가 압축되어 분해됨에도 불구하고 상당한 수준으로 워본 행렬을 근사할 수 있음

Truncated SVD 사용 : 사이파이에서만 지원됨

  from scipy.sparse.linalg import svds

검증 수행 순서

임의의 원본 행렬 6x6을 Normal SVD로 분해해 ⇒ 행렬의 차원, $\sum$ 행렬 내 특이값 확인
다시 Truncated SVD로 분해해 ⇒ 행렬의 차원, $\sum$ 행렬 내 특이값 확인
Truncated SVD로 분해된 행렬의 내적을 계산해서 ⇒ 원상 복구하여 원본데이터와 비교

import numpy as np
from scipy.sparse.linalg import svds # Truncated SVD
from scipy.linalg import svd # Nomarl SVD

# 원본 행렬을 출력하고, SVD를 적용할 경우 U, Sigma, Vt 의 차원 확인 
np.random.seed(121)
matrix = np.random.random((6, 6))
print('원본 행렬:\n',matrix)
U, Sigma, Vt = svd(matrix, full_matrices=False)
print('\n분해 행렬 차원:',U.shape, Sigma.shape, Vt.shape)
print('\nSigma값 행렬:', Sigma)

# Truncated SVD로 Sigma 행렬의 특이값을 4개로 하여 Truncated SVD 수행. 
num_components = 4
U_tr, Sigma_tr, Vt_tr = svds(matrix, k=num_components)
print('\nTruncated SVD 분해 행렬 차원:',U_tr.shape, Sigma_tr.shape, Vt_tr.shape)
print('\nTruncated SVD Sigma값 행렬:', Sigma_tr)
matrix_tr = np.dot(np.dot(U_tr,np.diag(Sigma_tr)), Vt_tr)  # output of TruncatedSVD

print('\nTruncated SVD로 분해 후 복원 행렬:\n', matrix_tr)

> 원본 행렬:
> [[0.11133083 0.21076757 0.23296249 0.15194456 0.83017814 0.40791941]
>  [0.5557906  0.74552394 0.24849976 0.9686594  0.95268418 0.48984885]
>  [0.01829731 0.85760612 0.40493829 0.62247394 0.29537149 0.92958852]
>  [0.4056155  0.56730065 0.24575605 0.22573721 0.03827786 0.58098021]
>  [0.82925331 0.77326256 0.94693849 0.73632338 0.67328275 0.74517176]
>  [0.51161442 0.46920965 0.6439515  0.82081228 0.14548493 0.01806415]]

> 분해 행렬 차원: (6, 6) (6,) (6, 6)

> Sigma값 행렬: [3.2535007  0.88116505 0.83865238 0.55463089 0.35834824 0.0349925 ]

> Truncated SVD 분해 행렬 차원: (6, 4) (4,) (4, 6)

> Truncated SVD Sigma값 행렬: [0.55463089 0.83865238 0.88116505 3.2535007 ]

> Truncated SVD로 분해 후 복원 행렬:
>  [[0.19222941 0.21792946 0.15951023 0.14084013 0.81641405 0.42533093]
>  [0.44874275 0.72204422 0.34594106 0.99148577 0.96866325 0.4754868 ]
>  [0.12656662 0.88860729 0.30625735 0.59517439 0.28036734 0.93961948]
>  [0.23989012 0.51026588 0.39697353 0.27308905 0.05971563 0.57156395]
>  [0.83806144 0.78847467 0.93868685 0.72673231 0.6740867  0.73812389]
>  [0.59726589 0.47953891 0.56613544 0.80746028 0.13135039 0.03479656]]

6 ⇒ 4 차원 & Truncated SVD 적용 후 원상 복구 하면, 완벽하진 않지만 근사하게 복원됨

사이킷런 TruncatedSVD 클래스를 이용한 변환

사이파이의 SVDs와 같이 $U, \sum, V^T$ 행렬을 반환하지는 않음.
사이킷런의 PCA 클래스와 유사하게, fit(), transform()으로 원본 데이터를 몇 개의 주요 컴포넌트로 차원축소해 변환

즉, 원본 데이터를 Truncated SVD 방식으로 분해된 $U * \sum$ 행렬에 선형변환하여 생성

from sklearn.decomposition import TruncatedSVD, PCA
from sklearn.datasets import load_iris
import matplotlib.pyplot as plt
%matplotlib inline

iris = load_iris()
iris_ftrs = iris.data
# 2개의 주요 component로 TruncatedSVD 변환
tsvd = TruncatedSVD(n_components=2)
tsvd.fit(iris_ftrs)
iris_tsvd = tsvd.transform(iris_ftrs)

# 2개의 주요 component로 TruncatedSVD 변환 (비교를 위해)
pca = PCA(n_components=2)
pca.fit(iris_ftrs)
iris_pca = pca.transform(iris_ftrs)

# TruncatedSVD 변환 데이터를 왼쪽에, PCA변환 데이터를 오른쪽에 표현 
fig, (ax1, ax2) = plt.subplots(figsize=(18,4), ncols=2)
ax1.scatter(x=iris_tsvd[:,0], y= iris_tsvd[:,1], c= iris.target)
ax2.scatter(x=iris_pca[:,0], y= iris_pca[:,1], c= iris.target)
ax1.set_title('Truncated SVD Transformed')
ax2.set_title('PCA Transformed')
ax1.set_xlabel('TruncatedSVD Component 1')
ax1.set_ylabel('TruncatedSVD Component 2')
ax2.set_xlabel('PCA Component 1')
ax2.set_ylabel('PCA Component 2')

- TruncatedSVD 역시 PCA와 유사하게 변환 후 품종별로 어느정도 클러스터링이 가능할정도로 고유성 가지고 있음
- 사실 두 클래스를 모두 뜨덩보면, 모두 SVD를 이용해 행렬을 분해함 ⇒ 원본 데이터를 스케일링으로 변환 후에 적용해보면 거의 동일함

    ```python
    from sklearn.preprocessing import StandardScaler

    # iris 데이터를 StandardScaler로 변환
    scaler = StandardScaler()
    iris_scaled = scaler.fit_transform(iris_ftrs)

    # 스케일링된 데이터를 기반으로 TruncatedSVD 변환 수행 
    tsvd = TruncatedSVD(n_components=2)
    tsvd.fit(iris_scaled)
    iris_tsvd = tsvd.transform(iris_scaled)

    # 스케일링된 데이터를 기반으로 PCA 변환 수행 
    pca = PCA(n_components=2)
    pca.fit(iris_scaled)
    iris_pca = pca.transform(iris_scaled)

    # TruncatedSVD 변환 데이터를 왼쪽에, PCA변환 데이터를 오른쪽에 표현 
    fig, (ax1, ax2) = plt.subplots(figsize=(9,4), ncols=2)
    ax1.scatter(x=iris_tsvd[:,0], y= iris_tsvd[:,1], c= iris.target)
    ax2.scatter(x=iris_pca[:,0], y= iris_pca[:,1], c= iris.target)
    ax1.set_title('Truncated SVD Transformed')
    ax2.set_title('PCA Transformed')
    ```

    ![](https://velog.velcdn.com/images/mios_leo/post/5636be7d-2897-4ef8-80e6-b076af20d277/image.png)


- 두개의 변환 행렬값과, 원복 속성별 컴포넌트 비율값을 실제로 서로 비교하면 거의 같음

    ```python
    print((iris_pca - iris_tsvd).mean())
    print((pca.components_ - tsvd.components_).mean())

    > 2.3419865583888347e-15
    > 6.245004513516506e-17
    ```

    - 모두 0에 가까운 값이므로, 2개의 변환이 서로 동일함을 알 수 있음
    - 즉, 데이터 세트가 스케일링으로 데이터 중심이 동일해지면, SVD와 PCA는 동일한 변환을 수행
    - 이는 PCA가 SVD 알고리즘으로 구현됐음을 의미
    - 그러나, PCA는 밀집 행렬(Dense Matrix)에 대한 변환만 가능하며, SVD는 희소 행렬(Sparse Matrix)에 대한 변환도 가능
    - 또한 SVD는 텍스트의 토픽 모델링 기법인 LSA(Latent Semantic Analysis)의 기반 알고리즘임.

4. NMF(Non-Negative Matrix Factorization)

: 원본 행렬 내의 모든 원소값이 모두 양수(0 이상)라는 게 보장되면, 두 개의 기반 양수 행렬로 분해될 수 있는 기법 : Truncated SVD와 같이 낮은 랭크를 통한 행렬 근사 방식의 변형

$W \times H \approx V$
- 일반적으로 길고 가는 행렬 $W$(원본 행렬과 행크기 같고 열크기 보다 작은 행렬) X 작고 넓은 행렬 $H$ (원본 행렬의 행 크기보다 작고 열 크기와 같은 행렬)로 분해된다.
- $W$ : 원본 행에 대해서 이 잠재요소의 값이 얼마나 되는지에 대응
- $H$ : 이 잠재요소가 원본 열(원본 속성)로 어떻게 구성됐는지를 나타냄

사용

  from sklearn.decomposition import NMF
  from sklearn.datasets import load_iris
  import matplotlib.pyplot as plt
  %matplotlib inline

  iris = load_iris()
  iris_ftrs = iris.data
  nmf = NMF(n_components=2)
  nmf.fit(iris_ftrs)
  iris_nmf = nmf.transform(iris_ftrs)
  plt.scatter(x=iris_nmf[:,0], y= iris_nmf[:,1], c= iris.target)
  plt.xlabel('NMF Component 1')
  plt.ylabel('NMF Component 2')

NMF와 SVD와 유사하게 이미지 압축을통한 패턴 인식, 텍스트의 토픽 모델링 기법, 문서 유사도 및 클러스터링, 추천 시스템에 활발히 적용 됨

5. 정리

PCA
- 입력 데이터의 변동성이 가장 큰 축을 구하고, 다시 이 축에 직각인 축을 반복적으로 축소하려는 차원의 개수만큼 구한 뒤 입력 데이터를 이 축들에 투영해 차원을 축소하는 방식
- 입력 데이터의 공분산 행렬을 기반으로, 고유 벡터를 생성하고, 이 고유 벡터에 입력 데이터를 선형변환하는 방식
LDA
- 입력 데이터의 결정값 클래스를 최대한으로 분리할 수 있는 축을 찾아 차원을 축소하는 방식
SVD, NMF
- 고차원 행렬을 두 개의 저차원 행렬로 분리하는 행렬기법
- 원본 행렬에서 잠재된 요소를 추출하기 때문에 토픽 모델이나 추천시스템에서 사용된다.

파이썬 머신러닝 완벽 가이드 - 7. Dimension Reduction(1) (PCA, LDA)

Tue, 11 Oct 2022 02:37:46 GMT

Dimension Reduction 차원 축소

: 매우 많은 피처로 구성된 다차원 세트의 차원을 축소해 새로운 차원의 데이터 세트를 생성하는 것

다차원 데이터 세트의 문제점
1. 차원이 증가할 수록 데이터 포인트 간의 거리가 기하급수적으로 멀어지고, 희소한Sparse 구조를 가져 예측 신뢰도가 떨어진다.
2. 다중공선성 문제(독립변수 간의 상관관계가 높은 것)로 예측 성능 저하
  - 회귀분석의 전제 가정 위배 : 독립변수간 상관관계는 높으면 안된다
차원 축소의 분류
- 피처(특성) 선택 : 특정 피처에 종속성이 강한 불필요 피처는 아예 제거 + 데이터 특징 잘 나타내는 주요 피처만 선택
- 피처(특성) 추출 : 기촌 피처를 저차원의 중요 피처로 압축하여 추출 ⇒ 기존 피처와 완전히 다른 새로운 값이 됨
  - 단순 압축이 아닌, 피처를 합축적으로 더 잘 설명할 수 있는 또 다른 공간으로 매칭하여 추출하는 것 ex) 학생의 모의고사성적, 내신성적, 수능성적, 봉사활동, 대외활동, 수상경력 등 ⇒ 학업 성취도, 커뮤니케이션 능력, 문제해결력 등 더 함축적인 요약 특성으로 추출할 수 있음
  - 가장 중요한 의미 : 데이터를 더 잘 설명할 수 있음 잠재적인 요소 추출 PCA, SVD, NMF 등
차원 축소의 활용
1. 이미지 데이터에서 잠재된 특성을 피처로 도출해 함축적 형태의 이미지 변환과 압축 수행 ⇒ 원본보다 작은 차원으로 과적향 방지
2. 텍스트 문서의 숨겨진 의미 추출. 문서 내 단어들의 구성에서 숨겨져 있는 시맨틱Semantic 의미나 토픽topic을 잠재 요소로 간주하고 이를 찾아낸다.

1. PCA(Principal Component Analysis, 주성분 분석)

: 변수 간 상관관계를 이용해 이를 대표하는 주성분을 추출해 차원을 축소하는 방법

PCA의 주성분: 정보 유실을 최소화하기 위해 가장 높은 분산을 가지는 데이터를 찾아, 이 축으로 차원을 축소한다. 즉, 분산이 데이터의 특성을 가장 잘 나타내는 것으로 간주한다.
PCA 차원 축소 하는 방법

첫 번째 벡터 축 : 가장 큰 데이터 변동성(Variance)을 기반으로 생성
두 번째 벡터 축 : 첫 번째 벡터 축에 직각이 되는 벡터(직교 벡터)를 축으로 함
세 번째 벡터 축 : 다시 두 번째 축과 직각이 되는 벡터를 설정하는 방식으로 축 생성
- 선형대수 관점 : 입력 데이터의 공분산 행렬(Covariance Matrix)을 고유값 분해하고, 이렇게 구한 고유벡터에 입력 데이터를 선형 변환하는 것
PCA의 주성분 : 위에서 말하는 고유벡터. 입력 데이터의 분산이 가장 큰 방향을 나타낸다.
고유값(eigenvalue) : 고유벡터의 크기. 입력 데이터의 분산을 나타냄
선형 변환 : 특정 벡터에 행렬 A를 곱해 새로운 벡터로 변환하는 것, 특정 벡터를 하나의 공간(행렬을 공간으로 가정)에서 다른 공간으로 투영하는 개념
고유 벡터 : 행렬A를 곱하더라도 방향이 변하지 않고, 그 크기만 변하는 벡터
- Ax = ax (A: 행렬, x: 고유 벡터, a: 스칼라 값)
- 이 고유 벡터는 여러 개가 존재하며,
- 정방 행렬은 최대 그 차원 수 만큼 고유 벡터를 가질 수 있다. (예: 2x2 행렬은 최대 2개의 고유벡터를 가질 수 있음, 3x3은 3개)
- 이렇듯 고유벡터는 행렬이 작용하는 힘의 방향과 관계가 있어서, 행렬을 분해하는데 사용됨
분산 : 한 개의 특정한 변수의 데이터 변동을 의미
공분산 : 두 변수 간의 변동을 의미
- 사람의 키 변수를 X, 몸무게 변수를 Y로 둘 때, 공분산 $Cov(X,Y) > 0$ == X(키)가 증가할 때 Y(몸무게)도 증가한다는 의미
공분산 행렬 : 여러 변수와 관련된 공분산을 포함하는, 정방 행렬 & 대칭 행렬

|  | X | Y | Z |
| --- | --- | --- | --- |
| X | 3.0 | -0.71 | -0.24 |
| Y | -0.71 | 4.5 | 0.28 |
| Z | -0.24 | 0.28 | 0.91 |
- 대각선 원소는 각 변수(X, Y, Z)의 분산을 의미
- 대각선 외의 원소는, 가능한 모든 변수 쌍 간의 공분산을 의미
- X와 Y의 공분산 = -0.71

정방 행렬(Diagonal Matrix) : 열과 행이 같은 행렬
대칭 행렬(Symmetric Matrix) : 정방 행렬 중에서 대각 원소를 중심으로 원소값이 대칭되는 행렬, $A^T = A$대
- 대칭 행렬은 항상 고유 벡터를 직교 행렬로, 고유값을 정방 행렬로 대각화 할 수 있음 ⇒ 고유값 분해
공분산 행렬의 분해
- $C = P \sum P^T$
  
  $C = [e_1\cdots e_n] \begin{bmatrix} \lambda_1 > \cdots> 0 \ \cdots > \cdots > \cdots \ 0 > \cdots > \lambda_n \end{bmatrix} \begin{bmatrix} e_1^t \ \cdots \ e_n^t \end{bmatrix}$
  
  $C$ = 고유벡터의 직교 행렬 * 고유값 정방행렬 * 고유벡터 직교행렬의 전치 행렬
  - $e_i$ 는 $i$ 번째 고유 벡터
  - $\lambda_i$ 는 $i$ 번째 고유벡터의 크기(고유값)
  - $e_1$ 는 가장 분산이 큰 방향을 가진 고유 벡터
  - $e_2$ 는 $e_1$ 에 수직이면서, 그 다음으로 분산이 큰 방향을 가진 고유벡터
PCA : 입력 데이터의 공분산 행렬이 고유벡터와 고유값으로 분해될 수 있으며, 이렇게 분해된 고유벡터를 이용해 입력 데이터를 선형 변환하는 방식
수행
1. 입력 데이터 세트의 공분산 행렬 생성 ( $C$ )
2. 공분산 행렬의 고유벡터( $e_i$ )와 고유값( $\lambda_i$ )을 계산
3. 고유값( $\lambda_i$ )이 가장 큰 순으로 K개(PCA 변환 차수)만큼 고유벡터( $e_i$ )를 추출
4. 고유값( $\lambda_i$ )이 가장 큰 순으로 추출된 고유벡터( $e_i$ )를 이용해 새롭게 입력 데이터 변환

📐 PCA의 구성 개념 정리

PCA : 입력 데이터의 공분산 행렬(Covariance Matrix)을 고유값 분해하고, 이렇게 구한 고유벡터(주성분)에 입력 데이터를 선형 변환하는 것
- 주성분 : 위에서 말하는 고유벡터. 입력 데이터의 분산이 가장 큰 방향을 나타낸다.
- 공분산 (행렬) : 두 변수 간의 변동을 의미 (여러 변수와 관련된 공분산을 포함하는 대칭 행렬)
- 공분산 행렬은 항상 고유 벡터를 직교 행렬로, 고유값을 정방 행렬로 대각화 할 수 있음 ⇒ 고유값 분해
- 고유값 ($\lambda$) : 고유벡터의 크기, 입력 데이터의 분산을 나타냄
- 고유 벡터 ($e$) : 행렬A 곱해도, 방향 변화 X & 크기만 변화 O 벡터, 행렬이 작용하는 힘의 방향과 관계 있음
- 선형 변환 : 특정 벡터(고유 벡터)에 행렬 A(입력 데이터)를 곱해 새로운 벡터로 변환하는 것
  - 특정 벡터를 하나의 공간(행렬을 공간으로 가정)에서 다른 공간으로 투영하는 개념
공분산 행렬의 분해
- $C = [e_1\cdots e_n] \begin{bmatrix} \lambda_1 > \cdots> 0 \ \cdots > \cdots > \cdots \ 0 > \cdots > \lambda_n \end{bmatrix} \begin{bmatrix} e_1^t \ \cdots \ e_n^t \end{bmatrix}$
  
  $[e_1\cdots e_n]$ = 고유 벡터 : 행렬이 작용하는 힘의 방향
  
  $\begin{bmatrix} \lambda_1 > \cdots> 0 \ \cdots > \cdots > \cdots \ 0 > \cdots > \lambda_n \end{bmatrix}$ = 고유값 : 입력데이터의 분산 & 고유 벡터의 크기
- $e_1$ 는 가장 분산이 큰 방향을 가진 고유 벡터, $e_2$ 는 $e_1$ 에 수직이면서, 그 다음으로 분산이 큰 방향을 가진 고유벡터

PCA를 적용하기 위해서는 각 속성값을 동일한 스케일로 변환해야 한다. ⇒ StandardScaler
- 여러 속성 값을 연상해야 하므로, 속성의 스케일에 영향을 받기 때문

사용


  from sklearn.preprocessing import StandardScaler

  # Target 값을 제외한 모든 속성 값을 StandardScaler를 이용하여 표준 정규 분포를 가지는 값들로 변환
  iris_scaled = StandardScaler().fit_transform(irisDF.iloc[:, :-1])

  from sklearn.decomposition import PCA

  pca = PCA(n_components=2)

  #fit( )과 transform( ) 을 호출하여 PCA 변환 데이터 반환
  pca.fit(iris_scaled)
  iris_pca = pca.transform(iris_scaled)
  print(iris_pca.shape)

  # PCA 환된 데이터의 컬럼명을 각각 pca_component_1, pca_component_2로 명명
  pca_columns=['pca_component_1','pca_component_2']
  irisDF_pca = pd.DataFrame(iris_pca, columns=pca_columns)
  irisDF_pca['target']=iris.target
  irisDF_pca.head(3)

n_components: PCA로 변환할 차원의 수
이후 fit()과 transform()을 호출해 PCA 변환 데이터 반환

explained_variance_ratio_: 전체 변동성에서 개별 PCA 컴포넌트별로 차지하는 변동성 비율 제공

  pca.explained_variance_ratio_

  > [0.72962445 0.22850762]
  >> 원본 데이터의 0.95 변동성을 설명할 수 있음

신용카드 고객 데이터

df.corr()로 각 속상간의 상관도를 구한 뒤, heatmap으로 보기
상관도 높은거 묶어서 하기(?)

2. LDA(Linear Discriminant Analysis, 선형 판별 분석)

: PCA와 유사하지만, 지도 학습의 분류에서 사용하기 쉽도록 개별 클래스를 분별할 수 있는 기준을 최대한 유지하면서 차원 축소

PCA는 입력 데이터의 변동성의 가장 큰 축을 찾았지만, LDA는 입력 데이터의 결정 값 클래스를 초대한 분리할 수 있는 축을 찾음
입력 데이터의 결정값 클래스를 최대한으로 분리할 수 있는 축을 찾기 위해, 클래스 간 분산(between)과 클래스 내부 분산(within)의 비율을 최대화하는 방식으로 차원 축소
- 클래스 간 분산은 크게, 클래스 내부 분산은 작게
$S_W^TS_B = [e_1\cdots e_n] \begin{bmatrix} \lambda_1 > \cdots> 0 \ \cdots > \cdots > \cdots \ 0 > \cdots > \lambda_n \end{bmatrix} \begin{bmatrix} e_1^T \ \cdots \ e_n^T \end{bmatrix}$

$[e_1\cdots e_n]$ = 고유 벡터 : 행렬이 작용하는 힘의 방향

$\begin{bmatrix} \lambda_1 > \cdots> 0 \ \cdots > \cdots > \cdots \ 0 > \cdots > \lambda_n \end{bmatrix}$ = 고유값 : 입력데이터의 분산 & 고유 벡터의 크기

수행
1. 입력 데이터의 결정값 클래스 별로 개별 피처의 평균 벡터(mean vector)를 기반으로 [클래스 내부, 클래스 간 분산 행렬]을 구한다.
2. 클래스 내부 분산 행렬( $S_W$ ), 클래스 간 분산 행렬( $S_B$ ) ⇒ 두 행렬을 고유벡터( $e$ )로 분해
3. 고유값이 가장 큰 순으로 K개(LDA 변환 차수)만큼 추출
4. 고유값이 가장 큰 순으로 추출된 고유벡터를 이용해 새롭게 입력 데이터를 변환

사용

  from sklearn.discriminant_analysis import LinearDiscriminantAnalysis
  from sklearn.preprocessing import StandardScaler
  from sklearn.datasets import load_iris

  iris = load_iris()
  iris_scaled = StandardScaler().fit_transform(iris.data)

  lda = LinearDiscriminantAnalysis(n_components=2)
  lda.fit(iris_scaled, iris.target) # 지도학습이라, fit할 때, 클래스 결정값 (y) 넣어야함
  iris_lda = lda.transform(iris_scaled)
  print(iris_lda.shape)

LDA는 실제로는 PCA와 다르게 비지도학습이 아닌 지도학습 ⇒ 즉, 클래스 결정값이 변환시에 필요함.

파이썬 머신러닝 완벽 가이드 - 6. Regression(2) (규제, 로지스틱회귀, 회귀 트리 및 예제)

Mon, 10 Oct 2022 01:52:40 GMT

5. 규제 Regularization

1. 릿지 회귀 Ridge

: $w^2$에 대해 패널티를 부여하는 방식. 주요 생성 파라미터는 alpha로, alpha가 커질 수록 회귀 계수 값을 작게 만든다.

$RSS(w) + alpha*||w||_2^2$ 식을 최소화하는 w를 찾는 것

from sklearn.linear_model import Ridge

2. 라쏘 회귀 Lasso

: $|w|$에 패널티를 부여하는 방식. 불필요한 회귀 계수를 급격하게 감소시켜 0으로 만든다.

$RSS(w) + alpha*||w||_1$ 식을 최소화하는 w를 찾는 것

from sklearn.linear_model import Lasso

3. 엘라스틱넷 회귀 ElasticNet

L2규제와 L1규제를 결합한 회귀
- L1 라쏘 회귀가 중요 피처만 셀렉션하고 다른 피처들은 회귀 계수를 0으로 만드는 성향이 강함
- alpha 값에 따라 회귀 계수 값이 급격히 변동할 수 있는데, 이를 완화하기 위해 L2 릿지를 L1 라쏘 회귀에 추가한 것
- 반대로 엘라스틱넷 회귀의 단점은 L1 + L2로 수행시간이 상대적으로 오래 걸린다는 것
$RSS(w) + alpha1||w||_1+alpha2||w||_2^2$ 식을 최소화하는 w를 찾는 것
- 엘라스틱 규제 : $a * L1 + b * L2$
- 릿지와 라쏘의 alpha값과는 다름
- $a$ = L1 규제의 alpha값, $b$ = L2 규제의 alpha값
- 엘라스틱넷 회귀의 alpha값은 = $a+b$
주요 생성 파라미터
- alpha = $a + b$
- l1_ratio = $\frac{a}{a+b}$
  - l1_ratio = 0이면, a=0이므로 L2규제와 동일
  - l1_ratio = 1이면, b=0이므로 L1 규제와 동일

from sklearn.linear_model import ElasticNet

4. 선형 회귀 모델을 위한 데이터 변환

데이터 분포도의 정규화와 인코딩의 중요성
데이터 변환 : 선형 회귀 모델은 피처값과 타겟값의 분포가 정규분포로 된 형태를 선호
- 정규분포 형태가 아니라, 특정값 분포로 치우친 왜곡(Skew)된 형태의 분포도일 경우, 성능에 부정적 영향 줄 가능성 높음
1. StandardScaler : 평균이 0, 분산이 1인 정규분포를 가진 데이터 세트로 변환
  
  MinMaxScaler : 최소값이 0, 최대값이 1인 값으로 정규화 수행
2. 스케일링/정규화를 수행한 데이터 세트에 다시 다항 특성을 적용하여 변환
  - 1번 방법을 통해 성능 향상이 없는 경우, 2번을 적용하는 경우가 많음
3. ⭐️로그 변환⭐️ : log함수를 적용하여 정규분포에 가까운 형태로 변환
  - 이 방법을 주로 사용
    - 1번은 성능 향상을 크게 기대하기 어려우며
    - 2번은 피처 갯수가 매우 많을 경우에는 다항 변환으로 생기는 피처 갯수가 기하급수로 늘어나서 과적합 이슈 발생 높음
  - 타깃값의 경우는 일반적으로 로그 변환을 적용 → 타깃값을 다른류의 정규값으로 변환하면 원복이 어렵고, 왜곡된 타깃 분포도를 로그 변환하면 성능 향상된 경우가 많은 사례에서 검증됐음
  - np.log1p() = $1 + log()$ 사용
    - $log()$는 언더플로우 발생 가능성이 있기 때문

6. 로지스틱 회귀 Logistic Regression

: 선형 회귀 방식을 분류에 적용한 알고리즘 (이진 분류에 뛰어남)

: 시그모이드Sigmoid 함수 최적선을 찾고 이 시그모이드 함수의 반환값을 확률로 간주해 확률에 따라 분류를 결정한다.

시그모이드 함수 : $y = \frac{1}{1+e^{-x}}$
- $x$ → $\infty$ : $y=1$
- $x$ → $-\infty$ : $y=0$
- $x$ → $0$ : $y=0.5$
로지스틱 회귀 하이퍼 파라미터
- penalty : 규제 유형 설정. ‘l2’, ‘l1’ (기본은 l2)
- C : 규제 강도 조절하는 alpha의 역수 (1/alpha) $\therefore$ 작을수록 규제강도 높아짐

7. 회귀 트리

: 회귀를 위한 트리를 생성하고 이를 기반으로 회귀 예측 진행

: 리프 노드에 속한 데이터 값의 평균값으로 회귀 예측값을 계산

: 결정트리, 랜덤포레스트, GBM, LightGBM, XGBoost 등 모든 트리 기반 알고리즘은 회귀 계산 가능

(뒤에 Regressor. 예: DecisionTreeRegressor)

단, 선형 회귀와 다른 처리 방식이므로 회귀 계수를 제공하는 coef_ 속성은 없다. 대신 피처별 중요도를 알려주는 feature_importances_ 제공

8. 회귀 실습

8.1. 캐글 자전거 대여 수요예측

회귀 모델 전, 데이터 전처리시 주의점
- 결괏값이 정규 분포로 돼 있는지 확인
- 카테고리형 회귀 모델의 경우 → 원-핫 인코딩으로 피처를 인코딩 하는 것

예측 오류가 큰 경우 ⇒ Target 값의 분포가 왜곡된 형태를 이루고 있는지 확인하기

  def get_top_error_data(y_test, pred, n_tops = 5):
      # DataFrame에 컬럼들로 실제 대여횟수(count)와 예측 값을 서로 비교 할 수 있도록 생성. 
      result_df = pd.DataFrame(y_test.values, columns=['real_count'])
      result_df['predicted_count']= np.round(pred)
      result_df['diff'] = np.abs(result_df['real_count'] - result_df['predicted_count'])
      # 예측값과 실제값이 가장 큰 데이터 순으로 출력. 
      print(result_df.sort_values('diff', ascending=False)[:n_tops])

  get_top_error_data(y_test,pred,n_tops=5)

  y_target.hist()

  y_log_transform = np.log1p(y_target)
  y_log_transform.hist()

결괏값이 왜곡된 경우, 로그 변환 하면 좋다

y_log_transform = np.log1p(y_target)
y_log_transform.hist()

로그 변환된 것 → 원상 복구 : np.expm1(y_data)

# 타겟 컬럼인 count 값을 log1p 로 Log 변환
y_target_log = np.log1p(y_target)

# 로그 변환된 y_target_log를 반영하여 학습/테스트 데이터 셋 분할
X_train, X_test, y_train, y_test = train_test_split(X_features, y_target_log, test_size=0.3, random_state=0)
lr_reg = LinearRegression()
lr_reg.fit(X_train, y_train)
pred = lr_reg.predict(X_test)

# 테스트 데이터 셋의 Target 값은 Log 변환되었으므로 다시 expm1를 이용하여 원래 scale로 변환
y_test_exp = np.expm1(y_test)

# 예측 값 역시 Log 변환된 타겟 기반으로 학습되어 예측되었으므로 다시 exmpl으로 scale변환
pred_exp = np.expm1(pred)

evaluate_regr(y_test_exp ,pred_exp)

숫자로 되어 있지만, 카테고리형이어야 할 feature ⇒ one-hot 인코딩

  # 'year', month', 'day', hour'등의 피처들을 One Hot Encoding
  X_features_ohe = pd.get_dummies(X_features, columns=['year', 'month','day', 'hour', 'holiday',
                                                'workingday','season','weather'])
                                  # X_features에서, columns=[] 들의 col을 o-h 인코딩 하겠다.

  X_features_ohe.head()

8.2. 캐글 주택 가격 : 고급 회귀 기법

9. 정리

기본 개념: 경사하강법 Gradient Descent
평가: MAE, MSE, RMSE, R^2
Linear Regressor
- 단항 회귀
- 다항 회귀
Reaularization
- Ridge
- Lasso
- ElasticNet
Logistic Regression
Regression Tree

+데이터 스케일링/정규화, 인코딩

+스태킹 기법 가능

파이썬 머신러닝 완벽 가이드 - 6. Regression(1) (경사하강법, 평가지표, 선형회귀)

Wed, 05 Oct 2022 01:17:48 GMT

Regression 회귀

: 여러 개의 독립 변수와 한 개의 종속 변수 간의 상관관계를 모델링 하는 기법

: 주어진 피처와 결정 값 데이터 기반에서 학습을 통해 최적의 회귀계수(Regression coefficients)를 찾아내는 것

회귀계수: 독립변수 값에 영향을 미치는 Wn

독립변수 갯수	회귀 계수의 결합
1개 : 단일 회귀	선형 : 선형 회귀
1개(n) ⁍ : 다항 회귀	선형 : 선형 회귀
여러개 : 다중 회귀	비선형 : 비선형 회귀

선형 회귀 : 실제 값과 예측 값의 차이(오류의 제곱 값)를 최소화하는 직선형 회귀선을 최적화하는 방식

일반 선형 회귀 : 실제-예측값의 RSS(Residual_잔여의_ Sum of Squares)를 최소화할 수 있도록 회귀 계수를 최적화하며, 규제를 적용하지 않은 모델
릿지 : 선형 회귀 + L2 규제 ⇒ L2 : 상대적으로 큰 회귀 계수 값의 예측 영향도를 감소시키기 위해 회귀 계수값을 더 작게 만드는 규제
라쏘 : 선형 회귀 + L1 규제 ⇒ L1 : (L2는 회귀계수값 크기 줄이는데 반해) 예측 영향력이 작은 피처의 회귀 계수를 0으로 만들어, 회귀예측시 피처가 선택되지 않게 하는 것 → L1 규제는 피처 선택 기능으로 불림
엘리스틱넷 : L2, L1 규제를 함께 결합한 모델 → 주로 피처가 많은 데이터 세트에 적용됨
로지스틱 회귀 : 분류에 사용되는 선형 회귀 모델

1. 경사하강법 Gradient Descent

단순 선형 회귀로 이해해보기
- 모델 : $f(x) = w_0 + w_1 * x$
- 실젯값 : $Y_i = w_0 + w_1 * X_i \cdots Error_i ; > ,$
- 예측값 : $\hat{Y} = w_0 + w_1*X$
RSS(Residual Sum of Square) : 오류에 제곱을 해서 더하는 방식
- (오류값(잔차)은 +,- 모두 될 수 있기 때문에) 오류값의 제곱을 더한 방식
- $RSS(w_0,w_1) = 1/N\sum_{i=1}^{N}(y_i-(w_0+w_1x_i))^2$
  - RSS에서는 독립변수 X, 종속변수 Y가 중심 변수가 아니라, 회귀 계수 w임을 인지하는 것이 매우 중요
  - 학습 데이터로 입력되는 독립/종속변수는 RSS에서 모두 상수로 간주
회귀에서 이 RSS 값은 비용(Cost)이며, w변수(회귀계수) 구성되는 RSS를 비용 함수라고 함
- 회귀 알고리즘은 이 비용 함수가 반환하는 값(즉, 오류 값)을 지속해서 감소시키고 최종적으로는 더 이상 감소하지 않는 최소의 오류값을 구하는 것
- 비용 함수를 손실 함수(loss function)라고도 함
경사하강법: 점진적으로 반복적인 계산을 통해 W를 업데이트하면서 오류값이 최소가 되는 W를 구하는 방식
- 2차함수의 최저점은 미분 값인 1차 함수의 기울기가 가장 최소일 때
- $\begin{matrix} R(w) &=& \frac{1}{N}\sum_{i=1}^N>(y_i->(w_0+w_1*x_i)>)^2 \ \ &=& \frac{1}{N}\sum_{i=1}^{N}>(y_i - \hat{y_i})^2 \ \ &=& 평균(>(실제값_i - 예측값_i)^2>) \ \ &=& 평균(오차제곱) \ \ &=& MSE \end{matrix}$
- $R(w_0,w_1)$를 각 $w_0, w_1$로 편미분
  - $\partial R(w)/\partial w_1 = \frac{2}{N} \sum_{i=1}^{N}-x_i * (y_i(-w_0+w_1x_i)) = -\frac{2}{N}\sum_{i=1}^{N}x_i*(실제값_i-예측값_i)$
  - $\partial R(w)/\partial w_0 = \frac{2}{N} \sum_{i=1}^{N}-(y_i-(w_0+w_1x_i)) = -\frac{2}{N}\sum_{i=1}^{N}(실제값_i-예측값_i)$
- $w_1, w_0$의 편미분 결괏값인 $-\frac{2}{N}\sum_{i=1}^{N}x_i*(실제값i-예측값_i)$, $-\frac{2}{N}\sum{i=1}^{N}(실제값_i-예측값_i)$ 을 반복적으로 보정하면서, $w_1, w_0$ 값을 업데이트 하면서 비용 함수 $R(w)$를 최소가 되는 $w_0, w_1$ 을 구할 수 있음
  - 이때, 편미분 값이 너무 클 수 있기 때문에 보정계수 $\eta$를 곱하는데, 이를 학습률(learning_rate)이라고 한다.
  - 업데이트는 편미분 결괏값을 마이너스(-)하면서 적용
  - $새로운;w_1 = 이전;w_1 - (>-\eta\frac{2}{N} \sum_{i=1}^{N}x_i(실제값_i-예측값_i)>)$
  - $새로운;w_0 = 이전;w_0 - (>- \eta \frac{2}{N} \sum_{i=1}^{N} (실제값_i-예측값_i)>)$
  - 이 과정을 반복적으로 적용하면서, 비용함수가 최소가 되는 값을 찾는 것
- 경사 하강법의 일반적인 프로세스
  - [Step 1] : $w_1, w_0$을 임의의 값으로 설정하고 첫 비용 함수의 값을 계산
  - [Step 2] : $w_1$을 $w_1 + \eta\frac{2}{N} \sum_{i=1}^{N}x_i(실제값i-예측값_i)$ 으로, $w_0$을 $w_0 + \eta \frac{2}{N} \sum{i=1}^{N} (실제값_i-예측값_i)$ 으로 업데이트한 후, 다시 비용 함수의 값을 계산
  - [Step 3] : 비용 함수의 값이 감소했으면, 다시 [Step 2]를 반복, 더 이상 비용 함수 값이 감소하지 않으면 그때의 $w_1,w_0$를 구하고 반복 중지

    import numpy as np
    import matplotlib.pyplot as plt
    %matplotlib inline

    ### --- 실제값을 Y=4X+6 시뮬레이션하는 데이터 값 생성 ----------------------------

    np.random.seed(0)
    # y = 4X + 6 식을 근사(w1=4, w0=6). random 값은 Noise를 위해 만듬
    X = 2 * np.random.rand(100,1)
    y = 6 +4 * X+ np.random.randn(100,1)
    print(type(X))

    ### --- w0과 w1의 값을 최소화 할 수 있도록 업데이트 수행하는 함수 생성 ---------------------

    # w1 과 w0 를 업데이트 할 w1_update, w0_update를 반환. 
    def get_weight_updates(w1, w0, X, y, learning_rate=0.01):
        N = len(y)

        # 먼저 w1_update, w0_update를 각각 w1, w0의 shape와 동일한 크기를 가진 0 값으로 초기화
        w1_update = np.zeros_like(w1)
        w0_update = np.zeros_like(w0)

        # 예측 배열 계산하고 예측과 실제 값의 차이 계산
        y_pred = np.dot(X, w1.T) + w0 # 예측값
        diff = y - y_pred # 실제값 - 예측값
        # diff == error

        # w0_update를 dot 행렬 연산으로 구하기 위해 모두 1값을 가진 행렬 생성 
        w0_factors = np.ones((N,1))

        # w1과 w0을 업데이트할 w1_update와 w0_update 계산
        w1_update = -(2/N)*learning_rate*(np.dot(X.T, diff)) # w1의 편미분 값
        w0_update = -(2/N)*learning_rate*(np.dot(w0_factors.T, diff)) # w0의 편미분 값

        return w1_update, w0_update

    ### --- 반복적으로 경사 하강법을 이용하여 get_weigth_updates()를 호출하여 w1과 w0를 업데이트 하는 함수 생성 ---

    # 입력 인자 iters로 주어진 횟수만큼 반복적으로 w1과 w0를 업데이트 적용함. 
    def gradient_descent_steps(X, y, iters=10000):
        # w0와 w1을 모두 0으로 초기화. 
        w0 = np.zeros((1,1))
        w1 = np.zeros((1,1))

        # 인자로 주어진 iters 만큼 반복적으로 get_weight_updates() 호출하여 w1, w0 업데이트 수행. 
        for ind in range(iters):
            w1_update, w0_update = get_weight_updates(w1, w0, X, y, learning_rate=0.01) # w1, w0 편미분값 return
            w1 = w1 - w1_update # 새로운 w1
            w0 = w0 - w0_update # 새로운 w0

        return w1, w0

    ### --- 예측 오차 비용을 계산을 수행하는 함수 생성 및 경사 하강법 수행 ---------------------

    def get_cost(y, y_pred):
        N = len(y) 
        cost = np.sum(np.square(y - y_pred))/N # 평균( (실제값 - 예측값)^2 ) = RMSE
        return cost

    w1, w0 = gradient_descent_steps(X, y, iters=1000)
    print("w1:{0:.3f} w0:{1:.3f}".format(w1[0,0], w0[0,0]))
    y_pred = w1[0,0] * X + w0
    print('Gradient Descent Total Cost:{0:.4f}'.format(get_cost(y, y_pred)))

경사하강법은 모든 학습 데이터에 반복적으로 업데이트 하기에 시간이 매우 오래 걸린다는 단점 ⇒ 확률적 경사하강법을 대신 사용

(미니배치) 확률적 경사하강법(Stochastic_통계학의/확률적인_ Gradient Desent): 일부 데이터만을 이용해 w가 없데이트되는 값 계산 ⇒ SGD

전반적으로 경사하강법과 비슷하지만, 전체 X, y 데이터에서 랜덤하게 batch_size만큼 데이터를 추출해서 w1, w0을 업데이트 함

def stochastic_gradient_descent_steps(X, y, batch_size=10, iters=1000):
  w0 = np.zeros((1,1))
  w1 = np.zeros((1,1))
  prev_cost = 100000
  iter_index =0

  for ind in range(iters):
      np.random.seed(ind)
      # 전체 X, y 데이터에서 랜덤하게 batch_size만큼 데이터 추출하여 sample_X, sample_y로 저장
      stochastic_random_index = np.random.permutation(X.shape[0]) # permutation : array를 복사해서 shuffle
      sample_X = X[stochastic_random_index[0:batch_size]]
      sample_y = y[stochastic_random_index[0:batch_size]]
      # 랜덤하게 batch_size만큼 추출된 데이터 기반으로 w1_update, w0_update 계산 후 업데이트
      w1_update, w0_update = get_weight_updates(w1, w0, sample_X, sample_y, learning_rate=0.01)
      w1 = w1 - w1_update
      w0 = w0 - w0_update

  return w1, w0

w1, w0 = stochastic_gradient_descent_steps(X, y, iters=1000)
print("w1:",round(w1[0,0],3),"w0:",round(w0[0,0],3))
y_pred = w1[0,0] * X + w0
print('Stochastic Gradient Descent Total Cost:{0:.4f}'.format(get_cost(y, y_pred)))

피처가 여러개인 경우 어떻게 회귀 계수 도출할 수 있을까? (↔ 지금까지는 피처 1개, 독립변수 1개인 단순 선형 회귀의 경사하강법)
- 피처 1개인 경우 : $\hat{Y} = w_0 + w_1 * X$ 로
- 피처가 M개($X_1, X_2, \cdots, X_m$) 인 경우 : $\hat{Y} = w_0 + w_1 * X_1 + w_2 * X_2 + \cdots + w_{100}*X_{100}$
  - 회귀 계수도는 M+1개 (1개는 $w_0$)
- 데이터가 N개이고 피처가 M개인 입력 행렬을 $X_{mat}$, 회귀 계수 $w_1, w_1, \cdots, w_{100}$을 W 배열로 표기하면 ⇒ $\hat{Y} = np.dot(X_{mat}, W^T) + w_0$
- $w_0$을 W배열에 포함시키기 위해서, $X_{mat}$의 맨 처음 열에 모든 데이터 값이 1인 피처 Feat 0을 추가 하면 ⇒ $\hat{Y} = X_{mat} * W^T$

2. 회귀 평가지표

보스턴 주택 가격 예측 예시
- LinearRegression 클래스는 RSS를 최소화해 OLS(Ordinary Least Squares) 추정 방식으로 구현됨
  - fit() 메서드로 X, y 배열 받으면, 회귀 계수(Coefficients)인 W를 coef_ 속성에 저장
  - 입력 파라미터에서, $nomalize=True$ 로 설정하면 회귀 수행 전, 입력 데이터 세트를 정규화함 $*default = False$
- OLS 기반 회귀 계수 계산은 입력 피처의 독립성에 많은 영향을 받아, 피처 상관관계가 높은 경우 분산이 매우 커져 오류에 매우 민감해짐
  - 다중회귀(비선형) ⇒ 다중 공선성 문제 (multi-collinearity)
  - 그래서 일반적으로 상관 관계가 높은 피처가 많은 경우 독립적인 중요한 피처만 남기고 제거 or 규제 및 PCA로 차원 축소 수행하기도 함
MAE(Mean Absolute Error)
- $1/N \sum_{i=1}^{N}|Y_i - \hat Y_i|$
- 실제값과 예측값의 차이를 절대값으로 변환해 평균한 것
- 사이킷런 평가지표: metrics.mean_absolute_error
- Scoring 함수 적용값 : ‘neg_mean_absolute_error’
  - ‘neg_’ ⇒ -1을 곱해서 반환 (scoring함수는 값이 클수록 좋은 평가 결과로 보기 때문)
  - 10 > 1 ⇒ -10 < -1 == neg_mean_absolute_error ⇒ -1 * metrics.mean_absolute_error
MSE(Mean Squared Error)
- $MSE = 1/N\sum_{i=1}^{N}(Y_i-\hat Y_i)^2$
- 실제값과 예측값의 차이를 제곱해 평균한 것
- metrics.mean_squared_error
- Scoring 함수 적용값 : ‘neg_mean_squared_error’
RMSE(Root MSE)
- $RMSE = \sqrt{1/N\sum_{i=1}^{N}(Y_i-\hat Y_i)^2}$
- MSE는 실제 오류 평균보다 커지므로 보정한 것
- 사이킷런은 RMSE를 제공하지 않음
$R^2$
- $R^2 = \frac{예측분산}{실제분산}$
- $R^2 = 1 - \frac { \sum ( y - \hat{y} )^2 } { \sum ( y - 평균 )^2 } = 1 - \frac { \sum ( 오차 )^2 } { \sum ( 편차 )^2 }$
- 1에 가까워질 수록 예측 정확도가 좋은 것
  - $R^2 = 1 = (>1 - \color{yellow}0\color{d}>)$ ⇒ $\frac { \color{yellow}\sum ( 오차 )^2 } { \sum ( 편차 )^2 } = \frac {\color{yellow} \sum ( y - \hat{y} )^2 } { \sum ( y - 평균 )^2 }$ ⇒ $\color{yellow}{(y - \hat{y}) = 0}$ ⇒ $\color{yellow} y = \hat{y}$ ⇒ 예측값이 실제값과 같다
  - $R^2 = 0 = (>1 - \color{red}1\color{d}>)$ ⇒ $\frac { \color{red}\sum ( 오차 )^2 } { \color{red} \sum ( 편차 )^2 } = \frac {\color{red} \sum ( y - \hat{y} )^2 } {\color{red} \sum ( y - 평균 )^2 }$ ⇒ $\color{red}{(y - \hat{y}) = (y - 평균)}$ ⇒ $\color{red} 평균 = \hat{y}$ ⇒ 예측값이 평균값과 같다 (예측하나마나다)
- metrics.r2_score
- Scoring 함수 적용값 : ‘r2’

3. 선형 회귀 Linear Regression

: 예측값과 실제값의 RSS를 최소화해 OLS(Ordinary Least Squares) 추정방식으로 구현한 클래스

입력 파라미터

| 파라미터 | 디폴트 | 설명 |
| --- | --- | --- |
| fit_intercept | Ture | Boolean, intercept(절편)값을 계산할 것인지 결정 |
| normalize | False | Boolean, True면 회귀를 수행하기 전에 입력 데이터 세트 정규화, fit_intercept=False 인 경우 이 파라미터는 무시됨 |

속성
- coef_: fit() 메서드를 수행했을 때, 회귀 계수가 배열 형태로 저장되는 속성, shape = (Target 개수, 피처 개수)
- intercept_: 절편 값

Seaborn의 regplot(): x, y축 값의 산점도와 선형 회귀 직선을 그려준다.

4. 다항 회귀 Polynomial Regression

: 회귀가 독립변수의 단항식이 아닌 2차, 3차 방정식과 같은 다항식으로 표현되는 것(하지만 선형회귀다!)

예) $y = w_0 + w_1x_1 + w_2x_2 + w_3x_1x_2 + w_4x_1^2 + w_5x_2^2$

선형회귀 / 비선형 회귀를 나누는 기준 : 회귀 계수가 선형/비선형인지에 따른 것(독립변수의 선형/비선형은 X)
사이킷런은 다항회귀를 위한 클래스를 명시적으로 제공 X

from sklearn.preprocessing import PolynomialFeatures
import numpy as np

# 다항식으로 변환한 단항식 생성, [[0,1],[2,3]]의 2X2 행렬 생성
X = np.arange(4).reshape(2,2)
print('일차 단항식 계수 feature:\n',X )

# degree = 2 인 2차 다항식으로 변환하기 위해 PolynomialFeatures를 이용하여 변환
poly = PolynomialFeatures(degree=2) # 2차 다항값을 만들겠다는 것
poly.fit(X)
poly_ftr = poly.transform(X)
print('변환된 2차 다항식 계수 feature:\n', poly_ftr)

------------------------------------------
> 일차 단항식 계수 feature:
> [[0 1]
> [2 3]]
> 변환된 2차 다항식 계수 feature:
> [[1. 0. 1. 0. 0. 1.]
> [1. 2. 3. 4. 6. 9.]]

3차 다항식 계수의 피처값과 3차 다항식 결정값으로 학습

# 3 차 다항식 변환 
poly_ftr = PolynomialFeatures(degree=3).fit_transform(X)
print('3차 다항식 계수 feature: \n',poly_ftr)

# Linear Regression에 3차 다항식 계수 feature와 3차 다항식 결정값으로 학습 후 회귀 계수 확인
model = LinearRegression()
model.fit(poly_ftr,y)
print('Polynomial 회귀 계수\n' , np.round(model.coef_, 2))
print('Polynomial 회귀 Shape :', model.coef_.shape)

------------------------------------------------
> 3차 다항식 계수 feature: 
>  [[ 1.  0.  1.  0.  0.  1.  0.  0.  0.  1.]
>  [ 1.  2.  3.  4.  6.  9.  8. 12. 18. 27.]]
> Polynomial 회귀 계수
>  [0.   0.18 0.18 0.36 0.54 0.72 0.72 1.08 1.62 2.34]
> Polynomial 회귀 Shape : (10,)

Polynomial Features로 변환 후 LinearRegression 사용 (Pipeline) (fit_transform 없이)

from sklearn.pipeline import Pipeline

def polynomial_func(X):
    y = 1 + 2*X[:,0] + 3*X[:,0]**2 + 4*X[:,1]**3 
    return y

# Pipeline 객체로 Streamline 하게 Polynomial Feature변환과 Linear Regression을 연결
model = Pipeline([('poly', PolynomialFeatures(degree=3)),
                  ('linear', LinearRegression())])
X = np.arange(4).reshape(2,2)
y = polynomial_func(X)

model = model.fit(X, y)
print('Polynomial 회귀 계수\n', np.round(model.named_steps['linear'].coef_, 2))

------------------------------------------------
> Polynomial 회귀 계수
> [0.   0.18 0.18 0.36 0.54 0.72 0.72 1.08 1.62 2.34]

차수가 높아질 수록 과적합의 문제가 발생한다.
편향-분산 트레이드 오프(Bias-Variance Trade off)
- 고편향: 매우 단순화된 모델
- 고분산: 매우 복잡한 모델, 지나치게 높은 변동성
최적 모델을 위한 비용함수 구성요소: 학습 데이터 잔차 오류 최소화 + 회귀 계수 크기 제어

⇒ 비용함수 목표: $Min(RSS(w) + alphaX||w||_2^2)$
- alpha : 학습 데이터 적합정도와 회귀 계수 값의 크기 제어를 수행하는 튜닝 파라미터
- alpha를 크게하면 w를 작게, alpha를 작게하면 w이 어느정도 크게하여(커져도) 상쇄함 $for$ 과적합 개선

파이썬 머신러닝 완벽 가이드 - 5. Classification(3) (예제 및 스태킹)

Tue, 04 Oct 2022 11:12:39 GMT

4. 실전 예시

A. Santander 예시

EDA 중, head, info, describe 사용
이상치 발생 ⇒ 제일 많은 걸로 대체하는 방법론도 있음

B. 신용카드 사기 검출 예시

LGBMClassifier( . . . boost_from_average=False) : 레이블값 매우 불균형한 경우 False, if True ⇒ 재현률 및 ROC-AUC 성능 매우 저하 ( : 왜인지는 아직 모름)

언더 샘플링과 오버 샘플링의 이해 : 지도 학습시 극도로 불균형한 레이블 값 분포로 인한 문제점을, 적절한 학습 데이터를 확보로 해결 방법들 (주로 오버 샘플링 방식이 예측 성능상 더 유리한 경우가 많아 주로 사용됨)

- 언더 샘플링 : 많은 데이터 세트를 적은 데이터 세트 수준으로 감소시키는 방식 ⇒ 너무 많은 정상 레이블 데이터를 감소시켜서, 오히려 학습이 잘 안될 수 있음
- 오버 샘플링 : 적은 데이터 세트를 많은 데이터 세트 수준으로 증식시키는 방식 ⇒ 동일한 데이터를 단순 증식하는 건 과적합 되기에 의미 X ⇒ 원본 피처 값들을 아주 약간만 변경하여 증식함
    1. 대표적으로 SMOTE(Synthetic Minority Over-sampling Technique) 방법이 있음
    2. SMOTE는 적은 제이터 세트에 있는 개별 데이터들의 K 최근접 이웃을 찾아서 이 데이터와 K개 이웃들의 차이를 일정 값으로 만들어거 기존 데이터와 약간 차이가 나는 새로운 데이터들을 생성하는 방식
    3. SMOTE를 구현하는 파이썬 패키지 == imbalanced-learn

(전처리) 데이터 분포도 변환

StandardScaler : 로지스틱 회귀 같은 선형 회귀 경우, 중요 피처값들이 정규분포 유지하는 것을 선호함.

중요한 피처인 Amount를 sns.distplot 해보니 긴 꼬리 형태 ⇒ 정규분포형태로 전처리 (StandarScaler)

별로 큰 효과는 없었음

from sklearn.preprocessing import StandardScaler
# 사이킷런의 StandardScaler를 이용하여 정규분포 형태로 Amount 피처값 변환하는 로직으로 수정. 
def get_preprocessed_df(df=None):
 df_copy = df.copy()
 scaler = StandardScaler()
 print(df_copy['Amount'].values)
 amount_n = scaler.fit_transform(df_copy['Amount'].values.reshape(-1, 1))
 # 변환된 Amount를 Amount_Scaled로 피처명 변경후 DataFrame맨 앞 컬럼으로 입력
 df_copy.insert(0, 'Amount_Scaled', amount_n)
 # 기존 Time, Amount 피처 삭제
 df_copy.drop(['Time','Amount'], axis=1, inplace=True)
 return df_copy

로그 변환 : 데이터 분포도가 심하게 왜곡돼있을 때 사용하면 좋음

원래 값을 log 값으로 변환해, 원래 큰 값을 상대적으로 작은 값으로 변환해주기에 데이터 분포도의 왜곡을 상당 수준 개선해 줌

약간식 개선됨

def get_preprocessed_df(df=None):
 df_copy = df.copy()
 # 넘파이의 log1p( )를 이용하여 Amount를 로그 변환 
 amount_n = np.log1p(df_copy['Amount'])
 df_copy.insert(0, 'Amount_Scaled', amount_n)
 df_copy.drop(['Time','Amount'], axis=1, inplace=True)
 return df_copy

(전처리) 이상치 데이터 제거
1. IQR (Inter Quantile Range) : 사분위 값의 편차를 이용하는 기법 → Q1(25%) ~ Q3(75%) 범위를 IQR이라고 부름 (중앙값에서 퍼져나간 정도) ⇒ IQR = Q3 - Q1 ⇒ Box Plot으로 시각화
2. IQR 이용해 이상치 데이터 검출하는 방식 : IQR * 1.5 하여 생성된 범위를 이용해, 최댓/최솟값을 결정한 뒤, 여기를 벗어나는 데이터를 이상치로 간주 ⇒ 경우에 따라 1.5가 변경될 수 있음 ⇒ Q3(3/4분위수)에, IQR1.5를 더함 == 최댓값 ⇒ Q2(1/2분위수) == 중앙값 ⇒ Q1(1/4분위수)에, IQR1.5를 뻄 == 최솟값

3. 매우 많은 피처가 있을 경우, 이들 중 결정값(레이블)과 가장 상관성이 높은 피처 위주로 이상치를 검출해야 시간/성능에 유리함

    ```python
    import seaborn as sns

    plt.figure(figsize=(9, 9))
    corr = card_df.corr()
    sns.heatmap(corr, cmap='RdBu')
    ```

4. IQR을 이용해, 이상치를 검출하는 함수 생성 ⇒ IQR 계산 ⇒ 최댓/최솟값 아웃라이어 찾기

    ```python
    import numpy as np

    def get_outlier(df=None, column=None, weight=1.5):
        # fraud에 해당하는 column 데이터만 추출, 1/4 분위와 3/4 분위 지점을 np.percentile로 구함. 
        fraud = df[df['Class']==1][column] # column = 'V14'
        quantile_25 = np.percentile(fraud.values, 25)
        quantile_75 = np.percentile(fraud.values, 75)
        # IQR을 구하고, IQR에 1.5를 곱하여 최대값과 최소값 지점 구함. 
        iqr = quantile_75 - quantile_25
        iqr_weight = iqr * weight
        lowest_val = quantile_25 - iqr_weight
        highest_val = quantile_75 + iqr_weight
        # 최대값 보다 크거나, 최소값 보다 작은 값을 아웃라이어로 설정하고 DataFrame index 반환. 
        outlier_index = fraud[(fraud < lowest_val) | (fraud > highest_val)].index
        return outlier_index

    outlier_index = get_outlier(df=card_df, column='V14', weight=1.5)
    print('이상치 데이터 인덱스:', outlier_index)
    ```

(전처리) SMOTE 오버 샘플링 적용

SMOTE 적용시에는 반드시 train(학습) 데이터 세트만 오버 샘플링 해야함 → eval(검증), test(테스트) 데이터 세트 하면 올바른 검증/테스트 불가

 from imblearn.over_sampling import SMOTE

 smote = SMOTE(random_state=0)
 X_train_over, y_train_over = smote.fit_resample(X_train, y_train) #fit_sample 없어지고 -> fit_resample로 바뀜
 print('SMOTE 적용 전 학습용 피처/레이블 데이터 세트: ', X_train.shape, y_train.shape)
 print('SMOTE 적용 후 학습용 피처/레이블 데이터 세트: ', X_train_over.shape, y_train_over.shape)
 print('SMOTE 적용 후 레이블 값 분포: \n', pd.Series(y_train_over).value_counts())

 lr_clf = LogisticRegression()
 # ftr_train과 tgt_train 인자값이 SMOTE 증식된 X_train_over와 y_train_over로 변경됨에 유의
 get_model_train_eval(lr_clf, ftr_train=X_train_over, ftr_test=X_test, tgt_train=y_train_over, tgt_test=y_test)

재현율/AUC는 엄청 올라가지만, 정밀도, 정밀도/F1은 급격히 내려감 ⇒ 실무에 적용할 수 없음
실제 원본 데이터의 유형보다 너무나 많은 Class=1 데이터가 학습되어, 테스트 데이터 세트 예측에서 Class=1 예측이 너무 많아짐

precision_recall_curve_plot() 으로 확인해보자 (추후 threshold를 변경하려나…?)

 import matplotlib.pyplot as plt
 import matplotlib.ticker as ticker
 from sklearn.metrics import precision_recall_curve
 %matplotlib inline

 def precision_recall_curve_plot(y_test , pred_proba_c1):
     # threshold ndarray와 이 threshold에 따른 정밀도, 재현율 ndarray 추출. 
     precisions, recalls, thresholds = precision_recall_curve( y_test, pred_proba_c1)

     # X축을 threshold값으로, Y축은 정밀도, 재현율 값으로 각각 Plot 수행. 정밀도는 점선으로 표시
     plt.figure(figsize=(8,6))
     threshold_boundary = thresholds.shape[0]
     plt.plot(thresholds, precisions[0:threshold_boundary], linestyle='--', label='precision')
     plt.plot(thresholds, recalls[0:threshold_boundary],label='recall')

     # threshold 값 X 축의 Scale을 0.1 단위로 변경
     start, end = plt.xlim()
     plt.xticks(np.round(np.arange(start, end, 0.1),2))

     # x축, y축 label과 legend, 그리고 grid 설정
     plt.xlabel('Threshold value'); plt.ylabel('Precision and Recall value')
     plt.legend(); plt.grid()
     plt.show()

 precision_recall_curve_plot( y_test, lr_clf.predict_proba(X_test)[:, 1] )

실제로 그려보니, 임계값이 0.99이하에서는 재현율이 매우 좋고/정밀도가 극단적으로 낮다가, 0.99에는 급격히 서로 cross 됨
이건, threshold 바꿔도 성능을 얻을 수 없으므로, 이번 사례에서 로지스틱 회귀의 경우에는 SMOTE 적용하면 안된다는 결론

LightGBM의 경우에는 SMOTE 활용하면, 이상치만 제거한 것에 비해 재현율은 높아지나, 정밀도는 낮아짐
1. 일반적으로 SMOTE를 쓰면 재현율은 높아지나, 정밀도는 낮아짐

5. 스태킹 Stacking

스태킹 앙상블 : 개별 알고리즘의 예측 결과 데이터 세트를 “최종적인 메타 데이터 세트”로 만들어 별도의 ML 알고리즘으로 최종학습을 수행하고 테스트 데이터를 기반으로 다시 최종 예측을 수행하는 방식
- 메타 모델: 개별 모델의 예측된 데이터 세트를 다시 기반으로 하여 학습하고 예측하는 방식
- 필요한 모델
  1. 개별적인 기반 모델
  2. 개별 기반 모델의 예측 데이터를 학습 데이터로 만들어서 학습하는 “최종 메타 모델”

        ```python
        # 개별 모델들을 학습/예측

        knn_pred = knn_clf.predict(X_test)
        rf_pred = rf_clf.predict(X_test)
        dt_pred = dt_clf.predict(X_test)
        ada_pred = ada_clf.predict(X_test)

        pred = np.array([knn_pred, rf_pred, dt_pred, ada_pred])
        print(pred.shape)

        # transpose를 이용해 행과 열의 위치 교환. 컬럼 레벨로 각 알고리즘의 예측 결과를 피처로 만듦. 
        pred = np.transpose(pred)
        print(pred.shape)

        lr_final.fit(pred, y_test)
        final = lr_final.predict(pred)

        print('최종 메타 모델의 예측 정확도: {0:.4f}'.format(accuracy_score(y_test , final)))
        ```

CV 세트 기반의 스태킹 : 과적합 개선 위해, 최종 메타 모델을 위한 데이터 세트를 만들 때, 교차 검증 기반으로 예측된 결과 데이터 세트를 이용한다.
1. 위 스태킹 코드에서, 로지스틱 회귀 메타모델 최종 학습시, 학습 데이터가 아닌 테스트용 데이터 기반으로 학습했기에 과적합이 발생할 수 있음
  1. 각 모델을 train data로 학습시킨 후
  2. 개별모델_pred = 개별모델.predict(X_test) ⇒ X_test 즉, 테스트용 데이터로 학습 시키고
  3. 최종 메타 모델때 y_test로 예측했으니 과적합 가능성 존재
2. CV 세트 기반의 스태킹은 개별 모델들이, 각각 교차 검증으로, [메타 모델을 위한 “학습용 스태킹 데이터 생성”] / [예측을 위한 “테스트용 스태킹 데이터”를 생성]한 뒤, 이를 기반으로 모델이 학습과 예측을 수행 ⇒ 2단계의 스텝으로 구분

CV 기반의 스태킹 모델 Step

각 모델 별로 원본 학습/테스트 데이터를 예측한 결과 값을 기반으로 메타 모델을 위한 학습/테스트용 데이터 생성
1. 원본 학습 데이터 n(폴드)-1개로 학습된 개별 모델을 만듦
2. 개별 모델로 원본 학습 데이터 폴드 1개를 Val 예측으로 [메타 학습 데이터] 칸 순차적으로 채우기
3. 개별 모델로 원본 테스트 데이터 예측해서 결괏값 순차적으로 나열(?)하기
4. 위 3개의 작업을 cv=n, n번 반복하면 ⇒ [메타 학습 데이터] 완성
5. 그리고 n개의 원본 테스트 데이터에 대한 결괏값에 대한 AVG 구해서 [메타 테스트 데이터] 만들기

[메타 학습/테스트 데이터] 완성 됐으니 그 다음부턴 그냥 fit, predict하면 됨

# Step 1

from sklearn.model_selection import KFold
from sklearn.metrics import mean_absolute_error

# 개별 기반 모델에서 최종 메타 모델이 사용할 학습 및 테스트용 데이터를 생성하기 위한 함수. 
def get_stacking_base_datasets(model, X_train_n, y_train_n, X_test_n, n_folds ):
 # 지정된 n_folds값으로 KFold 생성.
 kf = KFold(n_splits=n_folds, shuffle=False) #, random_state=0)
 #추후에 메타 모델이 사용할 학습 데이터 반환을 위한 넘파이 배열 초기화 
 train_fold_pred = np.zeros((X_train_n.shape[0] ,1 ))
 test_pred = np.zeros((X_test_n.shape[0],n_folds))
 print(model.__class__.__name__ , ' model 시작 ')

 for folder_counter , (train_index, valid_index) in enumerate(kf.split(X_train_n)):
     #입력된 학습 데이터에서 기반 모델이 학습/예측할 폴드 데이터 셋 추출 
     print('\t 폴드 세트: ',folder_counter,' 시작 ')
     X_tr = X_train_n[train_index] 
     y_tr = y_train_n[train_index] 
     X_te = X_train_n[valid_index]  

     #폴드 세트 내부에서 다시 만들어진 학습 데이터로 기반 모델의 학습 수행.
     model.fit(X_tr , y_tr)       
     #폴드 세트 내부에서 다시 만들어진 검증 데이터로 기반 모델 예측 후 데이터 저장.
     train_fold_pred[valid_index, :] = model.predict(X_te).reshape(-1,1)
     #입력된 원본 테스트 데이터를 폴드 세트내 학습된 기반 모델에서 예측 후 데이터 저장. 
     test_pred[:, folder_counter] = model.predict(X_test_n)

 # 폴드 세트 내에서 원본 테스트 데이터를 예측한 데이터를 평균하여 테스트 데이터로 생성 
 test_pred_mean = np.mean(test_pred, axis=1).reshape(-1,1)    

 #train_fold_pred는 최종 메타 모델이 사용하는 학습 데이터, test_pred_mean은 테스트 데이터
 return train_fold_pred , test_pred_mean

knn_train, knn_test = get_stacking_base_datasets(knn_clf, X_train, y_train, X_test, 7)
rf_train, rf_test = get_stacking_base_datasets(rf_clf, X_train, y_train, X_test, 7)
dt_train, dt_test = get_stacking_base_datasets(dt_clf, X_train, y_train, X_test,  7)    
ada_train, ada_test = get_stacking_base_datasets(ada_clf, X_train, y_train, X_test, 7)

# 각 모델별 학습/테스트 데이터 합치기
Stack_final_X_train = np.concatenate((knn_train, rf_train, dt_train, ada_train), axis=1)
Stack_final_X_test = np.concatenate((knn_test, rf_test, dt_test, ada_test), axis=1)
print('원본 학습 피처 데이터 Shape:',X_train.shape, '원본 테스트 피처 Shape:',X_test.shape)
print('스태킹 학습 피처 데이터 Shape:', Stack_final_X_train.shape,
   '스태킹 테스트 피처 데이터 Shape:',Stack_final_X_test.shape)

# 최종 메타 모델 돌리기
lr_final.fit(Stack_final_X_train, y_train) # 최종 메타 모델 돌릴 때, 원본 학습 라벨 y_train 가져야 써야함
stack_final = lr_final.predict(Stack_final_X_test)

print('최종 메타 모델의 예측 정확도: {0:.4f}'.format(accuracy_score(y_test, stack_final)))

6. 정리

분류 Classification
- 결정 트리 Decision Tree
- Voting
- Bagging
  - RandomForestClassifier
- Boosting
  - GBM
  - XGBoost
  - LightGBM
- Stacking

파이썬 머신러닝 완벽 가이드 - 5. Classification(2) (앙상블)

Thu, 29 Sep 2022 07:46:40 GMT

3. 앙상블 Ensemble

: 여러 개의 분류기(classifier)를 생성하고 그 예측을 결합함으로써 보다 정확한 최종 예측을 도출하는 기법

→ 보팅Voting, 배깅Bagging, 부스팅Boosting + 스태킹Stacking

보팅 : 서로 다른 알고리즘을 가진 분류기 결합
배깅 : 같은 유형의 알고리즘을 가진 분류기를 사용하지만, 데이터 샘플링을 다르게 가져감
- 부트스트래핑 Bootstrapping: 개별 분류기에게 데이터를 샘플링해서 추출하는 방식
- 데이터 세트 간의 중첩 허용 (cf. 교차검증은 중복 불허)
  - ex) 10,000개의 데이터를 10개의 분류기가 배깅 방식으로 나눠도, 각 1,000개의 데이터 내에서 중복된 데이터가 있을 수 있음
부스팅 : 여러 개의 분류기가 순차적으로 학습을 수행하되, 앞의 분류기의 틀린 예측에 대해서 다음 분류기에는 가중치를 부여하면서 학습과 예측을 진행하는 방식
- 대표적인 모듈: 그래디언트 부스트, XGBoost, LightGBM
스태킹 : 여러 가지 다른 모델의 예측 결과값을 “다시 학습 데이터로 만들어서” 다른 모델(메타 모델)로 재학습, 예측하는 방법

A. 보팅

유형

1. 하드 보팅 Hard Voting:  다수결원칙. 예측 결과값들 중 다수의 분류기가 결정한 예측값을 최종 보팅 결과값으로 선정
2. 소프트 보팅 Soft Voting : 분류기들의 레이블 값 결정 확률을 모두 더하고 이를 평균해서, 이들 중 확률이 가장 높은 레이블 값을 최종 보팅 결과값으로 선정(일반적으로 소프트 보팅 사용)

사용 (보팅 분류기)

 from sklearn.ensemble import VotingClassifier
 # 로지스틱 회귀, KNN 기반 소프트 보팅 방식 분류기 만들기
 vo_clf = VotingClassigier(estimator = [('LR', lr_clf), ('KNN', knn_clf)], voting='soft')

B. 배깅 - 대표적 알고리즘 랜덤 포레스트 Random Forest

(Bagging = Bootstrap Aggregating)

→ 서브 트리의 데이터 건수 = 전체 데이터 건수 (중첩되어 갖고 있다.)

사용

 from sklearn.ensemble import RandomForestClassifier
 from sklearn.metrics import accuracy_score
 import pandas as pd
 import warnings

 # 결정 트리에서 사용한 get_human_dataset( )을 이용해 학습/테스트용 DataFrame 반환
 X_train, X_test, y_train, y_test = get_human_dataset()

 # 랜덤 포레스트 학습 및 별도의 테스트 셋으로 예측 성능 평가
 rf_clf = RandomForestClassifier(random_state=0)
 rf_clf.fit(X_train , y_train)
 pred = rf_clf.predict(X_test)
 accuracy = accuracy_score(y_test , pred)
 print('랜덤 포레스트 정확도: {0:.4f}'.format(accuracy))

파라미터
- n_estimator : 결정 트리 개수, 디폴트 = 10
- max_features : 최적의 분할을 위해 고려할 피처 개수, 디폴트 = ‘auto’ (= ‘sqrt’) ↔ 결정트리에서는 ‘None’
- max_depth : 트리의 최대 깊이
- min_samples_leaf : 말단 노드가 되기 위한 최소한의 샘플 데이터 수
- - feature_importances_ : DecisionTreeClassifier와 같이 알고리즘이 선택한 피처의 중요도 파악 가능
```
import matplotlib.pyplot as plt
import seaborn as sns
%matplotlib inline

ftr_importances_values = rf_clf1.feature_importances_
ftr_importances = pd.Series(ftr_importances_values,index=X_train.columns  )
ftr_top20 = ftr_importances.sort_values(ascending=False)[:20]

plt.figure(figsize=(8,6))
plt.title('Feature importances Top 20')
sns.barplot(x=ftr_top20 , y = ftr_top20.index)
plt.show()
```

with GridSearch

 from sklearn.model_selection import GridSearchCV

 params = {
     'n_estimators':[100],
     'max_depth' : [6, 8, 10, 12], 
     'min_samples_leaf' : [8, 12, 18 ],
     'min_samples_split' : [8, 16, 20]
 }
 # RandomForestClassifier 객체 생성 후 GridSearchCV 수행
 rf_clf = RandomForestClassifier(random_state=0, n_jobs=-1)
 grid_cv = GridSearchCV(rf_clf , param_grid=params , cv=2, n_jobs=-1 )
 grid_cv.fit(X_train , y_train)

 print('최적 하이퍼 파라미터:\n', grid_cv.best_params_)
 print('최고 예측 정확도: {0:.4f}'.format(grid_cv.best_score_))

C. 부스팅 알고리즘

: 여러 개의 약한 학습기를 순차적으로 학습-예측하면서 잘못 예측한 데이터에 가중치를 부여해 개선하는 방식

( AdaBoost_Adaptive boosting_에이다부스팅 )

1. GBM(Gradient Boosting Machine)

경사하강법(Gradient Descent) : ‘오류 값 = 실제 값 - 예측 값'을 최소화하는 방향성을 갖고 반복적으로 가중치 업데이트
- 이때 가중치 업데이트에 경사하강법을 이용하는 것이, 에이다와 큰 차이점
- 반복수행을 통해 오류를 최소화할 수 있도록 가중치의 업데이트 값을 도출하는 과정

일반적으로 GBM이 랜덤 포레스트보다는 예측 성능이 조금 뛰어난 경우가 많지만, 수행 시간이 오래 걸리고 하이퍼 파라미터 튜닝 노력이 더 필요함

  import time
  import warnings
  from sklearn.ensemble import GradientBoostingClassifier
  from sklearn.model_selection import GridSearchCV
  warnings.filterwarnings('ignore')

  X_train, X_test, y_train, y_test = get_human_dataset()

  # GBM 수행 시간 측정을 위함. 시작 시간 설정.
  start_time = time.time()

  gb_clf = GradientBoostingClassifier(random_state=0)
  gb_clf.fit(X_train , y_train)
  gb_pred = gb_clf.predict(X_test)
  gb_accuracy = accuracy_score(y_test, gb_pred)

  print('GBM 정확도: {0:.4f}'.format(gb_accuracy))
  print("GBM 수행 시간: {0:.1f} 초 ".format(time.time() - start_time))

  # ------------------------------------------------------------------- #
  params = {
      'n_estimators':[100, 500],
      'learning_rate' : [ 0.05, 0.1]
  }
  grid_cv = GridSearchCV(gb_clf , param_grid=params , cv=2 ,verbose=1)
  grid_cv.fit(X_train , y_train)
  print('최적 하이퍼 파라미터:\n', grid_cv.best_params_)
  print('최고 예측 정확도: {0:.4f}'.format(grid_cv.best_score_))

  # ------------------------------------------------------------------- #

  # GridSearchCV를 이용하여 최적으로 학습된 estimator로 predict 수행. 
  gb_pred = grid_cv.best_estimator_.predict(X_test)
  gb_accuracy = accuracy_score(y_test, gb_pred)
  print('GBM 정확도: {0:.4f}'.format(gb_accuracy))

하이퍼 파라미터
- n_estimators, max_depth, max_features 등 트리 기반 자체의 파라미터 포함
- loss : 경사하강법에서 사용할 비용 함수, 디폴트 = deviance
- learning_rate : 학습을 진행할 때마다 적용하는 학습률, weak learner가 순차적으로 오류값을 보정해 나가는데 적용하는 계수
  - 0~1 사이 값 지정 가능, 디폴트 = 0.1
  - 너무 작은 값은 업데이트 되는 값이 작아져 최소 오류값을 찾아 예측 성능이 높아질 수 있지만, 수행시간이 증가하고 너무 작으면 반복이 완료되어도 최소 오류값을 못 찾을 수 있음
  - 반대로 큰 값은 최소 오류값을 지나쳐 예측 성능이 떨어질 수 있지만, 빠른 수행이 가능
  - 위 이유들로 n_estimator와 상호 보완적으로 사용
    - learning_rate 를 작게 하고 n_estimator를 크게 하면 더 이상 성능이 좋아지지 않는 한계점까지는 예측 성능이 조금씩 좋아질 수 있음
    - 하지만 수행시간이 너무 오래 걸리는 단점이 있으며, 예측 성능 역시 현격히 좋아지지는 않음
- n_estimator : weak learner의 개수, 디폴트 = 100
  - weak learner가 순차적으로 오류를 보정하므로 갯수가 많을 수록 예측 성능이 일정수준 이상까지는 좋아질 수 있으나, 시간 오래 걸림
- subsample : weak learner가 “학습에 사용하는” 데이터의 “샘플링 비율”
  - 0~1 사이 값 지정 가능, 디폴트 = 1 (학습 데이터 전체를 기반으로 학습, if 0.5 == 학습 데이터의 50% 사용)
  - 과적합이 염려되는 경우 1보다 작은 값으로 설정

2. XGBoost(eXtra Gradient Boost)

장점
- 뛰어난 예측 성능
- GBM 대비 빠른 수행 시간
- 자체에 과적합 규제 기능
- Tree pruning(나무 가지치기): 더 이상 긍정 이득이 없는 분할을 가지치기해서 분할 수를 줄임
- 자체 내장된 교차 검증
- 결손값 자체 처리
패키지
- 파이썬 래퍼 XGBoost 모듈: 초기의 독자적인 XGBoost 프레임워크 기반의 XGBoost
- 사이킷런 래퍼 XGBoost 모듈: 사이킷런과 연동되는 모듈

파이썬 래퍼 XGBoost
1. 하이퍼 파라미터
  - 일반 파라미터(디폴트 파라미터 값을 바꾸는 경우 거의 없음)

        | 파라미터 | 디폴트 | 설명 |
        | --- | --- | --- |
        | booster | gbtree | gbtree(tree based model) or gblinear(linear model) 선택 |
        | silent | 0 | 출력 메세지를 나타내고 싶지 않은 경우 1로 설정 |
        | nthread | cpu의 전체 스레드 다 사용 | cpu의 실행 스레드 개수 조정 |

    - 부스터 파라미터


        | 파라미터 | 디폴트 | 설명 |
        | --- | --- | --- |
        | eta***alias: learning_rate | 0.3 | 학습률. weak learner가 순차적으로 오류값을 보정하는데 적용하는 계수, 0~1 사이 값, 보통은 0.01~0.2 값 선호 |
        | num_boost_rounds |  | weak learner의 개수,
        | min_child_weight | 1 | 추가적으로 가지를 나눌지 결정하기 위해 필요한 데이터들의 가중치 총합, 클수록 분할을 자제함, 과적합 조절 역할 |
        | gamma alias: min_split_loss | 0 | 리프노드를 추가적으로 나눌지 결정할 최소 손실 감소 값, 해당값보다 큰 손실(loss)이 감소된 경우??? 리프 노드 분할, 값이 클수록 과적합 감소 효과 |
        | max_depth | 6 | 트리의 최대 깊이, 0으로 설정하면 깊이 제한 없음, 3~10 사이 값 적용 |
        | sub_sample | 1 | 데이터를 샘플링하는 비율 지정, 0.5~1 사이값 사용 |
        | colsample_bytree | 1 | 트리 생성에 필요한 피처를 임의로 샘플링하는데 사용, 매우 많은 피처가 있는 경우 과적합을 조정하는데 사용 |
        | lambda alias: reg_lambda | 1 | L2 Regularization 적용값, 피처가 많을 수록 적용을 검토, 값이 클수록 과적합 감소 효과 |
        | alpha alias: reg_alpha *** 확인 | 0 | L1 Regularization 적용값, 피처가 많을 수록 적용을 검토, 값이 클수록 과적합 감소 효과 |
        | scale_pos_weight | 1 | 특정값으로 치우친 비대칭한 클래스로 구성된 데이터 세트의 균형을 유지하기 위한 값 |
    - 학습 테스크 파라미터


        | 파라미터 | 디폴트 | 설명 |
        | --- | --- | --- |
        | objective |  | 최소값을 가져야할 손실 함수 정의 |
        | binary : logistic |  | 이진 분류일 때 적용 |
        | multi : softmax |  | 다중 분류일 때 적용 |
        | multi : softprob |  | 개별 레이블 클래스에 해당되는 예측 확률 반환 |
        | eval_metrics | rmse : Root Mean Square Error, mae : Mean Absolute Error, logloss : Negative log-likelihood, error : Binary classification error rate, merror : Multiclass classification error rate, mlogloss : Multiclass logloss, auc : Area under the curve | 검증에 사용되는 함수 정의 |
        - 과적합 문제가 심각할 경우
            - eta(학습률) 값을 낮춤(0.01~0.1) ⇒ 그럴 경우, num_round(n_estimators)는 반대로 높여줘야 함
            - max_depth 값을 낮춤
            - min_child_weight 값을 높임
            - gamma(min_split_loss) 값을 높임
            - sub_sample(subsample)과 colsample_bytree(max_features)를 조정하는 것도 트리가 너무 복잡하게 생성되는 것을 막아, 과적합에 도움이 될 수 있음
    - XGBoost 는 자체적으로 교차검증, 성능평가, 피처중요도 등의 시각화 기능과 조기중단 기능을 가지고 있음
    - 조기 중단 early stopping: 파라미터 값만큼 학습하는 동안 예측 오류가 감소하지 않으면 중단

    ```python
    from xgboost import plot_importance # 피처의 중요도를 시각화해주는 모듈

    plot_importance(xgb_model, ax=ax)
    ```

2. DMatrix: 파이썬 래퍼 XGBoost는 학습용/테스트용 데이터 세트를 위해 별도의 DMatrix를 생성한다.
    - `xgb.DMatirx()` : 넘파이 입력 파라미터를 받아서 만들어지는, XGBoost 만의 전용 데이터 세트

    ```python
    dtrain = xgb.DMatrix(data=피처 데이터 세트, label=분류:레이블 데이터 세트 | 회귀: 숫자형인 종속값 데이터 세트)
    ```

    - DMatrix는 넘파이, libsvm txt 포맷 파일, xgboost 이진 버퍼 파일, 판다스의 df.values를 이용해 적용 가능
    - 학습 수행전, 하이퍼 파라미터(딕셔너리)로 입력해야 함

        ```python
        params = { 'max_depth':3,
                   'eta': 0.1,
                   'objective':'binary:logistic',
                   'eval_metric':'logloss',
                   'early_stopping' : 100
                }
        num_rounds = 400
        ```

    - XGBoost 모델 학습시엔, 모듈의 train() 함수에 파라미터 전달 (사이킷런의 경우 Estimator의 생성자를 하이퍼 파라미터로 전달하는 데 반해 차이가 있음)
    - 조기중단시, params 외에 XGB 모델에 early_stopping_rounds 파라미터를 설정해야 하고, 반드시 eval_set 과 eval_metric이 함께 설정되어야 함.
        - (eval == test 라고 생각하면 편함)
        - eval_set : 성능 평가를 수행할 평가용 데이터 세트 설정
        - eval_metric : 평가 세트에 적용할 성능 평가 방법 ⇒ 분류일 경우 주로 ‘error’, ‘logloss’를 적용
        - XGBoost는 반복마다 eval_set으로 지정된 데이터 세트에서 eval_metric의 지정된 평가 지표로 오류를 측정 ⇒ 얘네가 조기중단 적용

    ```python

    import xgboost as xgb

    # train 데이터 셋은 ‘train’ , evaluation(test) 데이터 셋은 ‘eval’ 로 명기합니다. 
    wlist = [(dtrain,'train'),(dtest,'eval') ]

    # 하이퍼 파라미터와 early stopping 파라미터를 train( ) 함수의 파라미터로 전달
    xgb_model = xgb.train(params=params,
                                                dtrain=dtrain,
                                                num_boost_round=num_rounds,
                          early_stopping_rounds=100,
                                                evals=wlist)
    # xgb.train은 학습이 완료된 모델을 객체로 반환

    xgb_model = xgb.train(params=파라미터 딕셔너리(성능평가 방법 포함되어 있음),
                                                dtrain=XGBoost전용 데이터 세트,
                                                numboost_round=숫자,
                                                early_stopping_rounds=숫자,
                                                evals=평가용 데이터 세트)

    ```

    - 모델 객체의 예측을 위해서는 `predict()` 메서드를 사용하는데, 예측 결괏값이 아닌, 예측 결과를 추정할 수 있는 확률 값을 반환함

    ```python
    pred_probs = xgb_model.predict(dtest)
    print('predict( ) 수행 결과값을 10개만 표시, 예측 확률 값으로 표시됨')
    print(np.round(pred_probs[:10],3))

    # 예측 확률이 0.5 보다 크면 1 , 그렇지 않으면 0 으로 예측값 결정하여 List 객체인 preds에 저장 
    preds = [ 1 if x > 0.5 else 0 for x in pred_probs ]
    print('예측값 10개만 표시:',preds[:10])
    ```

    - 내장된 시각화 기능 (↔ 사이킷런은 Estimator 객체에 feature_importances_ 속성을 이용해 직접 시각화 코드를 해야함)
        - XGBoost 넘파이 기반의 피처 데이터를 학습시에는 피처명을 제대로 알 수 없으므로, f0, f1와 같이 피처 순서별 f자 뒤에 순서를 붙여서 X축에 피처들로 나열해야함 (즉 f0은 첫 번째 피처, f1는 두 번째 피처를 의미)

    ```python
    import matplotlib.pyplot as plt
    %matplotlib inline

    fig, ax = plt.subplots(figsize=(10, 12))
    plot_importance(xgb_model, ax=ax)
    ```

3. cv(): 데이터 세트에 대한 교차 검증 수행 후 최적 파라미터를 구할 수 있는 방법 제공. 반환값은 DataFrame (사이킷런의 GridSearchCV 기능)                                          

    ```python
    xgboost.cv(params, # (dict) 부스터 파라미터
                         dtrain, # (DMatrix) 학습 데이터
                         num_boost_round=10, # (int) 부스팅 반복 횟수
                         nfold=3, # (int) CV 폴드 갯수
                         stratified=False, # (bool) CV 수행시 층화 표본 추출 수행 여부
                         folds=None,
                         metrics=(), # (string or list of strings) CV 수행시 모니터링할 선능 평가 지표
                         obj=None,
                         feval=None,
                         maximize=False,
                         early_stopping_rounds=None, # (int) 조기 중단을 활성화시킴. 반복 횟수 지정.
                         fpreproc=None,
                         as_pandas=True,
                         verbose_eval=None,
                         show_stdv=True,
                         seed=0,
                         callbacks=None,
                         shuffle=True)
    ```

    - params: dict, 부스터 파라미터
    - dtrain: DMatrix, 학습데이터
    - num_boost_round: int, 부스팅 반복 횟수
    - n_fold: int, cv 폴드 개수
    - stratified: string or list of strings, cv 수행 시 모니터링할 성능지표
    - early_stopping_rounds: int, 조기중단 활성화, 반복횟수 지정

사이킷런 래퍼 XGBoost: fit(), predict()로 학습 및 예측

하이퍼 파라미터: 파이썬 래퍼 XGBoost 보기!

eat → learning_rate
sub_sample → subsample
lambda → reg_lambda

alpah → reg_alpha

# 사이킷런 래퍼 XGBoost 클래스인 XGBClassifier 임포트
from xgboost import XGBClassifier

xgb_wrapper = XGBClassifier(n_estimators=400, learning_rate=0.1, max_depth=3)
xgb_wrapper.fit(X_train, y_train)
w_preds = xgb_wrapper.predict(X_test)
w_pred_proba = xgb_wrapper.predict_proba(X_test)[:, 1]

조기 중단

fit() 에 입력
early_stopping_rounds: 반복 횟수 정의
eval_metrics: 조기 중단을 위한 평가 지표 예) logloss

eval_set: 성능평가를 수행할 데이터 세트

from xgboost import XGBClassifier

xgb_wrapper = XGBClassifier(n_estimators=400, learning_rate=0.1, max_depth=3)
evals = [(X_test, y_test)]
xgb_wrapper.fit(X_train, y_train, early_stopping_rounds=100, eval_metric="logloss", 
              eval_set=evals, verbose=True)

ws100_preds = xgb_wrapper.predict(X_test) # 원래는 X_test가 evals에 들어가 있으니, 사용하면 안됨
ws100_pred_proba = xgb_wrapper.predict_proba(X_test)[:, 1]

plot_importance(): 피처의 중요도를 시각화하는 모듈

파이썬 래퍼 때처럼 그대로 사용해도 무방

from xgboost import plot_importance
import matplotlib.pyplot as plt
%matplotlib inline

fig, ax = plt.subplots(figsize=(10, 12))
# 사이킷런 래퍼 클래스를 입력해도 무방. 
plot_importance(xgb_wrapper, ax=ax)

3. LightGBM

XGBoost 대비 장단점
- 장점 : 더 빠른 학습과 예측 수행 시간, 더 작은 메모리 사용량, 카테고리형 피처의 자동변환과 최적 분할(원핫 인코딩 안써도 카테고리형 피처를 최적으로 변환하에 이에 따른 노드 분할 수행)
- 단점 : 적은 데이터 세트에 적용할 경우 과적합이 발생하기 쉬움 (일반적으로 10,000건 이하의 데이터 세트 정도)
- 주의점 : XGBoost와 대부분이 유사하지만, 리프 노드가 계속 분할 → 트리 깊어짐, 이러한 트리 특성에 맞는 하이퍼 파라미터 설정이 필요함
  - ex) max_depth를 매우 크게 가짐
트리 분할 방법 : 리프 중심 트리 분할(Leaf Wise) ↔ GBM 계열 트리 분할 방법 : 균형 트리 분할 (Level Wise)

- Level Wise : 최대한 균형 잡힌 트리 유지하면서 분할 → 트리의 깊이가 최소화 → 오버피팅에 보다 더 강한 구조를 가질 수 있음 ← 시간 오래 걸림
- Leaf Wise : 트리 균형 보다, 최대 손실 값 (max delta loss)을 가지는 리프 노드를 지속적 분할 → 트리 깊이 깊어지고 비대칭 ← 반복 학습하면, 결국 Level Wise 방식 보다 예측 오류 손실을 최소화할 수 있다는 것이 LightGBM의 구현 사상

```python
# LightGBM의 파이썬 패키지인 lightgbm에서 LGBMClassifier 임포트
from lightgbm import LGBMClassifier

import pandas as pd
import numpy as np
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import train_test_split

dataset = load_breast_cancer()
ftr = dataset.data
target = dataset.target

# 전체 데이터 중 80%는 학습용 데이터, 20%는 테스트용 데이터 추출
X_train, X_test, y_train, y_test=train_test_split(ftr, target, test_size=0.2, random_state=156 )

# 앞서 XGBoost와 동일하게 n_estimators는 400 설정. 
lgbm_wrapper = LGBMClassifier(n_estimators=400)

# LightGBM도 XGBoost와 동일하게 조기 중단 수행 가능. 
evals = [(X_test, y_test)]
lgbm_wrapper.fit(X_train, y_train, early_stopping_rounds=100, eval_metric="logloss", 
                 eval_set=evals, verbose=True)
preds = lgbm_wrapper.predict(X_test)
pred_proba = lgbm_wrapper.predict_proba(X_test)[:, 1]
```

하이퍼 파라미터

| 파라미터 (뒤에는 사이킷런 호환 클래스) | 디폴트 | 설명 |
| --- | --- | --- |
| num_iterations | n_estimators | 100 | 반복수행하려는 트리의 개수
크게 지정할 수록 예측성능이 올라가지만 과적합 가능성도 높아진다. |
| learning_rate | 0.1 | 부스팅 스텝을 반복적으로 수행할 때 업데이트되는 학습률. 0~1 사이 값 |
| max_depth | -1 | 트리의 최대 깊이. 0보다 작은 값을 지정하면 깊이 제한 X |
| min_data_in_leaf | min_child_samples | 20 | 리프노드가 되기 위해 최소한으로 필요한 레코드 수 |
| num_leaves | 31 | 하나의 트리가 가질 수 있는 최대 리프 개수 |
| boosting | gbdt | 부스팅의 트리를 생성하는 알고리즘 기술, - gbdt : 일반적인 그래디언트 부스팅 결정 트리, - rf : 랜덤 포레스트 |
| bagging_fraction (subsample) | 1.0 | 데이터를 샘플링하는 비율 |
| feature_fraction (colsample_bytree) | 1.0 | 개별 트리를 학습할 때마다 무작위로 선택하는 피처의 비율율 |
| lambda_l2 (reg_lambda) | 0.0 | L2 Regularizaton 제어를 위한 값 : 피처 개수가 많을 수록 적용 검토, 값이 클수록 과적합 감소 효과 |
| lambda_l1 (reg_alpha) | 0.0 | L1 Regularization 제어를 위한 값 : 피처 개수가 많을 수록 적용 검토, 값이 클수록 과적합 감소 효과 |
| objective |  | 최소값을 가져야할 손실함수 지정 : 회귀, 다중 클래스 분류, 이진 분류에 따라서 손실함수가 지정됨 |
- plot_importance(): 피처 중요도 시각화

하이퍼 파라미터 튜닝 방안
- num_leaves의 개수를 중심으로 min_child_samples(min_data_in_leaf), max_depth를 함께 조정하면서 모델의 복잡도를 줄인다.
  - num_leaves는 개별 트리가 가질 수 있는 최대 리프 갯수이고, LightGBM 모델 복잡도 제어하는 주요 파라미터 (일반적으로, num_leaves의 갯수를 높이면 정확도가 높아지지만, 트리가 깊어지고 복잡도가 커져 과적합 영향도 커짐)
  - min_child_samples는 보통, 큰 값으로 설정하면 트리 깊이가 깊어지는 걸 방지함
  - max_depth는 깊이의 크기 제한
- learning_rate를 작게 하면서 n_estimators를 크게 하는 것 (n_estimators를 너무 크게 하면 과적합으로 성능이 저하될 수 있다.)
- reg_lambda, reg_alpha와 같은 regularization을 적용
- colsample_bytree, subsample을 적용하여 학습 데이터에 사용할 피처의 개수, 데이터 샘플링 레코드 수를 줄임
하이퍼 파라미터 비교

| 파이썬 래퍼 LightGBM | 사이킷런 래퍼 LightGBM | 사이킷런 래퍼 XGBoost |
| --- | --- | --- |
| num_iterations | n_estimators | n_estimators |
| learning_rate | learning_rate | learning_rate |
| max_depth | max_depth | max_depth |
| min_data_in_leaf | min_child_samples | N/A |
| bagging_fraction | colsample_bytree | colsample_bytree |
| lambda_l2 | reg_lambda | reg_lambda |
| lambda_l1 | reg_alpha | reg_alpha |
| early_stopping_round | early_stopping_rounds | early_stopping_rounds |
| num_leaves | num_leaves | N/A |
| min_sum_hessian_in_leaf | min_child_weight | min_child_weight |

파이썬 머신러닝 완벽 가이드 - 5. Classification(1) (결정트리)

Thu, 29 Sep 2022 02:09:47 GMT

Classification 분류

: 학습 데이터로 주어진 데이터의 피처와 레이블 값(결정 값, 클래스 값)을 머신러닝 알고리즘으로 학습해 모델을 생성하고, 이렇게 생성된 모델에 새로운 데이터 값이 주어졌을 때 미지의 레이블 값을 예측하는 것

<분류를 구현할 수 있는 머신러닝 알고리즘>

나이브 베이즈 Naive Bayes: 베이즈 통계와 생성 모델에 기반
로지스틱 회귀 Logistic Regression: 독립변수와 종속변수의 선형관계에 기반
결정 트리 Decision Tree: 데이터 균일도에 따름
서포트 벡터 머신 Support Vector Machine: 개별 클래스 간의 최대 분류 마진을 찾아줌
최소 근접 알고리즘 Nearest Neighbor: 근접 거리 기준
신경망 Neural Network: 심층 연결 기반
앙상블 Ensemble: 서로 같은(또는 다른) 머신러닝 알고리즘 결합

from sklearn.base import BaseEstimator
# : customized 형태의 Estimator를 개발자가 생성할 수 있다.

2. 결정 트리 Decision Tree

: 데이터에 있는 규칙을 학습을 통해 자동으로 찾아내 트리 기반의 분류 규칙을 만든다.

→ (조건문) 따라서, 데이터의 어떤 기준을 바탕으로 규칙을 만들어야 가장 효율적인 분류가 될 것인가가 알고리즘 성능을 좌우한다.

깊이(depth)가 깊어질 수록 예측 성능이 저하될 가능성이 커진다.
- 많은 규칙 존재 → 분류를 결정하는 방식이 복잡해진 것 → 과적합될 가능성 높음
데이터를 분류할 때 최대한 많은 데이터가 해당 분류에 속할 수 있도록 결정 노드의 규칙이 정해져야 한다. (최대한 균일한 데이터세트를 구성할 수 있도록 분할 필요)
결정 노드는 정보 균일도가 높은 데이터 세트를 먼저 선택할 수 있도록 규칙 조건을 만듦
정보 균일도를 측정하는 방법
1. 정보이득 Information Gain
  - 엔트로피 기반 : 주어진 데이터 집합의 혼잡도. 서로 다른 값이 섞여있으면 엔트로피 값 증가
  - 정보이득 지수 = 1 - 엔트로피 지수
  - 결정트리는 정보이득 지수로 분할. 즉, 정보이득이 높은 속성을 기준으로 분할
  - $정보이득 = 부모의 불순도 - (\frac{왼쪽 노드 샘플수}{부모의 샘플수} * 왼쪽 노드 불순도) - (\frac{오른쪽 노드 샘플수}{부모의 샘플수} * 오른쪽 노드 불순도)$
2. 지니계수
  - 0이 가장 평등하고 1로 갈수록 불평등
  - 지니계수가 낮을수록 데이터터 균일도가 높은 것으로 해석. 지니계수가 낮은 속성을 기준으로 분할
    - 그러면 정보이득 지수 같은 지표를 만들자면 = 1 - 지니계수 (?)
  - $지니불순도 = 1 - 음성클래스비율^2 + 음성클래스비율^2$
  - 사이킷런 DecisionTreeClassifier은 기본으로 지니계수를 이용해 데이터 분할
```
  from sklearn.tree import DecisionTreeClassifier
```

결정 트리 모델의 특징

장점 : 정보의 ‘균일도’ 라는 룰을 기반으로 하고 있어 알고리즘이 직관적, 균일도만 신경쓰면 되므로 각 피처의 스케일링과 정규화 같은전처리 작업이 (일반적인 경우) 필요 없음
단점 : 과적합으로 (테스트) 정확도가 떨어짐 (트리가 계속 깊어질수록)
- (학습) 모델의 정확도를 높이기 위해 계속 조건을 추가하며 트리 깊이가 깊어지면, 테스트 정확도가 떨어질 것임
- 오히려 완벽한 규칙을 만들 수 없다고 먼저 인정하고, 트리의 크기를 사전에 제한하는 것이 오히려 성능 튜닝에 더 도움이 될 것

결정 트리의 파라미터

사이킷런 결정 트리 = DesicionTreeClassifier (for 분류) , DisicionTreeRegressor (for 회귀)
- 결정 트리 구현은 CART ( Classfication And Regression Trees ) 알고리즘 기반 ⇒ 분류뿐 아니라 회귀에서도 사용될 수 있음
- 하위의 파라미터는 동일함
min_samples_split
- 노드를 분할하기 위한 최소한의 샘플 데이터 수
- 디폴트 = 2
- 작게 설정할 수록 분할되는 노드가 많아진다. (과적합 가능성 증가)
min_samples_leaf
- 말단 노드(leaf)가 되기 위한 최소한의 샘플 데이터 수
- 비대칭적 데이터의 경우 특정 클래스의 데이터가 극도로 작을 수 있으므로 이 경우는 작게 설정 필요
max_features
- 최적의 분할을 위해 고려할 최대 피처 개수
- 디폴트 = None : 전체 피처 선정
- int 형으로 지정 : 대상 피처의 개수
- float 형으로 지정: 전체 피처 중 대상 피처의 퍼센트
- ‘sqrt’ : $\sqrt{전체피처 개수}$ 만큼 선정 (=’auto’)
- ‘log’ : $log_2(전체 피처개수)$ 만큼 선정
- ‘None’ : 전체 피처 선정
max_depth
- 트리의 최대 깊이 규정
- 디폴트 = None : 완벽하게 클래스 결정 값이 될 때까지 깊이를 계속 키우며 분할하거나, 노드가 가지는 데이터 갯수가 min_samples_split보다 작아질 대까지 계속 깊이를 증가시킴
- 깊이가 깊어지면 min_samples_split 설정대로 초대분할하여 과적합할 수 있으므로 적절한 값으로 제어 필요
max_leaf_nodes
- 말단 노드의 최대 개수

결정 트리 모델의 시각화

from sklearn.tree import export_graphviz

export_graphviz(estimator, out_file='파일명', class_names=클래스 명칭,
                                feature_names=피처명칭, impurity=True, filled=True)

# 위에서 생성한 파일을 graphviz가 읽어서 주피터 노트북 상에서 시각화
import graphviz

with open ('파일명') as f: dot_graph = f.read()

graphviz.Source(dot_graph)

시각화 결과의 구성들 :
- 조건 : 피처 조건이 있는 것은 자식 노드를 만들기 위한 조건 규칙, 이게 없으면 리프 노드
- gini(지니계수) : value=[ ] 로 주어진 데이터 분포에서의 지니 계수
- samples : 현 규칙에 해당하는(적용되는) 데이터 건수
- value=[ ] : 클래스 값 기반의 데이터 건수
- 색상 : 레이블 값, 선명도가 높을 수록 지니계수 낮음

feautre_importance_ 속성: ndarray로 반환, 피처 순서대로 값 할당, 값이 높을 수록 중요도 높음 : estimator.feature_importance_

  import seaborn as sns
  import numpy as np
  %matplotlib inline

  # feature importance 추출 
  print("Feature importances:\n{0}".format(np.round(dt_clf.feature_importances_, 3)))

  # feature별 importance 매핑
  for name, value in zip(iris_data.feature_names , dt_clf.feature_importances_):
      print('{0} : {1:.3f}'.format(name, value))

  # feature importance를 column 별로 시각화 하기 
  sns.barplot(x=dt_clf.feature_importances_ , y=iris_data.feature_names)

make_classification(): 분류를 위한 테스트용 데이터를 쉽게 만들 수 있다.

  from sklearn.datasets import make_classification
  import matplotlib.pyplot as plt
  %matplotlib inline

  plt.title("3 Class values with 2 Features Sample data creation")

  # 2차원 시각화를 위해서 feature는 2개, 결정값 클래스는 3가지 유형의 classification 샘플 데이터 생성. 
  X_features, y_labels = make_classification(n_features=2, n_redundant=0, n_informative=2,
                               n_classes=3, n_clusters_per_class=1,random_state=0)

  # plot 형태로 2개의 feature로 2차원 좌표 시각화, 각 클래스값은 다른 색깔로 표시됨. 
  plt.scatter(X_features[:, 0], X_features[:, 1], marker='o', c=y_labels, s=25, cmap='rainbow', edgecolor='k')

반환되는 객체: 피처 데이터 세트, 클래스 레이블 데이터 세트

예시: 피처 2개, 클래스 3가지 유형의 분류 샘플 데이터 생성

  X_features, y_labels = make_classification(n_features=2, n_redundant=0, n_informative=2, n_classes=3, n_clusters_per_class=1, random_state=0)

visualize_boundary(): 머신러닝 모델이 만든 결정 기준을 색상과 경계로 나타낸다.

visualize_boundary(estimator, X_features, y_labels)

파이썬 머신러닝 완벽 가이드 - 4. Evaluation

Wed, 28 Sep 2022 03:15:40 GMT

Evaluation 평가 ( in 분류)

1. 평가 지표

1. 정확도 Accuracy

실제 데이터에서 예측 데이터가 얼마나 같은지 판단하는 지표

특히 정확도는 불균형한 레이블 값 분포에서는, 적합한 평가 지표가 아님
ex) MNIST 데이터 셋을 다중분류에서 이진분류로 바꾸면 (7을 True, 나머지를 False) ⇒ 0과 1중 0을 찍으면 90%의 정확도가 나오게 됌

$$ 정확도(Accuracy) = \frac{TN+TP}{TN+FP+FN+TP} $$

2. 오차 행렬 Confusion Matrix

T/F : ‘같은가 틀린가' & N/P : $\widehat{y}$ 이 ‘neg 0 인가 pos 1 인가’

|  |    $$\hat{y}$$ = 0 |    $$\hat{y}$$ = 1 |
| --- | --- | --- |
|    y = 0 |    TN |    FP |
|    y = 1 |    FN |    TP |

from sklearn.metrics import confusion_matirx

불균형한 이진분류 데이터 세트에서는 positive 데이터 건수가 작아, negative로 예측 정확도가 높아지는 경향이 발생한다.
- 보통 사기 행위나 암 검진 예측 이진분류 등에서는, Positive 데이터 건수가 작게 됨 ⇒ TN는 매우 커지고, TP, FN, FP 모두 낮아지게 됨 (그냥 neg로 예측하면 정확도 자체가 올라가므로)

3. 정밀도와 재현율

3.1. 정밀도 Precision

$$ \frac{TP}{FP+TP} = \frac{실제 양성}{ 실제 음성(잘못판단)+실제양성} $$

양성으로 예측한 값 중에서 실제 양성인 값
- “P야!” 라고 말한 것들 중에, <실제 P>이 있는 확률
[실제 음성인 데이터 예측을 양성으로 잘못 판단하면 안되는 경우]에 [정밀도]가 중요하다.
- 스팸 메일 판단 모델 ⇒ FN 오류의 댓가는 불편한 정도, FP 경우 업무의 차질이 생김
precision_score()

3.2. 재현율 Recall == 민감도 Sensitivity == TPR True Positive Rate

$$ \frac{TP}{FN+TP} = \frac{실제 양성}{실제 양성(잘못 판단)+실제 양성} $$

실제 양성인 대상 중에 양성으로 예측한 값
- *<실제 P들> 중에 “P야!” 라고 말한 게 있는 확률*
[실제 양성인 데이터 예측을 음성으로 잘못 판단하면 안되는 경우]에 [재현율]이 중요하다.
- 암 판단 모델 ⇒ FN 오류의 댓가가 생명이기에, 양성을 음성으로 잘못 판단하면 안되는 경우 ↔ FP 경우, 재검사를 하는 수준의 비용
- 금융 사기 모델 ⇒ FN 오류의 댓가가 어마어마한 금액 ↔ FP 경우, 사기인지 재확인 하는 수준의 비용
- 통상적으로도, 정밀도보다는 재현율이 더 중요한 업무가 많긴 함
recall_score()

정밀도와 재현율 모두 TP를 높이는데 동일하게 촛점을 맞추지만, 정밀도는 FP를 낮추는데 촛점을 맞추고 재현율을 FN을 낮추는데 촛점을 맞춘다. 그러므로 서로 보완적인 지표로 분류의 성능을 평가하는데 도움이 되며, 가장 좋은 성능 평가는 재현율과 정밀도 모두 높은 수치를 얻는 것이며, 어느 한 평가 지표만 매우 높고 반대는 매우 낮은 경우는 바람직하지 않음

3.3. 정밀도/재현율 트레이드 오프 trade-off

정밀도와 재현율은 상호보완적 지표이다.
predict_proba(): 개별 데이터별로 예측 확률을 반환하는 메서드
- predict() 가 위 메서드를 참고, 정제하여 보여주는 개념이라 생각하면 편함

predict()의 의사(pseudo) 코드 만들기

  from sklearn.preprocessing import Binarizer

  #Binarizer의 threshold 설정값. 분류 결정 임곗값임.  
  custom_threshold = 0.5

  # predict_proba( ) 반환값의 두번째 컬럼 , 즉 Positive 클래스 컬럼 하나만 추출하여 Binarizer를 적용
  pred_proba_1 = pred_proba[:,1].reshape(-1,1)

  binarizer = Binarizer(threshold=custom_threshold).fit(pred_proba_1) 
  custom_predict = binarizer.transform(pred_proba_1)

  get_clf_eval(y_test, custom_predict)

임곗값 threshold 보다 같거나 작으면 0을, 크면 1로 변환하고 반환한다.
- 분류 결정 임곗값은 양성 예측값을 결정하는 확률의 기준이 된다.
  - 임곗값이 낮을 수록 True값이 많아진다. (양성증가)
  - 양성 예측값이 많아지면 상대적으로 재현율이 높아진다. 정밀도는 떨어진다.

threshold 임곗값에 따른 재현률/정밀도 변화
precision_recall_curve() : 임곗값 변화에 따른 정밀도와 재현율 값 나타내주는 API
- 입력 파라미터
  - y_true : 실제 클래스값 배열 (배열 크기 = [데이터 건수])
  - probas_pred : pos 칼럼의 예측 확률 배열 (배열 크기 = [데이터 건수])
- 반환 값
  - 정밀도 : 임곗값별 정밀도 값을 ndarray로 반환
  - 재현율 : 임곗값별 재현율 값을 ndarray로 반환
  - 임곗값 : 일반적으로 0.11~0.95 정도의 임곗값들을 ndarray로 반환
```
from sklearn.metrics import precision_recall_curve

precision, recalls, threshold = precision_recall_curve(y_test, \
                                                              *X_test의 predict_proba() 의 양성 예측 확률 배열* ) *# == [:,1]*
```

4. F1 Score

정밀도와 재현율을 결합한 지표. 정밀도와 재현율이 어느 쪽으로 치우치지 않을 때 상대적으로 높은 값을 가짐

$$ F1 = 2\frac{prcisionrecall}{precision+recall} $$

from sklearn.metrics import f1_score

5. ROC 곡선과 AUC

: 머신러닝 이진분류 모델의 예측 성능을 판단하는 중요한 평가지표

ROC 곡선: FPR(False Positive Rate)이 변할 때 [X축], TPR(True Positive Rate)이 변하는지 [Y축] 나타내는 곡선
- TPR (재현율) = TP/(FN+TP) = 실제 양성이 정확히 예측되어야 하는 수준(민감도)
  - 질병이 있는 사람은 질병이 있는 것으로 양성 판정
  $$ TPR(재현율, 민감도) = \frac{TP}{FN+TP} $$
- TNR (특이성) = TN/(FP+TN) = 실제 음성이 정확히 예측되어야 하는 수준 (특이성 ↔ 민감도에 대응하는 지표)
  - 질병이 없는 사람은 질병이 없는 것으로 음성 판정
    
    $$ TNR(특이성) = \frac{TN}{FP+TN} $$
ROC 곡선의 X축 기준인 FRP = FP/(FN+TP) = 1 - TNR (pos 틀린 비율?)

$$ FPR = \frac{FP}{FP+TN} = 1-TNR(특이성) = 1 - \frac{TN}{FP+TN} $$

ROC 곡선이 중앙 직선에 가까울수록 성능이 떨어지는 것이며, 멀어질수록 성능이 뛰어난 것
- ROC 곡선은 FPR을 0부터 1까지 변경하면서 TPR의 변화 값을 구함 [HOW?] ⇒ 분류 결정 임곗값(thresholds)을 변경하면 됨
- thresholds는 Positive 예측값을 결정하는 확률이기에, FPR을 0으로 만들려면 임곗값을 1로 지정하면 됨
roc_curve()
- 입력 파라미터
  - y_true : 실제 클래스 값 array ( array shape = [데이터 건수] )
  - y_score : predict_proba()의 반환 값 array에서 Positive 칼럼의 예측 확률이 보통 사용 됨 (array shape = [n_samples] )
- 반환 값
  - FPR : FPR 값을 array로 반환
  - TPR : TPR 값을 array로 반환
  - Thresholds : Thresholds 값 array

AUC (Area Under Curve) : ROC 곡선 밑의면적을 구한 것으로, 일반적으로 1에 가까울 수록 좋은 수치

AUC 수치가 커지려면, FPR이 작은 상태에서 알마나 큰 TPR을 얻을 수 있느냐가 관건

  from sklearn.metrics import roc_auc_score

  ### roc_auc_score(y_test, y_score)로 y_score는 predict_proba()로 호출된 예측 확률
  ### ndarray중 Positive 열에 해당하는 ndarray입니다. 

  pred_proba = lr_clf.predict_proba(X_test)[:, 1]
  roc_score = roc_auc_score(y_test, pred_proba)
  print('ROC AUC 값: {0:.4f}'.format(roc_score))

파이썬 머신러닝 완벽 가이드 - 3. Scikit-Learn

Wed, 28 Sep 2022 03:05:16 GMT

Scikit-Learn 사이킷런

1. Estimator

Classifier 분류

: DecisionTreeClassifier, RandomForestClassifier, GradientBoostingClassifier, GaussianNB, SVC
Regressor 회귀

: LinearRegression, Ridge, Lasso, RandomForestRegressor, GradientBoostingRegressor
비지도학습/피처추출(전처리) 에서의 fit(), transform() : fit()이 학습이 아니라, 입력 데이터 형태에 맞춰 데이터를 변환하기 위한 사전 구조를 맞추는 작업 : transform()은 fit으로 변환된 사전 구조를 가지고 차원변환/클러스터링/피처추출 등을 하는 작업

2. Module

sklearn.model_selection 의 train_test_split(features, labels, test_size)
교차 검증: 데이터 편중을 막기 위해 별도의 여러 세트로 구성된 학습 데이터 세트와 검증 데이터 세트에서 학습, 평가를 수행하는 것
- KFold : K개의 데이터 폴드 세트를 만들어서, K번만큼 각 폴드 세트에 학습과 검증 평가를 반복적으로 수행하는 방법
  - KFold(n_splits = 폴드 개수)
  - split(): 학습용/검증용 데이터로 분할할 수 있는, 각각의 인덱스를 반환
  1. 객체 생성
  2. 인덱스 얻기
  3. 인덱스 활용해 데이터 추출
  4. 학습
  5. 예측
  6. 정확도 측정
  7. 평균 정확도
  - Kfold 사용 예시 코드
```
  kfold = KFold(n_splits=5)
  cv_accuracy = []

  n_iter = 0

  # KFold객체의 split( ) 호출하면 폴드 별 학습용, 검증용 테스트의 로우 인덱스를 array로 반환  
  for train_index, test_index  in kfold.split(features):
      # kfold.split( )으로 반환된 인덱스를 이용하여 학습용, 검증용 테스트 데이터 추출
      X_train, X_test = features[train_index], features[test_index]
      y_train, y_test = label[train_index], label[test_index]
      #학습 및 예측 
      dt_clf.fit(X_train , y_train)    
      pred = dt_clf.predict(X_test)
      n_iter += 1
      # 반복 시 마다 정확도 측정 
      accuracy = np.round(accuracy_score(y_test,pred), 4)
      train_size = X_train.shape[0]
      test_size = X_test.shape[0]
      print('\n#{0} 교차 검증 정확도 :{1}, 학습 데이터 크기: {2}, 검증 데이터 크기: {3}'
            .format(n_iter, accuracy, train_size, test_size))
      print('#{0} 검증 세트 인덱스:{1}'.format(n_iter,test_index))
      cv_accuracy.append(accuracy)

  # 개별 iteration별 정확도를 합하여 평균 정확도 계산 
  print('\n## 평균 검증 정확도:', np.mean(cv_accuracy))
```
  - Kfold 사용 예시 코드 결과
    
    #1 교차 검증 정확도 :1.0, 학습 데이터 크기: 120, 검증 데이터 크기: 30 #1 검증 세트 인덱스:[ 0 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]
    
    #2 교차 검증 정확도 :0.9667, 학습 데이터 크기: 120, 검증 데이터 크기: 30 #2 검증 세트 인덱스:[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]
    
    #3 교차 검증 정확도 :0.8667, 학습 데이터 크기: 120, 검증 데이터 크기: 30 #3 검증 세트 인덱스:[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]
    
    #4 교차 검증 정확도 :0.9333, 학습 데이터 크기: 120, 검증 데이터 크기: 30 #4 검증 세트 인덱스:[ 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119]
    
    #5 교차 검증 정확도 :0.7333, 학습 데이터 크기: 120, 검증 데이터 크기: 30 #5 검증 세트 인덱스:[120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149]
    
    평균 검증 정확도: 0.9
- Stratified KFold : 레이블 데이터 분포도에 따라 학습/검증 데이터를 나눔 ⇒ 회귀에서는 연속형 데이터라 (not 이산형) Stratify가 의미가 없음
  - split(features, labels): split에 피처, 레이블 데이터 모두를 입력해야 한다.
  - Stratified Kfold 사용 예시 코드
```
  iris = load_iris()
  features = iris.data
  label = iris.target

  dt_clf = DecisionTreeClassifier(random_state=156)

  skfold = StratifiedKFold(n_splits=3)
  n_iter=0
  cv_accuracy=[]

  # StratifiedKFold의 split( ) 호출시 반드시 레이블 데이터 셋도 추가 입력 필요  
  for train_index, test_index  in skfold.split(features, label):
      # split( )으로 반환된 인덱스를 이용하여 학습용, 검증용 테스트 데이터 추출
      X_train, X_test = features[train_index], features[test_index]
      y_train, y_test = label[train_index], label[test_index]
      #학습 및 예측 
      dt_clf.fit(X_train , y_train)    
      pred = dt_clf.predict(X_test)

      # 반복 시 마다 정확도 측정 
      n_iter += 1
      accuracy = np.round(accuracy_score(y_test,pred), 4)
      train_size = X_train.shape[0]
      test_size = X_test.shape[0]
      print('\n#{0} 교차 검증 정확도 :{1}, 학습 데이터 크기: {2}, 검증 데이터 크기: {3}'
            .format(n_iter, accuracy, train_size, test_size))
      print('#{0} 검증 세트 인덱스:{1}'.format(n_iter,test_index))
      cv_accuracy.append(accuracy)

  # 교차 검증별 정확도 및 평균 정확도 계산 
  print('\n## 교차 검증별 정확도:', np.round(cv_accuracy, 4))
  print('## 평균 검증 정확도:', np.mean(cv_accuracy))
```
  - Stratified Kfold 사용 예시 코드 결과
    
    #1 교차 검증 정확도 :0.98, 학습 데이터 크기: 100, 검증 데이터 크기: 50 #1 검증 세트 인덱스:[ 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115]
    
    #2 교차 검증 정확도 :0.94, 학습 데이터 크기: 100, 검증 데이터 크기: 50 #2 검증 세트 인덱스:[ 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132]
    
    #3 교차 검증 정확도 :0.98, 학습 데이터 크기: 100, 검증 데이터 크기: 50 #3 검증 세트 인덱스:[ 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149]
    
    교차 검증별 정확도: [0.98 0.94 0.98]
    
    평균 검증 정확도: 0.9666666666666667
- cross_val_score(estimator, feartures, labels, scoring=단일_예측성능_평가지표, cv=교차검증_폴드수) : 교차 검증 편하게 used Stratified KFold
- cross_validation(estimator, feartures, labels, scoring=[복수_예측성능_평가지표], cv=교차검증_폴드수): 여러 개의 평가지표를 반환

GridSearchCV(estimator, param_grid=파라미터 값 딕셔너리, scoring=평가지표, cv=분할되는 학습/테스트 세트 개수, refit=True) : 교차 검증 + 최적 파라미터 튜닝을 한 번에

refit : 최적 하이퍼 파라미터로 재학습한다. ⇒ default가 True임

cf) 평가지표들

  from sklearn.metrics import SCORERS
  SCORERS.keys()

GridSearchCV 사용 예시 코드


  dtree = DecisionTreeClassifier()

  # parameter 들을 dictionary 형태로 설정
  parameters = {'max_depth':[1,2,3], 'min_samples_split':[2,3]}

  grid_dtree = GridSearchCV(dtree, param_grid=parameters, scoring='accuracy' , cv=3, refit=True)
  # 이렇게 multi-metric 줄 수도 있음 => refit을 어떤 metric으로 할지 설정해줘야함
  grid_dtree = GridSearchCV(dtree, param_grid=parameters, scoring=['accuracy', 'r2'] , cv=3, refit='accuracy')

  # 붓꽃 Train 데이터로 param_grid의 하이퍼 파라미터들을 순차적으로 학습/평가 .
  grid_dtree.fit(X_train, y_train)

  # GridSearchCV 결과 추출하여 DataFrame으로 변환
  scores_df = pd.DataFrame(grid_dtree.cv_results_)
  scores_df[['params', 'mean_test_score', 'rank_test_score', \
             'split0_test_score', 'split1_test_score', 'split2_test_score']]

  print('GridSearchCV 최적 파라미터:', grid_dtree.best_params_)
  print('GridSearchCV 최고 정확도: {0:.4f}'.format(grid_dtree.best_score_))

  # GridSearchCV의 refit으로 이미 학습이 된 estimator 반환
  estimator = grid_dtree.best_estimator_

  # GridSearchCV의 best_estimator_는 이미 최적 하이퍼 파라미터로 학습이 됨
  pred = estimator.predict(X_test)
  print('테스트 데이터 세트 정확도: {0:.4f}'.format(accuracy_score(y_test,pred)))

3. 데이터 전처리

: 사이킷런 머신러닝에서 문자열과 NaN은, 입력값이 될 수 없다 → 숫자형이어야만 함 → 인코딩이 필수적

3.1.레이블 인코딩 (Label encoding) : 카테고리 피처를 코드형 숫자값으로 변환

LabelEncoder() : 객체생성 → fit_transform() ← inverse_transform() : 디코딩

레이블 인코딩 과정

  from sklearn.preprocessing import LabelEncoder

  items=['TV','냉장고','전자렌지','컴퓨터','선풍기','선풍기','믹서','믹서']

  # LabelEncoder를 객체로 생성한 후 , fit( ) 과 transform( ) 으로 label 인코딩 수행. 
  encoder = LabelEncoder()
  encoder.fit(items)
  labels = encoder.transform(items)

  print('인코딩 변환값:',labels)
  print('인코딩 클래스:',encoder.classes_)
  print('디코딩 원본 값:',encoder.inverse_transform([4, 5, 2, 0, 1, 1, 3, 3]))

인코딩 변환값: [0 1 4 5 3 3 2 2] 인코딩 클래스: ['TV' '냉장고' '믹서' '선풍기' '전자렌지' '컴퓨터'] 디코딩 원본 값: ['전자렌지' '컴퓨터' '믹서' 'TV' '냉장고' '냉장고' '선풍기' '선풍기']

inverse_transform(): 디코딩
Label Encoding은 숫자의 크기에 따라 순서나, 중요도 등의 가중치로 반영될 수 있으므로, 선형회귀와 같은 ML 알고리즘에는 적용되지 않아야 함
트리 계열의 ML 알고리즘은 숫자의 이러한 특성을 반영하지 않으므로, 레이블 인코딩도 별 문제가 없음

3.2. 원-핫 인코딩 (One-Hot encoding) : 피처 값의 유형에 따라 고유 값에 해당 칼럼만 1 표시 / 나머지는 0

원-핫 인코더로 변환하기 전, 모든 문자열 값이 숫자형 값으로 변환 돼야 한다 (used by LabelEncoder())
- == 원-핫 인코더의 input으로 숫자형이 와야한다
입력값으로 2차원 데이터가 필요하다는 것 (used by reshape(-1, 1))
LabelEncoder() : 객체생성 → fit_transform() → labels.reshape(-1, 1) → OneHotEncoder() → fit_transform()← inverse_transform() : 디코딩

원-핫 인코딩 과정

  items=['TV','냉장고','전자렌지','컴퓨터','선풍기','선풍기','믹서','믹서']

  # 먼저 숫자값으로 변환을 위해 LabelEncoder로 변환합니다. 
  encoder = LabelEncoder()
  encoder.fit(items)
  labels = encoder.transform(items)

  # 2차원 데이터로 변환합니다. 
  labels = labels.reshape(-1,1)
  print(labels.transpose())

  # 원-핫 인코딩을 적용합니다. 
  oh_encoder = OneHotEncoder()
  oh_encoder.fit(labels)
  oh_labels = oh_encoder.transform(labels)

  print('원-핫 인코딩 데이터')
  print(oh_labels) # 1이 있는 좌표를 표시하는 matrix로 반환하는 구나
  print(type(oh_labels))
  print(oh_labels.toarray())

  print('원-핫 인코딩 데이터 차원')
  print(oh_labels.shape)

[[0 1 4 5 3 3 2 2]]

원-핫 인코딩 데이터 (0, 0) 1.0 (1, 1) 1.0 (2, 4) 1.0 (3, 5) 1.0 (4, 3) 1.0 (5, 3) 1.0 (6, 2) 1.0 (7, 2) 1.0 [[1. 0. 0. 0. 0. 0.] [0. 1. 0. 0. 0. 0.] [0. 0. 0. 0. 1. 0.] [0. 0. 0. 0. 0. 1.] [0. 0. 0. 1. 0. 0.] [0. 0. 0. 1. 0. 0.] [0. 0. 1. 0. 0. 0.] [0. 0. 1. 0. 0. 0.]]

원-핫 인코딩 데이터 차원 (8, 6)

원본 데이터 : 8개의 레코드와 1개의 칼럼을 가진 원본 데이터 (index=각 상품명들, col=상품분류)가
원핫 인코딩으로 : 8개의 레코드와 6개의 칼럼을 가진 데이터로 최종 변환

3.3. 판다스의 `get_dummies()` 로 원-핫 인코딩 바로 하기

사이킷런의 원핫인코더와 다르게, 문자열 카테고리 값을 숫자형으로 변환할 필요 없이 바로 변환 가능
```
  import pandas as pd

  df = pd.DataFrame({'item':['TV','냉장고','전자렌지','컴퓨터','선풍기','선풍기','믹서','믹서'] })
  pd_oh = pd.get_dummies(df)
  print(type(pd_oh))
  pd_oh.astype('float64').values.tolist()
```
[[1.0, 0.0, 0.0, 0.0, 0.0, 0.0], [0.0, 1.0, 0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0, 1.0, 0.0], [0.0, 0.0, 0.0, 0.0, 0.0, 1.0], [0.0, 0.0, 0.0, 1.0, 0.0, 0.0], [0.0, 0.0, 0.0, 1.0, 0.0, 0.0], [0.0, 0.0, 1.0, 0.0, 0.0, 0.0], [0.0, 0.0, 1.0, 0.0, 0.0, 0.0]]

3.4. 피처 스케일링과 정규화

3.4.1. Standardization 표준화: 가우시안 정규분포로 변환 (평균 0, 분산 1)

$x_i$_new $= \frac{x_i-mean(x)}{std(x)} = \frac{x-평균}{표준편차}$

StandarScaler() 객체 생성 → fit() → transform()

  from sklearn.preprocessing import StandardScaler

  # StandardScaler객체 생성
  scaler = StandardScaler()
  # StandardScaler 로 데이터 셋 변환. fit( ) 과 transform( ) 호출.  
  scaler.fit(iris_df)
  iris_scaled = scaler.transform(iris_df)

  #transform( )시 scale 변환된 데이터 셋이 numpy ndarry로 반환되어 이를 DataFrame으로 변환
  iris_df_scaled = pd.DataFrame(data=iris_scaled, columns=iris.feature_names)
  print('feature 들의 평균 값')
  print(iris_df_scaled.mean())
  print('\nfeature 들의 분산 값')
  print(iris_df_scaled.var())

feature 들의 평균 값 sepal length (cm) -1.690315e-15 # == 0에 수렴 sepal width (cm) -1.637024e-15 petal length (cm) -1.482518e-15 petal width (cm) -1.623146e-15 dtype: float64

feature 들의 분산 값 sepal length (cm) 1.006711 == 1에 수렴 sepal width (cm) 1.006711 petal length (cm) 1.006711 petal width (cm) 1.006711 dtype: float64

3.4.2. Normalization 정규화: 피처 크기를 동일구간으로 변환 (0~~1 사이값, 음수가 있으면 -1~~1)

$x_i$_new $= \frac{x_i-min(x)}{max(x)-min(x)} = \frac{x-최솟값}{최댓값-최솟값}$ : 일반적인 정규화 식

$x_i$_new $= \frac{x_i}{\sqrt{x_i^2 + y_i^2 + z_i^2}}$ : 사이킷런 Normalizer 모듈의 정규화 식

MinMaxScaler() 객체 생성 → fit() → transform()

  from sklearn.preprocessing import MinMaxScaler

  # MinMaxScaler객체 생성
  scaler = MinMaxScaler()
  # MinMaxScaler 로 데이터 셋 변환. fit() 과 transform() 호출.  
  scaler.fit(iris_df)
  iris_scaled = scaler.transform(iris_df)

  # transform()시 scale 변환된 데이터 셋이 numpy ndarry로 반환되어 이를 DataFrame으로 변환
  iris_df_scaled = pd.DataFrame(data=iris_scaled, columns=iris.feature_names)
  print('feature들의 최소 값')
  print(iris_df_scaled.min())
  print('\nfeature들의 최대 값')
  print(iris_df_scaled.max())

feature들의 최소 값 sepal length (cm) 0.0 sepal width (cm) 0.0 petal length (cm) 0.0 petal width (cm) 0.0 dtype: float64

feature들의 최대 값 sepal length (cm) 1.0 sepal width (cm) 1.0 petal length (cm) 1.0 petal width (cm) 1.0 dtype: float64

데이터의 분포가 가우시안이 아닐 경우에, MinMaxScaler를 적용해볼 수 있음

![](https://velog.velcdn.com/images/mios_leo/post/ca0052b0-e41e-426c-a35c-b353baf9bc7a/image.png)

4. 정리

데이터 가공 및 변환(전처리)
- 데이터 클렌징
- 인코딩
- 스케일링, 정규화
데이터세트 분리
- 교차검층 수행
- KFold
  - kfold = KFold(estimator,
- StratifiedKFold
- cross_val_score
  - cross_val_score(estimator, X_data, y_label, cv=n )
    - 최적의 하이퍼 파라미터를 위해 GridSearchCV
학습
예측
평가

파이썬 머신러닝 완벽 가이드 - 2. Pandas

Mon, 26 Sep 2022 02:46:41 GMT

🗂 Pandas 판다스

1. 데이터 읽기 및 확인

read_csv() : ,, read_table() : \t, read_fwf() : 고정길이 파일
value_counts(): 해당 칼럼 값의 유형과 건수 확인 (Series 객체에만 정의)
describe() : agg류 연산 보여줌

2. 데이터 변환

2.1. list, ndarray, dictionary를 DataFrame으로 변환하기

2차원 이하의 데이터들만 변환 가능
생성인자로 list, ndarray, dictionary 입력
- list, ndarray는 컬러명 지정해줘야 함 ⇒ 안해줘도 defalut로 만들어지긴 함

2.2. DataFrame ⇒ list, ndarray, dictionary 로 변환하기

list 로 변환하기
- values()로 얻은 ndarray에 또 다시 tolist() 호출
- DataFrame → ndarray → list 과정
ndarray로 변환하기
- values()
- 머신러닝 패키지의 입력인자로 적용하기 위해 다시 ndarray로 변환하는 경우 빈번
dictionary 로 변환하기
- DataFrame 객체에 to_dict() 호출 ⇒ dict의 value 값이 또다시 idx:val인 이중 dict으로 나옴
- to_dict(’list’)로 호출하면 ⇒ dict의 value 값이 리스트( [] )로 나옴

3. 데이터 수정, 인덱싱, 정렬, groupby()

3.1. 데이터 삭제

drop('삭제할 칼럼명', axis=0, inplace=False)
- 삭제할 축 설정: axis=0은 row, axis=1은 column
- inplace: False는 자기 자신의 데이터를 삭제하지 않고, 삭제된 결과를 반환. True는 자기 자신의 데이터를 삭제하고 None을 반환
- axis = 0 으로 row drop : df.drop([0,1,2], axis=0)

3.2 Index 객체

df.index: index 추출
- print(type(indexes)) print(type(indexes.values)) print(indexes.values.shape) print(indexes[:5].values) print(indexes.values[:5]) print(indexes[6])
- (891,) [0 1 2 3 4] [0 1 2 3 4] 6*
- indexes[0] = 5 : error ⇒ 한번 만들어진 Index 객체는 함부로 변경할 수 없음
- Series 객체는 Index 객체를 포함하지만, 연산 함수를 적용할 때는 Index는 연산에서 제외되고, Index 객체는 오직 식별용으로만 사용 됨
reset_index()
- 새로운 연속 숫자형 인덱스 생성. 기존 인덱스는 index 칼럼명으로 추가됨
- drop=True로 설정하면 기존 인덱스는 추가되지 않고 삭제됨
- Series에 rest_index() 를 적용하면, Series가 아닌, DataFrame으로 반환됨 ⇒ 기존 인덱스가 칼럼으로 추가 되어, 칼럼이 2개가 됨
  - drop=True로 하면 기존 인덱스 칼럼이 날아가서, Series로 반환 됨
- df.index = df.index+1 으로 새로운 index값 생성해서, index 재할당이 가능

3.3. 데이터 셀렉션 및 필터링

3.3.1. [ ] 연산자 ⇒ 단일 컬럼 데이터 추출 : df['col'], 여러 컬럼 데이터 추출 : df[['col_1', ‘col_2’]]

안에 숫자 index는 KeyError 오류 발생 ⇒ df[0]
단, 숫자 index가 pandas default index 형태면 가능 ⇒ df[0:2]

3.3.2. column [명칭] 기반 인덱싱과 column [위치] 기반 인덱싱의 구분

3.3.2.1. column [명칭] 기반 인덱싱 : df.loc[시작점:종료점] ⇒ 여기서 인덱싱 시작점과 종료점 모두 (-1 없이) 다 포함(명칭 기반이기에)

loc[]: 명칭 기반 인덱싱으로 행은 index값, 열은 column명 입력
- df.loc['one', 'Year']
index*가 *pandas default index 형태면 df.loc[ ]에 숫자형을 줘도 됨
- df.loc[1, 'Year']
- 이때, index=0은 없음 ⇒ (0, 0)의 빈자리임
loc['A':'Z', 'Name'] : 명칭의 슬라이싱도 가능
궁극적으로 아래의 세 가지가 모두 가능 ⇒ index가 default여서 숫자가 가능한거고, 명칭으로도 가능
- df.loc[1:2, 'Name' : 'Year']
- df.loc[1:2, ['Name', 'Year']]
- df.loc[[1,2], ['Name', 'Year']]

3.3.2.2. column [위치] 기반 인덱싱 : df.iloc[행, 렬] ⇒ 여기서는 일반적인 슬라이싱 처럼 (시작, 종료) ⇒ (시작, 종료-1)

iloc[ 0, 1:3] : 처럼 슬라이싱도 가능
- iloc[]: 위치 기반 인덱싱으로 index, column 의 위치를 입력
  - df.iloc[0,1] 만약 df.iloc['A', 0] or df.iloc[0, 'A'] 등 명칭을 입력하면 error

3.3.3. 불린 인덱싱 , 예시) (row조건) ‘Age’가 60 초과인 row에서, (컬럼) ‘Name’ 과 ‘Age’ 인덱싱

titanic_df[titanic_df[’Age’] > 60][['Name', 'Age']] : “인덱싱 ” df[조건(에맞는row)][칼럼명]
titanic_df.loc[titanic_df['Age'] > 60.0 , ['Name','Age']] : “명칭 loc“ df.loc[조건(에 맞는row)[칼럼명]
불린 인덱싱 종류 ( and & , or | , not ~ )
- titanic_df[ (titanic_df['Age'] > 60) & (titanic_df['Pclass']==1) & (titanic_df['Sex']=='female') ] : 불린으로 row 조건걸기
  - titanic_df[ (titanic_df['Age'] > 60) & (titanic_df['Pclass']==1) & (titanic_df['Sex']=='female') ] ['Name'] : col 명 인덱싱
- titanic_df.loc[ (titanic_df['Age'] > 60) & (titanic_df['Pclass']==1) & (titanic_df['Sex']=='female') ] : loc로 row에 조건걸기
  - titanic_df.loc[ (titanic_df['Age'] > 60) & (titanic_df['Pclass']==1) & (titanic_df['Sex']=='female') ] ['Name] : col 명 인덱싱
- 조건을 할당해서 적용할 수도 있음
  - cond1 = titanic_df['Age'] > 60 cond2 = titanic_df['Pclass']==1 cond3 = titanic_df['Sex']=='female' titanic_df[ cond1 & cond2 & cond3]
자주 쓸 것을 요점정리 하자면
- df.loc[조건 , [cols]]
- df[조건][[cols]]

3.3.4. 정렬, Aggregation함수, GroupBy 적용

DataFrame, Series의 정렬 ⇒ sort_values()
- sort_values(by=['칼럼명'], ascending=True, inplace=False)
DataFrame에서 Aggregation 호출하면 ⇒ 모든 칼럼에 해당 aggregation이 적용됨
- df.count()
- df[['Age', 'Fare']].mean()
- df['Age'].mean() : Series에 mean 적용
GroupBy + Agg 호출하면 ⇒ groupby( ) 대상 칼럼 제외한 모든 칼럼에 해당 agg 함수 적용됨
- titanic_df.groupby(by='Pclass') : 타입은 DataFrameGroupBy로 객체만 반환
- titanic_df.groupby('Pclass')['Age'].count() : 이 객체에 다음과 같이 agg 함수를 적용해야함
  - 단독으로 위의 예시처럼도 사용 가능하고
  - titanic_df.groupby('Pclass')['Age'].agg([max, min]) : agg를 호출해서 여러개 적용도 가능
서로 다른 column에, 서로 다른 agg 함수 넣기 ← dict으로 지정해서 넣어야 함 : groupby에서 호출하려면 SQL에 비해 조금 복잡함
- SQL ⇒ Select max(Age), sum(SibSP), avg(Fare) From titanic_table group by Pclass
- Pandas ⇒ `agg_format={'Age':'max', 'SibSp':'sum', 'Fare':'mean'}
```
     titanic_df.groupby('Pclass').agg(agg_format)`
                                   OR
           `titanic_df.groupby('Pclass').agg({'Age':'max', 'SibSp':'sum', 'Fare':'mean'})`
```

4. 결손 데이터 처리

isna(): NaN 결손 데이터 여부 확인 (boolean)
- isna().sum() : 각 col별로 결손 데이터 확인하기
fillna('대체할 값'): NaN 값을 대체하여 Missing 데이터 처리
- titanic_df['Age'] = titanic_df['Age'].fillna(titanic_df['Age'].mean()) titanic_df['Embarked'] = titanic_df['Embarked'].fillna('S') titanic_df.isna().sum()
apply(lambda x: 식) : apply lambda식으로 데이터 가공
- pandas에서 lambda를 쓰려면 .apply() 를 써야함
  - titanic_df['Name_len']= titanic_df['Name'].apply(lambda x : len(x))
- lambda에서 if else 조건식 쓰기
  - titanic_df['Child_Adult'] = titanic_df['Age'].apply(lambda x : 'Child' if x <=15 else 'Adult' )
- lambda에서 if else (if else) 이중 쓰기
  - titanic_df['Age_cat'] = titanic_df['Age'].apply(lambda x : 'Child' if x<=15 else ('Adult' if x <= 60 else 'Elderly'))
- 너무 많으면 그냥 함수를 따로 만들어라

99. DataFrame 크기 조정

pd.options.display.max_rows = None : 전체 보기, None 대신 숫자 지정
pd.options.display.max_columns = None : 전체 보기, None 대신 숫자 지정

파이썬 머신러닝 완벽 가이드 - 1. Numpy

Mon, 26 Sep 2022 02:24:44 GMT

🧮 Numpy 넘파이

1. 데이터 생성 및 수정

데이터 타입: ndarray
array(): 인자를 받아 ndarray로 변환
arange(): 연속된 숫자(정수)를 ndarray로 변환

예) np.arange(10): 0~9의 숫자를 ndarray로 만듦
zeros(): shape 값을 입력하면 0으로 채운 뒤 해당 shape를 가진 ndarray를 반환 예) np.zeros((3,2))
ones(): shape 값을 입력하면 1로 채운 뒤 해당 shape를 가진 ndarray를 반환
reshape(): 차원, 크기 변환 예) array1.reshape(2, 5)

2. 인덱싱 indexing

단일값
슬라이싱
- array2d[ :2, 0 ] : 한 쪽은 슬라이싱, 한쪽은 단일을 적용해도 된다.
팬시 인덱싱 : 리스트나 ndarray로 인덱스 집합을 지정하면, 해당 위치의 인덱스에 해당하는 ndarray를
- array2d[ [0, 1], 0:2 ] 반환하는 인덱싱 방식
불린 인덱싱: [ ] 안에 array1d > 5 Boolean indexing을 적용
- array3 = array1d[ array1d > 5 ] : [ ] 안에 조건 넣기
- boolean_indexes = np.array([False, False, False, False, False, True, True, True, True]) array3 = array1d[boolean_indexes] : 위의 거랑 같음
- indexes = np.array([5,6,7,8]) array4 = array1d[ indexes ] : 위의 거랑 같음

3. 데이터 정렬 - sort( )와 argsort( )

행렬 정렬(기본적으로 list와 비슷)
- np.sort(ndarray) : 원행렬은 유지, 정렬된 행렬 반환 ⇒ 기본 오름차순, [::-1]로 내림차순
  - np.sort( )[::-1] : 내림 차순 정렬시 슬라이싱 사용
- ndarray.sort( ) : 원행렬을 정렬, None 반환(원행렬을 sort하여 inplace 됨)
  - ndarray[::-1].sort( ) : 사실상 슬라이싱으로 순서를 바꾸는 거
2차원 이상 행렬 정렬 : axis값 이용해서 row 방향, col 방향 정렬
- sort_array2d_axis0 = np.sort(array2d, axis=0) : row 방향 정렬 (axis=0)
- sort_array2d_axis1 = np.sort(array2d, axis=1) : col 방향 정렬 (axis=1)
정렬 행렬의 인덱스 반환 : 원본 행렬이 정렬 됐을 때, 기존 행렬 원소에 대한 인덱스가 피요할 때
- np.argsort(ndarray): 원본 행렬 정렬 시, 행렬 인덱스 값 반환
  - org_array = np.array([ 3, 1, 9, 5]) sort_indices = np.argsort(org_array) print(type(sort_indices)) print('행렬 정렬 시 원본 행렬의 인덱스:', sort_indices)
  - 행렬 정렬 시 원본 행렬의 인덱스: [1 0 3 2]*
- np.argsort(ndarray)[: : -1] : 원본 행렬 내림차순 정렬시, 행렬 인덱스 값 반환
  - org_array = np.array([ 3, 1, 9, 5]) sort_indices_desc = np.argsort(org_array)[::-1] print('행렬 내림차순 정렬 시 원본 행렬의 인덱스:', sort_indices_desc)
  - 행렬 내림차순 정렬 시 원본 행렬의 인덱스: [2 3 0 1]*
- RDBMS의 TABLE 칼럼이나 Pandas의 DataFrame 칼럼과 같은 메타 데이터 갖기 어려우므로, [실제 값]과 [그 값이 뜻하는 메타 데이터]를 별도의 ndarray로 각각 가져야 함
  - # [그 값이 뜻하는 메타 데이터] name_array = np.array(['John', 'Mike', 'Sarah', 'Kate', 'Samuel']) # [실제 값] score_array= np.array([78, 95, 84, 98, 88])
    
    sort_indices_asc = np.argsort(score_array) print('성적 오름차순 정렬 시 score_array의 인덱스:', sort_indices_asc) print('성적 오름차순으로 name_array의 이름 출력:', name_array[sort_indices_asc])
  - 성적 오름차순 정렬 시 score_array의 인덱스: [0 2 4 1 3]
    
    성적 오름차순으로 name_array의 이름 출력: ['John' 'Sarah' 'Samuel' 'Mike' 'Kate']*

4. 선형대수 연산

np.dot( A, B ): 행렬 곱(내적)
np.transpose(A): 전치 행렬

Mon, 22 Aug 2022 06:20:37 GMT

제 1장 상대에게 전달한다는 것

📍 중요한 것은 (내가 말하고 싶은 것이 아니라)

과제에 대해 상대에게 전달할 메시지

📍 메시지의 3요소

[명쾌한 과제] : 내가 답변해야 하는 것
[상대의 기대 반응]
과제에 대한 나의 [답변]

📍 상대 기대 반응의 3분류

이해시키기 : 전달 내용을 상대에게 정확하게 이해시킨다
피드백 받기 : 판단, 조언, 감상 등
행동 유도

📍 답변의 3요소 : 핵심은 상대도 명쾌하게 납득이 되어야 한다는 점

결론 : 작성자의 명확한 의견(요약)
1. 함정 1 : 하고 싶은 말 요약 X, 과제의 요약이어야 함
  → 어떤 결론에 이르렀다면, 한 번 더 과제를 확인하라
  → if ‘그래서 결론이 뭐야? ⇒ 실패
2. 함정 2 : 애매하고 주관적인 부대조건은 안됨
  → 명확히 설명할 수 없다면 문제 자체를 제대로 해결하지 못했다는 뜻
  → ex) ~에 따라서’ 와 같은 것들은 안됨
근거 : 결론의 타당성
1. 함정 1 : 인과 관계를 잘 파악해라
  → ex) ‘A가 필요하다. 왜냐하면 A가 없기 때문이다’
2. 함정 2 : 수치로 말하라 (객관성을 유지하라) (수치화가 어렵다면, 개념의 조작적 정의를 해라)
  → if ‘그것은 사실인가? 아니면 당신의 판단/가설 인가?’ ⇒ 실패
3. 함정 3 : 당연한 건 없다
  → 나만 당연하게 여기는 것일 확률이 높다
  → ex) ‘말할 것도 없고', ‘당연하다’
방법 : 결론이 행동으로 옮겨야 하는 경우의 구체성
1. 함정 1 : 타사 및 10년전에도 통할 공리는 방법이 아니다.
  → 방법은 기업에 적용할 때, 구체적으로 무엇을 해야하는지 전달해야 의미가 있음
  → ‘타사에도 통용될까?’ , ‘10년 전/후에도 통용될까?’ 자문자답하고 yes면 방법이 아니다.
2. 함정 2 : 수식어로는 구체적으로 되지 않는다.
  → 내용이 구체적이지 않으면, 여러 수식어를 붙여 내용을 부풀리고 싶은 충동에 사로잡힘
  → 답변이 구체적이지 않으면, 그 원인은 과제를 충분히 이해/분석하지 못함에 있다.
  → [Five Whys] [5W1H] 같은 방법론을 적용해보아 원인을 분석해보는 것도 방법

배민, 지난해 허위리뷰 11만건 차단…AI 시스템 도입

Tue, 02 Aug 2022 09:16:24 GMT

📰 본문

배달의민족(이하 배민) 운영사 우아한형제들은 지난해 11만4054건의 허위리뷰를 차단했다고 밝혔다. 허위리뷰는 음식의 배달 및 취식 없이 거짓으로 작성한 리뷰를 뜻한다.

배민은 허위리뷰 근절을 위해 ‘실시간 모니터링 시스템’부터 ‘자전거래 탐지’, ‘인공지능(AI)를 활용한 고도화 모델’ 등 기술적 수단을 동원해왔다. 그 결과 허위 의심 리뷰 제보건수는 지난해 연 최고점 대비 60% 이상 줄었다는 설명이다.

배민은 2020년까지만 해도 업주 및 이용자의 제보와 전담인력 검수 등에 의존해 허위리뷰를 차단했다. 회사는 2020년 11월 허위 의심 리뷰 실시간 모니터링 시스템 도입을 통해 허위 의심 리뷰 적발 속도와 정확도를 높였다. 이 시스템은 배민 앱에 등록되는 리뷰를 실시간으로 탐지해 24시간 이내 분석 및 조치를 취하는 시스템이다. 허위리뷰로 의심될 경우 자동으로 노출을 일시 제한시킨다.

배민은 실시간 모니터링 활성화 외에도 허위리뷰 근절을 위한 다양한 시스템을 가동했다. 2021년 6월부터 리뷰조작이 의심되는 업주의 데이터를 분석해 차단하는 조치를 취하고, 12월엔 AI를 활용한 고도화 모델을 탑재했다. 허위리뷰의 주문 수법이 다양해지고 복잡해짐에 따라 AI가 그간의 다양한 허위리뷰 사례를 학습, 허위 의심 리뷰를 빠르게 적발하도록 했다

배민은 리뷰 조작이 불법임을 알리고자 악성 리뷰조작 업체에 대한 고소 및 경고 작업을 진행했다. 현재까지 6건에 대한 수사가 진행 중이며, 34개 업체를 대상으로 경고 및 내용 증명을 발송했다. 지난해 5월에는 법적 대응 끝에 허위리뷰 조작 업체가 실형을 선고받기도 했다. 더불어 최근에는 리뷰 조작 업체에 대한 모니터링을 강화했다. 또 경고를 했음에도 지속적으로 유사한 행위를 하는 리뷰조작업체 대상으로 고소를 해나갈 예정이다.

이원재 우아한형제들 서비스위험관리실장은 "이용자가 믿고 볼 수 있는 리뷰 환경을 만들고자 실시간 모니터링 시스템부터 법적 대응까지 허위리뷰에 대해 강경 대응을 취하고 있다"며 "지난해말 탑재한 AI 고도화 모델을 통해 앞으로 더 빠르게 효과적으로 허위리뷰에 대응해 나갈 것이다"고 말했다.

🔎 본문 선정 이유

**📍 배민에서 허위 리뷰를 AI를 활용해 어떤 식으로 판별하는지 궁금**

📝 핵심 요약

📍 지난해 11만4054건의 허위리뷰를 차단했다고 밝혔고, **허위 의심 리뷰 제보건수는 지난해 연 최고점 대비 60% 이상 줄었다는 설명이다.**

****현재까지 6건에 대한 수사가 진행 중이며, 34개 업체를 대상으로 경고 및 내용 증명 발송 및 허위리뷰 조작 업체가 실형을 선고받기도 함****
****최근에는 리뷰조작업체에 대한 모니터링을 강화했하여 리뷰조작업체 대상으로 고소 해나갈 예정****

📍 **허위리뷰 근절을 위해 ‘실시간 모니터링 시스템’부터 ‘자전거래 탐지’, ‘인공지능(AI)를 활용한 고도화 모델’ 등 기술적 수단을 동원해왔다.**

**배민은 실시간 모니터링 활성화 외에도 허위리뷰 근절을 위한 다양한 시스템을 가동했다.**
**2021년 6월부터 리뷰조작이 의심되는 업주의 데이터를 분석해 차단하는 조치를 취하고,**
**12월엔 AI를 활용한 고도화 모델을 탑재했다.**

📚 추가 조사할 내용

📍 어떤 알고리즘 혹은 기준으로 허위 리뷰를 구별할까?

[못 믿을 음식 리뷰...배민, 가짜 리뷰 어떻게 적발하나

배달 애플리케이션(앱)으로 음식을 주문할 때 눈여겨보게 되는 리뷰. 맛이 없다거나 위생이나 응대 서비스가 좋지 않았다는 리뷰를 보게 되면 그 식당에서는 당연히 주문을 하기 꺼려진다. 반면

www.edaily.co.kr](https://www.edaily.co.kr/news/read?newsId=03968806625864368&mediaCodeNo=257)

" 결국 배민은 ‘부정거래감시팀’이라는 전담조직을 두고 리뷰를 지속적으로 모니터링 했다. 인공지능(AI) 기술을 활용한 리뷰 검수 기능도 도입했다. 리뷰 자동 탐지 시스템으로 주문대비 리뷰 작성률이 지나치게 높거나 단기간에 리뷰가 급증한 음식점을 골라낸 후 검수 전담 인력이 직접 리뷰를 세밀하게 살피는 방법이다. "

[배달의민족, 허위 리뷰 사전 차단 시스템 도입 - 디지털투데이 (DigitalToday)

[디지털투데이 정유림 기자] 배달앱 배달의민족을 운영하는 우아한형제들(대표 김범준)이 허위로 의심되는 리뷰(후기)를 사전에 자동 탐지하는 실시간 모니터링 시스템을 도입한다고 24일 밝혔

www.digitaltoday.co.kr](https://www.digitaltoday.co.kr/news/articleView.html?idxno=254065)

" 기존에는 거짓 주문을 발생시켜 지어낸 후기, 대행 업체가 쓴 리뷰 등이 앱에 등록된 다음에야 이를 찾아내 차단할 수 있었다. 그러나 이제는 이용자가 리뷰 작성 완료 버튼을 누르는 순간, 시스템이 허위 여부를 실시간으로 판별하도록 했다. 허위가 의심되면 아예 등록되지 않도록 조치했으며 이를 위해 주문 기록, 이용 현황 등을 분석한다는 설명이다 "

📍 허위 리뷰 업체는 어떤 정보의 처벌을 받았을까?

[‘허위리뷰 실형 판결’ 받아낸 배달의민족, 클린리뷰 문화 정착 선도 - 업다운뉴스

[업다운뉴스 김민주 기자] 음식점의 의뢰를 받아 300차례 넘게 허위 리뷰를 작성한 혐의로 재판에 넘겨진 업자 A씨에게 최근 실형이 확정된 사실이 유통업계에서 주목을 받는다. 국내 배달앱 시

www.updownnews.co.kr](http://www.updownnews.co.kr/news/articleView.html?idxno=231930)

" 배달의민족 운영사인 우아한형제들은 지난해 11월 서울동부지방법원에서 징역 10월형을 선고받은 A씨가 항소했지만 법원은 최근 이를 기각하면서 원심이 최종 확정됐다고 지난 25일 밝혔다. "

📍 실형을 받을 정도로 심각해진 **리뷰, 다른 업체들은 어떻게 대처해나가고 있을까?**

[‘인공지능’으로 <가짜 리뷰와의 전쟁> 나선 5개 IT스타트업

가짜, 허위를 근절해 세상을 건강하게 바꾸려는 기업들이 있다. ‘진짜 제품’, ‘진짜 리뷰’. 이를 골라내는 일은 바로 인공지능(AI)이 한다. 인공지능 기술을 활용해 ‘가짜와의 전쟁’을 펼

www.top3.kr](https://www.top3.kr/entry/%E2%80%98%EC%9D%B8%EA%B3%B5%EC%A7%80%EB%8A%A5%E2%80%99%EC%9C%BC%EB%A1%9C-%EA%B0%80%EC%A7%9C-%EB%A6%AC%EB%B7%B0%EC%99%80%EC%9D%98-%EC%A0%84%EC%9F%81-%EB%82%98%EC%84%A0-5%EA%B0%9C-IT%EC%8A%A4%ED%83%80%ED%8A%B8%EC%97%85)

" 인공지능 기술을 활용해 ‘가짜와의 전쟁’을 펼치는 대표적인 IT회사로 마크비전, 당근마켓, 인덴트코퍼레이션과 같은 스타트업부터, 배달의민족, 카카오 등 규모급 기업에 이르기까지 다양한 곳에서 건전한 생태계와 시장 환경 조성에 발벗고 나서며 이용자 보호에 힘을 쏟고 있다. "

[거짓, 가짜, 그리고 AI

거짓리뷰와 제한된 게시글을 탐지하고 가짜를 신고하는 인공지능 | #17. 인공지능이 활용되는 분야별로 대표성을 띈 사례들을 차근차근, 꾸준히 정리해보려 한다. 이번 글에서는 인공지능을 활

brunch.co.kr](https://brunch.co.kr/@monglec/64)

[##Image|kage@b2jPIn/btrzDu1DayA/KlkOkITuD1AMuFHJlXKoY0/img.png|CDM|1.3|{"originWidth":1432,"originHeight":1162,"style":"widthContent","caption":"출처 : 마크비전 사이트"}##]

📰 기사 원문

[배민, 지난해 허위리뷰 11만건 차단…AI 시스템 도입

배달의민족(이하 배민) 운영사 우아한형제들은 지난해 11만4054건의 허위리뷰를 차단했다고 밝혔다. 허위리뷰는 음식의 배달 및 취식 없이 거짓으..

it.chosun.com](http://it.chosun.com/m/svc/article.html?contid=2022041101577&utm_source=undefined&utm_medium=unknown&utm_campaign=itchosun)