jaam_mini.log

ML - 15. 자연어 처리 NLP (Natural Language Processing)

Thu, 01 Feb 2024 03:33:55 GMT

install

# 가장 최신 버전으로 유지
!conda update conda
!pip install --upgrade pip
# 한글 자연어 처리 패키지
!pip install konlpy
!pip install tweepy==3.10.0
!conda install -y -c conda-forge jpype1==1.0.2
!conda install -y -c conda-forge wordcloud
!conda install -y nltk
!conda install -y scikit-learn

import nltk
nltk.download()

from konlpy.tag import Okt
t = Okt()

Kkma

from konlpy.tag import Kkma
kkma = Kkma()

# 문장(sentences)
kkma.sentences('한국어 분석을 시작합니다 재미있어요 ~')

['한국어 분석을 시작합니다', '재미있어요 ~']

# 명사(nouns)
kkma.nouns('한국어 분석을 시작합니다 재미있어요 ~')

['한국어', '분석']

# 형태소분석(pos)
kkma.pos('한국어 분석을 시작합니다 재미있어요 ~')

[('한국어', 'NNG'), ('분석', 'NNG'), ('을', 'JKO'), ('시작하', 'VV'), ('ㅂ니다', 'EFN'), ('재미있', 'VA'), ('어요', 'EFN'), ('~', 'SO')]

Hannanum

from konlpy.tag import Hannanum
hannanum = Hannanum()

hannanum.nouns('한국어 분석을 시작합니다 재미있어요 ~')

['한국어', '분석', '시작']

hannanum.morphs('한국어 분석을 시작합니다 재미있어요 ~')

['한국어', '분석', '을', '시작', '하', 'ㅂ니다', '재미있', '어', '요', '~']

hannanum.pos('한국어 분석을 시작합니다 재미있어요 ~')

[('한국어', 'N'), ('분석', 'N'), ('을', 'J'), ('시작', 'N'), ('하', 'X'), ('ㅂ니다', 'E'), ('재미있', 'P'), ('어', 'E'), ('요', 'J'), ('~', 'S')]

Okt

# UserWarning: "Twitter" has changed to "Okt" since KoNLPy v0.4.5. warn('"Twitter" has changed to "Okt" since KoNLPy v0.4.5.')
from konlpy.tag import Okt
t = Okt()

t.nouns('한국어 분석을 시작합니다 재미있어요 ~')

['한국어', '분석', '시작']

t.morphs('한국어 분석을 시작합니다 재미있어요 ~')

['한국어', '분석', '을', '시작', '합니다', '재미있어요', '~']

t.pos('한국어 분석을 시작합니다 재미있어요 ~')

[('한국어', 'Noun'), ('분석', 'Noun'), ('을', 'Josa'), ('시작', 'Noun'), ('합니다', 'Verb'), ('재미있어요', 'Adjective'), ('~', 'Punctuation')]

1.워드클라우드 wordcloud

중요하지 않은 영어 단어들을 제거하는 역할

from wordcloud import WordCloud, STOPWORDS
import numpy as np
from PIL import Image

# 소설 읽어오기
text = open("./15. alice.txt").read()
# 이미지 읽어오기
alice_mask = np.array(Image.open("./15. alice_mask.png"))
# said 단어 제거
stopwords = set(STOPWORDS)
stopwords.add('said')

import platform
import matplotlib.pyplot as plt
from matplotlib import font_manager, rc

path = "c:/Windows/Fonts/malgun.ttf"

if platform.system() == "Darwin":
  print("Hangle OK in your MAC!!!")
  rc("font", family="AppleGothic")
elif platform.system() == "Windows":
  font_name = font_manager.FontProperties(fname=path).get_name()
  print("Hangle OK in your Windows!!!")
  rc("font", family=font_name)
else:
  print("Sorry, Unkwnown System")

plt.rcParams["axes.unicode_minus"] = False

Hangle OK in your Windows!!!

plt.figure(figsize=(8,8))
plt.imshow(alice_mask, cmap=plt.cm.gray, interpolation='bilinear')
# plt.axis('off')
plt.show()

# WordCloud 모듈은 자체적으로 단어를 추출해서 빈도수를 조사하고 정규화하는 기능을 가지고 있다
wc = WordCloud(
    background_color='white', max_words=2000, mask=alice_mask, stopwords=stopwords
)
wc = wc.generate(text)
wc.words_

plt.figure(figsize=(8,8))
plt.imshow(wc,interpolation='bilinear')
# plt.axis('off')
plt.show()

Twitter

import nltk
from konlpy.corpus import kobill

files_ko = kobill.fileids()
doc_ko = kobill.open('1809890.txt').read()
doc_ko

명사분석

from konlpy.tag import Okt

t = Okt()
token_ko = t.nouns(doc_ko)
token_ko # 명사 단어들의 집합

빈도수분석

ko = nltk.Text(token_ko, name='육아휴직법')

#token_ko : 명사 단어들의 집합

# 이 문자열 단위 : token
print(len(ko.tokens)) # 사용된 단어들
print(len(set(ko.tokens))) # 중복 제외 단어들
ko.vocab() # 어떤 단어들이 있나요? : vocab(단어의 집합)

plt.figure(figsize=(12,6))
ko.plot(50)
plt.show()

# 제거할 글자들
stop_words = [
    '의',    '.',    '(',    ')',    ',',    '%',    '-',    'X',    ').',    'x',    '의',
    '안',    '번',    '호',    '발',    '의',    '자',    '가',    '를',    '만',    '을',
    '다',    '인',    '김',    '태',    '완',    '및',    '정',    '문',    '종',    '팀',
    '장',    '위',    '의 ',    '호']
ko = [each_word for each_word in ko if each_word not in stop_words]
ko

ko = nltk.Text(ko, name='대한민국 국회 의안 제 1809890호')
plt.figure(figsize=(12,6))
ko.plot(50)
plt.show()

특정단어 빈도수 조사/조회

ko.count('고용')

plt.figure(figsize=(12,6))
ko.dispersion_plot(['육아휴직','자녀','고용']) # dispersion_plot : 어디쯤에 위치한지 알려줌

ko.concordance('고용') # 좌우 글자를 보여줘, 문맥을 파악하는데 도움을 줌

연관있어보이는 단어들 출력

ko.collocations()

워드클라우드 출력


data = ko.vocab().most_common(150)

# WordCloud 모듈은 자체적으로 단어를 추출해서 빈도수를 조사하고 정규화하는 기능을 가지고 있다
wordcloud = WordCloud(
    font_path = "c:/Windows/Fonts/malgun.ttf",
    relative_scaling=0.2, # 글자 간격
    background_color='white'
).generate_from_frequencies(dict(data))

plt.figure(figsize=(12,8))
plt.imshow(wordcloud)
plt.axis('off')
plt.show()

2. 나이브베이즈 분류

나이브베이즈 분류를 이용한 감성분석

✍🏻 영어 ver.

from nltk.tokenize import word_tokenize
import nltk

train = [
    ('i like you', 'pos'),
    ('i hate you', 'neg'),
    ('you like me', 'neg'),
    ('i like her', 'pos')
]

말뭉치 만들기

train[0]

'i like you'

sentence = train[0]
word_tokenize(sentence[0]) #word_tokenize : 글자 분리

['i', 'like', 'you']

# set 명령으로 인해 중복 없이 출력
all_words = set(
    word.lower() for sentence in train for word in word_tokenize(sentence[0])
)
all_words

{'hate', 'her', 'i', 'like', 'me', 'you'}

말 뭉치에서 각 단어 유무 파악

train 에서 x(=문장)를 하나씩 가져올 것임
x[0](첫문장의 첫번쨰 것)을 띄어쓰기로 분리(word_tokenize)하고,
all_words에 있는 모든 단어(word)를 가지고 2.에 있는지 확인

t = [({word: (word in word_tokenize(x[0])) for word in all_words}, x[1]) for x in train]
t

[({'her': False, 'i': True, 'me': False, 'like': True, 'you': True, 'hate': False}, 'pos'), ({'her': False, 'i': True, 'me': False, 'like': False, 'you': True, 'hate': True}, 'neg'), ({'her': False, 'i': False, 'me': True, 'like': True, 'you': True, 'hate': False}, 'neg'), ({'her': True, 'i': True, 'me': False, 'like': True, 'you': False, 'hate': False}, 'pos')]

훈련 시작

like가 있을 때 positive할 확률이 1.7 : 1

classifier = nltk.NaiveBayesClassifier.train(t) # 학습
classifier.show_most_informative_features() # 가장 많은 정보를 담고 있는 특성을 나열

테스트 시작

test_sentence = "i like MeRui"
test_sent_features = {
    word.lower(): (word in word_tokenize(test_sentence.lower())) for word in all_words
}
test_sent_features

{'her': False, 'i': True, 'me': False, 'like': True, 'you': False, 'hate': False}

결과

classifier.classify(test_sent_features)

'pos'

✍🏻 한글 ver.

from konlpy.tag import Okt

pos_tagger = Okt()

train = [
    ('메리가 좋아','pos'),
    ('고양이도 좋아','pos'),
    ('난 수업이 지루해','neg'),
    ('메리는 이쁜 고양이야', 'pos'),
    ('난 마치고 메리랑 놀거야','pos')
]

all_words = set(
    word.lower() for sentence in train for word in word_tokenize(sentence[0])
)

t = [({word: (word in word_tokenize(x[0])) for word in all_words}, x[1]) for x in train]

classifier = nltk.NaiveBayesClassifier.train(t)
classifier.show_most_informative_features()

test_sentence = "난 수업이 마치면 메리랑 놀거야"
test_sent_features = {
    word.lower(): (word in word_tokenize(test_sentence.lower())) for word in all_words
}
test_sent_features

classifier.classify(test_sent_features)

'neg'

Negative가 떴으니, 형태소 분석을 통해 정확히 맞혀보자

형태소분석

형태소 분석을 한 뒤 품사를 단어 뒤에 붙여봄

def tokenize(doc):
    return["/".join(t) for t in pos_tagger.pos(doc, norm=True, stem=True)]

train_docs = [(tokenize(row[0]), row[1]) for row in train]
train_docs

[(['메리/Noun', '가/Josa', '좋다/Adjective'], 'pos'), (['고양이/Noun', '도/Josa', '좋다/Adjective'], 'pos'), (['난/Noun', '수업/Noun', '이/Josa', '지루하다/Adjective'], 'neg'), (['메리/Noun', '는/Josa', '이쁘다/Adjective', '고양이/Noun', '야/Josa'], 'pos'), (['난/Noun', '마치/Noun', '고/Josa', '메리/Noun', '랑/Josa', '놀다/Verb'], 'pos')]

말뭉치 만들기

tokens = [t for d in train_docs for t in d[0]]
tokens

['메리/Noun', '가/Josa', '좋다/Adjective', '고양이/Noun', '도/Josa', '좋다/Adjective', '난/Noun', '수업/Noun', '이/Josa', '지루하다/Adjective', '메리/Noun', '는/Josa', '이쁘다/Adjective', '고양이/Noun', '야/Josa', '난/Noun', '마치/Noun', '고/Josa', '메리/Noun', '랑/Josa', '놀다/Verb']

def term_exists(doc):
    return{word: (word in set(doc)) for word in tokens}

train_xy = [(term_exists(d),c) for d,c in train_docs]
train_xy

classifier = nltk.NaiveBayesClassifier.train(train_xy)

test_sentence = "난 수업이 마치면 메리랑 놀거야"
test_docs = pos_tagger.pos(test_sentence[0])
test_docs

classifier.show_most_informative_features()

test_sent_features = {word: (word in tokens) for word in test_docs}
test_sent_features

classifier.classify(test_sent_features)

3. 문장의 유사도 측정

count vectorize

tfidf vectorize

네이버 API를 통해 유사 질문 찾기

ML - 14. mini project _ CREDIT CARD FRAUD DETECTION

Wed, 31 Jan 2024 09:02:30 GMT

프로젝트 소개

주제 : 신용카드 부정 사용자 검출
데이터 : https://www.kaggle.com/MLG-ULB/CREDITCARDFRAUD
개념
- 신용카드와 같은 금융데이터들은 구하기가 어려움
- 금융 데이터들의 데이터는 또한 다루기 쉽지 않음
- 그러나 지능화되어가는 현대 범죄에 맞춰 사전 이상 징후 검출 등 금융 기관이 많은 노력을 기울이고 있음 이 데이터 역시 센서를 이용한 사람의 행동 과정 유추처럼 머신러닝의 이용 분야 중 하나
개요
- 신용카드 사기 검출 분류용 데이터
- 데이터에 class라는 이름의 컬럼이 사기 유무를 의미
- calss 컬럼의 불균형이 극심해서 전체 데이터의 약 0.172%가 1(사기 Fraud)를 가짐
  - Class : Fraud 여유 (1 이면 Fraud)
  - Amount : 거래금액

데이터 확인

# 1) 데이터 읽기
import pandas as pd

data_path = './14. mini project_creditcard.csv'
raw_data = pd.read_csv(data_path)
raw_data.head()

# 2) 특성

raw_data.columns.values

# 3) 데이터 라벨 확인 (Class : 사기 유무)

raw_data['Class'].value_counts()

Frauds 0.17 % of the dataset

# 5) 데이터 선정
X = raw_data.iloc[:, 1:-1] # Time, Class 컬럼 제외
y = raw_data.iloc[:, -1] # 모든 행의 마지막 컬럼을 선택

X.shape, y.shape

((284807, 29), (284807,))

train_test_split 의 인자들 (https://wikidocs.net/193722)

stratify=y로 지정하면 레이블 데이터 y에 따라 학습 데이터셋과 테스트 데이터셋의 클래스 비율이 유지
random_state : 데이터를 나눌 때 사용되는 난수 시드, 이 값을 지정하지 않으면, 매번 실행할 때마다 다른 결과를 얻을 수 있음
test_size=0.2로 지정하면 전체 데이터셋의 20%를 테스트 데이터셋으로 사용
train_size : 학습 데이터셋의 크기 결정 (기본값은 None으로, 학습 데이터셋 크기를 1 - test_size로 결정)
shuffle : 데이터를 섞을지 여부를 결정
```
# 6) 데이터 나누기
```

from sklearn.model_selection import train_test_split

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=13, stratify=y)

```py
# 7) 나눈 데이터의 불균형 정도 확인 (y_train 원소의 갯수 세기)

import numpy as np

# 원소의 갯수 세기 : unique + return_counts
# return_counts=True : 각 원소의 중복 갯수가 담긴 배열이 반환/원소가 각각 몇개 존재하는지 확인
tmp = np.unique(y_train, return_counts=True)

tmp, tmp[1], tmp[1]/len(y_train)*100

# 8) 나눈 데이터의 불균형 정도 확인 (y_test 원소의 갯수 세기)

import numpy as np

tmp = np.unique(y_test, return_counts=True)

tmp, tmp[1], tmp[1]/len(y_test)*100 # %를 구한 것

(무식 ver.) 데이터 분석

# 1) 분류기 성능 return 함수 설정

from sklearn.metrics import (accuracy_score, precision_score, recall_score, f1_score, roc_auc_score)

def get_clf_eval(y_test, pred):
    acc = accuracy_score(y_test, pred) # 정확도 : 정확하게 정답을 맞힌 비중
    pre = precision_score(y_test, pred) # 정밀도 : positive 예측치 중 실제 positive 관측치 비중
    re = recall_score(y_test, pred) # 재현율 : positive 관측치 중에서 실제로 예측된 비중
    f1 = f1_score(y_test, pred) # Precision과 recall의 조화평균(정밀도, 재현율 -> 평균)
    auc = roc_auc_score(y_test, pred) # 모델의 성능

    return acc, pre, re, f1, auc



from sklearn.metrics import confusion_matrix

def print_clf_eval(y_test, pred):
    confusion = confusion_matrix(y_test, pred)
    acc, pre, re, f1, auc = get_clf_eval(y_test, pred)

    print('=> confusion metrix')
    print(confusion)
    print('==================')

    print('Accuracy : {0:.4f}, Precision : {1:.4f} '.format(acc, pre))
    print('Recall : {0:.4f}, F1 : {1:.4f}, AUC : {2:.4f} '.format(re, f1, auc))

# (https://coduking.com/entry/ROC-curve-AUC-%EA%B0%9C%EB%85%90-%EB%B0%8F-sklearn-%EC%BD%94%EB%93%9C)
# (https://coduking.com/entry/%EB%B6%84%EB%A5%98%EB%AC%B8%EC%A0%9C-%EC%84%B1%EB%8A%A5%ED%8F%89%EA%B0%80-%EC%A7%80%ED%91%9C-Accuracy-Recall-Precision-F1-score-titanic-%EC%8B%A4%EC%8A%B5)

# 2) Logistic Regression

from sklearn.linear_model import LogisticRegression

lr_clf = LogisticRegression(random_state=13, solver='liblinear')
lr_clf.fit(X_train, y_train)
lr_pred = lr_clf.predict(X_test)

print_clf_eval(y_test, lr_pred)

Accuracy가 99.92%로 보이지만, 실제 1중에서 몇개를 맞췄는지 보는 Recall 의 값이 59%에 불과함 -> Fraud 검출을 못했다고 봐야 함 -> 더 성능을 끌어 올려야 함

# 3) Decision Tree

from sklearn.tree import DecisionTreeClassifier

dt_clf = DecisionTreeClassifier(random_state=13, max_depth=4)
dt_clf.fit(X_train, y_train)
dt_pred = dt_clf.predict(X_test)

print_clf_eval(y_test, dt_pred)

DecisionTreeClassifier 의 결과는 106개 중 42개가 틀렸고 71.62% 로 나옴. 이전 보다 높음

# 4) Random Forest

from sklearn.ensemble import RandomForestClassifier

rf_clf = RandomForestClassifier(random_state=13, n_jobs=-1, n_estimators=100)
rf_clf.fit(X_train, y_train)
rf_pred = rf_clf.predict(X_test)

print_clf_eval(y_test, rf_pred)

recall이 조금더 올라감. 이전보다 덜 틀린 38개

# 5) LightGBM

from lightgbm import LGBMClassifier

lgbm_clf = LGBMClassifier(n_estimators=1000, num_leaves=64, n_jobs=-1, boost_from_average=False)
lgbm_clf.fit(X_train, y_train)
lgbm_pred = lgbm_clf.predict(X_test)

print_clf_eval(y_test, lgbm_pred)

성능이 조-금 좋아진 느낌.

(한걸음 전진ver.) 분석

은행 입장에서는 Recall이 좋을 것이다.
사용자 입장에서는 Precision이 좋겠지.
왜? ->>
get_clf_eval : 성능지표

# 1) 모델, 데이터를 주고 성능을 출력하는 함수

def get_result(model, X_train, y_train, X_test, y_test):
    model.fit(X_train, y_train)
    pred = model.predict(X_test)

    return get_clf_eval(y_test, pred)

# 2) 여러개 모델의 성능을 정리 -> DataFrame 반환

def get_result_pd(models, model_names, X_train, y_train, X_test, y_test):
    col_name = ['accuracy', 'precision', 'recall', 'f1', 'roc_auc']
    tmp = []

    for model in models:
        tmp.append(get_result(model, X_train, y_train, X_test, y_test))

    return pd.DataFrame(tmp, columns=col_name, index=model_names)

# 3) 4개의 분류모델 > 표 (정리)

import time

models = [lr_clf, dt_clf, rf_clf, lgbm_clf]
model_names = ['LinearReg', 'DecisionTree', 'RandomForest', 'LightGBM']

start_time = time.time()
results = get_result_pd(models, model_names, X_train, y_train, X_test, y_test)

print('Fit time : ', time.time() - start_time)
results

(데이터 정리 & 크기 조정 / scaling ver.) 분석

그래프로 'Amount'의 값이 어떻게 분포되어 있는지 확인

# 1) raw_data의 Amount 컬럼 확인

plt.figure(figsize=(10,5))
sns.distplot(raw_data['Amount'], color='b')
plt.show()

raw_data['Amount'].values

array([149.62, 2.69, 378.66, ..., 67.88, 10. , 217. ])

raw_data['Amount'].values.reshape(-1,1)
# reshape : https://domybestinlife.tistory.com/149

raw_data.iloc[:, 1:-2] # Time, Amount, Class 삭제

StandardScaler 를 통해, 'Amount'가 몰려있는 상태의 편형성을 바꿔보고 싶음

# 2) Amount + StandardScaler

from sklearn.preprocessing import StandardScaler

scaler = StandardScaler()
amount_n = scaler.fit_transform(raw_data['Amount'].values.reshape(-1,1))

raw_data_copy = raw_data.iloc[:, 1:-2]
raw_data_copy['Amount_Scaler'] = amount_n # StandardScaler 학습한 컬럼 생성
raw_data_copy.head()

# 3) 데이터 나누기 >> 재평가

X_train, X_test, y_train, y_test = train_test_split(raw_data_copy, y, test_size=0.3, random_state=13, stratify=y)

models = [lr_clf, dt_clf, rf_clf, lgbm_clf]
model_names = ['LinearReg', 'DecisionTree', 'RandomForest', 'LightGBM']

start_time = time.time()
results = get_result_pd(models, model_names, X_train, y_train, X_test, y_test)

print('Fit time : ', time.time() - start_time)
results

models 안에 model이 넘어올건데, 그 모델에다가 predict를 시키고, predict_proba를 X_test에 대해서 시켜 줌 왜? ROC 커브를 그리려면 '확률값(predict_proba)'이 있어야 하기 때문
대각선 그리는 방법 : plt.plot([0,1], [0,1], 'k--', label='random quess')

# 4) 모델별 ROC 커브

from sklearn.metrics import roc_curve

def draw_roc_curve(models, model_names, X_test, y_test):
    plt.figure(figsize=(10,10))

    for model in range(len(models)):
        pred = models[model].predict_proba(X_test)[:, 1]
        fpr, tpr, thresholds = roc_curve(y_test, pred)
        plt.plot(fpr, tpr, label=model_names[model])
    # 대각선
    plt.plot([0,1], [0,1], 'k--', label='random quess')
    plt.title('ROC')
    plt.legend()
    plt.grid()
    plt.show()

# draw_roc_curve(models, model_names, X_test, y_test)

from sklearn.metrics import roc_curve

def draw_roc_corve(models,model_names,  X_test, y_test):
    plt.figure(figsize=(10, 10))

    for model in range(len(models)):
        pred = models[model].predict_proba(X_test)[:, 1]
        fpr, tpr, thresholds = roc_curve(y_test, pred)
        plt.plot(fpr, tpr, label=model_names[model])

    plt.plot([0, 1], [0, 1], 'k--', label='random quess')
    plt.title('ROC')
    plt.legend()
    plt.grid()
    plt.show()

draw_roc_corve(models, model_names, X_test, y_test)

log 함수를 적용해 보겠음! log 함수 : 높은 값은 상대적으로 낮게 잡아주고 낮은 값은 그대로 사용

# 5) log scale 확인

amount_log = np.log1p(raw_data['Amount'])

raw_data_copy['Amount_Scaler'] = amount_log
raw_data_copy.head()

# 6) 분포(displot) 확인
import matplotlib.pyplot as plt
import seaborn as sns
plt.figure(figsize=(10,5))
sns.distplot(raw_data_copy['Amount_Scaler'], color='r')
plt.show()

```
# 7) 성능 확인
```

X_train, X_test, y_train, y_test = train_test_split(raw_data_copy, y, test_size=0.3, random_state=13, stratify=y) start_time = time.time() results = get_result_pd(models, model_names, X_train, y_train, X_test, y_test)

print('Fit time : ', time.time() - start_time) results

- ![](https://velog.velcdn.com/images/jaam_mini/post/5f34daa2-2e82-46c4-8875-76cbc0e35e01/image.png)

### 데이터의 Outlier를 정리


```py
# 1) 특이한 데이터 확인
import seaborn as sns

plt.figure(figsize=(10,7))
sns.boxplot(data=raw_data[['V13', 'V14', 'V15']]);

# 2) Outlier를 정리하기 위해 Outlier의 인덱스를 파악하는 코드

def get_outlier(df=None, column=None, weight=1.5):
    fraud = df[df['Class']==1][column]
    # 25% 지점
    quantile_25 = np.percentile(fraud.values, 25)
    # 75% 지점
    quantile_75 = np.percentile(fraud.values, 75)

    iqr = quantile_75 - quantile_25
    iqr_weight = iqr * weight # (weight = 1.5)
    lowest_val = quantile_25 - iqr_weight
    highest_val = quantile_75 + iqr_weight
    # 제거할 outlier_index 를 설정
    outlier_index = fraud[(fraud < lowest_val) | (fraud > highest_val)].index

    return outlier_index

# 3) 파악하는 코드 작성했으니, Outlier 찾기

get_outlier(df=raw_data, column='V14', weight=1.5)

Index([8296, 8615, 9035, 9252], dtype='int64')

# 4) Outlier 제거 전에 전체 개수 확인
raw_data_copy.shape

(284807, 29)

# 5) Outlier 제거
outlier_index = get_outlier(df=raw_data, column='V14', weight=1.5)
raw_data_copy.drop(outlier_index, axis=0, inplace=True) # 행제거 (axis=0)
raw_data_copy.shape

(284803, 29)

# 6) Outlier 제거 후 데이터 다시 나누기 >> 재평가
X = raw_data_copy

raw_data.drop(outlier_index, axis=0, inplace=True)
y = raw_data.iloc[:, -1]

X_train, X_test, y_train, y_test = train_test_split(raw_data_copy, y, test_size=0.3, random_state=13, stratify=y)

models = [lr_clf, dt_clf, rf_clf, lgbm_clf]
model_names = ['LinearReg', 'DecisionTree', 'RandomForest', 'LightGBM']

start_time = time.time()
results = get_result_pd(models, model_names, X_train, y_train, X_test, y_test)

print('Fit time : ', time.time() - start_time)
results

SMOTE Oversampling

데이터의 불균형이 극심할 때 불균형한 두 클래스의 분포를 강제로 맞춰보는 작업
언더샘플링 : 많은 수의 데이터를 적은 수의 데이터로 강제로 조정
오버샘플링 :
- 원본데이터의 피처 값들을 아주 약간 변경하여 증식
- 대표적으로 SMOTE(Synthetic Minority Over-sampling Technique) 방법이 있음
- 적은 데이터 세트에 있는 개별 데이터를 k-최근접이웃 방법으로 찾아서 데이터의 분포 사이에 새로운 데이터를 만드는 방식
- imbalanced-learn 이라는 Python pkg가 있음
```
!pip install imbalanced-learn
```

ML - 13. GBM - Gradient Boosting Machine

Wed, 31 Jan 2024 01:08:48 GMT

[이번에 사용한 데이터] : HAR_dataset

import pandas as pd
url = 'https://raw.githubusercontent.com/PinkWink/ML_tutorial/master/dataset/HAR_dataset/features.txt'

# '\s+' 공백, header 그대로, 컬럼 이름 names
feature_name_df = pd.read_csv(url, sep='\s+', header=None, names=['columns_index','columns_name'])

# 밸류만 가지고 feature_name 추출 -> 즉, 앞으로 561개의 이름만 저장하게 됨
feature_name = feature_name_df.iloc[:, 1].values.tolist()

X_train_url = 'https://raw.githubusercontent.com/PinkWink/ML_tutorial/master/dataset/HAR_dataset/train/X_train.txt'
X_test_url = 'https://raw.githubusercontent.com/PinkWink/ML_tutorial/master/dataset/HAR_dataset/test/X_test.txt'
X_train = pd.read_csv(X_train_url, sep='\s+', header=None)
X_test = pd.read_csv(X_test_url, sep='\s+', header=None)

X_train.columns = feature_name
X_test.columns = feature_name

y_train_url = 'https://raw.githubusercontent.com/PinkWink/ML_tutorial/master/dataset/HAR_dataset/train/y_train.txt'
y_test_url = 'https://raw.githubusercontent.com/PinkWink/ML_tutorial/master/dataset/HAR_dataset/test/y_test.txt'
y_train = pd.read_csv(y_train_url, sep='\s+', header=None, names=['action'])
y_test = pd.read_csv(y_test_url, sep='\s+', header=None, names=['action'])

GBM

GBM - Gradient Boosting Machine

부스팅 알고리즘은 여러 개의 약한 학습기(week learner)를 순차적으로 학습-예측하면서 잘못 예측한 데이터에 가중치를 부여해서 오류를 개선해가는 방식
GBM은 가중치를 업데이트할 때 경사 하강법(Gradient Descent)을 이용하는 것이 큰 차이

from sklearn.ensemble import GradientBoostingClassifier
from sklearn.metrics import accuracy_score
import time
import warnings

warnings.filterwarnings('ignore')

# GradientBoostingClassifier
start_time = time.time()

gb_clf = GradientBoostingClassifier(random_state=13)
gb_clf.fit(X_train, y_train)
gb_pred = gb_clf.predict(X_test)

print('ACC : ', accuracy_score(y_test, gb_pred))
print('Fit time : ', time.time() - start_time)

다른 분들은 40분만에 결과를 볼 수 있었다고 했는데.. 난 저녁 약속을 다녀와도 계속 running 중이라 멈출 수 밖에 없었다....🙄

# GridSearch로 조금 더 찾아보자~
from sklearn.model_selection import GridSearchCV

params = {
    'n_estimators' : [100,500],    'learning_rate' : [0.05, 0.1]
}

start_time = time.time()
grid = GridSearchCV(gb_clf, param_grid=params, cv=2, verbose=1, n_jobs=-1)
grid.fit(X_train, y_train)
print('Fit time : ', time.time() - start_time)

# test 성능
accuracy_score(y_test, grid.best_estimator_.predict(X_test))

# test 성능
accuracy_score(y_test, grid.best_estimator_.predict(X_test))

XGBoost

XGBoost는 트리 기반의 앙상블 학습에서 가장 각광받는 알고리즘 중 하나
GBM 기반의 알고리즘인데, GBM의 느린 속도를 다양한 규제를 통해 해결
특히 병렬 학습이 가능하도록 설계됨
XGBoost는 반복 수행 시마다 내부적으로 학습데이터와 검증데이터를 교차검증을 수행
교차검증을 통해 최적화되면 반복을 중단하는 조기 중단 기능을 가지고 있음

파라미터 종류 - nthread : CPU의 실행 스레드 개수를 조정. 디폴트는 CPU의 전체 스레드를 사용하는 것 - eta : GBM 학습률 - num_boost_rounds : n_estimators와 같은 파라미터 - max_depth

!pip install xgboost

from xgboost import XGBClassifier

start_time = time.time()
xgb = XGBClassifier(n_estimators=400, learning_rate=0.1, max_depth=3)

# numpy array 값을 받아들이기 때문에, values 값만 넣어야 한다.
xgb.fit(X_train.values, y_train)
print('Fit time : ', time.time() - start_time)

# 289.586 나옴

accuracy_score(y_test, grid.best_estimator_.predict(X_test.values))
#0.9392 나옴

# 조기 종료 설정 (early_stopping_round)

from xgboost import XGBClassifier

evals = [(X_test.values, y_test)]

start_time = time.time()
xgb = XGBClassifier(n_estimators=400, learning_rate=0.1, max_depth=3)

# numpy array 값을 받아들이기 때문에, values 값만 넣어야 한다.
# early_stopping_rounds=10 : 같은 성능으로 10번 이상 비슷한 값이 나오면 종료 해라
xgb.fit(X_train.values, y_train, early_stopping_rounds=10, eval_set=evals)
print('Fit time : ', time.time() - start_time)

LightGBM

LightGBM은 XGBoost와 함께 부스팅 계열에서 가장 각광받는 알고리즘
LGBM의 큰 장점은 속도
단, 적은 수의 데이터에는 어울리지 않음 (일반적으로 10000건 이상의 데이터가 필요하다고 함)
GPU 버전도 존재함

!pip install lightgbm

start_time = time.time()

from lightgbm import LGBMClassifier
import time

evals = [(X_test.values, y_test)]

start_time = time.time()
lgbm = LGBMClassifier(n_estimators=400)
lgbm.fit(X_train.values, y_train,eval_set=evals)
print('Fit time : ', time.time() - start_time)

ML - 12. kNN (k Nearest Neighber)

Tue, 30 Jan 2024 05:36:00 GMT

kNN 이란?

새로운 데이터가 있을 때, 기존 데이터의 그룹 중 어떤 그룹에 속하는지 분류하는 문제
k는 몇 번째 가까운 데이터까지 볼 것인가를 정하는 수치
즉, 쉽게 말해 새로운 데이터(검은점)이 빨강-파랑 중 어디로 분류 되는지 정하는 것
더 간단히 말해, K값을 설정하고, 그 값에 가까이 있는 애로 분류할게~

더 자세히 볼까요??? N은 파랑과 녹색 중 어디 일까?

2번째 거리에 가깝게 설정 ; 세모 그룹
3번째 거리에 가깝게 설정 ; 동그라미 그룹

💡따라서 k값(거리)는 표준화!! 해주는 것이 상당히 중요하다

kNN 장단점

실시간 예측을 위한 학습이 필요치 않다
결국 속도가 빨라진다
고차원 데이터에는 적합하지 않다

실습 _ iris

from sklearn.datasets import load_iris
iris = load_iris()

from sklearn.model_selection import train_test_split

X_train, X_test, y_train, y_test = train_test_split(
    iris.data, iris.target, test_size=0.2, random_state=13, stratify=iris.target
)

# 1) kNN 학습

from sklearn.neighbors import KNeighborsClassifier

# n_neighbors= : 몇개 까지 가까운걸 찾을래?
knn = KNeighborsClassifier(n_neighbors=5)
knn.fit(X_train, y_train)

# 2) accuracy 확인

from sklearn.metrics import accuracy_score

pred = knn.predict(X_test)
print(accuracy_score(y_test, pred))

0.9666666666666667

# 3) 간단한 성과 (?)

from sklearn.metrics import (classification_report, confusion_matrix)

print(confusion_matrix(y_test, pred))
print(classification_report(y_test, pred))

간단한 ㄷ이터를 다룰 때 kNN은 큰 두각을 나타내지 못합니다... 다음 언젠가 실습 시 두각을 나타내는 결과를 보길 기대하며..

ML - 11. 앙상블기법_Boosting Algorithm (기초)

Tue, 30 Jan 2024 03:48:48 GMT

앙상블기법

앙상블은 전통적으로 Voting, Boosting, Bagging, 스태깅 으로 나뉨
보팅과 배깅은여러개의 분류기가 투표를 통해 최종 예측 결과를 결정하는 방식이다
둘의 차이점은 보팅은 각각 다른 분류기, 배깅은 같은 분류기를 사용
대표적인 Bagging 방식은 landomforest 이다.
- Voting
  - 하나의 데이터(전체 데이터)를 다 쓰면서 각각 다른 알고리즘을 적용 시키는 방법
- Bagging
  - 하나의 알고리즘을 쓰는데, 전체 데이터를 나눠서 씀
  - 나누는 방법 ; 중복을 허락해서 데이터를 수집 한다 (boot strapping)

그렇다면, Boosting은 뭘까..? 알아봅시다 😎

Boosting 이란?

여러개의 약한(?)분류기(=성능이 떨어지고 겁나 빠른 = DecisionTree, maxdepth=2_낮게 주는 것)가 순차적으로 학습하면서 앞에서 학습한 분류기가 예측이 틀린 데이터에 대해 다음 분류기가 가중치를 인가해 학습을 이어 진행하는 방식
예측 성능이 뛰어나 앙상블 학습을 주도함

Boosting 기법 3가지

GBM (Gradient Boosting Machine)
- AdaBoost 기법과 비슷하지만 가중치를 업데이트 할때 경사하깅법(Gradient Descent)를 사용

XGBoost (eXtra Gradient Boost)
- GBM에서 PC의 파워를 효율적으로 사용하기 위한 다양한 기법에 채택되 빠른 속도와 효율을 가짐
- GBM에서 효율을 극도로 올리고 CPU를 쓸 수 있게 하는 것

LightGBM (Light Gradient Boost)
- XGBoost 보다 빠른 속도를 가짐
- 속도를 향상시ㅣ기 위한 각종 장치들이 있음

Bagging과 Boosting 의 차이는?

Bagging
- 데이터를 통 or 잘라서 쓰던지 학습하는 타이밍이 동시에 이뤄짐 (= 한번에 병렬적으로 결과를 얻음)
- 데이터들이 각각의 분류기에 들어가고 각각의 모델들이 동시에 학습을 해서 결과를 투표

Boosting
- 데이터를 가지고 학습
- 그 결과(틀린것, 가중치가 필요한 것들)를 가지고 또 학습
- 또 학습 (= 순차적으로 진행됨)

Boosting 계열의 기본적인 그림(AdaBoost)을 통해 알아봅시다~

Boosting 계열 개념 설명

D1 먼저 +-를 구분해야 하는데, 매우 약한 분류기를 썼기 때문에 성능의 경계면이 말도 안되게 설정됨...

D2 그리고 틀린 아이들에게 가중치를 줌

D3 다시 놓친 -에 가중치를 인가해, 다시 경계를 설정

마지막 단계 앞서 결정한 경계들을 합침 (이어붙임)

실습 - Wine data

1. 데이터 확인

# 1) 데이터 가져오기
import pandas as pd
wine_url = 'https://raw.githubusercontent.com/PinkWink/ML_tutorial/master/dataset/wine.csv'
wine = pd.read_csv(wine_url,index_col=0)
wine.head()

# 2) 맛 등급 설정
    # (1) quality 컬럼 이진화
    # wine 데이터의 ['taste'] 컬럼 생성
    # wine의 quality column울 grade로 잡고, 5등급 보다 크면 1, 그게 아니라면 0으로 잡음
wine['taste'] = [1. if grade>5 else 0. for grade in wine['quality']]
    # (2) 모델링
    # label인 taste, quality를 drop, 나머지를 X의 특성으로 봄
X = wine.drop(['taste', 'quality'], axis=1)
# 새로만들 y데이터
y = wine['taste']

# 3) StandardScaler
from sklearn.preprocessing import StandardScaler
# StandardScaler를 installation
sc = StandardScaler()
# X 데이터를 StandardScaler로 변환
X_sc = sc.fit_transform(X)

# 4) 데이터 나누기
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=13)

# 5) 히스토그램
import matplotlib.pyplot as plt
%matplotlib inline

wine.hist(bins=10, figsize=(15,15))
plt.show()

wine.columns.values

array(['fixed acidity', 'volatile acidity', 'citric acid', 'residual sugar', 'chlorides', 'free sulfur dioxide', 'total sulfur dioxide', 'density', 'pH', 'sulphates', 'alcohol', 'quality', 'color', 'taste'], dtype=object)

# 6) quality 별 어떤 특성이 있는지 확인

column_names = ['fixed acidity', 'volatile acidity', 'citric acid',
       'residual sugar', 'chlorides', 'free sulfur dioxide',
       'total sulfur dioxide', 'density', 'pH', 'sulphates', 'alcohol']

df_pivot_table = wine.pivot_table(column_names, ['quality'], aggfunc='median')
print(df_pivot_table)

# 7) quality 대한 나머지 특성들의 상관관계
# (주의사항) : 상관관계를 sort_values로 볼때, |절대값|으로 값을 생각해야 함, -라고 안좋은게 아님. 

corr_matrix = wine.corr()
corr_matrix['quality'].sort_values(ascending=False)

2. train

⭐오늘의 keypoint

# 8) 다양한 모델을 한번에 테스트

# ensemble(앙상블 기법) 에서 3가지 분류기 사용
from sklearn.ensemble import (AdaBoostClassifier, GradientBoostingClassifier,
                              RandomForestClassifier)
# 각 분류기 import
from sklearn.tree import DecisionTreeClassifier
from sklearn.linear_model import LogisticRegression

# 빈 리스트 만들고
models = []
# 전부 append 시켜줌 (이름, 분류기 함수()) - 리스트으로 저장(리스트는 뭐든 들어가기 때문)
models.append(('RandomForestClassifier', RandomForestClassifier()))
models.append(('DecisionTreeClassifier', DecisionTreeClassifier()))
models.append(('AdaBoostClassifier', AdaBoostClassifier()))
models.append(('GradientBoostingClassifier', GradientBoostingClassifier()))
models.append(('LogisticRegression', LogisticRegression(solver='liblinear')))

models

[('RandomForestClassifier', RandomForestClassifier()), ('DecisionTreeClassifier', DecisionTreeClassifier()), ('AdaBoostClassifier', AdaBoostClassifier()), ('GradientBoostingClassifier', GradientBoostingClassifier()), ('LogisticRegression', LogisticRegression(solver='liblinear'))]

# 9) 각 분류기별 models 결과를  저장하기  위한  작업

%time
# 러닝시간 측정
# CPU times: total: 0 ns
# Wall time: 0 ns

from sklearn.model_selection import KFold, cross_val_score

results = []
names = []

# models 는 이미 리스트 안에 튜플로 되어 있음 (위에 쿼리)
# 그렇기 때문에 name 과 model로 받을 수 있음
for name, model in models:
    # kfold 선언 = (5겹 폴딩, - , 5개로 나누기 전에 데이터를 썪어라)
    kfold = KFold(n_splits=5, random_state=13, shuffle=True)
    # 5개의 model 마다 X_train, y_train 데이터로 kfolding(cv=kfold) 시킴
    cv_results = cross_val_score(model, X_train, y_train,
                                 cv=kfold, scoring='accuracy')
    results.append(cv_results)
    names.append(name)

    print(name, cv_results.mean(), cv_results.std())

# 결과 : results 변수에는 5개의 알고리즘 성증들이 저장되어 있음
# cv_results.mean() : training data를 5겹으로 나눈 mean(평균값)

CPU times: total: 0 ns Wall time: 0 ns RandomForestClassifier 0.8235476049455839 0.014660814747173595 DecisionTreeClassifier 0.7548571111275635 0.007232581517245795 AdaBoostClassifier 0.7533103205745169 0.02644765901536818 GradientBoostingClassifier 0.7663961279336641 0.02129278386035166 LogisticRegression 0.7423482268453395 0.014274628192480914

results
# 5개 알고리즘 마다 5번 폴딩했을 때 결과값(=성능)

[array([0.82019231, 0.85 , 0.80846968, 0.8267565 , 0.81231954]), array([0.75192308, 0.76538462, 0.74879692, 0.76130895, 0.74687199]), array([0.74903846, 0.80384615, 0.72666025, 0.74687199, 0.74013474]), array([0.77019231, 0.80192308, 0.73820982, 0.76900866, 0.75264678]), array([0.73269231, 0.76826923, 0.74013474, 0.7439846 , 0.72666025])]

names
# results 항목명

['RandomForestClassifier', 'DecisionTreeClassifier', 'AdaBoostClassifier', 'GradientBoostingClassifier', 'LogisticRegression']

# 10) croocross-validation 결과를  일목요연하게  확인하기
import matplotlib.pyplot as plt

fig = plt.figure(figsize=(12, 5))
fig.suptitle('Algorithm Comparison')
ax = fig.add_subplot(111)
plt.boxplot(results)
ax.set_xticklabels(names)
plt.show()

3. test

# 11) 테스트  데이터에  대한  평가  결과
from sklearn.metrics import accuracy_score

for name, model in models:
    model.fit(X_train, y_train)
    pred = model.predict(X_test)
    print(name, accuracy_score(y_test, pred))

RandomForestClassifier 0.8392307692307692 DecisionTreeClassifier 0.7838461538461539 AdaBoostClassifier 0.7553846153846154 GradientBoostingClassifier 0.7884615384615384 LogisticRegression 0.7446153846153846

[EDA] mini project 12 _ 세계 테러 분석

Sun, 28 Jan 2024 17:12:46 GMT

전처리

데이터 불러오기

import pandas as pd

raw_data = pd.read_csv('./globalterrorismdb_0718dist.csv', encoding = 'latin-1')
raw_data.head()

모든 컬럼 확인

raw_data.columns.values

컬럼_데이터 확인

raw_data['summary'].values

보기 좋게 컬럼명 변경

# 필요한 컬럼들 : 날짜, 이슈, 국가, 사망자수, 부상자수, 지역구분, 공격형태(테러양상)

terr_df = raw_data.copy()

terr_df.rename(columns={
    'eventid':'eventid', 'iyear':'Year','imonth':'Month','iday':"day",
    'country_txt':'Country','region_txt':'Region','provstate':'State','city':'City',
    'latitude':'lat',  'longitude':'lng',
    'targtype1_txt':'Targettype','attacktype1_txt':'Attacktype','weaptype1_txt':'Weapon',
    'nkill':'Kill','nwound':'Wound',
    'gname':'Group','summary':'Summary','motive':'Motive',
}, inplace=True)

terr_df.reset_index()
terr_df.tail(2)

사용할 컬럼으로 변경

terr_df = terr_df[[
    'eventid', 'Year', 'Month', 'day', 
    'Country', 'Region', 'State', 'City', 
    'lat', 'lng',
    'Targettype', 'Attacktype', 'Weapon', 
    'Kill', 'Wound', 'Group', 'Summary', 'Motive'
]]

비어 있는 데이터 확인 : isnull().sum()

terr_df.isnull().sum()

데이터 타입 확인

terr_df.info()

분석 시작!

# 연도 컬럼에 몇해연도가 있는지 확인
year = terr_df['Year'].unique()
year

# 그래프(시각화) 전에 각 연도별 데이터 수 확인
year_count = terr_df['Year'].value_counts(dropna=False).sort_index()
year_count[:4]

연간 테러 발생 건수

import matplotlib.pyplot as plt
import seaborn as sns

year = terr_df['Year'].unique()
year_count = terr_df['Year'].value_counts(dropna=False).sort_index()


plt.figure(figsize=(12, 4))
ax = sns.barplot(x=year, y=year_count, palette='YlOrBr')
for p in ax.patches:
    ax.annotate(f'{p.get_height()}', (p.get_x() + p.get_width() / 2., p.get_height()),
                ha='center', va='baseline', fontsize=10, color='black', xytext=(0, 5),
                textcoords='offset points',rotation = 90)
plt.xlabel('Attack Year')
plt.xticks(rotation=50, fontsize=7)
plt.ylabel('Number of attacks cases')
plt.title('Attacks In Years', fontsize=15)
plt.show()

# 1번 방법
# # 어떤 데이터를?
# year = terr_df['Year'].unique()
# year_count = terr_df['Year'].value_counts(dropna=False).sort_index()

# # 그래프 (쿼리 순서 중요)
# plt.figure(figsize=(12, 4))
# sns.barplot(x=year, y=year_count, palette='YlOrBr')
# plt.xlabel('Attack Year')
# plt.xticks(rotation=50, fontsize=7)
# plt.ylabel('Number of attacks cases')
# plt.title('Attacks In Years', fontsize=15)
# plt.show()


# 2번 방법
# # sns.countplot 사용
# plt.figure(figsize = (15,5))
# sns.countplot(x='Year',data=terr_df)
# plt.xticks(rotation=90)
# plt.xlabel('year', fontsize=10)
# plt.ylabel('counts', fontsize=10)
# plt.title('Number of terrorist activites each year', fontsize=15)
# plt.show()

# 3번 방법
# sns.countplot + counts text 추가
# plt.figure(figsize = (15,5))
# ax = sns.countplot(x='Year',data=terr_df)
# plt.xticks(rotation=90)
# # Adding annotations to the chart
# for p in ax.patches:
#     ax.annotate(f'{p.get_height()}', (p.get_x() + p.get_width() / 2., p.get_height()),
#                 ha='center', va='baseline', fontsize=10, color='black', xytext=(0, 5),
#                 textcoords='offset points',rotation = 90)

# plt.title('Attacks In Years')
# plt.show

테러발생 상위 10개국

terr_rank_10 = terr_df['Country'].value_counts()[:10]
terr_rank_10

terr_counts = terr_df.Country.value_counts()[:10].unique()
terr_counts

terr_rank = terr_df['Country'].value_counts()[:10].index
terr_rank

plt.figure(figsize=(12, 4))
top_10_country = terr_df['Country'].value_counts().head(10)

# Remove 'Unknown'
# top_10_cities = top_10_cities[top_10_cities.index != 'Unknown']

sns.barplot(x=top_10_country.index, y=top_10_country.values, palette='rocket')
plt.title('Most attacks Country Top10')
plt.xlabel('Country')
plt.ylabel('Counts')
plt.xticks(rotation=30)

plt.show()

# 또 다른 방법
# terr_rank = terr_df['Country'].value_counts()[:10].index
# terr_counts = terr_df.Country.value_counts()[:10].unique()

# plt.figure(figsize=(12, 4))
# sns.barplot(x=terr_rank, y=terr_counts, palette='YlOrBr_r')

# plt.xlabel('Countries')
# plt.xticks(fontsize=7)
# plt.ylabel('Count')
# plt.title('Most attacks Country Top10')
# plt.show()

fig,ax = plt.subplots(figsize=(12,4))
ax = sns.barplot(x=terr_df.Country.value_counts()[:10].values,y = terr_df.Country.value_counts()[:10].index, palette='RdYlGn')
ax.set_title('Most attacks Country Top10')

# columns ['Country','Terror_cases']으로 상위 10개국 DataFrame 만들기
terr_rank_10 = terr_df.groupby('Country').size().to_frame(name='Terror_cases')
terr_rank_10.sort_values('Terror_cases', ascending=False, inplace=True)
terr_rank_10 = terr_rank_10.head(10).reset_index()
terr_rank_10

사상자 상위 10개국

coun_terror=terr_df['Country'].value_counts()[:10].to_frame()
coun_terror.columns=['Wound']
coun_kill=terr_df.groupby('Country')['Kill'].sum().to_frame()
coun_terror.merge(coun_kill,left_index=True,right_index=True,how='left').plot.bar()
fig=plt.gcf()
fig.set_size_inches(12,4)
plt.xticks(rotation=0)
plt.title('Wound & Kill County Top10 ')
plt.show()

지역별 테러 특성 확인

resion_counts = terr_df['Region'].value_counts()

fig = plt.figure(figsize=(12,8))

plt.pie(
    resion_counts,
    labels=None,
    autopct='%.1f%%',
    startangle=90,
    textprops={'fontsize':10}
)

centre_circle = plt.Circle((0,0), 0.4, fc='white')
fig = plt.gcf()
fig.gca().add_artist(centre_circle)

plt.axis('equal')
plt.title('Terrorist attack by Region')
plt.legend(resion_counts.index, loc='center left', bbox_to_anchor=(1, 0.5))
plt.show()

#  df.loc[ '행이름':'행이름', '열이름': '열이름']
#  df.iloc[ 행번호:행번호, 열번호:열번호]
#  .unstack(fill_value=0) : 데이터 프레임으로 만들고 측정 결측치를 0 값으로 지정
region_year_counts = terr_df.groupby(['Region', 'Year']).size().unstack(fill_value=0)

region_year_counts.index

region_year_counts.columns

pd.crosstab(terr_df.Year,terr_df.Region).plot(figsize=(12,4))
plt.title('Terrorist Attack By Region',size=10)
plt.ylabel('counts')

# region_year_counts = terr_df.groupby(['Region', 'Year']).size().unstack(fill_value=0)

# plt.figure(figsize=(12, 4))

# for region in region_year_counts.index:
#     plt.plot(region_year_counts.columns, region_year_counts.loc[region], label=region)

# plt.title('Terrorist attack by Region')
# plt.xlabel('Year')
# plt.ylabel('counts')
# plt.legend(loc='upper left')
# plt.grid(True)

# plt.show()

plt.figure(figsize=(12,4))
sns.countplot(x = terr_df['Region'], order = terr_df['Region'].value_counts().index)
plt.xticks(rotation=30, fontsize=8)
plt.xlabel('region')
plt.title('counts')
plt.show()

pd.crosstab(terr_df.Region,terr_df.Attacktype).plot.barh(stacked=True)
fig=plt.gcf()
fig.set_size_inches(12,7)
plt.show()

coun_terror=terr_df['Region'].value_counts().to_frame()
coun_terror.columns=['Wound']
coun_kill=terr_df.groupby('Region')['Kill'].sum().to_frame()
coun_terror.merge(coun_kill,left_index=True,right_index=True,how='left').plot.bar()
fig=plt.gcf()
fig.set_size_inches(18,6)
plt.xticks(rotation=30, fontsize=8)
plt.show()

연도별 테러 양상 분석

import folium
import pandas as pd
import json
from folium.plugins import MarkerCluster 

terr_topYear = terr_df['Year'] == 2014
filterData = terr_df[terr_topYear] # filter data

# filterData.info()
filterData_info = filterData.loc[:,'City':'lng'] #We are getting the required fields
filterData_info = filterData_info.dropna() # drop NaN values in latitude and longitude
filterData_list = filterData_info.values.tolist()

# reqFilterDataList
map = folium.Map(location = [0, 30], tiles='CartoDB positron', zoom_start=2)

# clustered marker
markerCluster = folium.plugins.MarkerCluster().add_to(map)
for point in range(0, len(filterData_list)):
    folium.Marker(location=[filterData_list[point][1],filterData_list[point][2]],
                  popup = filterData_list[point][0]).add_to(markerCluster)
map

coun_terror=terr_topRate['Region'].value_counts().to_frame()
coun_terror.columns=['Wound']
coun_kill=terr_topRate.groupby('Region')['Kill'].sum().to_frame()
coun_terror.merge(coun_kill,left_index=True,right_index=True,how='left').plot.bar()
fig=plt.gcf()
fig.set_size_inches(18,6)
plt.xticks(rotation=30, fontsize=8)
plt.show()

plt.figure(figsize=(12, 4))
terr_topRate = terr_topRate['Country'].value_counts().head(10)

# Remove 'Unknown'
# top_10_cities = top_10_cities[top_10_cities.index != 'Unknown']

sns.barplot(x=terr_topRate.index, y=terr_topRate.values, palette='rocket')
plt.title('Most attacks Country Top10')
plt.xlabel('Country')
plt.ylabel('Counts')
plt.xticks(rotation=30)

plt.show()

terr_topRate = terr_df.copy()
terr_topRate = terr_topRate.loc[(terr_topRate['Year']==2012)|(terr_topRate['Year']==2013)|(terr_topRate['Year']==2014)]

plt.figure(figsize=(12, 4))
top_5_weapon_types = terr_topRate['Weapon'].value_counts().head()

sns.barplot(x=top_5_weapon_types.index, y=top_5_weapon_types.values, palette='flare')
plt.title('Top 5 Most Used Weapon Types', fontsize=10)
plt.xlabel('Weapon Types')
plt.ylabel('counts')
plt.show()

![](https://velog.velcdn.com/images/jaam_mini/post/738a0a6a-6060-4ef8-a3a5-7035eb311324/image.png)

terr_topRate = terr_df.copy()
terr_topRate = terr_topRate.loc[(terr_topRate['Year']==2012)|(terr_topRate['Year']==2013)|(terr_topRate['Year']==2014)]

coun_terror=terr_topRate['Country'].value_counts()[:10].to_frame()
coun_terror.columns=['Attacks']
coun_kill=terr_topRate.groupby('Country')['Kill'].sum().to_frame()
coun_terror.merge(coun_kill,left_index=True,right_index=True,how='left').plot.bar()
fig=plt.gcf()
fig.set_size_inches(12,4)
plt.title('Attacks & Killed (2012-2014)')
plt.show()

fig,ax = plt.subplots(figsize=(12,4))
# Unkown 삭제를 위해 _counts()[1:10]
ax = sns.barplot(x=terr_topRate.Group.value_counts()[1:10].values,y = terr_topRate.Group.value_counts()[1:10].index, palette='mako')
ax.set_title('Terrorist Groups with Highest Terror Attacks')

df_Iraq = terr_topRate[terr_topRate['Country'] == 'Iraq']

fig,ax = plt.subplots(figsize=(12,4))
ax = sns.barplot(x=df_Iraq.Group.value_counts()[1:6].values,y = df_Iraq.Group.value_counts()[1:6].index, palette='Blues')
ax.set_title('Terrorist Groups, Iraq (2012-2014)')

plt.figure(figsize=(4, 2))
sns.barplot(x=df_Iraq_Bag['Year'].value_counts().index, y=df_Iraq_Bag['Year'].value_counts().values, palette='viridis')
plt.title('Terror Attacks by ISIL, Iraq (2012-2014)')
plt.xlabel('Years')
plt.ylabel('Number of Attacks')
plt.show()

df_Iraq['City'].value_counts()[:10].to_frame().sort_values('count', ascending=False).plot(kind='bar',figsize=(12,4),color='lightblue')
plt.xlabel("City")
plt.ylabel("Number of attack")
plt.title("Top 10 most effected city in Iraq(2012-2014)", fontsize=15)
plt.show()

df_Iraq['Attacktype'].value_counts()[:5].plot(kind='bar',figsize=(12, 4),color='steelblue')
plt.xticks(rotation=0, fontsize=8)
plt.xlabel("Attacktype")
plt.ylabel("Number of attack")
plt.title("Top 5 Attacktype, Iraq (2012-2014)",fontsize=15)
plt.show()

df_Iraq['Targettype'].value_counts()[:5].plot(kind='bar',figsize=(12, 4),color='steelblue')
plt.xticks(rotation=0, fontsize=8)
plt.xlabel("Targettype")
plt.ylabel("count")
plt.title("Top 5 Targettype, Iraq (2012-2014)",fontsize=15)
plt.show()

df_Af = terr_topRate[terr_topRate['Country'] == 'Afghanistan']

fig,ax = plt.subplots(figsize=(12,4))
ax = sns.barplot(x=df_Af.Group.value_counts()[:5].values,y = df_Af.Group.value_counts()[:5].index, palette='crest')
ax.set_title('Terrorist Groups, Afghanistan (2012-2014)')

plt.figure(figsize=(4, 2))
sns.barplot(x=df_Af_Ta['Year'].value_counts().index, y=df_Af_Ta['Year'].value_counts().values, palette='viridis')
plt.title('Terror Attacks by Taliban, Afghanistan (2012-2014)')
plt.xlabel('Years')
plt.ylabel('Number of Attacks')
plt.show()

df_Af['City'].value_counts()[1:11].to_frame().sort_values('count', ascending=False).plot(kind='bar',figsize=(12,4),color='seagreen')
plt.xlabel("City")
plt.ylabel("Number of attack")
plt.title("Top 10 most effected city in Afghanistan(2012-2014)", fontsize=15)
plt.show()

df_Af['Attacktype'].value_counts()[:5].plot(kind='bar',figsize=(12, 4),color='cadetblue')
plt.xticks(rotation=0, fontsize=8)
plt.xlabel("Attacktype")
plt.ylabel("Number of attack")
plt.title("Top 5 Attacktype, Afghanistan (2012-2014)",fontsize=15)
plt.show()

df_Af['Targettype'].value_counts()[:5].plot(kind='bar',figsize=(12, 4),color='cadetblue')
plt.xticks(rotation=0, fontsize=8)
plt.xlabel("Targettype")
plt.ylabel("count")
plt.title("Top 5 Targettype, Afghanistan (2012-2014)",fontsize=15)
plt.show()

df_Pakistan = terr_topRate[terr_topRate['Country'] == 'Pakistan']

fig,ax = plt.subplots(figsize=(12,4))
ax = sns.barplot(x=df_Pakistan.Group.value_counts()[1:6].values,y = df_Pakistan.Group.value_counts()[1:6].index, palette='YlOrBr')
ax.set_title('Terrorist Groups, Pakistan (2012-2014)')

plt.figure(figsize=(4, 2))
sns.barplot(x=df_Paki_TTP['Year'].value_counts().index, y=df_Paki_TTP['Year'].value_counts().values, palette='viridis')
plt.title('Terror Attacks by TTP, Pakistan (2012-2014)')
plt.xlabel('Years')
plt.ylabel('Number of Attacks')
plt.show()

df_Pakistan['City'].value_counts()[:10].to_frame().sort_values('count', ascending=False).plot(kind='bar',figsize=(12,4),color='khaki')
plt.xlabel("City")
plt.ylabel("Number of attack")
plt.title("Top 10 most effected city in Pakistan (2012-2014)", fontsize=15)
plt.show()

df_Pakistan['Attacktype'].value_counts()[:5].plot(kind='bar',figsize=(12, 4),color='darkkhaki')
plt.xticks(rotation=0, fontsize=8)
plt.xlabel("Attacktype")
plt.ylabel("Number of attack")
plt.title("Top 5 Attacktype, Pakistan (2012-2014)",fontsize=15)
plt.show()

df_Pakistan['Targettype'].value_counts()[:5].plot(kind='bar',figsize=(12, 4),color='darkkhaki')
plt.xticks(rotation=0, fontsize=8)
plt.xlabel("Targettype")
plt.ylabel("count")
plt.title("Top 5 Targettype, Pakistan (2012-2014)",fontsize=15)
plt.show()

df_Nigeria = terr_topRate[terr_topRate['Country'] == 'Nigeria']

fig,ax = plt.subplots(figsize=(12,4))
ax = sns.barplot(x=df_Nigeria.Group.value_counts()[:5].values,y = df_Nigeria.Group.value_counts()[:5].index, palette='ch:start=.2,rot=-.3')
ax.set_title('Terrorist Groups, Nigeria (2012-2014)')

plt.figure(figsize=(4, 2))
sns.barplot(x=df_Ni_Bo['Year'].value_counts().index, y=df_Ni_Bo['Year'].value_counts().values, palette='viridis')
plt.title('Terror Attacks by Taliban, Iraq (2012-2014)')
plt.xlabel('Years')
plt.ylabel('Number of Attacks')
plt.show()

df_Nigeria['City'].value_counts()[:10].to_frame().sort_values('count', ascending=False).plot(kind='bar',figsize=(12,4),color='lightslategray')
plt.xlabel("City")
plt.ylabel("Number of attack")
plt.title("Top 10 most effected city in Nigeria (2012-2014)", fontsize=15)
plt.show()

df_Nigeria['Attacktype'].value_counts()[:5].plot(kind='bar',figsize=(12, 4),color='darkgrey')
plt.xticks(rotation=0, fontsize=8)
plt.xlabel("Attacktype")
plt.ylabel("Number of attack")
plt.title("Top 5 Attacktype, Nigeria (2012-2014)",fontsize=15)
plt.show()

df_Nigeria['Targettype'].value_counts()[:5].plot(kind='bar',figsize=(12, 4),color='darkgrey')
plt.xticks(rotation=0, fontsize=8)
plt.xlabel("Targettype")
plt.ylabel("count")
plt.title("Top 5 Targettype, Nigeria (2012-2014)",fontsize=15)
plt.show()

연도별(10년 단위) 특성 분석

terr_df['Year'].unique()

df_70s = terr_df.loc[(terr_df['Year']==1970) | (terr_df['Year']==1971) | (terr_df['Year']==1972) | (terr_df['Year']==1973) | (terr_df['Year']==1974) | (terr_df['Year']==1975) | (terr_df['Year']==1976) | (terr_df['Year']==1977) | (terr_df['Year']==1978) | (terr_df['Year']==1979)]
df_80s = terr_df.loc[(terr_df['Year']==1980) | (terr_df['Year']==1981) | (terr_df['Year']==1982) | (terr_df['Year']==1983) | (terr_df['Year']==1984) | (terr_df['Year']==1985) | (terr_df['Year']==1986) | (terr_df['Year']==1987) | (terr_df['Year']==1988) | (terr_df['Year']==1989)]
df_90s = terr_df.loc[(terr_df['Year']==1990) | (terr_df['Year']==1991) | (terr_df['Year']==1992) | (terr_df['Year']==1993) | (terr_df['Year']==1994) | (terr_df['Year']==1995) | (terr_df['Year']==1996) | (terr_df['Year']==1997) | (terr_df['Year']==1998) | (terr_df['Year']==1999)]
df_00s = terr_df.loc[(terr_df['Year']==2000) | (terr_df['Year']==2001) | (terr_df['Year']==2002) | (terr_df['Year']==2003) | (terr_df['Year']==2004) | (terr_df['Year']==2005) | (terr_df['Year']==2006) | (terr_df['Year']==2007) | (terr_df['Year']==2008) | (terr_df['Year']==2009)]
df_10s = terr_df.loc[(terr_df['Year']==2010) | (terr_df['Year']==2011) | (terr_df['Year']==2012) | (terr_df['Year']==2013) | (terr_df['Year']==2014) | (terr_df['Year']==2015) | (terr_df['Year']==2016) | (terr_df['Year']==2017)]

pd.crosstab(df_70s.Year,df_70s.Region).plot(figsize=(12,4))
# plt.title('Terrorist Attack By Region')
plt.title('Terrorism By Region')
plt.ylabel('counts')

70년대

plt.figure(figsize=(12,4))
sns.barplot(x = df_70s['Region'].value_counts().values[:10], y = df_70s['Region'].value_counts()[:10].index,palette = 'autumn')
plt.xlabel('Number of Attacks')
plt.ylabel('Region')
plt.title('Top 10 Attacks in 70s',size=15)

pd.crosstab(df_70s.Region,df_70s.Attacktype).plot.barh(stacked=True)
fig=plt.gcf()
fig.set_size_inches(12,7)
plt.show()

pd.crosstab(df_70s.Region,df_70s.Weapon).plot.barh(stacked=True)
fig=plt.gcf()
fig.set_size_inches(12,7)
plt.show()

pd.crosstab(df_70s.Region,df_70s.Targettype).plot.barh(stacked=True)
fig=plt.gcf()
fig.set_size_inches(12,7)
plt.show()ㅊ

attack_data = df_70s.groupby('Region')[['Kill', 'Wound']].sum()
attack_data.plot(kind='bar', stacked=True,figsize = (12,4))
plt.xlabel('Region')
plt.ylabel('Count')
plt.title('Kill & Wound in 70s')
plt.show()

80년대

plt.figure(figsize=(12,4))
sns.barplot(x = df_80s['Region'].value_counts().values[:10], y = df_80s['Region'].value_counts()[:10].index,palette = 'autumn')
plt.xlabel('Number of Attacks')
plt.ylabel('Region')
plt.title('Top 10 Attacks in 80s',size=15)

pd.crosstab(df_80s.Region,df_80s.Attacktype).plot.barh(stacked=True)
fig=plt.gcf()
fig.set_size_inches(12,7)
plt.show()

pd.crosstab(df_80s.Region,df_80s.Weapon).plot.barh(stacked=True)
fig=plt.gcf()
fig.set_size_inches(12,7)
plt.show()

df_80s['Weapon'].value_counts()[:5].to_frame().sort_values('count', ascending=False).plot(kind='bar',figsize=(12,4),color='lightslategray')
plt.xlabel("Weapon")
plt.ylabel("Number of attack")
plt.title("Top 5 Weapons in 80s", fontsize=15)
plt.show()

df_80s['Targettype'].value_counts()[:10].to_frame().sort_values('count', ascending=False).plot(kind='bar',figsize=(12,4),color='lightslategray')
plt.xlabel("Targettype")
plt.ylabel("Number of attack")
plt.title("Top 10 Targettype in 80s", fontsize=15)
plt.show()

90년대

plt.figure(figsize=(12,4))
sns.barplot(x = df_90s['Region'].value_counts().values[:10], y = df_90s['Region'].value_counts()[:10].index,palette = 'autumn')
plt.xlabel('Number of Attacks')
plt.ylabel('Region')
plt.title('Top 10 Attacks in 90s',size=15)

pd.crosstab(df_90s.Region,df_90s.Attacktype).plot.barh(stacked=True)
fig.set_size_inches(12,4)
plt.show()

df_90s['Attacktype'].value_counts()[:5].to_frame().sort_values('count', ascending=False).plot(kind='bar',figsize=(12,4),color='lightslategray')
plt.xlabel("Weapon")
plt.ylabel("Number of attack")
plt.title("Top 5 Attacktype in 90s", fontsize=15)
plt.xticks(rotation=0)
plt.show()

df_90s['Targettype'].value_counts()[:10].to_frame().sort_values('count', ascending=False).plot(kind='bar',figsize=(12,4),color='lightslategray')
plt.xlabel("Targettype")
plt.ylabel("Number of attack")
plt.title("Top 10 Targettype in 90s", fontsize=15)
plt.xticks(rotation=30)
plt.show()

2000년대

plt.figure(figsize=(12,4))
sns.barplot(x = df_00s['Region'].value_counts().values[:10], y = df_00s['Region'].value_counts()[:10].index,palette = 'autumn')
plt.xlabel('Number of Attacks')
plt.ylabel('Region')
plt.title('Top 10 Attacks in 2000',size=15)

attack_data = df_00s.groupby('Region')[['Kill', 'Wound']].sum()
attack_data.plot(kind='bar', stacked=True,figsize = (12,4))
plt.xlabel('Region')
plt.ylabel('Count')
plt.title('Kill & Wound in 90s')
plt.xticks(rotation=30)
plt.show()

df_2000_MN = df_00s[df_00s['Region'] == 'Middle East & North Africa']

plt.figure(figsize=(12, 4))
sns.barplot(x=df_2000_MN['Year'].value_counts().index, y=df_2000_MN['Year'].value_counts().values, palette='viridis')
plt.title('Terror Attacks in Middle East & North Africa (2000s)')
plt.xlabel('Years')
plt.ylabel('Number of Attacks')
plt.show()

a = df_2000_MN[df_2000_MN['Year'] == 2008]
a['City'].value_counts()[:10].to_frame().sort_values('count', ascending=False).plot(kind='bar',figsize=(12,4),color='cadetblue')
plt.xlabel("City")
plt.ylabel("Number of attack")
plt.title("Top 10 most effected city in Middle East & North Africa (2008y)", fontsize=15)
plt.show()

a = df_00s[(df_00s['City'] == 'Baghdad') | (df_00s['Year'] == 2008)]
plt.figure(figsize=(12, 4))
sns.barplot(x=a['Targettype'].value_counts()[:5].index, y=a['Targettype'].value_counts()[:5].values, palette='viridis')
plt.title('Targettype in Baghdad(Middle East & North Africa, 2008y)')
plt.xlabel('Years')
plt.ylabel('Number of Attacks')
plt.show()

df_2000_SA = df_00s[df_00s['Region'] == 'South Asia']

plt.figure(figsize=(12, 4))
sns.barplot(x=df_2000_SA['Year'].value_counts().index, y=df_2000_SA['Year'].value_counts().values, palette='viridis')
plt.title('Terror Attacks in South Asia (2000s)')
plt.xlabel('Years')
plt.ylabel('Number of Attacks')
plt.show()

b = df_2000_SA[df_2000_SA['Year'] == 2009]
b['City'].value_counts()[:10].to_frame().sort_values('count', ascending=False).plot(kind='bar',figsize=(12,4),color='cadetblue')
plt.xlabel("City")
plt.ylabel("Number of attack")
plt.title("Top 10 most effected city in South Asia (2009y)", fontsize=15)
plt.show()

b = df_00s[(df_00s['City'] == 'Quetta') | (df_00s['Year'] == 2009)]
plt.figure(figsize=(12, 4))
sns.barplot(x=b['Targettype'].value_counts()[:5].index, y=b['Targettype'].value_counts()[:5].values, palette='viridis')
plt.title('Targettype in Quetta(South Asia, 2009y)')
plt.xlabel('Years')
plt.ylabel('Number of Attacks')
plt.show()

b = df_00s[(df_00s['City'] == 'Peshawar') | (df_00s['Year'] == 2009)]
plt.figure(figsize=(12, 4))
sns.barplot(x=b['Targettype'].value_counts()[:5].index, y=b['Targettype'].value_counts()[:5].values, palette='YlOrBr')
plt.title('Targettype in Peshawar(South Asia, 2009y)')
plt.xlabel('Years')
plt.ylabel('Number of Attacks')
plt.show()

2010년

plt.figure(figsize=(12,4))
sns.barplot(x = df_10s['Region'].value_counts().values[:10], y = df_10s['Region'].value_counts()[:10].index,palette = 'autumn')
plt.xlabel('Number of Attacks')
plt.ylabel('Region')
plt.title('Top 10 Attacks in 2010s',size=15)

attack_data = df_10s.groupby('Region')[['Kill', 'Wound']].sum()
attack_data.plot(kind='bar', stacked=True,figsize = (12,4))
plt.xlabel('Region')
plt.ylabel('Count')
plt.title('Kill & Wound in 2010s')
plt.xticks(rotation=90)
plt.show()

df_2010_MN = df_10s[df_10s['Region'] == 'Middle East & North Africa']

plt.figure(figsize=(12, 4))
sns.barplot(x=df_2010_MN['Year'].value_counts().index, y=df_2010_MN['Year'].value_counts().values, palette='viridis')
plt.title('Terror Attacks in Middle East & North Africa (2010s)')
plt.xlabel('Years')
plt.ylabel('Number of Attacks')
plt.show()

c = df_2010_MN[df_2010_MN['Year'] == 2014]
c['City'].value_counts()[:10].to_frame().sort_values('count', ascending=False).plot(kind='bar',figsize=(12,4),color='cadetblue')
plt.xlabel("City")
plt.ylabel("Number of attack")
plt.title("Top 10 most effected city in Middle East & North Africa (2014y)", fontsize=15)
plt.show()

d = df_10s[(df_10s['City'] == 'Baghdad') | (df_10s['Year'] == 2014)]
plt.figure(figsize=(12, 4))
sns.barplot(x=d['Targettype'].value_counts()[:5].index, y=d['Targettype'].value_counts()[:5].values, palette='viridis')
plt.title('Targettype in Baghdad(Middle East & North Africa, 2014)')
plt.xlabel('Years')
plt.ylabel('Number of Attacks')
plt.show()

한국 집계

#Preparing the data for analysis
Ko = terr_df[terr_df.Country == 'South Korea']
Ko_cities = Ko.groupby(by='City',as_index=False).count().sort_values(by='eventid',ascending=False).iloc[:5,]

Ko_kill_size = Ko['Kill'].sum() / len(Ko)
labels = ['Kill', 'Not Kill']

Ko_year = Ko.groupby(by='Year', as_index=False).sum().loc[:, ['Year', 'Kill']]

Iraq_weapon = Ko.groupby(by='Weapon',as_index=False).count().sort_values(by='eventid',ascending=False).iloc[:,:2]
fig, axs = plt.subplots(nrows=2, ncols=2, figsize=(15, 10))

# Plot 1 - Top 5 terrorism cities    
sns.barplot(x='eventid', y='City', data=Ko_cities, ci=None, ax=axs[0, 0],palette='summer')
axs[0, 0].set_title(f'Top 5 South Korea Cities With Most Terrorism Occurences')
axs[0, 0].set_ylabel('City')
axs[0, 0].set_xlabel('Victims')

# Plot 2 - Suicide Rate
center_circle = plt.Circle((0,0), 0.75, color='white')
axs[0, 1].pie((Ko_kill_size, 1-Ko_kill_size), labels=labels,colors=['crimson','green'] , autopct='%1.1f%%')
axs[0, 1].add_artist(center_circle)
axs[0, 1].set_title('South Korea Terrorism kill Rate')
axs[0, 0].set_ylabel('Victims')

# Plot 3 - Victims through the years
sns.lineplot(x='Year', y='Kill', data=Ko_year, ax=axs[1, 0],color='crimson')
axs[1, 0].set_xlim([1970, 2017])
axs[1, 0].set_title('South Korea Number of Victims Over Time')
axs[1, 0].set_ylabel('Victims')

# Plot 4 - Terrorism Weapons
sns.barplot(x='Weapon', y='eventid', data=Iraq_weapon, ci=None, ax=axs[1, 1],palette='summer')
axs[1, 1].set_xticklabels(axs[1, 1].get_xticklabels(), rotation=90)
axs[1, 1].set_xlabel('')
axs[1, 1].set_ylabel('Count')
axs[1, 1].set_title('South Korea Weapons Used in Attacks')

plt.suptitle('Terrorism Analysis in South Korea between 1970 and 2017', size=16)    
plt.subplots_adjust(top=0.90)
plt.show()

pd.crosstab(Ko.Year,Ko.City).plot(figsize=(12,4))
# plt.title('Terrorist Attack By Region')
plt.title('Terrorism in Korea')
plt.ylabel('counts')

plt.figure(figsize=(12, 4))
sns.barplot(x=Ko['City'].value_counts().index, y=Ko['City'].value_counts().values, palette='viridis')
plt.title('Attacks by Student Radicals, Korea')
plt.xlabel('Years')
plt.ylabel('Number of Attacks')
plt.show()

plt.figure(figsize=(12,4))
sns.barplot(x = Ko['City'].value_counts().values, y = Ko['City'].value_counts().index,palette = 'autumn')
plt.xlabel('Number of Attacks')
plt.ylabel('Region')
plt.title('Attacks in Korea',size=15)

제로베이스 데이터 스쿨

SQL - mini test _ 세계 테러 분석

Sun, 28 Jan 2024 16:50:57 GMT

원본 Data Download

https://www.kaggle.com/datasets/START-UMD/gtd

문제 1. csv 파일에 저장된 세계 테러 데이터를 하나의 테이블에 저장하세요.

globalterrorismmdb_0718.csv - https://www.kaggle.com/datasets/START-UMD/gtd
pandas의 to_sql 함수 사용 (힌트 : create_engine)
Table name : origin_terror_data

# !pip install sqlalchemy
# !pip install pymysql
# !pip install SQLAlchemy Flask-SQLAlchemy

# 실수로 oneday DB를 삭제해서...다시 생성(1)
import mysql.connector

conn = mysql.connector.connect(
    host = "내꺼",
    port = 3306,
    user = "admin",
    password = "내꺼",
    database = "zerobase"
)

cursor = conn.cursor(buffered = True)
sql = 'create database oneday default character set utf8mb4'
cursor.execute(sql)

cursor.execute("create user 'oneday'@'%' identified by '1234'")
cursor.execute("grant all on oneday.* to 'oneday'@'%'")

conn = mysql.connector.connect(
    host = "내꺼",
    port = 3306,
    user = "oneday",
    password = "1234",
    database = "oneday"
)

import time
import pandas as pd
import pymysql
from sqlalchemy import create_engine
import configparser

# 데이터 불러오기
df = pd.read_csv('./globalterrorismdb_0718dist.csv', encoding='ISO-8859-1')

# DB 접속 엔진 객체 생성
user = 'oneday'
password = '1234'
host = '내꺼'
port = 3306
database = 'oneday'

# Engine 객체 설정 (URL 문자열을 사용하여 데이터베이스 호스트 연결)
engine = create_engine(f'mysql+pymysql://{user}:{password}@{host}:{port}/{database}?charset=utf8mb4')

# DB 테이블 명(생성될 테이블 이름)
table_name = "origin_terror_data"

# DB에 DataFrame 적재
df.to_sql(index = False, 
          name = table_name,
          con = engine,
          if_exists = 'append',
          method = 'multi', 
          chunksize = 10000)

# (에러) 'Engine' object has no attribute 'execute'
# records = engine.execute("SELECT COUNT(*) FROM origin_terror_data").fetchall()
# print(records)

# 방법을 바꿈 (참고 : https://blog.naver.com/lechga/223290561410)
from sqlalchemy import text

conn = engine.connect()

with engine.connect() as conn:
    records = conn.execute(text("SELECT COUNT(*) FROM origin_terror_data")).fetchall()
    print(records)

문제 2. origin_terror_data 에서 region, country 관련 데이터는 code 와 txt (name) 속성으로 정의되어 있습니다. 문제 2-1. Region 및 Country 테이블을 그림과 같은 구조로 생성하세요.

origin_terror_data 를 분석하여 각 테이블의 데이터 타입을 정의하세요.
문자열 데이터의 사이즈는 origin_terror_data 테이블에서 해당 데이터의 max length 를 쿼리로 체크하여 정의하세요.
Region 과 Country 데이터 사이의 관계를 파악하여 Foreign Key 를 설정하세요. 참고>
Region.region_code = origin_terror_data.region
Region.region_name = origin_terror_data.region_txt
Country.country_code = origin_terror_data.country
Country.country_name = origin_terror_data.country_txt

##############################################################################################
#  문제 2. region / country / city 데이터 추출하여 데이터베이스로 변환하기 
#  중복을 제거한 code - name 값 
#  region - country - city 관계 정의 
##############################################################################################
import mysql.connector

conn = mysql.connector.connect(
    host = 'database-1.cj22sogoe8oa.ap-southeast-2.rds.amazonaws.com',
    port = 3306,
    user = "oneday",
    password = "1234",
    database = "oneday"
)
cursor = conn.cursor(buffered=True)

# region_txt 의 max length 체크 
region_maxL = 'select max(char_length(region_txt)) from origin_terror_data'

cursor.execute(region_maxL)
result = cursor.fetchall()
result

# Region 테이블 만들기
region_table = ("create table Region(region_code int not null auto_increment primary key, region_name varchar(32))")
cursor.execute(region_table)
conn.commit()

sql = ('desc Region')
cursor.execute(sql)
result = cursor.fetchall()
for i in result:
    print(i)

# country_txt 의 max length 체크 

country_maxL = "select max(char_length(country_txt)) from origin_terror_data"

cursor.execute(country_maxL)
result = cursor.fetchall()
result

# Country 테이블 만들기 
country_table = ("create table Country ("
        "country_code int not null auto_increment primary key, "
        "region_code int, "
        "country_name varchar(32), "
        "foreign key (region_code) references Region(region_code)"
        ")"
        )
cursor.execute(country_table)
conn.commit()

# desc country
sql = ('desc Country')
cursor.execute(sql)
result = cursor.fetchall()
for i in result:
    print(i)

문제 2-2. origin_terror_data 테이블에서 Region 및 Country 데이터를 추출하여 문제 2-1.에서 생성한 테이블에 입력하고 확인하세요.

중복을 제거한 Unique Data 를 추출하세요.
데이터를 INSERT 할때 순서를 고민하세요.

# Region 데이터 추출하기 

region_data = ('SELECT DISTINCT region, region_txt FROM origin_terror_data ORDER BY region ASC')
cursor.execute(region_data)

result = cursor.fetchall()
for i in result:
    print(i)

# Region 데이터 추출하기 

region_data = ('SELECT DISTINCT region, region_txt FROM origin_terror_data ORDER BY region ASC')
cursor.execute(region_data)

result = cursor.fetchall()
print(result)

# Region 테이블에 INSERT 
region_insert = ('INSERT INTO Region(region_code, region_name) SELECT DISTINCT region, region_txt FROM origin_terror_data')

cursor.execute(region_insert)
conn.commit()

# Country 데이터 추출하기 
country_data = ('SELECT DISTINCT country, country_txt FROM origin_terror_data')
cursor.execute(country_data)

result = cursor.fetchall()
print(result)

# Country 테이블에 INSERT 
country_insert = ("INSERT INTO Country (country_code, region_code, country_name)"
        "SELECT DISTINCT country, region, country_txt FROM origin_terror_data;")

cursor.execute(country_insert)
conn.commit()

문제 3. origin_terror_data 에서 attack type, target type, weapon type 관련 데이터는 code 와 txt 속성으로 정의되어 있습니다. 문제 3-1. AttackType, TargetType, WeaponType 테이블을 그림과 같은 구조로 생성하세요.

origin_terror_data 를 분석하여 각 테이블의 데이터 타입을 정의하세요.
문자열 데이터의 사이즈는 origin_terror_data 테이블에서 해당 데이터의 max length 를 쿼리로 체크하여 정의하세요. 참고>
AttackType.attacktype_code = origin_terror_data.attacktype1
AttackType.attacktype_desc = origin_terror_data.attacktype1_txt
TargetType.targtype_code = origin_terror_data.targtype1
TargetType.targtype_desc = origin_terror_data.targtype1_txt
WeaponType.weaptype_code = origin_terror_data.weaptype1
WeaponType.weaptype_desc = origin_terror_data.weaptype1_txt

# attacktype1 의 max length 체크 

attacktype1 = "SELECT max(char_length(attacktype1_txt)) FROM origin_terror_data"

cursor.execute(attacktype1)
result = cursor.fetchall()
result

# AttackType 테이블 만들기 
sql = ("CREATE table AttackType ("
        "attacktype_code int not null auto_increment primary key, "
        "attacktype_desc varchar(35) "
        ")"
        )

cursor.execute(sql)
conn.commit()

# targettype1 의 max length 체크 
targettype1_l = 'SELECT max(char_length(targtype1_txt)) FROM origin_terror_data;'

cursor.execute(targettype1_l)
result = cursor.fetchall()
result

# TargetType 테이블 만들기 
TargetType = ("CREATE table TargetType ("
        "targtype_code int not null auto_increment primary key, "
        "targtype_desc varchar(32) "
        ")"
        )

cursor.execute(TargetType)
conn.commit()

# weaptype1 의 max length 체크 
weaptype1_l = 'SELECT max(char_length(weaptype1_txt)) FROM origin_terror_data'

cursor.execute(weaptype1_l)
result = cursor.fetchall()
result

# WeaponType 테이블 만들기 
WeaponType = ("create table WeaponType ("
        "weaptype_code int not null auto_increment primary key, "
        "weaptype_desc varchar(80) "
        ")"
        )

cursor.execute(WeaponType)
conn.commit()

문제 3-2. origin_terror_data 테이블에서 Attack Type, Target Type, Weapon Type 데이터를 추출하여 문제 3-1.에서 생성한 테이블에 입력하고 확인하세요.

중복을 제거한 Unique Data 를 추출하세요.
데이터를 INSERT 할때 순서를 고민하세요.

# attacktype1 데이터 추출하기 
attacktype1_data = ('SELECT DISTINCT attacktype1, attacktype1_txt FROM origin_terror_data ORDER BY attacktype1 ASC')
cursor.execute(attacktype1_data)

result = cursor.fetchall()
for i in result:
    print(i)

# AttackType 테이블에 INSERT 
AttackType_data = ("INSERT INTO AttackType (attacktype_code, attacktype_desc)"
        "SELECT DISTINCT attacktype1, attacktype1_txt FROM origin_terror_data")

cursor.execute(AttackType_data)
conn.commit()

# desc AttackType
sql = ('desc AttackType')
cursor.execute(sql)
result = cursor.fetchall()
for i in result:
    print(i)

# targtype1 데이터 추출하기 
targtype1_data = ('SELECT DISTINCT targtype1, targtype1_txt FROM origin_terror_data ORDER BY targtype1 ASC ')
cursor.execute(targtype1_data)

result = cursor.fetchall()
for i in result:
    print(i)

# TargetType 테이블에 INSERT 

# ALTER TABLE tablename
# CHANGE COLUMN old_columnname new_columnname new_datatype;

targetType_insert = ('INSERT INTO TargetType (targtype_code, targtype_desc) SELECT DISTINCT targtype1, targtype1_txt FROM origin_terror_data')

cursor.execute(targetType_insert)
conn.commit()

# desc TargetType
sql = ('desc TargetType')
cursor.execute(sql)
result = cursor.fetchall()
for i in result:
    print(i)

# weaptype1 데이터 추출하기 
weaptype1_data = ('SELECT DISTINCT weaptype1, weaptype1_txt FROM origin_terror_data ORDER BY weaptype1 ASC')
cursor.execute(weaptype1_data)

result = cursor.fetchall()
for i in result:
    print(i)

# WeaponType 테이블에 INSERT 
sql = ('INSERT INTO WeaponType (weaptype_code, weaptype_desc) SELECT DISTINCT weaptype1, weaptype1_txt FROM origin_terror_data')

cursor.execute(sql)
conn.commit()

# desc WeaponType
sql = ('desc WeaponType')
cursor.execute(sql)
result = cursor.fetchall()
for i in result:
    print(i)

문제 4. TerrorData 테이블을 만들고 앞서 만들어둔 테이블과 관계를 설정하도록 하겠습니다. 문제 4-1. TerrorData 테이블을 앞의 그림과 같이 생성하세요.

origin_terror_data 를 분석하여 데이터 타입을 정의하세요.
문자열 데이터의 사이즈는 origin_terror_data 테이블에서 해당 데이터의 max length 를 쿼리로 체크하여 정의하세요. 참고>
TerrorData.terror id : Auto Increment
TerrorData.city_name = origin_terror_data.city
TerrorData.target = orgin_terror_data.target1
TerrorData.group_name = origin_terror_data.gname
TerrorData.kill_count = origin_terror_data.nkill
TerrorData.wound_count = origin_terror_data.nwound
TerrorData.motive = origin_terror_data.motive
TerrorData.summary = origin_terror_data.summary
TerrorData.latitude = origin_terror_data_latitude
TerrorData.longitude = origin_terror_data_longitude
TerrorData.terror_date = origin_terror_data.iyear + origin_terror_Data.imonth + origin_terror_data.iday (Date Type)

# max length 체크 

# city 의 max length 체크 
city_ML = 'SELECT max(char_length(city)) FROM origin_terror_data'
cursor.execute(city_ML)
city = cursor.fetchone()

# target1 의 max length 체크 
target1_ML = 'SELECT max(char_length(target1)) FROM origin_terror_data'
cursor.execute(target1_ML)
target = cursor.fetchone()

# gname 의 max length 체크 
gname_ML = 'SELECT max(char_length(gname)) FROM origin_terror_data'
cursor.execute(gname_ML)
gname = cursor.fetchone()

# summary 의 max length 체크 
summary_ML = 'SELECT max(char_length(summary)) FROM origin_terror_data'
cursor.execute(summary_ML)
summary = cursor.fetchone()

# motive 의 max length 체크 
motive_ML = 'SELECT max(char_length(motive)) FROM origin_terror_data'
cursor.execute(motive_ML)
motive = cursor.fetchone()

print(f'city: {city}')
print(f'target1: {target}')
print(f'gname: {gname}')
print(f'summary: {summary}')
print(f'motive: {motive}')

# TerrorData 테이블 만들기 
terrorData_table = ("create table TerrorData ("
        "terror_id int not null auto_increment primary key, "
        "terror_date date, "
        "region_code int, "
        "country_code int, "
        "city varchar(65), "
        "target varchar(350), "
        "group_name varchar(120), "
        "targtype_code int, "
        "attacktype_code int, "  
        "weaptype_code int, "
        "kill_count int, "
        "wound_count int, "     
        "motive varchar(900), "
        "summary varchar(2450), "
        "latitude decimal(16, 14), "
        "longitude decimal(17, 14), "  
        "foreign key (region_code) references Region(region_code), "
        "foreign key (country_code) references Country(country_code), "
        "foreign key (attacktype_code) references AttackType(attacktype_code), "
        "foreign key (targtype_code) references TargetType(targtype_code), "
        "foreign key (weaptype_code) references WeaponType(weaptype_code) "
        ");"
        )

cursor.execute(terrorData_table)
conn.commit()

문제 4-2. origin_terror_data 테이블에서 Terror Data를 추출하여 문제 4-1.에서 생성한 테이블에 입력하고 확인하세요.

앞서 생성한 Region, Country, AttackType, TargetType, WeaponType 데이터와의 관계에 주의하세요.
Count 값을 가지는 칼럼의 값이 null 인 경우, 0으로 예외처리 해주세요.
위도 경도 데이터 중 범위를 넘어서는 데이터가 존재합니다. 이 경우, null 값으로 예외처리 해주세요. (위도 경도 범위 : 구글링해보세요.)
terror_date 칼럼의 경우, origin_terror_data 의 연, 월, 일 정보를 조합하여 date type 으로 정의해주세요. (Format : ‘YYYY-mm-dd’)
origin_terror_data 의 월, 일 정보중 값이 0 인 경우 date type 으로 변환되지 않습니다. 이 경우, 1 로 예외처리 해주세요.
데이터 입력까지 완료한 이후, origin_terror_data 테이블을 삭제하고 확인하세요.

# data 전처리 
# date type : year + month + day (month = 0 인경우 1, day = 0 인경우 1)
# nkill, nwound : null 인 경우 0
# longitude range : 180 ~ -180
# check : select longitude from origin_terror_data where longitude < -180 or longitude > 180; '-86185896'

sql = ("INSERT INTO TerrorData (region_code, country_code, attacktype_code, targtype_code, weaptype_code, terror_date, city, target, group_name, kill_count, wound_count, motive, summary, latitude, longitude) "
        "SELECT region, country, attacktype1, targtype1, weaptype1, city, target1, gname, "
        "IF(nkill IS NULL, 0, nkill), "   
        "IF(nwound IS NULL, 0, nwound), "
        "motive, summary, "
        "CASE WHEN latitude BETWEEN -90 and 90 THEN NULL ELSE latitude END, "
        "CASE WHEN longitude BETWEEN -180 and 180 THEN NULL ELSE longitude END, "
        "STR_TO_DATE(CONCAT(IF(iyear = 0, 1, iyear)'-'IF(imonth = 0, 1, imonth)'-'IF(iday = 0, 1, iday)), '%Y-%m-%d') FROM origin_terror_data")

cursor.execute(sql)
conn.commit()

# terror 데이터 추출하기 
# desc TerrorData
sql = ('desc TerrorData')
cursor.execute(sql)
result = cursor.fetchall()
for i in result:
    print(i)

sql = 'SELECT COUNT(*) FROM TerrorData'
cursor.execute(sql)
result = cursor.fetchall()
print(result)

문제 5. TerrorData 의 전체 기간에서 테러의 숫자를 연도별로 집계하여 연도별 테러 발생 건수를 조회하세요.

답 틀림...🙄

sql = "SELECT DATE_FORMAT(terror_date, '%Y') as Y, count(*) as C FROM TerrorData GROUP BY Y"
cursor.execute(sql)
result = cursor.fetchall()
for i in result:
    print(i)

문제 6. TerrorData 에서 테러가 가장 많이 일어난 순서로 국가를 정렬하여 상위 10위 국가를 조회하세요.

# 테러가 많이 일어난 상위 10위 Region
terrorRegion_10 = ("SELECT R.region_name, COUNT(*) FROM TerrorData as T "
         "JOIN Region as R ON T.region_code = R.region_code "
         "GROUP BY T.region_code ORDER BY COUNT(*) DESC limit 10"
         )

cursor.execute(terrorRegion_10)
result = cursor.fetchall()
for i in result:
    print(i)

# 테러가 많이 일어난 상위 10위 Country 
terrorCountry_10 = ("SELECT C.country_name, COUNT(*) FROM TerrorData as T "
         "JOIN Country as C ON T.country_code = C.country_code "
         "GROUP BY T.country_code ORDER BY COUNT(*) DESC limit 10"
         )

cursor.execute(terrorCountry_10)
result = cursor.fetchall()
for i in result:
    print(i)

문제 7. TerrorData 에서 테러가 가장 많이 일어난 상위 10위 국가에 대해 국가별로 사망자수와 부상자수, 사상자수(사망자수 + 부상자수)를 조회하세요.

country_10 = ("SELECT C.country_name, COUNT(*), " # 모든행의 갯수
        "sum(T.kill_count), "
        "sum(T.wound_count), "
        "sum(T.kill_count + T.wound_count) "
        "FROM TerrorData as T "
        "JOIN Country as C ON T.country_code=C.country_code "
        "GROUP BY T.country_code, C.country_code "
        "ORDER BY COUNT(*)" #  COUNT(*) 값을 기준으로 descending
        "DESC limit 10")

cursor.execute(country_10)
result = cursor.fetchall()
for i in result:
    print(i)

문제 8. 지역별 테러 공격 형태에 따른 사망자수, 부상자수, 사상자수를 조회하세요.

답 틀림..🙄

# 지역별 테러 공격 형태에 따른 사망자와 사상자 수 

region_c = ("SELECT R.region_name, AttackType.attacktype_desc, "
            "sum(T.kill_count), sum(T.wound_count),"
            "sum(T.kill_count + T.wound_count) "
            "FROM TerrorData as T "
            "JOIN Region as R "
            "ON T.region_code = R.region_code "
            "JOIN AttackType ON T.attacktype_code = AttackType.attacktype_code "
            "GROUP BY R.region_name, AttackType.attacktype_desc")

cursor.execute(region_c)
result = cursor.fetchall()
for i in result:
    print(i)

제로베이스 데이티 스쿨

SQL - mini test _ 유가 분석

Sun, 28 Jan 2024 04:31:51 GMT

하루 온종일 풀어본 SQL 유가 분석

ctrl+shift+i

import mysql.connector

conn = mysql.connector.connect(
    host = "",
    port = 3306,
    user = "oneday",
    password = "1234",
    database = "oneday"
)

cursor = conn.cursor(buffered=True)

# gas_brand
sql_b = "CREATE TABLE GAS_BRAND(" + \
            "id int not null auto_increment primary key, " + \
            "name varchar(16) not null)"

cursor.execute(sql_b)


# gas_station
sql_s = "CREATE TABLE GAS_STATION(" + \
            "id int auto_increment primary key, " +\
            "brand int not null, " +\
            "name varchar(64) not null, " +\
            "city char(2) not null, " +\
            "gu varchar(10) not null, " +\
            "address varchar(128) not null, " +\
            "gasoline int not null, " +\
            "diesel int not null, " +\
            "self boolean not null, " +\
            "car_wash boolean not null, " +\
            "charging_station boolean not null, " +\
            "car_maintenance boolean not null, " +\
            "convenience_store boolean not null, " +\
            "24_hours boolean not null, " +\
            "lat decimal(16,14) not null, " +\
            "lng decimal(17,14) not null, " +\
            "foreign key (brand) references GAS_BRAND(id));"

cursor.execute(sql_s)

queries1 = [
    (1, 'SK에너지'),
    (2, 'HD현대오일뱅크'),
    (3, 'GS칼텍스'),
    (4, 'S-OIL'),
    (5, '알뜰주유소'),
    (6, '자가상표')
]

query = "INSERT INTO GAS_BRAND VALUES (%s, %s)"
cursor.executemany(query, queries1)

conn.commit()

sql_result = "DESC GAS_STATION"
cursor.execute(sql_result)

result = cursor.fetchall()
for i in result:
    print(i)

sql_result = "SELECT * FROM GAS_BRAND"
cursor.execute(sql_result)

result = cursor.fetchall()
for i in result:
    print(i)

# 화폐단위 문자형 >>  숫자형 
def stringToInt(s):
    if s != '':
        s = s.replace(',', '')
        return int(s)
    else: 
        return None

stringToInt('1,000')

# 주유소 브랜드를 입력하면 GAS_BRAND 데이터를 참고하여 ID 반환
def getID(brand):
    sql_result = "SELECT * FROM GAS_BRAND"
    cursor.execute(sql_result)
    result = cursor.fetchall()
    for i in result:
        if i[1] == brand:
            return i[0]
        # 브랜드명이 '알뜰(ex)'인 경우 있음
        elif brand == '알뜰(ex)':
            return 5

getID('SK에너지')

# 주소를 입력받아 구 이름 반환
def getGu(add):
    addList = add.split()
    return addList[1]

getGu('서울시 강남구 헌릉로 730')

import googlemaps
gmaps_key = 'AIzaSyALyv5xMRzF_RJUIeJ84qh25GgNWoIJ8LM'
gmaps = googlemaps.Client(key = gmaps_key)

# 주소를 입력받아 위도, 경도 반환
def getLL(add):
    tmp = gmaps.geocode(add, language='ko')
    lat = tmp[0].get("geometry")["location"]["lat"]
    lng = tmp[0].get("geometry")["location"]["lng"]

    return lat, lng

getLL('서울시 강남구 헌릉로 730')

import time 
from selenium import webdriver
from selenium.webdriver.common.by import By
from bs4 import BeautifulSoup
from tqdm import tqdm_notebook

# 오피넷 -> 구 정보 가져오기
url = 'https://www.opinet.co.kr/searRgSelect.do'
driver = webdriver.Chrome(executable_path='../driver/chromedriver.exe')
driver.get(url)

# 시/도
sido_list_raw = driver.find_element(By.ID, "SIDO_NM0")
sido_list = sido_list_raw.find_elements(By.TAG_NAME, "option")

# 서울 선택
seoul_select = sido_list[1].get_attribute("value")
sido_list_raw.send_keys(seoul_select)

# 구 리스트 만들기
gu_list_raw = driver.find_element(By.ID, "SIGUNGU_NM0")
gu_list = gu_list_raw.find_elements(By.TAG_NAME, "option")

gu_names = [option.get_attribute("value") for option in gu_list]
gu_names = gu_names[1:]

sql = "INSERT INTO GAS_STATION (brand, name, city, gu, address, gasoline, diesel, self, " +\
        "car_wash, charging_station, car_maintenance, convenience_store, 24_hours, lat, lng) " +\
        "VALUES (%s, %s, '서울', %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s)"

def check(data, tag):
    return 'off' not in data.select_one(tag)['src']

sqltmp = "ALTER TABLE GAS_STATION MODIFY diesel int NULL;"
cursor.execute(sqltmp)
conn.commit()

for gu in tqdm_notebook(gu_names):
    element = driver.find_element(By.ID, 'SIGUNGU_NM0')
    element.send_keys(gu)
    time.sleep(0.5)

    html = driver.page_source
    soup = BeautifulSoup(html, 'html.parser')

    # 검색할 주유소 개수
    cnt = int(driver.find_element(By.ID, 'totCnt').text)

    for i in range(1, cnt+1):

        # 각 주유소 클릭
        station = driver.find_element(By.CSS_SELECTOR, f'#body1 > tr:nth-child({i}) > td.rlist > a')
        station.click()

        html = driver.page_source
        soup = BeautifulSoup(html, 'html.parser')

        data = soup.select('#os_dtail_info')[0]

        # brand
        brand = getID(data.select_one('#poll_div_nm').text)

        # name
        name = data.select_one('.header').text.strip()

        # address
        address = data.select_one('#rd_addr').text

        # gasoline
        gasoline = stringToInt(data.select_one('#b027_p').text)

        # diesel
        diesel = stringToInt(data.select_one('#d047_p').text)

        # self 
        slf = data.select_one('#SPAN_SELF_VLT_YN_ID')
        if type(slf.find('img')) == type(None):
            is_self = False
        else:
            is_self = True

        # car_wash
        car_wash = check(data, '#cwsh_yn')

        # charging_station
        charging_station = check(data, '#lpg_yn')

        # car_maintenance
        car_maintenance = check(data, '#maint_yn')

        # convenience_store
        convenience_store = check(data, '#cvs_yn')

        # 24_hours
        sel24 = check(data, '#sel24_yn')

        tmp = gmaps.geocode(address, language='ko')
        # lat
        lat = tmp[0].get('geometry')['location']['lat']

        # lng
        lng = tmp[0].get('geometry')['location']['lng']

        cursor.execute(sql, (brand, name, gu, address, gasoline, diesel, 
                            is_self, car_wash, charging_station, car_maintenance, convenience_store, sel24, lat, lng))

        conn.commit()

# 데이터 개수 확인
cursor.execute("select count(*) from GAS_STATION")
result = cursor.fetchall()
print(result[0])

# 데이터 상위 10개 출력
cursor.execute("select * from GAS_STATION limit 10")
result = cursor.fetchall()
for i in result:
    print(i)

import pandas as pd

sql = "select s.id, b.name 'brand', s.name, s.city, s.gu, s.address, s.gasoline, s.diesel, s.self, " +\
        "s.car_wash, s.charging_station, s.car_maintenance, s.convenience_store, s.24_hours, " +\
        "s.lat, s.lng " +\
        "from GAS_BRAND b, GAS_STATION s " +\
        "where b.id = s.brand ORDER BY s.id"

cursor.execute(sql)
result = cursor.fetchall()

columns = [i[0] for i in cursor.description]

df = pd.DataFrame(data=result, columns=columns)
df.to_csv("[DS]sql2_oilstation_ohjaemin.csv", index=False, encoding='euc-kr')

df = pd.read_csv("[DS]sql2_chasuhui.csv",  index_col=0, thousands=',', encoding='euc-kr')
df.head(10)

# 미왕빌딩 주소: 서울 강남구 강남대로 364
lat, lng = getLL('서울 강남구 강남대로 364')
lat, lng

# POINT(경도, 위도)
# SET @location = POINT(경도, 위도) : 기준이 되는 위치 설정
# ST_DISTANCE_SPHERE(POINT, POINT) : 두 좌표 간 거리(단위: m)

cursor.execute("SET @location = POINT(127.029340, 37.495599)")

cursor.execute("SELECT * FROM (SELECT s.id id, b.name brand, s.name name, address, \
    ST_DISTANCE_SPHERE(@location, POINT(lng, lat))/1000 distance \
    FROM GAS_BRAND b, GAS_STATION s WHERE b.id = s.brand) t \
    WHERE distance*1000 <= 1000")

result = cursor.fetchall()
for row in result:
    print(row)

cursor.execute("SELECT * FROM (SELECT s.id id, b.name brand, s.name name, address, \
    gasoline, self, 24_hours, convenience_store, \
    ST_DISTANCE_SPHERE(@location, POINT(lng, lat))/1000 distance \
    FROM GAS_BRAND b, GAS_STATION s \
    WHERE b.id = s.brand and self = 1 and 24_hours = 1 and convenience_store = 1 \
    ORDER BY distance LIMIT 10) t \
    ORDER BY gasoline")

result = cursor.fetchall()
for row in result:
    print(row)

cursor.execute("SELECT gu, b.name brand, avg(gasoline) avg_price \
    FROM GAS_BRAND b, GAS_STATION s \
    WHERE b.id = s.brand GROUP BY gu, brand ORDER BY avg_price")

result = cursor.fetchall()
for row in result:
    print(row)

conn.close()
driver.quit()

ML - 10. 앙상블 기법 - H AR, Human Activity Recognition - 센서를 활용한 행동인식 실험

Tue, 23 Jan 2024 16:05:50 GMT

앙상블 ?

📌 앙상블 기법의 voting

전체 데이터 셋에서 각기 다른 알고리즘을 돌리는 것
아는 것 다 돌려보고 다수결에 의해서 최종결정 하겠다

📌 bagging 기법

bootstrapping : 중복을 허용해 샘플링 함
랜덤하게 샘플링된 데이터에 각각의 알고리즘을 붙여서 결과를 받아들임

📌 결정 방법에서의 하드보팅

우리가 아는 다수결
모두가 1인데 하나가 2면, 2는 제거하고 1을 선택

📌 소프트보팅

동일한 값의 확률 평균을 구해서, 다른 값과 비교
동점일 시 [다수결]을 따르고
더 높은 값이 있다면, 높은 점수를 선택

📌 랜덤포레스트

DecisionTree(결정나무) 여러개를 사용해서 투표하는 방식
bagging 기법의 대표적인 방법

HAR, Human Activity Recognition

IMU 센서를 활용해서 사람의 행동을 인식하는 실험
폰에 있는 가속도/자이로 센서 사용
데이터 소개

데이터 특성

데이터 클래스

1) 데이터 읽기

import pandas as pd
import matplotlib.pyplot as plt

# txt 파일
url = 'https://raw.githubusercontent.com/PinkWink/ML_tutorial/master/dataset/HAR_dataset/features.txt'

# '\s+' 공백, header 그대로, 컬럼 이름 names
feature_name_df = pd.read_csv(url, sep='\s+', header=None, names=['columns_index','columns_name'])
feature_name_df.head()

2) 특성(feature) 갯수 확인

len(feature_name_df)

3) 데이터 확인

# 밸류만 가지고 feature_name 추출 -> 즉, 앞으로 561개의 이름만 저장하게 됨
feature_name = feature_name_df.iloc[:, 1].values.tolist()
feature_name[:10]

4) 일단 X데이터만

X_train_url = 'https://raw.githubusercontent.com/PinkWink/ML_tutorial/master/dataset/HAR_dataset/train/X_train.txt'
X_test_url = 'https://raw.githubusercontent.com/PinkWink/ML_tutorial/master/dataset/HAR_dataset/test/X_test.txt'

X_train = pd.read_csv(X_train_url, sep='\s+', header=None)
X_test = pd.read_csv(X_test_url, sep='\s+', header=None)

5) 대용량 데이터 컬럼 확인

X_train.columns = feature_name
X_test.columns = feature_name
X_train.head()

6) y 데이터 읽어오기

y_train_url = 'https://raw.githubusercontent.com/PinkWink/ML_tutorial/master/dataset/HAR_dataset/train/y_train.txt'
y_test_url = 'https://raw.githubusercontent.com/PinkWink/ML_tutorial/master/dataset/HAR_dataset/test/y_test.txt'

y_train = pd.read_csv(y_train_url, sep='\s+', header=None, names=['action'])
y_test = pd.read_csv(y_test_url, sep='\s+', header=None, names=['action'])

7) shape - 개수 확인

X_train.shape, X_test.shape, y_train.shape, y_test.shape

8) 각 action 별 데이터 수

y_train['action'].value_counts()

action 6 1407 5 1374 4 1286 1 1226 2 1073 3 986 Name: count, dtype: int64

9) DecisionTree 결정나무

from sklearn.tree import DecisionTreeClassifier
from sklearn.metrics import accuracy_score

dt_clf = DecisionTreeClassifier(random_state=13, max_depth=4)
dt_clf.fit(X_train, y_train)

pred = dt_clf.predict(X_test)
accuracy_score(y_test, pred)

0.8096369189005769

10) Train - GridSearchCV (max_depth를 다양하게 하기 위해)

from sklearn.model_selection import GridSearchCV

params = {
    'max_depth' : [6,8,10,12,16,20,24]
}

# scoring='accuracy': accuracy 계열은 기록해주세요
# cv=5  :KFold는 5개
grid_cv = GridSearchCV(dt_clf, param_grid=params, scoring='accuracy', cv=5, return_train_score=True)
grid_cv.fit(X_train, y_train)

11) Train 밸리데이션한 값의 best score & params 확인

grid_cv.best_score_, grid_cv.best_params_

(0.8543335321892183, {'max_depth': 8})

12) Train max_depth별로 표로 성능을 정리

cv_result_df = pd.DataFrame(grid_cv.cv_results_)
cv_result_df[['param_max_depth', 'mean_test_score', 'mean_train_score']]

13) Test 데이터에서의 결과

max_depth = [6,8,10,12,16,20,24]

for depth in max_depth:
    dt_clf = DecisionTreeClassifier(max_depth=depth, random_state=156)
    dt_clf.fit(X_train, y_train)
    pred = dt_clf.predict(X_test)
    accuracy = accuracy_score(y_test, pred)
    print('Max_Depth =', depth, ', Accuracy =', accuracy)

Max_Depth = 6 , Accuracy = 0.8557855446216491 Max_Depth = 8 , Accuracy = 0.8707159823549372 Max_Depth = 10 , Accuracy = 0.8673227010519172 Max_Depth = 12 , Accuracy = 0.8646080760095012 Max_Depth = 16 , Accuracy = 0.8574821852731591 Max_Depth = 20 , Accuracy = 0.8547675602307431 Max_Depth = 24 , Accuracy = 0.8547675602307431

14) Test - 베스트 모델의 결과는

best_dt_clf = grid_cv.best_estimator_
pred1 = best_dt_clf.predict(X_test)
accuracy_score(y_test, pred1)

0.8734306073973532

15) 랜덤포레스트 적용

from sklearn.model_selection import GridSearchCV
from sklearn.ensemble import RandomForestClassifier

params = {
    'max_depth' : [6,8,10], # DecisionTree에 적용할 파라미터
    'n_estimators' : [50,100,200], # DecisionTree에 tree 몇개
    'min_samples_leaf' : [8,12], # DecisionTree에 맨끝 데이터(leaf) 최소 몇개
    'min_samples_split' : [8,12] # 분할 기준에서 최소한으로 남는 데이터 수 (큰영향 X)
}

rf_clf = RandomForestClassifier(random_state=13, n_jobs=-1) # n_jobs=-1 : cpu core 다 써서
grid_cv = GridSearchCV(rf_clf, param_grid=params, cv=2, n_jobs=-1)
grid_cv.fit(X_train, y_train)

16) 결과 정리

cv_results_df = pd.DataFrame(grid_cv.cv_results_)
cv_result_df.columns

Index(['mean_fit_time', 'std_fit_time', 'mean_score_time', 'std_score_time',

 'param_max_depth', 'params', 'split0_test_score', 'split1_test_score',
 'split2_test_score', 'split3_test_score', 'split4_test_score',
 'mean_test_score', 'std_test_score', 'rank_test_score',
 'split0_train_score', 'split1_train_score', 'split2_train_score',
 'split3_train_score', 'split4_train_score', 'mean_train_score',
 'std_train_score'],
dtype='object')

17) target_cols 지정 & 순위 메기기

# mean_test_score : train 데이터의 validation score (아까는 85% 였는데, randomforest하니까 90% 이상)
# param_n_estimators : 몇개의 나무
target_cols = ['rank_test_score', 'mean_test_score', 'param_n_estimators', 'param_max_depth']

cv_results_df[target_cols].sort_values('rank_test_score').head()

18) best 찾기

grid_cv.best_params_, grid_cv.best_score_

({'max_depth': 10, 'min_samples_leaf': 8, 'min_samples_split': 8, 'n_estimators': 100}, 0.9151251360174102)

19) Test 데이터에 적용

rf_clf_best = grid_cv.best_estimator_
rf_clf_best.fit(X_train, y_train)

pred1 = rf_clf_best.predict(X_test)
accuracy_score(y_test, pred1)

0.9205972175093315

20) 중요특성 확인

# 베스트 모델에서 랜덤포레스트를 반환(feature_importances_) 받아서
best_cols_values = rf_clf_best.feature_importances_ 

# 영향력이 높은(best_cols_values) feature만 추려서
best_cols = pd.Series(best_cols_values, index=X_train.columns)

# 정렬(sort_values) 한 다음에 20개만 출력
top20_cols = best_cols.sort_values(ascending=False)[:20]
top20_cols

angle(X,gravityMean) 0.034638 tGravityAcc-max()-Y 0.032518 tGravityAcc-energy()-X 0.031309 tGravityAcc-mean()-X 0.029513 tGravityAcc-min()-X 0.027775 tGravityAcc-max()-X 0.027662 angle(Y,gravityMean) 0.026553 tGravityAcc-mean()-Y 0.026052 tGravityAcc-min()-Y 0.023037 tGravityAcc-energy()-Y 0.018678 tGravityAcc-mean()-Z 0.015688 angle(Z,gravityMean) 0.012837 fBodyAcc-mad()-X 0.012558 tBodyAcc-max()-X 0.011970 fBodyAccJerk-bandsEnergy()-1,24 0.011803 tBodyAccJerk-entropy()-X 0.011647 tGravityAccMag-std() 0.011451 tBodyAccJerk-energy()-X 0.011333 tGravityAcc-arCoeff()-Z,1 0.011257 fBodyAccJerk-max()-X 0.011040 dtype: float64

21) 주요 특성 확인

import seaborn as sns

plt.figure(figsize=(8, 8))
sns.barplot(x=top20_cols, y=top20_cols.index)
plt.show()

22) 주요 특성 20 가지

561개를 굳이 다써야 하나? 아래 그래프를 보아 하니 주요 특성 몇가지만 가지고 봐도 될 것 같음
따라서 20개로 보고자 함
```
top20_cols.index
```

Index(['angle(X,gravityMean)', 'tGravityAcc-max()-Y', 'tGravityAcc-energy()-X',

 'tGravityAcc-mean()-X', 'tGravityAcc-min()-X', 'tGravityAcc-max()-X',
 'angle(Y,gravityMean)', 'tGravityAcc-mean()-Y', 'tGravityAcc-min()-Y',
 'tGravityAcc-energy()-Y', 'tGravityAcc-mean()-Z',
 'angle(Z,gravityMean)', 'fBodyAcc-mad()-X', 'tBodyAcc-max()-X',
 'fBodyAccJerk-bandsEnergy()-1,24', 'tBodyAccJerk-entropy()-X',
 'tGravityAccMag-std()', 'tBodyAccJerk-energy()-X',
 'tGravityAcc-arCoeff()-Z,1', 'fBodyAccJerk-max()-X'],
dtype='object')

23) 20개 특성으로 다시 확인

X_train_re = X_train[top20_cols.index]
X_test_re = X_test[top20_cols.index]

rf_clf_best_re = grid_cv.best_estimator_
rf_clf_best_re.fit(X_train_re, y_train.values.reshape(-1, ))

pred1_re = rf_clf_best_re.predict(X_test_re)

accuracy_score(y_test, pred1_re)

0.8177807940278249

ML - 9. Precision(정밀도) and Recall(재현율)

Tue, 23 Jan 2024 15:39:44 GMT

Precision(정밀도) and Recall(재현율)

1) 데이터 가져오기

import pandas as pd
wine_url = 'https://raw.githubusercontent.com/PinkWink/ML_tutorial/master/dataset/wine.csv'
wine = pd.read_csv(wine_url,index_col=0)
wine.head()

2) 맛 등급 설정

# (1) quality 컬럼 이진화
# wine 데이터의 ['taste'] 컬럼 생성
# wine의 quality column울 grade로 잡고, 5등급 보다 크면 1, 그게 아니라면 0으로 잡음
wine['taste'] = [1. if grade>5 else 0. for grade in wine['quality']]
# (2) 모델링
# label인 taste, quality를 drop, 나머지를 X의 특성으로 봄
X = wine.drop(['taste', 'quality'], axis=1)
# 새로만들 y데이터
y = wine['taste']

3) 데이터 분리

from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=13)

4) 로지스틱 회귀

from sklearn.linear_model import LogisticRegression
from sklearn.metrics import accuracy_score

lr = LogisticRegression(solver='liblinear', random_state=13)
lr.fit(X_train, y_train)

y_pred_tr = lr.predict(X_train)
y_pred_test = lr.predict(X_test)

print('Train Acc : ', accuracy_score(y_train, y_pred_tr))
print('Test Acc : ', accuracy_score(y_test, y_pred_test))

Train Acc : 0.7429286126611506 Test Acc : 0.7446153846153846

5) classification report

from sklearn.metrics import classification_report
print(classification_report(y_test, lr.predict(X_test)))

6) confusion matrix

from sklearn.metrics import confusion_matrix
confusion_matrix(y_test, lr.predict(X_test))

array( [ [ 275, 202 ] , [ 130, 693 ] ] , dtype=int64 )

0라인 | 0이라고 한 갯수, 1이라고 한 갯수 : [275,202]
1라인 | 0이라고 한 갯수, 1이라고 한 갯수 : [130,693]

7) precision_recall curve

import matplotlib.pyplot as plt
from sklearn.metrics import precision_recall_curve

# predict_proba : class 별 확률을 구해주기 떄문에 1일 때 확률을 가져옴
pred = lr.predict_proba(X_test)[:, 1]
precisions, recalls, thresholds = precision_recall_curve(y_test, pred)

plt.figure(figsize=(6, 3))
# thresholds를 기준으로, precisions그래프를 그림
# :len(thresholds) : thresholds의 크기 만큼 그리겠다
plt.plot(thresholds, precisions[:len(thresholds)], label='precision')
plt.plot(thresholds, recalls[:len(thresholds)], label='recall')
plt.grid()
plt.legend()
plt.show()

8) threshlod = 0.5

threshlod 값을 따로 정해주지 않으면 0.5가 디폴트값 임

# lr(분류기)에서 predict_proba를 X_test에 대해서 해라
pred_proba = lr.predict_proba(X_test)
# 앞부분 3개만 보고싶음
pred_proba[:3]

array ([[0.40472417, 0.59527583],

 [0.51002386, 0.48997614],
 [0.10222708, 0.89777292]])

9) 간단히 확인해보기

1_ y_pred_test을 pred_proba 옆으로 붙인 데이터를 만들고 싶음
2_그래서 reshape을 통해 y_pred_test 먼저 틀을 만들어 줌 (리스트 안 리스트)
- .reshape(-1,1) : reshape(니가 알아서해, 마지막만 1로 만들어줘)
3_ np.concatenate을 이용해 둘을 붙여 줌
```
import numpy as np
```

np.concatenate([pred_proba, y_pred_test.reshape(-1,1)], axis=1)





10) Binarizer
threshold를 사용자의 지정을 받아서 0과 1을 바꿔주는 명령어

```py
from sklearn.preprocessing import Binarizer
binarizer = Binarizer(threshold=0.6).fit(pred_proba)
pred_bin = binarizer.transform(pred_proba)[:,1]
pred_bin

array([0., 0., 1., ..., 1., 0., 1.])

11) 다시 classification report

from sklearn.metrics import classification_report
print(classification_report(y_test, pred_bin))

11) 다시 classification report

from sklearn.metrics import classification_report
print(classification_report(y_test, pred_bin))

ML - 8. (분류)Logistic Regression - PIMA 인디언 당뇨병 예측

Tue, 23 Jan 2024 06:07:11 GMT

Logistic Regression을 쓰는 이유 : 💡분류기 역할

즉, linear regression (선형회귀)을 분류에 적용한 것이 Logistic Regression (로지스틱 회귀)이다.

LR 이론

악성 종양을 찾는다고 가정하자. linear regression (선형회귀)에 적용한다면 0과 1밖에 없어서 수 많은 데이터를 분류하기가 어려 움. 보이지 않는 데이터가 멀-리 있다면 확인이 어려움

출력이 0과 1사이에 위치하게 하는 [시그모이드]에 linear regression() 함수를 넣으면 = "직선"이 됨

📌 sigmoid (function)

기울어진 S자 형태의 곡선

linear regression에서 sigmoid를 재정의

  import numpy as np
  import matplotlib.pyplot as plt

  # np의 arrange 명령으로 (-10 ~ 10 까지, 0.01 간격)
  z = np.arange(-10,10,0.01)
  g = 1/(1+np.exp(-z))

  plt.plot(z,g);

그래프 멋내기

import numpy as np
import matplotlib.pyplot as plt

plt.figure(figsize=(10,8))
ax = plt.gca()

ax.plot(z,g)
ax.spines['left'].set_position('zero')
ax.spines['bottom'].set_position('center')
ax.spines['right'].set_color('none')
ax.spines['top'].set_color('none')

📌 Cost Function (funtion)

Logistic Regression에서 Cost Function을 재정의


c0 = -np.log(1-h)
c1 = -np.log(h)

plt.figure(figsize=(7,3))
plt.plot(h, c0, label='y=0')
plt.plot(h, c1, label='y=1')
plt.legend()

plt.show()

와인 분석

1) 데이터 가져오기

import pandas as pd

wine_url = 'https://raw.githubusercontent.com/PinkWink/ML_tutorial/master/dataset/wine.csv'
wine = pd.read_csv(wine_url,index_col=0)
wine.head()

2) 맛 등급 설정

# (1) quality 컬럼 이진화
# wine 데이터의 ['taste'] 컬럼 생성
# wine의 quality column울 grade로 잡고, 5등급 보다 크면 1, 그게 아니라면 0으로 잡음
wine['taste'] = [1. if grade>5 else 0. for grade in wine['quality']]



# (2) 모델링
# label인 taste, quality를 drop, 나머지를 X의 특성으로 봄
X = wine.drop(['taste', 'quality'], axis=1)

# 새로만들 y데이터
y = wine['taste']

3) 데이터 분리

from sklearn.model_selection import train_test_split

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=13)

4) 로지스틱 회귀

# 분류기
from sklearn.linear_model import LogisticRegression

# 성능
from sklearn.metrics import accuracy_score

# solver(최적화 알고리즘) = liblinear(데이터 수가 작으면 보통 이걸로 선택)
lr = LogisticRegression(solver='liblinear', random_state=13)

# 학습 (train, train)
lr.fit(X_train, y_train)

# 예측 = 학습이 완료된 lr에게 시킴
y_pred_tr = lr.predict(X_train)
y_pred_test = lr.predict(X_test)

# 성능 확인
print('Train Acc :', accuracy_score(y_train, y_pred_tr))
print('Test Acc :', accuracy_score(y_test, y_pred_test))

Train Acc : 0.7429286126611506 Test Acc : 0.7446153846153846

5) 파이프라인 구축 (스케일러 적용)

# Pipeline
from sklearn.pipeline import Pipeline
# StandardScaler
from sklearn.preprocessing import StandardScaler

# 평가 변수
estimators = [
    # 표준화(scaler)
    ('scaler', StandardScaler()),
    # 분류기(clf)
    ('clf', LogisticRegression(solver='liblinear', random_state=13))
]

pipe = Pipeline(estimators)

6) 학습, 예측, 성능 확인

# 학습
pipe.fit(X_train, y_train)

# 예측 = 학습이 완료된 lr에게 시킴
y_pred_tr = pipe.predict(X_train)
y_pred_test = pipe.predict(X_test)

# 성능 확인
print('Train Acc :', accuracy_score(y_train, y_pred_tr))
print('Test Acc :', accuracy_score(y_test, y_pred_test))

Train Acc : 0.7444679622859341 Test Acc : 0.7469230769230769

7) Decision Tree와 비교

from sklearn.tree import DecisionTreeClassifier

wine_tree = DecisionTreeClassifier(max_depth=2, random_state=13)
wine_tree.fit(X_train, y_train)

models = {'LogisticRegression' : pipe, 'DecisionTree' : wine_tree}

8) AUC 그래프로 비교 확인

thresholds(임계값) 보다 크면 양성, 작으면 음성
모델은 분류에서 확률(0~~1) 또는 음수~~양수 사이의 실수를 예측값으로 출력
sklearn에서는 predict_proba을 제공
predict_proba : 0.5 이상이면 1로 예측

# roc_curve
from sklearn.metrics import roc_curve

plt.figure(figsize=(10,8))
plt.plot([0,1], [0,1])

# model_name : LogisticRegression, DecisionTree
# model : pipe, wine_tree
for model_name, model in models.items():
    # 첫번째 커럼은 0일 확률, 두번쨰 컬럼은 1일 확률이라서 [:, 1]
    # predict_proba : 0.5 이상이면 1로 예측
    pred = model.predict_proba(X_test)[:, 1]
    # roc_curve의 thresholds (임계값)
    fpr, tpr, thresholds = roc_curve(y_test, pred)
    plt.plot(fpr, tpr, label=model_name)

plt.grid()
plt.legend()
plt.show()

LogisticRegression의 결과가 더 좋은 것으로 확인 됨

PIMA 인디언 당뇨병 예측 분석

1) 데이터 가져오기

import pandas as pd

PIMA_url = 'https://raw.githubusercontent.com/PinkWink/ML_tutorial/master/dataset/diabetes.csv'
PIMA = pd.read_csv(PIMA_url)
PIMA.head()

2) 데이터 확인

PIMA.info()

3) 데이터 전부 float 으로 변환 (astype)

PIMA = PIMA.astype('float')
PIMA.info()

4) 상관관계 확인

import seaborn as sns
import matplotlib.pyplot as plt

plt.figure(figsize=(6,4))

# PIMA.corr() : PIMA의 상관계수()
sns.heatmap(PIMA.corr(), cmap='YlGnBu')
plt.show()

5) 0인 데이터 확인 - 이상한 값들이 있는지 보기 위해

# (PIMA==0) : 0이 있는지 확인, T/F로 뜸
# (PIMA==0).astype(int) : T=1, F=0
# (PIMA==0).astype(int).sum() : 컬럼별로 0이 몇개 있는지 나옴
(PIMA== 0).astype(int).sum()

⭐ 이상한 값(결측치) 해결

6) 이상한 값들은 평균값으로 대체 (replace)

# - 혈압(BloodPressure)은 0일수 없다...

zero_features = ['Glucose', 'BloodPressure', 'SkinThickness', 'BMI']
PIMA[zero_features] = PIMA[zero_features].replace(0, PIMA[zero_features].mean())

7) 데이터 분리

X = PIMA.drop(['Outcome'], axis=1)
y = PIMA['Outcome']

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2,
                                                    random_state=13, stratify=y)

estimators = [('scaler', StandardScaler()),
               ('clf', LogisticRegression(solver='liblinear', random_state=13))]
pipe_lr = Pipeline(estimators)
pipe_lr.fit(X_train, y_train)
pred = pipe_lr.predict(X_test)

8) 수치 확인

from sklearn.metrics import (accuracy_score, recall_score, precision_score,
                             roc_auc_score, f1_score)

print(accuracy_score(y_test, pred))
print(recall_score(y_test, pred))
print(precision_score(y_test, pred))
print(roc_auc_score(y_test, pred))
print(f1_score(y_test, pred))

9) 다변수 방정식의 각 계수 값 확인

coeff = list(pipe_lr['clf'].coef_[0])
labels = list(X_train.columns)

10) feature 그리기

# DataFrame
features = pd.DataFrame({'Features': labels, 'importance': coeff})
features.sort_values(by=['importance'], ascending=True, inplace=True)

# positive 생성
features['positive'] = features['importance'] > 0
features.set_index('Features', inplace=True)

# importance 를 그릴 것
features['importance'].plot(kind='barh', figsize=(11, 6),
                            color=features['positive'].map({True: 'blue', False: 'red'}))
plt.xlabel('Importance')
plt.show()

ML - 7. Cost Function & Gradient Descent _ 보스턴 집값 예측(분석)

Mon, 22 Jan 2024 09:00:50 GMT

1. Cost Function

📌 에러를 표현하는 도구

최소값 지점 찾기

import sympy as sym

# Symbol : 기호로 인식됨
theta = sym.Symbol('theta')

# diff : 미분하세요
diff_th = sym.diff(38*theta**2 - 94*theta + 62, theta)
diff_th

```
94/76
```
1.236842105263158 지점

데이터 = 모델
- 에러는 '0'
데이터 != 모델
- 에러가 '증가'

2. Gradient Descent

개념 설명

즉 ! Gradient Descent 는 미분을 해서 어디로(오/왼) 가야할지 정하는 것

3. 다변수 데이터에 대한 회귀

feature : 여러개의 특성

보스턴 집값 예측

the boston house-price data of Harrison, D. and Rubinfeld, D.L. 'Hedonic prices and the demand for clean air'

강의 시 제공해준 seaborn이 제대로 실행되지 않아, csv 파일로 진행

데이터 읽기
```
import pandas as pd
```

boston_url = 'https://raw.githubusercontent.com/blackdew/tensorflow1/master/csv/boston.csv' boston = pd.read_csv(boston_url)


2. key값 확인

boston.keys


3. 컬럼 확인

boston.columns

Index(['crim', 'zn', 'indus', 'chas', 'nox', 'rm', 'age', 'dis', 'rad', 'tax',
       'ptratio', 'b', 'lstat', 'medv'],
      dtype='object')

4. 컬럼 예쁘게 확인

[each for each in boston.columns]

['crim',
 'zn',
 'indus',
 'chas',
 'nox',
 'rm',
 'age',
 'dis',
 'rad',
 'tax',
 'ptratio',
 'b',
 'lstat',
 'medv']

5. 전체 데이터 확인

boston

- ![](https://velog.velcdn.com/images/jaam_mini/post/42bc1745-4b92-4599-8d4c-2565e2290a20/image.png)

6. 데이터 파악을 위해 pandas로 정리
- csv 파일을 불러와서 이미 df 임, 생략

7. ['medv'] -> ['price']
강의 자료와 동일시 하기 위해 컬럼명 변경

- [다양한 컬럼/인덱스 변경 방법](https://blog.naver.com/rising_n_falling/222061033231)

데이터 파악을 위해 pandas로 정리 (csv로 이미 되어 있어서 생략)

컬럼명 변경

boston.columns.values[13] = 'price' boston.head(2)


8. 상관계수 확인

#모듈 import matplotlib.pyplot as plt import seaborn as sns %matplotlib inline

상관계수 변수 = df.상관계수 함수().소수점 첫쨰자리

corr_mat = boston.corr().round(1)

사이즈 설정

sns.set(rc={'figure.figsize':(18,8)})

히트맵 (상관계수 변수, 숫자를 기록해주세요, 컬러)

sns.heatmap(data=corr_mat, annot=True, cmap='bwr')

- ![](https://velog.velcdn.com/images/jaam_mini/post/9a5b7d70-bcdd-4c88-972c-e120f1568281/image.png)


9. RM과 LSTAT와 PRICE의 관계 보기

sns.set_style('darkgrid') sns.set(rc={'figure.figsize':(18,8)})

컬럼의 개수는 2개(그래프 2개 그릴 것임)

fig, ax = plt.subplots(ncols=2)

위에서 medv -> price 컬럼명을 바꿨지만, 그래프가 생성되지 않아, 그대로 [medv] 사용

regplot(방수, 가격, 왼쪽)

sns.regplot(x='rm', y='medv', data=boston, ax=ax[0])

regplot(하위계층, 가격, 왼쪽)

sns.regplot(x='lstat', y='medv', data=boston, ax=ax[1])

- ![](https://velog.velcdn.com/images/jaam_mini/post/949ad439-2ae7-4b1a-b461-a632843fb79d/image.png)

10. 데이터 나누기

from sklearn.model_selection import train_test_split

X = boston.drop('medv', axis=1) y = boston['medv']

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=13)


11. LinearRegression (학습)

from sklearn.linear_model import LinearRegression

reg = LinearRegression() reg.fit(X_train, y_train)


12. RMS (평가)

import numpy as np from sklearn.metrics import mean_squared_error

predict

pred_tr = reg.predict(X_train) pred_test = reg.predict(X_test)

mean_squared_error (선형 회귀 에서 주로 사용)

루트(np.sqrt)(mean_squared_error(참값, pred_tr-예측값))

rmse_tr = (np.sqrt(mean_squared_error(y_train, pred_tr))) rmse_test = (np.sqrt(mean_squared_error(y_test, pred_test)))

print('RMSE of Train Data : ', rmse_tr) print('RMSE of Test Data : ', rmse_test)

RMSE of Train Data :  4.642806069019824
RMSE of Test Data :  4.9313525841467145


13. 성능 확인 (그래프로 확인)

import matplotlib.pyplot as plt

plt.scatter(x=참값, y=예측값)

plt.scatter(y_test, pred_test) plt.plot([0,48], [0,48], 'r')

plt.xlabel("Actual House Price ($1000)") plt.ylabel("predicted Prices") plt.title("Real vs Predicted")

plt.show()

- ![](https://velog.velcdn.com/images/jaam_mini/post/d8ca7acc-9546-466a-8ce8-dd5df072d2e5/image.png)

ML - 6. Basic of Regression _ 회귀 기초

Mon, 22 Jan 2024 06:40:02 GMT

지난 시간까지 배운 것 ▶ 지도학습 (라벨을 달아주는 것 = 정답을 알려주는것)

데이터를 기반으로 하는 문제 해결 방법

문제 분석 > 학습 시킴(데이터 계속 유입됨) > 데이터를 베이스로 하기 때문에, 알고리즘 구현 & 서비스 런칭 부분만 코딩으로 해결

모델 스스로 데이터 수집 > 트레이닝 > 업데이트(평가, 런칭) > 데이터 유입

- 회귀 모델

- 1차 함수

기울기 & y절편이 있음

- 선형 회귀

내가 가지고 있는 데이터와 가장 잘 맞는 직선을 찾겠다
그리고 그 직선을 hypothesis 라고 한다

1. OLS : Ordinary Linear Least Square

1_기본 예제

# !pip install statsmodels

# 1) 데이터 설정
import pandas as pd

data = {'x':[1.,2.,3.,4.,5.], 'y':[1.,3.,4.,6.,5.]}
df = pd.DataFrame(data)
df

# 2) 가설 세우기

import statsmodels.formula.api as smf

# formula="y~x" : y=ax+b  라는 의미를 내포
lm_model = smf.ols(formula="y~x", data=df).fit()

# 3) 결과

lm_model.params

# 4) seaborn

import matplotlib.pyplot as plt
import seaborn as sns

plt.figure(figsize=(10,7))
sns.lmplot(x='x', y='y', data=df);

# xlim : plt 축 범위 설정 함수, x축 범위 지정
plt.xlim([0,5])

2_잔차 (resid) 평가

잔차 란?
- 내 모델과 실제 값의 차이
- 잔차 평가는 잔차의 평균이 0(=이라서 회귀하는 것임)이고 정규분포를 따라야 함

# 잔차 확인
resid = lm_model.resid
resid

▼ 에러값s

0 -0.6 1 0.3 2 0.2 3 1.1 4 -1.0 dtype: float64

3_R-Squared (결정계수)

- 녹색 : 평균
- 분모 : 참값(점)이 가지는 평균으로 부터의 오차(점~녹색 거리)
- 분자 : 예측값(노랑~녹색 거리)으로 부터 가지는 평균으로의 오차

참값 = 예측값 : 1 참값이 예측값과 일치한다면 1임

(기본) 결정계수 구하기
```
import numpy as np
```

df의 y컬럼 평균을 mu로 잡음

mu = np.mean(df['y']) y = df['y']

예측값(y_hat)

y_hat = lm_model.predict()

합계

분자(예측값-평균)^2 / 분모(참값-평균)^2

np.sum((y_hat - mu)2 / np.sum((y - mu)2))

0.8175675675675673

- (쉽게) 결정계수 구하기

lm_model.rsquared

0.8175675675675677


- 분포도 확인

잔차의 분포도 확인

sns.distplot(resid, color='black');

- ![](https://velog.velcdn.com/images/jaam_mini/post/422a552b-1851-482f-b210-50afeb43014d/image.png)

## 2. 통계적 회귀
---

모듈

import pandas as pd import numpy as np import matplotlib.pyplot as plt import seaborn as sns

1) 데이터 로드

data_url = 'https://raw.githubusercontent.com/PinkWink/ML_tutorial/master/dataset/ecommerce.csv' data = pd.read_csv(data_url)

2) 구조 확인

data.tail()

- ![](https://velog.velcdn.com/images/jaam_mini/post/a449b9f8-a6ad-431b-bdcf-ef3b9c01b822/image.png)

3) 컬럼 확인

data.columns

Index(['Email', 'Address', 'Avatar', 'Avg. Session Length', 'Time on App',
       'Time on Website', 'Length of Membership', 'Yearly Amount Spent'],
      dtype='object')

4) 필요 없는 컬럼 삭제

data.drop(['Email', 'Address', 'Avatar'], axis=1, inplace=True) data.info()

- ![](https://velog.velcdn.com/images/jaam_mini/post/845d985e-6ccc-40d2-90fa-0370d7a722cb/image.png)

5) 컬럼별 boxplot

plt.figure(figsize=(12,6)) sns.boxplot(data=data);

- ![](https://velog.velcdn.com/images/jaam_mini/post/8d05e637-396f-4f6c-b0da-20b4946c8f89/image.png)

6) 특정 칼럼 다시 boxplot

plt.figure(figsize=(12,6)) sns.boxplot(data=data.iloc[:, :-1]);

- ![](https://velog.velcdn.com/images/jaam_mini/post/d10a4037-d229-4976-a01d-cd44256fc50a/image.png)
  - ```
    data.iloc[:]
    ```
  - ![](https://velog.velcdn.com/images/jaam_mini/post/b1a1112d-2f54-4a2d-8cbb-5ba67c92d721/image.png)

  - ```
    data.iloc[:, :-1]
    ```
  - ![](https://velog.velcdn.com/images/jaam_mini/post/200f9d70-6f9a-4718-a98b-47d9b54d6017/image.png)

7) label 값에 대한 boxplot

plt.figure(figsize=(12,6)) sns.boxplot(data=data['Yearly Amount Spent']);

- ![](https://velog.velcdn.com/images/jaam_mini/post/c5129e03-30fa-48d1-bb9e-6d772e5ce1c9/image.png)

8) pairplot으로 경향 확인

plt.figure(figsize=(12,6)) sns.pairplot(data=data);

- ![](https://velog.velcdn.com/images/jaam_mini/post/cf2cec6e-a9b7-41fa-b5f4-b4ba57fbd0c2/image.png)

10) 상관관계를 갖는 것을 lmplot으로 확인

plt.figure(figsize=(12,6)) sns.lmplot(x='Length of Membership', y='Yearly Amount Spent', data=data);

- ![](https://velog.velcdn.com/images/jaam_mini/post/d773b894-e1b8-4b61-bcd7-508269a68a5e/image.png)

11) 상관이 높은 멤버십 유지기간 만 가지고 통계적 회귀

import statsmodels.api as sm X = data['Length of Membership'] y = data['Yearly Amount Spent'] lm = sm.OLS(y, X).fit() lm.summary()

- ![](https://velog.velcdn.com/images/jaam_mini/post/e1598fe4-9633-46e1-a8cd-0967767ee7f0/image.png)

12) 회귀 모델 그리기

pred = lm.predict(X)

sns.scatterplot(x=X, y=y) plt.plot(X, pred, 'r', ls='dashed', lw=3)

- ![](https://velog.velcdn.com/images/jaam_mini/post/da9460b7-8b8c-4cb9-888d-1e1483ed92e5/image.png)

13) 참 값, 예측값 그리기

sns.scatterplot(x=y, y=pred) plt.plot([min(y), max(y)], [min(y), max(y)], 'r', ls='dashed', lw=3);

- ![](https://velog.velcdn.com/images/jaam_mini/post/9b348fcf-66ef-4969-a378-d79db9cd2535/image.png)

14) 참 값, 예측값 그리기

sns.scatterplot(x=y, y=pred) plt.plot([min(y), max(y)], [min(y), max(y)], 'r', ls='dashed', lw=3);3 plt.plot([0,max(y)], [0, max(y)], 'b', ls='dashed', lw=3); plt.axis([0,max(y), 0, max(y)])

- ![](https://velog.velcdn.com/images/jaam_mini/post/eb0bebcb-4d32-407f-8360-e462869fdc7b/image.png)

15) 상수항 추가 (열추가)

c_를 해주면 바아로 삽입됨

추가 [원래 X에, 1을 X의 길이 만큼 만들어서]

X = np.c_[X, [1]*len(X)]

잘 추가 됐는지 5개만 보기

X[:5]

array([[4.08262063, 1.        ],
       [2.66403418, 1.        ],
       [4.1045432 , 1.        ],
       [3.12017878, 1.        ],
       [4.44630832, 1.        ]])

16) 다시 fit()

lm = sm.OLS(y, X).fit() lm.summary()

- ![](https://velog.velcdn.com/images/jaam_mini/post/68e2e591-f938-49cb-9863-111f8f7cf8a3/image.png)

  - 아까와는 다르게 x1의 밸류와 constant가 잡힘
  - R aquared가 작아짐
    - R aquared : 평균을 기준으로 데이터가 얼마나 예측과 실체값 간의 편차
  - AIC 가 작아짐 (낮을 수 록 좋음)
    - AIC : 내가 만들어낸 모델이 나의 데이터를 얼마나 잘 반영하는지 측정하는 도구 (=원래 정보를 얼마나 손실 시키는지의 정도)

17) 다시 선형 회귀

pred = lm.predict(X)

sns.scatterplot(x=X[:, 0], y=y) plt.plot(X[:, 0], pred, 'r', ls='dashed', lw=3)

- ![](https://velog.velcdn.com/images/jaam_mini/post/7dae7fae-b154-4894-a384-967912f69fc3/image.png)

18) 참 값, 예측값 그리기

(x=참값, y=예측값)

sns.scatterplot(x=y, y=pred) plt.plot([min(y), max(y)], [min(y), max(y)], 'r', ls='dashed', lw=3);

- ![](https://velog.velcdn.com/images/jaam_mini/post/94603d0a-e45b-4df9-8956-d2b9f401e5ea/image.png)

19) 데이터 분리 후

from sklearn.model_selection import train_test_split

X = data.drop('Yearly Amount Spent', axis=1) y = data['Yearly Amount Spent']

X_train, X_test, y_train, y_test = train_test_split( X, y, test_size=0.3, random_state=13 )

20) 4개 컬럼 모두 변수로 회귀

import statsmodels.api as sm

lm = sm.OLS(y_train, X_train).fit() lm.summary()

- ![](https://velog.velcdn.com/images/jaam_mini/post/4fdd5cb7-5e94-45cb-9f1a-c78263fb8f96/image.png)

- 이전 값보다
  - R aquared가 높아짐
  - AIC 가 작아짐 (낮을 수 록 좋음)

21) 참값 vs 예측값

pred = lm.predict(X_test)

sns.scatterplot(x=y_test, y=pred) plt.plot([min(y_test), max(y_test)], [min(y_test), max(y_test)], 'r', ls='dashed', lw=3);

- ![](https://velog.velcdn.com/images/jaam_mini/post/1bba58d0-383e-4971-b120-56af25766354/image.png)

ML - 5. Model Evaluation _ 함수 & box plot

Mon, 22 Jan 2024 04:43:54 GMT

기초 수학 개념

회귀 모델

내가 가지고 있는 데이터를 직선으로 만들어 두고, 각 값들을 예측하는 것
(회귀 모델 예측 결과) : 연속된 변수값

분류 모델

구분이 명확함
몇개의 종류에서 값을 찾아내는 것 (iris, 와인 프로젝트)

이진 분류

0 과 1
맞다, 아니다
전체 데이터 에서 실제 1의 값을 가진 데이터
- TP = 실제 1인데 1로 맞춘 것
- FN = 실제 1인데 틀리게 예측한 값
전체 데이터 에서 0의 값을 가진 데이터(아래)
- TN = 0을 0으로 맞춤
- FP = 0을 1이라고 클리게 맞춤

Accuracy

전체 데이터 중 맞게 예측한 것의 비율

Precision

내가 1이라고 말한(예측한) 것들 중에서 실제 1인 것의 비율

recall (재현율)

실제 1일 데이터 중에서 1이라고 예측

fall out (FPR)

실제 0 중에서 1이라고 잘못 예측한 것

F1-Score (조합평균)

recall + recision 결합한 지표
어느 한쪽으로 치우치지 않고 둘다 높은 값을 가질 수록 높은 값을 가짐

ROC 곡선

FPR(= fall out)이 변할때 TPR(= Recall)의 변화를 그린 그림
FPR을 X축, TPR을 Y축
직선에 가까울 수록 머신러닝 모델의 성능이 떨어지는 것으로 판단

ROC 커브의 밑에 면적

1. ROC 커브 그리그

# 1) 데이터 불러오기 & concat

import pandas as pd

red_url = 'https://raw.githubusercontent.com/PinkWink/ML_tutorial/master/dataset/winequality-red.csv'
white_url = 'https://raw.githubusercontent.com/PinkWink/ML_tutorial/master/dataset/winequality-white.csv'
red_wine = pd.read_csv(red_url, sep=';')
white_wine = pd.read_csv(white_url, sep=';')

red_wine['color'] = 1.
white_wine['color'] = 0.

wine = pd.concat([red_wine, white_wine])


# 2) 맛 분류를 위한 데이터 정리
wine['taste'] = [1. if grade > 5 else 0 for grade in wine['quality']]

X = wine.drop(['taste','quality'], axis= 1)
y = wine['taste']



# 3) 의사 결정 나무 모델 확인
from sklearn.model_selection import train_test_split
from sklearn.tree import DecisionTreeClassifier
from sklearn.metrics import accuracy_score

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=13)

wine_tree = DecisionTreeClassifier(max_depth=2, random_state=13)
wine_tree.fit(X_train, y_train)

y_pred_tr = wine_tree.predict(X_train)
y_pred_test = wine_tree.predict(X_test)

print('Train Acc: ', accuracy_score(y_train, y_pred_tr))
print('Test Acc: ', accuracy_score(y_test, y_pred_test))

Train Acc: 0.7294593034442948 Test Acc: 0.7161538461538461

# 4) 각 수치 구하기

from sklearn.metrics import (accuracy_score, precision_score, 
                             recall_score, f1_score, roc_auc_score, roc_curve)

print('accuracy : ', accuracy_score(y_test, y_pred_test))
print('recall :', recall_score(y_test, y_pred_test))
print('precision :', precision_score(y_test, y_pred_test))
print('AUC score : ', roc_auc_score(y_test, y_pred_test))
print('F1-score', f1_score(y_test, y_pred_test))

accuracy : 0.7161538461538461 recall : 0.7314702308626975 precision : 0.8026666666666666 AUC score : 0.7105988470875331 F1-score 0.7654164017800381

wine_tree.predict_proba(X_test)

array([[0.61602594, 0.38397406], [0.61602594, 0.38397406], [0.12197802, 0.87802198], ..., [0.12197802, 0.87802198], [0.61602594, 0.38397406], [0.12197802, 0.87802198]])

# 5) 그리기

# 모듈
import matplotlib.pyplot as plt
%matplotlib inline

# X_test에 대한 predict_proba를 먼저 찾음
# 위에서 학습한 wine_tree의 predict_proba 함수에 X_test에를 넣어 줌
# [:, 1] : 1인 확률들만 취득 (위 결과값의 배열 = [0,1])
pred_proba = wine_tree.predict_proba(X_test)[:, 1]

# pred_proba : 위 결과값
# pred_proba를 roc_curve에 넣고 확률값을 확인
fpr, tpr, thresholds = roc_curve(y_test, pred_proba)

plt.figure(figsize=(10,8))
plt.plot([0,1], [0,1], 'o', ls='dashed')

# x축, y축
plt.plot(fpr, tpr)

plt.grid()
plt.show()

2.함수의 기초

1) 다항함수

# 1) 기본 

import numpy as np
import matplotlib.pyplot as plt
import matplotlib as mpl

mpl.style.use('seaborn-whitegrid')

# -3 ~ 2 까지 100개 만들기
x = np.linspace(-3,2,100)
y = 3*x**2 + 2

plt.figure(figsize=(6,4))
plt.plot(x,y)

# 수학 기호 (이탤릭체)
plt.xlabel('$x$', fontsize=25)
plt.ylabel('$3x^2 +2$', fontsize=25)

plt.show()

# 2) x축 방향 이동
x = np.linspace(-5,5,100)
y1 = 3*x**2 +2
y2 = 3*(x+1)**2 +2

plt.figure(figsize=(6,4))
plt.plot(x, y1, lw=2, ls='dashed', label='$y=3x^2 +2$')
plt.plot(x, y2, label='$y=3(x+1)^2 +2$')
plt.legend(fontsize=15)
plt.xlabel('$x$', fontsize=25)
plt.ylabel('$y$', fontsize=25)
plt.show()

2) 지수함수

x = np.linspace(-2,2,100)
a11, a12, a13 = 2,3,4
y11, y12, y13 = a11**x, a12**x, a13**x

a21, a22, a23 = 1/2, 1/3, 1/4
y21, y22, y23 = a21**x, a22**x, a23**x

# 1) 그래프

# plt.subplots(1행, 2열, 사이즈)
fig, ax = plt.subplots(1, 2, figsize=(12, 6))

ax[0].plot(x, y11, color='k', label=r"$2^x$")
ax[0].plot(x, y12, '--', color='k', label=r"$3^x$")
ax[0].plot(x, y13, ':', color='k', label=r"$4^x$")
ax[0].legend(fontsize=20)

ax[1].plot(x, y21, color='k', label=r"$(1/2)^x$")
ax[1].plot(x, y22, '--', color='k', label=r"$(1/3)^x$")
ax[1].plot(x, y23, ':', color='k', label=r"$(1/4)^x$")
ax[1].legend(fontsize=20)

3)특이한 지수

# 어떤 함수 인지 대략 확인
import numpy as np

x = np.array([10,100,1000,10000,100000])
(1+1/x)**x

array([2.59374246, 2.70481383, 2.71692393, 2.71814593, 2.71826824])

=> x 값이 커질 수록 어떠한 값으로 수렴(----)하는 함수임을 확인

4) 로그함수

# 데이터 준비

# 로그함수를 만들고 싶다면
def log(x, base):
    # 밑수(base)를 return으로 지정
    return np.log(x)/np.log(base)

x1 = np.linspace(0.0001, 5, 1000)
x2 = np.linspace(0.01, 5, 100)

y11, y12 = log(x1, 10), log(x2, np.e)
y21, y22 = log(x1, 1/10), log(x2, 1/np.e)

# 그리기 준비
fig, ax = plt.subplots(1,2, figsize=(12, 6))

ax[0].plot(x1, y11, color='k', label=r'$\log_{10} x$')
ax[0].plot(x2, y12, '--', color='k', label=r'$\log_{e} x$')

ax[0].set_xlabel('$x$', fontsize=25)
ax[0].set_ylabel('$y$', fontsize=25)
ax[0].legend(fontsize=20, loc='lower right')

ax[1].plot(x1, y21, color='k', label=r'$\log_{1/10} x$')
ax[1].plot(x2, y22, '--', color='k', label=r'$\log_{1/e} x$')

ax[1].set_xlabel('$x$', fontsize=25)
ax[1].set_ylabel('$y$', fontsize=25)
ax[1].legend(fontsize=20, loc='upper right')

plt.show()

5) 시그모이드

0 과 1사이의 값을 가진다 0으로 수렴하지 않음 무조건 1로 수렴함

z = np.linspace(-10,10,100)
sigma = 1/(1+np.exp(-z))

plt.figure(figsize=(12,8)) plt.plot(z, sigma) plt.xlabel('$z$', fontsize=25) plt.ylabel('$\sigma(z)$', fontsize=25) plt.show()

- ![](https://velog.velcdn.com/images/jaam_mini/post/29fcd8f8-d231-43cf-828f-13109d4a6894/image.png)


# 3. 함수의 표현
---

### 1_벡터의 표현
- ![](https://velog.velcdn.com/images/jaam_mini/post/bac3f759-08f8-47e3-88b2-c9de06f8f06b/image.png)


### 2_스칼라 함수
- 단일변수 스칼라함수
  - ![](https://velog.velcdn.com/images/jaam_mini/post/ea7040f1-fc6e-4056-8e2c-19c8ed7a63a7/image.png)

- 다중변수 스칼라 함수
  - ![](https://velog.velcdn.com/images/jaam_mini/post/b8835364-bac2-48e6-b153-313a7e720c64/image.png)



### 3_다변수 벡터 함수
- ![](https://velog.velcdn.com/images/jaam_mini/post/ddb4377d-39ff-4b44-bca9-c19d439aa2ca/image.png)

- ![](https://velog.velcdn.com/images/jaam_mini/post/e248ac51-c68d-4537-b2ac-cd33d73d4562/image.png)

u = np.linspace(0,1,30) v = np.linspace(0,1,30)

np.meshgrid : u,v의 많은 값을 한번에 계산(점찍고)하고 싶을 때 meshgrid를 사용

U, V = np.meshgrid(u, v)

Z = (1+U2) + V/(1+V2)

fig = plt.figure(figsize=(7,7))

projection : 3D로 그리는 명령어

ax = plt.axes(projection='3d')

ax.xaxis.set_tick_params(labelsize=10) ax.yaxis.set_tick_params(labelsize=10) ax.zaxis.set_tick_params(labelsize=10)

ax.set_xlabel('$x$',fontsize=10) ax.set_ylabel('$y$',fontsize=10) ax.set_zlabel('$z$',fontsize=10)

ax.scatter3D(U, V, Z, marker='.', color='gray') plt.show()

- ![](https://velog.velcdn.com/images/jaam_mini/post/c590f070-25fd-45e4-b8ef-4aa2d1f00239/image.png)

### 4_함수의 합성
log 함수는 x가 크면 조금 변하고, x가 작으면 많이 변한다
- ![](https://velog.velcdn.com/images/jaam_mini/post/4268eae3-1cf6-48f5-a133-a8ba64e8516d/image.png)

- 각 함수의 모양 확인

x = np.linspace(-4, 4, 100)

f(x)

y = x*3 - 15x + 30

g(y)

z = np.log(y)

fig, ax = plt.subplots(1, 2, figsize=(12, 6))

ax[0].plot(x, y, label=r'$x^3 - 15x + 30$', color='k') ax[0].legend(fontsize=18)

ax[1].plot(y, z, label=r'$\log(y)$', color='k') ax[1].legend(fontsize=18)

plt.show()

- ![](https://velog.velcdn.com/images/jaam_mini/post/db64ebab-102e-4d6e-a0e7-1901c93607b9/image.png)


- 합성 함수 모양 확인

x = np.linspace(-4, 4, 100)

f(x)

y = x*3 - 15x + 30

g(y)

z = np.log(y)

fig, ax = plt.subplots(1, 2, figsize=(12, 6))

ax[0].plot(x, z, '--', label=r'$\log(f(x))$', color='k') ax[0].legend(fontsize=18)

ax[1].plot(x, y, label=r'$x^3 - 15x + 30$', color='k') ax[1].legend(fontsize=18)

2번째 그림에서 x축을 하나 더 만들라는 명령

ax_tmp = ax[1].twinx() ax_tmp.plot(x,z, '--', label=r'$\log(f(x))$', color='k')

plt.show()

- ![](https://velog.velcdn.com/images/jaam_mini/post/21ae407d-d13b-49ab-a6e7-4661961711e2/image.png)


# 4. boxplot
----
boxplot을 이용해서 
몇% 지점의 데이터를 찾아서 버리거나 검토하는 용도를 배우고자 함

- ![](https://velog.velcdn.com/images/jaam_mini/post/18a8a172-7551-4394-841f-5e1027fa69ac/image.png)

- 예제

모듈

import matplotlib.pyplot as plt

samples = [1,7,9,16,36,39,45,45,46,48,51,100, 101]

[1]이 len(sample) 만큼 있기를 기대함

tmp_y = [1]*len(samples)

plt.figure(figsize=(12,4)) plt.scatter(samples, tmp_y) plt.grid() plt.show()

- ![](https://velog.velcdn.com/images/jaam_mini/post/e9caf556-7b83-47d5-a518-ea986078fc97/image.png)

- 각 지표 찾는 방법
  - ![](https://velog.velcdn.com/images/jaam_mini/post/aaa1d1d0-ff98-4f0b-8ca8-fc9e611ce263/image.png)

- 그래프로 아웃라이어 확인

중간값

import numpy as np np.median(samples)

# 25프로 지점 찾기

np.percentile(samples, 25)

# 75프로 지점 찾기

np.percentile(samples, 75)

# 중앙값 찾기

np.percentile(samples, 75) - np.percentile(samples, 25)

iqr = q3 - q1 q1 = np.percentile(samples, 25) q2 = np.median(samples) q3 = np.percentile(samples, 75)

IQR

upper_fence = q3 + iqr1.5 lower_fence = q1 - iqr1.5

plt.figure(figsize=(12,4)) plt.scatter(samples, tmp_y) plt.axvline(x=q1, color='black') plt.axvline(x=q2, color='red') plt.axvline(x=q3, color='black') plt.axvline(x=upper_fence, color='black', ls='dashed') plt.axvline(x=lower_fence, color='black', ls='dashed') plt.grid() plt.show()

- ![](https://velog.velcdn.com/images/jaam_mini/post/f00aa69d-2c53-408d-ae23-ae0b98cc4fbb/image.png)

- seaboen boxplot

import seaborn as sns plt.figure(figsize=(3,6)) sns.boxplot(samples) plt.grid() plt.show()

- ![](https://velog.velcdn.com/images/jaam_mini/post/c6b99976-c4ac-4ed5-91c5-c10e1fd14080/image.png)

ML - 4. Decision tree, Pipeline, 하이퍼파라미터 튜닝 - 와인 분석

Mon, 22 Jan 2024 03:16:43 GMT

1. 와인데이터 분석

1_데이터 읽어오기

import pandas as pd

red_url = 'https://raw.githubusercontent.com/PinkWink/ML_tutorial/master/dataset/winequality-red.csv'
white_url = 'https://raw.githubusercontent.com/PinkWink/ML_tutorial/master/dataset/winequality-white.csv'

red_wine = pd.read_csv(red_url, sep=';')
white_wine = pd.read_csv(white_url, sep=';')

# (주의) ; 로 해야 아래 처럼 뜸. :로 하면 이상하게 뜬다...

2_컬럼조사

white_wine.columns

Index(['fixed acidity', 'volatile acidity', 'citric acid', 'residual sugar', 'chlorides', 'free sulfur dioxide', 'total sulfur dioxide', 'density', 'pH', 'sulphates', 'alcohol', 'quality'], dtype='object')

3_데이터합치기

데이터를 합치기 전에 레드/화이트 구분을 지어줘야 함

red_wine['color'] = 1.
white_wine['color'] = 0.

wine = pd.concat([red_wine, white_wine])
wine.info()

4_['quality'] 컬럼 histogram

wine['quality'].unique()

array([5, 6, 7, 4, 8, 3, 9], dtype=int64)

import plotly.express as px

# 데이터는 wine, x축은 quality
fig = px.histogram(wine, x='quality')
fig.show()

5_등급별 histogram (레드/화이트)

# y자리에 color 로 함으로써 데이터별 색상을 넣어 줌
fig = px.histogram(wine, x='quality', color='color')
fig.show()

6_분류기 (레드/화이트)

# 1) feature data = 레드/화이트 맞추기
X = wine.drop(['color'], axis=1)

# 2) label data = 맞추고 싶은 대상
y = wine['color']

# 3) 훈련/테스트용 설정 (train/test split)

# 모듈
from sklearn.model_selection import train_test_split
import numpy as np

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=13)

# y_train에 어떤게 있는지 확인, return_counts(갯수) 확인
np.unique(y_train, return_counts=True)

(array([0., 1.]), array([3913, 1284], dtype=int64))

# 4) 어느 정도 구분되었는지 Histogram으로 확인

# graph_objects 모듈
import plotly.graph_objects as go

# Figure 호출
fig = go.Figure()

# go에서 Histogram을 가지고 옴
fig.add_trace(go.Histogram(x=X_train['quality'], name='Train'))
fig.add_trace(go.Histogram(x=X_test['quality'], name='Test'))

# 설정
# update_layout은 겹쳐지게(overlay)
# 투명도(update_traces)는 0.75
fig.update_layout(barmode='overlay')
fig.update_traces(opacity=0.75)
fig.show()

7_Decision tree

# 1) fit(학습)

# 모듈
from sklearn.tree import DecisionTreeClassifier

wine_tree = DecisionTreeClassifier(max_depth=2, random_state=13)
wine_tree.fit(X_train, y_train)

# 2) train accuracy(학습 결과 확인)

# 모듈
from sklearn.metrics import accuracy_score

# predict(훈련된 값)
y_pred_tr = wine_tree.predict(X_train)
y_pred_test = wine_tree.predict(X_test)

# 결과 확인 (참값, 예측값)
print('Train Acc :', accuracy_score(y_train, y_pred_tr))
print('Test Acc :', accuracy_score(y_test, y_pred_test))

Train Acc : 0.9553588608812776 Test Acc : 0.9569230769230769

8_데이터 전처리

X.columns

# feature data = 레드/화이트 맞추기
# X = wine.drop(['color'], axis=1)

1) Boxplot

# graph_objects 모듈
import plotly.graph_objects as go

# Figure 호출
fig = go.Figure()

# go에서 Boxplot 가지고 옴
fig.add_trace(go.Box(y=X['fixed acidity'], name='fixed acidity'))
fig.add_trace(go.Box(y=X['chlorides'], name='chlorides'))
fig.add_trace(go.Box(y=X['quality'], name='quality'))

fig.show()

2) MinMaxScaler & StandardScaler 중 어떤게 좋을지 확인

# 모듈
from sklearn.preprocessing import MinMaxScaler, StandardScaler

인스턴시에이션 (instantiation) : 이름을 가진 독립된 객체를 다룰 수 있게 함

둘 다 해봐야 어떤 것이 좋은지 알 수 있음

MMS = MinMaxScaler() SS = StandardScaler()

fit()

MMS.fit(X) SS.fit(X)

transform()

X_mms = MMS.transform(X) X_ss = SS.transform(X)

그래프를 그리고 싶어서 DataFrame을 만듬

X_mms_pd = pd.DataFrame(X_mms, columns=X.columns) X_ss_pd = pd.DataFrame(X_ss, columns=X.columns)

- 3) MinMaxScaler : 최대/최소값을 1,0으로 강제로 맞춤

graph_objects 모듈

import plotly.graph_objects as go

Figure 호출

fig = go.Figure()

go에서 Boxplot 가지고 옴

fig.add_trace(go.Box(y=X_mms_pd['fixed acidity'], name='fixed acidity')) fig.add_trace(go.Box(y=X_mms_pd['chlorides'], name='chlorides')) fig.add_trace(go.Box(y=X_mms_pd['quality'], name='quality'))

fig.show()

- ![](https://velog.velcdn.com/images/jaam_mini/post/556a1a7a-ec37-4c08-a491-bc4e6c349483/image.png)

- 4) StandardScaler : 평균을 0, 표준편차를 1로 맞춤

graph_objects 모듈

import plotly.graph_objects as go

Figure 호출

fig = go.Figure()

go에서 Boxplot 가지고 옴

fig.add_trace(go.Box(y=X_ss_pd['fixed acidity'], name='fixed acidity')) fig.add_trace(go.Box(y=X_ss_pd['chlorides'], name='chlorides')) fig.add_trace(go.Box(y=X_ss_pd['quality'], name='quality'))

fig.show()

- ![](https://velog.velcdn.com/images/jaam_mini/post/93023ba9-160e-4998-96e6-48d1c8dd5583/image.png)

- 5) [함수]로 만들어보기 : MinMaxScaler, StandardScaler

graph_objects 모듈

import plotly.graph_objects as go

target_df 만들고

def px_box(target_df):

# Figure 호출
fig = go.Figure()

# y값에 target_df 반영
fig.add_trace(go.Box(y=target_df['fixed acidity'], name='fixed acidity'))
fig.add_trace(go.Box(y=target_df['chlorides'], name='chlorides'))
fig.add_trace(go.Box(y=target_df['quality'], name='quality'))

fig.show()

px_box(X_mms_pd)

- ![](https://velog.velcdn.com/images/jaam_mini/post/212394e5-e699-4d75-ba39-ab55774f0411/image.png)

px_box(X_ss_pd)

- ![](https://velog.velcdn.com/images/jaam_mini/post/87d12d79-25a8-44f0-b5d0-5734f1dd178c/image.png)

- 6) MinMaxScaler 적용/학습

#split X_train, X_test, y_train, y_test = train_test_split(X_mms_pd, y, test_size=0.2, random_state=13)

wine_tree = DecisionTreeClassifier(max_depth=2, random_state=13)

fit

wine_tree.fit(X_train, y_train)

predict

y_pred_tr = wine_tree.predict(X_train) y_pred_test = wine_tree.predict(X_test)

print('Mms Train Acc :', accuracy_score(y_train, y_pred_tr)) print('Mms Test Acc :', accuracy_score(y_test, y_pred_test))

Mms Train Acc : 0.9553588608812776
Mms Test Acc : 0.9569230769230769

- 7) StandardScaler 적용/학습

#split X_train, X_test, y_train, y_test = train_test_split(X_ss_pd, y, test_size=0.2, random_state=13)

wine_tree = DecisionTreeClassifier(max_depth=2, random_state=13)

fit

wine_tree.fit(X_train, y_train)

predict

y_pred_tr = wine_tree.predict(X_train) y_pred_test = wine_tree.predict(X_test)

print('Ss Train Acc :', accuracy_score(y_train, y_pred_tr)) print('Ss Test Acc :', accuracy_score(y_test, y_pred_test))

Ss Train Acc : 0.9553588608812776
Ss Test Acc : 0.9569230769230769

8) zip - 레드/화이트 와인 구분 특성

X_train의 컬럼 이름을 그대로 사용

분류기 : fit 했던 wine_tree

feature_importances_

# 트리 기반 모델 중, 밀접한 관련이 있는 피처를 중요도 순으로 나열함
# 가중치가 적은 변수를 제거, 모델의 성능을 최적화 & 정확도를 높임

zip-> dict 로 바꿈

dict(zip(X_train.columns, wine_tree.feature_importances_))

▼ 결과

max_depth=2 로 잡았기 때문에, 2개 결과만 값이 0이 아님을 확인할 수 있다

{'fixed acidity': 0.0,
 'volatile acidity': 0.0,
 'citric acid': 0.0,
 'residual sugar': 0.0,
 'chlorides': 0.24230360549660776,
 'free sulfur dioxide': 0.0,
 'total sulfur dioxide': 0.7576963945033922,
 'density': 0.0,
 'pH': 0.0,
 'sulphates': 0.0,
 'alcohol': 0.0,
 'quality': 0.0}


### 9_이진분류

1) quality 컬럼 이진화

wine 데이터의 ['taste'] 컬럼 생성

quality column울 grade로 잡고, 5등급 보다 크면 1, 그게 아니라면 0으로 잡음

wine['taste'] = [1. if grade>5 else 0. for grade in wine['quality']]

wine.head()

-- ![](https://velog.velcdn.com/images/jaam_mini/post/a34628c1-9e8f-42c4-b0e1-cae5be080a40/image.png)

2) 모델링(fit)

label인 taste를 drop, 나머지를 X의 특성으로 봄

X = wine.drop(['taste'], axis=1)

새로만들 y데이터

y = wine['taste']

#split X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=13)

fit

wine_tree = DecisionTreeClassifier(max_depth=2, random_state=13) wine_tree.fit(X_train, y_train)

3) 평가(accuracy)

모듈

from sklearn.metrics import accuracy_score

predict(훈련된 값)

y_pred_tr = wine_tree.predict(X_train) y_pred_test = wine_tree.predict(X_test)

결과 확인 (참값, 예측값)

print('Train Acc :', accuracy_score(y_train, y_pred_tr)) print('Test Acc :', accuracy_score(y_test, y_pred_test))

Train Acc : 1.0
Test Acc : 1.0

- 결정트리 모델의 정확도가 1.0이 나온다면, 이는 모델이 학습 데이터에 완벽하게 적합되어 과적합(overfitting)된 상태일 수 있는데 결정트리를 시각화하여 무엇이 잘못되었는지 확인해봐야 함

4) 결정트리

import matplotlib.pyplot as plt import sklearn.tree as tree

plt.figure(figsize=(6,5)) tree.plot_tree(wine_tree, feature_names=X.columns.tolist());

- ![](https://velog.velcdn.com/images/jaam_mini/post/841d1cd7-87c1-414b-86cf-a93e73605efc/image.png)


- taste를 만들었던 quality 컬럼 값이 아직 살아 있음
- quality 컬럼을 가지고 학습하여 1.0이 나온 것임
- 따라서 quality 컬럼을 drop해서 다시 모델을 제작

5) drop(['taste','quality'] 후 모델링 & 평가

x = wine.drop(['taste','quality'], axis=1) y = wine['taste']

x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.2, random_state=13)

wine_tree = DecisionTreeClassifier(max_depth=2, random_state=13) wine_tree.fit(x_train, y_train)

y_pred_tr = wine_tree.predict(x_train) y_pred_test = wine_tree.predict(x_test)

accuracy_score(y_train, y_pred_tr) accuracy_score(y_test, y_pred_test)

print('Train Acc: ', accuracy_score(y_train, y_pred_tr)) print('Test Acc: ', accuracy_score(y_test, y_pred_test))

[0.6007692307692307,
 0.6884615384615385,
 0.7090069284064665,
 0.7628945342571208,
 0.7867590454195535]
0.709578255462782
[0.5523076923076923,
 0.6884615384615385,
 0.7143956889915319,
 0.7321016166281755,
 0.7567359507313318]
fixed acidity    volatile acidity    citric acid    residual sugar    chlorides    free sulfur dioxide    total sulfur dioxide    density    pH    sulphates    alcohol    quality
0    7.4    0.7    0.0    1.9    0.076    11.0    34.0    0.9978    3.51    0.56    9.4    5
fixed acidity    volatile acidity    citric acid    residual sugar    chlorides    free sulfur dioxide    total sulfur dioxide    density    pH    sulphates    alcohol    quality
0    7.0    0.27    0.36    20.7    0.045    45.0    170.0    1.001    3.0    0.45    8.8    6
Index(['fixed acidity', 'volatile acidity', 'citric acid', 'residual sugar',
       'chlorides', 'free sulfur dioxide', 'total sulfur dioxide', 'density',
       'pH', 'sulphates', 'alcohol', 'quality'],
      dtype='object')

Index: 6497 entries, 0 to 4897
Data columns (total 13 columns):
 #   Column                Non-Null Count  Dtype  
---  ------                --------------  -----  
 0   fixed acidity         6497 non-null   float64
 1   volatile acidity      6497 non-null   float64
 2   citric acid           6497 non-null   float64
 3   residual sugar        6497 non-null   float64
 4   chlorides             6497 non-null   float64
 5   free sulfur dioxide   6497 non-null   float64
 6   total sulfur dioxide  6497 non-null   float64
 7   density               6497 non-null   float64
 8   pH                    6497 non-null   float64
 9   sulphates             6497 non-null   float64
 10  alcohol               6497 non-null   float64
 11  quality               6497 non-null   int64  
 12  color                 6497 non-null   float64
dtypes: float64(12), int64(1)
memory usage: 710.6 KB
array([5, 6, 7, 4, 8, 3, 9], dtype=int64)
(array([0., 1.]), array([3913, 1284], dtype=int64))

DecisionTreeClassifier
DecisionTreeClassifier(max_depth=2, random_state=13)
Train Acc : 0.9553588608812776
Test Acc : 0.9569230769230769
Index(['fixed acidity', 'volatile acidity', 'citric acid', 'residual sugar',
       'chlorides', 'free sulfur dioxide', 'total sulfur dioxide', 'density',
       'pH', 'sulphates', 'alcohol', 'quality'],
      dtype='object')
Mms Train Acc : 0.9553588608812776
Mms Test Acc : 0.9569230769230769
Ss Train Acc : 0.9553588608812776
Ss Test Acc : 0.9569230769230769
{'fixed acidity': 0.0,
 'volatile acidity': 0.0,
 'citric acid': 0.0,
 'residual sugar': 0.0,
 'chlorides': 0.24230360549660776,
 'free sulfur dioxide': 0.0,
 'total sulfur dioxide': 0.7576963945033922,
 'density': 0.0,
 'pH': 0.0,
 'sulphates': 0.0,
 'alcohol': 0.0,
 'quality': 0.0}
fixed acidity    volatile acidity    citric acid    residual sugar    chlorides    free sulfur dioxide    total sulfur dioxide    density    pH    sulphates    alcohol    quality    color    taste
0    7.4    0.70    0.00    1.9    0.076    11.0    34.0    0.9978    3.51    0.56    9.4    5    1.0    0.0
1    7.8    0.88    0.00    2.6    0.098    25.0    67.0    0.9968    3.20    0.68    9.8    5    1.0    0.0
2    7.8    0.76    0.04    2.3    0.092    15.0    54.0    0.9970    3.26    0.65    9.8    5    1.0    0.0
3    11.2    0.28    0.56    1.9    0.075    17.0    60.0    0.9980    3.16    0.58    9.8    6    1.0    1.0
4    7.4    0.70    0.00    1.9    0.076    11.0    34.0    0.9978    3.51    0.56    9.4    5    1.0    0.0

DecisionTreeClassifier
DecisionTreeClassifier(max_depth=2, random_state=13)
Train Acc : 1.0
Test Acc : 1.0

Train Acc:  0.7294593034442948
Test Acc:  0.7161538461538461

- 6)결정트리 값을 통해 와인의 맛 평가의 기준이 [alchol] 인 것을 확인함

6) 결정트리

import matplotlib.pyplot as plt import sklearn.tree as tree

plt.figure(figsize=(12,5)) tree.plot_tree(wine_tree, rounded=True, filled=True, feature_names=X.columns.tolist()); plt.show()

- ![](https://velog.velcdn.com/images/jaam_mini/post/19c1428b-7f80-4762-9f55-e3fcb2d56f2b/image.png)

# 2. Pipeline
----
- 단순히 Iris, Wine 데이터를 받아서 사용했을 뿐인데, 직접 공부하면서 코드를 하나씩 실행해보면 혼돈이 크다는 것을 알 수 있다.
- Jupyter Notebook 상황에서 데이터의 전처리와 여러 알고리즘의 반복 실행, 하이퍼 파라미터의 튜닝 과정을 번갈아 하다 보면 코드의 실행 순서에 혼돈이 있을 수 있다.
- 이런 경우 클래스(class)로 만들어서 진행해도 되지만, sklearn 유저에게는 꼭 그럴 필요없이 준비된 기능인 Pipeline이 있다.

1) 데이터 불러오기 & concat

import pandas as pd

red_url = 'https://raw.githubusercontent.com/PinkWink/ML_tutorial/master/dataset/winequality-red.csv' white_url = 'https://raw.githubusercontent.com/PinkWink/ML_tutorial/master/dataset/winequality-white.csv' red_wine = pd.read_csv(red_url, sep=';') white_wine = pd.read_csv(white_url, sep=';')

red_wine['color'] = 1. white_wine['color'] = 0.

wine = pd.concat([red_wine, white_wine])

x = wine.drop(['color'], axis=1) y = wine['color']

- 파이프라인을 한번 짜 놓으면, 호출 시 알아서 진행

2) 파이프라인 생성

3가지 모듈

from sklearn.pipeline import Pipeline from sklearn.tree import DecisionTreeClassifier from sklearn.preprocessing import StandardScaler

변수에 리스트 형, 튜플로 지정

estimators = [ ('scaler', StandardScaler()), ('clf', DecisionTreeClassifier()) ]

변수에 파이프라인 설정

pipe = Pipeline(estimators)


- 어떤 스텝으로 움직이는지 확인
    - 첫번쨰 단계는 scaler라고 부르고, StandardScaler() 가 지정되어 있음
    - 두번쨰 단계는 clf라고 부르고, DecisionTreeClassifier() 가 지정되어 있음

pipe

- ![](https://velog.velcdn.com/images/jaam_mini/post/5cb49bdf-03f3-4ec6-b7aa-e4cf42c32142/image.png)

pipe.steps

[('scaler', StandardScaler()), ('clf', DecisionTreeClassifier())]


- 객체 호출 방법

pipe.steps[0]

('scaler', StandardScaler())

pipe['scaler']

- ![](https://velog.velcdn.com/images/jaam_mini/post/a4b4b01f-8954-4a5d-a1d4-e7420ee1df8c/image.png)


- DecisionTreeClassifier() 에는 지정해야 하는 [파라미터]가 있음
- set_params (스탭이름 “clf” + 언더바 두 개 “- -” + 속성 이름)

3) Params 접근

DecisionTreeClassifier() 메서드를 'clf'로 위에서 정의했고, 언더바를 붙여서 max_dept 파라미터를 2로 설정 한 것

즉, 언더바 2개를 추가해서 접근했다고 보면 됨 (https://guru.tistory.com/50)

clf에 max_depth=2를 설정 : clf + _ _ + max_depth=2

pipe.set_params(clf__max_depth=2) pipe.set_params(clf__random_state=13)

- ![](https://velog.velcdn.com/images/jaam_mini/post/9bf4b8c4-b6a3-49e2-84b8-00de1c66db1e/image.png)

4) split + fit

from sklearn.model_selection import train_test_split

stratify=y : y데이터의 분로픞 맞춰라

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=13, stratify=y)

(1) Parameter

arrays : 분할시킬 데이터를 입력 (Python list, Numpy array, Pandas dataframe 등..)

test_size : 테스트 데이터셋의 비율(float)이나 갯수(int) (default = 0.25)

train_size : 학습 데이터셋의 비율(float)이나 갯수(int) (default = test_size의 나머지)

random_state : 데이터 분할시 셔플이 이루어지는데 이를 위한 시드값 (int나 RandomState로 입력)

shuffle : 셔플여부설정 (default = True)

stratify : 지정한 Data의 비율을 유지한다.

예를 들어, Label Set인 Y가 25%의 0과 75%의 1로 이루어진 Binary Set일 때, stratify=Y로 설정하면 나누어진 데이터셋들도 0과 1을 각각 25%, 75%로 유지한 채 분할된다.


- (예전) Scaler 통과 + 분류기 학습
- (지금) 이미 선언해둔 pipe 이용

5) pipe

pipe.fit(X_train, y_train)


- ![](https://velog.velcdn.com/images/jaam_mini/post/1f9d441f-f394-40bc-8418-1569a378cf88/image.png)

6) 결과 확인

from sklearn.metrics import accuracy_score

y_pred_tr = pipe.predict(X_train) y_pred_test = pipe.predict(X_test)

print('Train Acc :', accuracy_score(y_train, y_pred_tr)) print('Test Acc :', accuracy_score(y_test, y_pred_test))

Train Acc : 1.0
Test Acc : 1.0


# 3. 교차검증
---

1) 데이터 불러오기 & concat

import pandas as pd

red_wine['color'] = 1. white_wine['color'] = 0.

wine = pd.concat([red_wine, white_wine])

2) 맛 분류를 위한 데이터 정리

wine['taste'] = [1. if grade > 5 else 0 for grade in wine['quality']]

X = wine.drop(['taste','quality'], axis= 1) y = wine['taste']

3) 의사 결정 나무 모델 확인

from sklearn.model_selection import train_test_split from sklearn.tree import DecisionTreeClassifier from sklearn.metrics import accuracy_score

x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.2, random_state=13)

wine_tree = DecisionTreeClassifier(max_depth=2, random_state=13) wine_tree.fit(x_train, y_train)

y_pred_tr = wine_tree.predict(x_train) y_pred_test = wine_tree.predict(x_test)

print('Train Acc: ', accuracy_score(y_train, y_pred_tr)) print('Test Acc: ', accuracy_score(y_test, y_pred_test))

Train Acc:  0.7294593034442948
Test Acc:  0.7161538461538461


### 1_KFold()

Train Acc: 0.7294593034442948 Test Acc: 0.7161538461538461

- 위 값이 최선인지, acc를 신뢰할 수 있는지 확인하기 위해 KFold(교차검증)이 필요

4) KFold

모듈

from sklearn.model_selection import KFold

n_splits는 몇 개의 폴드(fold)로 나눌 것인지를 의미하는 매개변수

5겹 교차 검증이 가장 일반적

kfold = KFold(n_splits=5)

wine_tree_cv = DecisionTreeClassifier(max_depth=2, random_state=13)

5) 모델링 (학습 & 결과 확인)

기록 보관을 위해 '빈리스트'생성

cv_accuracy =[]

for train_idx, test_idx in kfold.split(X):

# 데이터 구성
X_train, X_test = X.iloc[train_idx], X.iloc[test_idx]
y_train, y_test = y.iloc[train_idx], y.iloc[test_idx]

# 학습
wine_tree_cv.fit(X_train, y_train)

# 모델링
pred = wine_tree_cv.predict(X_test)

# 리스트 저장 (결과값)
cv_accuracy.append(accuracy_score(y_test, pred))

cv_accuracy

[0.6007692307692307,
 0.6884615384615385,
 0.7090069284064665,
 0.7628945342571208,
 0.7867590454195535]

6) KFold 평균값 확인

import numpy as np

np.mean(cv_accuracy)

0.709578255462782

### 2_StratifiedKFold()

7) StratifiedKFold

from sklearn.model_selection import StratifiedKFold

skfold = StratifiedKFold(n_splits=5) wine_tree_cv = DecisionTreeClassifier(max_depth=2, random_state=13)

cv_accuracy = []

for train_idx, test_idx in skfold.split(X, y):

# 데이터 구성
X_train, X_test = X.iloc[train_idx], X.iloc[test_idx]
y_train, y_test = y.iloc[train_idx], y.iloc[test_idx]

# 학습
wine_tree_cv.fit(X_train, y_train)

# 모델링
pred = wine_tree_cv.predict(X_test)

# 리스트 저장 (결과값)
cv_accuracy.append(accuracy_score(y_test, pred))

cv_accuracy

[0.5523076923076923,
 0.6884615384615385,
 0.7143956889915319,
 0.7321016166281755,
 0.7567359507313318]

8) StratifiedKFold 평균값 확인

import numpy as np

np.mean(cv_accuracy)

0.6888004974240539

### 3_cross validation

from sklearn.model_selection import cross_val_score

skfold = StratifiedKFold(n_splits=5) wine_tree_cv = DecisionTreeClassifier(max_depth=2, random_state=13)

cross_val_score(wine_tree_cv, X, y, scoring=None, cv=skfold)

array([0.55230769, 0.68846154, 0.71439569, 0.73210162, 0.75673595])


### 4_함수로 풀어보기

def skfold_dt(depth): from sklearn.model_selection import cross_val_score

skfold = StratifiedKFold(n_splits=5)
wine_tree_cv = DecisionTreeClassifier(max_depth=depth, random_state=13)

print(cross_val_score(wine_tree_cv, X, y, scoring=None, cv=skfold))

skfold_dt(3)

[0.56846154 0.68846154 0.71439569 0.73210162 0.75673595]

### 5_train score와 함께 보고 싶다면

from sklearn.model_selection import cross_validate cross_validate(wine_tree_cv, X, y, scoring=None, cv=skfold, return_train_score=True)

{'fit_time': array([0.01700068, 0.01591516, 0.01597691, 0.01599717, 0.01500058]),
 'score_time': array([0.00108767, 0.01203322, 0.00293016, 0.00198984, 0.00199056]),
 'test_score': array([0.50076923, 0.62615385, 0.69745958, 0.7582756 , 0.74903772]),
 'train_score': array([0.78795459, 0.78045026, 0.77568295, 0.76356291, 0.76279338])}

# 4. 하이퍼파라미터 튜닝
----

- 튜닝 대상
    - 결정나무에서 아직 우리가 튜닝해 볼만한 것은 max_depth이다.
    - 간단하게 반복문으로 max_depth를 바꿔가며 테스트해볼 수 있을 것이다.
    - 그런데 앞으로를 생각해서 보다 간편하고 유용한 방법을 생각해보자.

1) 데이터 불러오기 & concat

import pandas as pd

red_wine['color'] = 1. white_wine['color'] = 0.

wine = pd.concat([red_wine, white_wine])

2) 맛 분류를 위한 데이터 정리

wine['taste'] = [1. if grade > 5 else 0 for grade in wine['quality']]

X = wine.drop(['taste','quality'], axis= 1) y = wine['taste']


### 1) GridSearchCV
- 매번 하이퍼파라미터를 수정할 순 없음
- 예를 들어 pipeline을 5개 만든 경우, 하이퍼파라미터를 수정해야 하는 경우의 수는 엄청남
- 그래서, 수정할 파라미터를 지정 -> GridSearchCV(분류기)에 알아서 cv=5겹으로 fit해라는 명령인 "GridSearchCV"를 이용
- (참고)https://blog.naver.com/dalgoon02121/222103377185

모듈

from sklearn.model_selection import GridSearchCV from sklearn.tree import DecisionTreeClassifier

파라미터 지정

params = {'max_depth':[2,4,7,10]} wine_tree = DecisionTreeClassifier(max_depth=2, random_state=13)

변수에 = GridSearchCV(분류기로 wine_tree를 지정, param_grid는 params로, 5겹으로)

gridsearch = GridSearchCV(estimator=wine_tree, param_grid=params, cv=5)

학습 (split을 쓰지 않아도 됨)

gridsearch.fit(X,y)

- ![](https://velog.velcdn.com/images/jaam_mini/post/b4f4da6c-e611-457f-a7ac-9c7f3db8b47d/image.png)

결과 확인

pprint는 데이터를 보기 좋게 출력(pretty print)할 때 사용하는 모듈

import pprint

pp = pprint.PrettyPrinter(indent=4) pp.pprint(gridsearch.cv_results_)

- ![](https://velog.velcdn.com/images/jaam_mini/post/1aa1f92d-234f-448b-8f84-4a0f0d225d2e/image.png)


### 2) 데이터 관찰

최고의 성능을 가진 모델

gridsearch.best_estimator_

결과 : max_depth=2 일때

최고 점수

gridsearch.best_score_

결과 : 69%

최고 파라미터

gridsearch.best_params_

결과 : {'max_depth': 2}

### 3) pipeline + GridSearchCV

pipeline 생성 모델

from sklearn.pipeline import Pipeline from sklearn.tree import DecisionTreeClassifier from sklearn.preprocessing import StandardScaler

estimators = [ ('scaler', StandardScaler()), ('clf', DecisionTreeClassifier(random_state=13)) ]

pipe = Pipeline(estimators)

param 지정

param_grid = [{'clf__max_depth':[2,4,7,10]}]

GridSearchCV

GridSearch = GridSearchCV(estimator=pipe, param_grid=param_grid, cv=5)

fit

GridSearch.fit(X,y)

- ![](https://velog.velcdn.com/images/jaam_mini/post/2bbac17c-ee51-45ae-983c-3c2ec9d6f254/image.png)

### 4) DataFrame으로 예쁘게 정리

import pandas as pd

GridSearch 변수에 cv_results_를 호출

cv_results_ : 파라미터 조합별 결과 조회

score_df = pd.DataFrame(GridSearch.cv_results_) score_df

보고 싶은 컬럼들만 확인

score_df[['params', 'rank_test_score', 'mean_test_score', 'std_test_score']]

Tableau - (과제2) 주유소 평균 가격

Sun, 21 Jan 2024 16:51:37 GMT

1. 지역별 평균 가격

1_self (계산 필드)

2_휘발유 가격

매개변수

계산된 필드

3_완성

조금 다르지만 일단 완성..

2. 거리

1_시설정보

매개변수
계산필드

2_경도/위도

3_완성

드디어 배경을 거리맵으로 하는 방법을 찾아서 적용했다! 미리 알았더라면 이디야 답안도 이렇게 제출했을텐데... piblic은 처음부터 새롭게 만들어야 해서...주유소 문제만이라도 답안과 동일하게 만들기로..! (지금이라도 찾아서 다행이라고 생각한다 😉)

3. 휘발유/경유 최저/최고

1_휘발유 최저

최대한 답안지와 비슷하게 만들었다...

2_휘발유 최고

최저 sheet를 복사해서 수정!

3_경유 최저

4_경유 최고

4. 최종

https://public.tableau.com/shared/59KH8ZR5J?:display_count=n&:origin=viz_share_link

Tableau - (과제1) 이디야 스타벅스 매장 간 거리 _ 답안 추가

Fri, 19 Jan 2024 04:13:50 GMT

1. 기본 설정 세팅

1_매장간 거리

MAKEPOINT는 위도와 경도로 구성된 공간 개체를 반환해줌
DISTANCE는 (시작, 끝, 단위)로 이뤄져 있음

2_이디야 매장수

COUNTD() 사용

3_Meters Away (매개변수)

4_거리 설정

2. 그래프 만들기

1_매장수

답안지와 동일한 그래프로 만들기 위해 표 선(그리드)를 찾는데 한참 걸렸다...

2_비중

[매장수] 시트를 복제해서 사용

Meters Away 위의 Total을 [숨기기]처리 했다. [이항목만유지]하는 경우 비중이 100%로 뜨기 때문!

[테이블(아래로)] 도 잊지 말아야 한다!

3_매장수(네모박스)

4_지도맵

먼저 경도, 위도를 생성한다

(시군구)를 그래프에 나타내기 위해 (이전 학습 rawdata)를 불러오면 아래와 같은 경고 문구가 뜬다

이를 해결하기 위해 [데이터를 유니온 해줬다] 컬럼은 [E Gu] = [시군구] 로 맞춰줘야 한다!

2시간 걸린...결과물

5_거리

정.말 어떻게 구성해야 할지 한시간 고민한 sheet 였다 🙄

1) E name > 레이블 > 측정값 > 카운트

2) Buffer 생성 이 함수를 다들 어떻게 찾은 걸까..?

스타벅스의 위도와 경도를 기준으로 매개변수 '거리' 만큼 'meter'단위로 원을 그리는 함수

3) MAKEPOINT() 이디야 매장수를 찍기 위해서 생성

4) 이중축

5) 스타벅스와의 거리

6) 이디야 포인트

답지와 동일한 지도로 하고 싶었지만, 해결하지 못했다..

답지 지도

3. 대시보드

1) 동작 설정 왼쪽 지도에서 구를 선택 시, 오른쪽 지도에서 해당 구가 필터링 되게 해야 한다

2) 하이라이트 생성 위 그래프 선택 시 아래 [비중]이 하이라이트되게 해야 한다

4. 결과물

https://public.tableau.com/shared/C99FQK3J4?:display_count=n&:origin=viz_share_link

Tableau가 쉬우니 금방 따라갈 거라던 내 친구들의 말이 무색하게 굉-장히 힘들게 과제를 풀었다... 결과물도 답안과 조금 달라 속상하지만 ! 최선을 다했음에 만족..!

5.😆답안지

전체 매장수

📌 기본 설정

스타벅스 - 이디야 매장간 거리 계산을 위한 매장별 위치값 필요 : MAKEPOINT 이용

스타벅스 위치값
- 필드명 : S_LOCATION
- MAKEPOINT([스타벅스 위도], [경도])
이디야 위치값
- 필드명 : E_LOCATION
- MAKEPOINT([이디야 위도], [경도])

스벅/이디야 매장간 거리

필드명 : DISTANCE
DISTANCE([S_LOCATION], [E_LOCATION], "M")

이디야 매장수

필드명 : '# OF EDIYA
- COUNT([E ID])

특정 거리내에 위치한 매장에 참/거짓 달기

필드명 : T/F_METERS AWAY
- [METERS AWAY]보다 작거나 같으면 'METERS WAY', 아닌 경우 'TOTAL'
- IIF([DISTANCE] <= [METERS AWAY], 'METERS WAY', 'TOTAL')
매개변수 : METERS AWAY

📌 그래프

이디야 매장정보를 활용할거라서, E EU > 열 선반
T/F_METERS AWAY > 행렬 선반 > 내림차순
'# OF EDIYA > 마크 > 텍스트
METERS AWAY > 우클릭 > 매개변수 사용

거리내 매장수

📌 그래프

전체 매장수를 볼꺼기 때문에 T/F_METERS AWAY > 필터 > 거리 내 매장수만 ㅛ시할 예정으로 'METERS AWAY' 체크
'# OF EDIYA > 마크 > 텍스트

비중

📌 그래프

[전체 매장수] 복제
'# OF EDIYA > 퀵테이블계산 > 구성비율 > 우클릭 > 다음을 사용해 계산 > 테이블 아래 > 우큵 > 서식 > 숫자 '백분율','소수점 0'

시군구 맵차트

📌 기본 설정

시군구 정보만 가지고 있는 별도의 필드가 없는 상태
SPLIT을 사용해 [시군구 필드]만들 예정
- 이디야 매장 기준 지역별 매장수 확인 예정 > [E ADDRESS]사용
- [E ADDRESS] > 우클릭 > 변환 > 사용자지정분할 > '구분기호': 띄어쓰기 1칸, '분할해제' 2열
[분할1] [분할2] 생성됨
[분할1] > 우클릭 > 편집 > 필드 이름 : 시도 > 지리적 역할 > 주시도
[분할2] > 우클릭 > 편집 > 필드 이름 : 시군구 > 지리적 역할 > 시군구
[시도], [시군구] 선택 > 우클릭 > 계층 > 계층 만들기 > [지역]으로 이름 짖기
⭐ [E GU]를 세부정보에 추가해야 함, 이후 대시보드 동작 시 원본/대상 시트가 같은 정보를 갖고 있어야 동작기능이 정상적으로 작동하기 때문 ; [E GU] > 세부정보 로 드래그

📌 그래프

경도, 위도 > 더블클릭
시군구 > 마크 > 맵 으로 변경

이제 스타벅스 기준, 특정거리 내에 있는 이디야 매장수 표시해야 함

'# OF EDIYA > 마크
'# OF EDIYA > 색상 > 오른쪽 상단 색상범례 더블클릭 > '남색'으로 색상 변경
T/F_METERS AWAY > 필터 > 'METERS AWAY'
시군구 > 레이블 > 텍스트 편집 >
상단 '맵' 메뉴 > 맵 계층 > 백그라운드 투명도 100% 로 변경

거리 맵차트

BUFFER 함수를 써서 특정 위치를 중심으로 지정된 거리 만큼 원으로 표시되게 할 것임

스타벅스를 기준으로 '매개변수' 거리 만큼 BUFFER를 만들 것임

📌 기본 설정

필드이름 : S_BUFFER
BUFFER([S_LOCATINO], [METERS AWAY], "M")

📌 그래프

스타벅스 매장 위치를 표시할 것임

위도, 경도 추가
S_BUFFER 더블클릭
⭐ S_NAME > 마크로 드래그 : 하나로 뭉쳐있는 S_BUFFER를 나눠주는 기능
S_BRAND > 색상 > 색상범례 더블클릭 > 진한 초록색

이디야 매장 위치를 표시할 것임

위도 + CTRL > 옆으로 복제
기존 마크에 있던 모든 것을 빼줌
E_LOCATINO 더블클릭
E_NAME > 세부정보 드래그
E_BRAND > 색상 > 빨간색으로 변경
오른쪽 위도 > 우클릭 > 이중축

특정 거리 내에 위치한 이디야 매장만 확인하면 됨 관련 없는 매장은 없애기 위해

T/F_METERS AWAY > 필터 > METERS AWAY

이디야 매장수를 숫자로 표시하기 위해

T/F_METERS AWAY 복제 > 우클릭 > 편집
- 필드명 : '# OF EDIYA_HIDDEN
- 합계(참인 경우 숫자 1, 거짓인 경우 0)
- SUM(IIF([DISTANCE] <= [METERS AWAY], '1', '0'))
'# OF EDIYA_HIDDEN > 우클릭 > 연속형 으로 변경 > 왼쪽 위도 레이블에 드래그 > 우클릭 > 서식 > 글자 크기 변경

맵 예쁘게 변경하기

상단 '멥' > 배경맵 > 거리 선택

대시보드

대시보드 > 동작 > 필터
대시보드 > 동작 > 하이라이트

ML - 3. label_encoder , min-max scaling , Standard , Robust Scaler

Wed, 17 Jan 2024 11:13:09 GMT

1. label_encoder

import pandas as pd

df = pd.DataFrame({
    'A' : ['a', 'b', 'c', 'a', 'b'],
    'B' : [1,2,3,1,0]
})

df

1) fit ~ transform (문자 -> 숫자

from sklearn.preprocessing import LabelEncoder

# 변수 설정
le = LabelEncoder()

# (1) 학습(df의 A컬럼을 기준으로)
le.fit(df['A'])

# (2) 잘 학습되었는지 확인
le.classes_

array(['a', 'b', 'c'], dtype=object)

# (3) transformation (fit 이후 해야 함)
le.transform(df['A'])

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

# (4) transformation 값, 컬럼에 넣기
df['le_A'] = le.transform(df['A'])

2) fit+transform

le.fit_transform(df['A'])

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

3) 답 물어보기

le.transform(['a'])

array([0])

4) 역변환 (문자 -> 숫자)

le.inverse_transform(df['le_A'])

array(['a', 'b', 'c', 'a', 'b'], dtype=object)

2. min-max scaling (정규화)

(min)은 0으로, (max)는 1로 만들어 줌

df = pd.DataFrame({
    'A' : [10,20,-10,0,25],
    'B' : [1,2,3,1,0]
})

df

1) fit

# MinMaxScaler 모듈
from sklearn.preprocessing import MinMaxScaler

mms = MinMaxScaler()
mms.fit(df)

2) 데이터 확인

# data_range_ : 분모 역할(전체 길이)
mms.data_max_, mms.data_min_, mms.data_range_

(array([25., 3.]), array([-10., 0.]), array([35., 3.]))

3) transform

(min)은 0으로, (max)는 1로 만들어 줌
```
df_mms = mms.transform(df)
df_mms
```

4) 역변환

mms.inverse_transform(df_mms)

5) 한번에~

mms.fit_transform(df)

3. Standard Scaler (표준화)

표준정규분포 (표준을 빼고 편차로 나눠주는~)

1) fit

from sklearn.preprocessing import StandardScaler

ss = StandardScaler()
ss.fit(df)

2) 표준편차 작동 인자

(분모) 표준편차
(분자) 평균
```
# 평균, 표준편차
ss.mean_, ss.scale_
```
(array([9. , 1.4]), array([12.80624847, 1.0198039 ]))

3) transform

df_ss = ss.transform(df)
df_ss

4) 한번에~

ss.fit_transform(df)

4. Robust Scaler

df = pd.DataFrame({
    'A' : [-0.1,0.,0.1,0.2,0.3,0.4,1.0,1.1,5]
})

df

1) 3가지 모듈을 한번에 적용

from sklearn.preprocessing import MinMaxScaler, StandardScaler, RobustScaler

mm = MinMaxScaler()
ss = StandardScaler()
rs = RobustScaler()

2) fit_transform + 컬럼 추가

df_scaler = df.copy()

df_scaler['MinMax'] = mm.fit_transform(df)
df_scaler['Standard'] = ss.fit_transform(df)
df_scaler['Robust'] = rs.fit_transform(df)

df_scaler

3) 이해를 위해 Boxplot

import seaborn as sns
import matplotlib.pyplot as plt

plt.figure(figsize=(16,6))
sns.set_theme(style='whitegrid')
sns.boxplot(data=df_scaler, orient='h') #orient='h':수평bar

A 안에는 0.1 기준으로 증감하는 데이터들 사이에 5라는 아웃라이어가 있음
5라는 아웃라이어 때문에 MinMaxScaler 결과 한쪽으로 치우치게 됨
MinMaxScaler는 아웃라이어의 영향을 받으면 데이터가 이상해질 수 있음
평균과 중앙값을 쓸때, 평균 이상치를 반영하고, 중앙값은 이상치 영향을 덜 받게 됨
StandardSCaler를 확인했을 때, 평균이 반영되어 대다수의 데이터가 왼쪽으로 치우침
RobustSCaler는 median이 0이 되고, 아웃라이어는 그대로 유지되며 데이터에 영향을 크게 주지 않음

ML - 2. Titanic 생존 분석 _ titanic disaster kaggle

Wed, 17 Jan 2024 08:44:48 GMT

# !pip install plotly_express

import pandas as pd

titanic_url = 'http://raw.githubusercontent.com/PinkWink/ML_tutorial/master/dataset/titanic.xls'
titanic = pd.read_excel(titanic_url)
titanic.head(2)

1. 데이터 정리

생존상황 확인

import matplotlib.pyplot as plt
import seaborn as sns

# plt.subplots : 그래프 2개 한번에 그리기 (1행, 2열로)
f, ax = plt.subplots(1,2,figsize=(18,8))

# titanic['survived'].value_counts() : [0]비생존자, [1]생존자
# .plot.pie : 동그란 그래프로 그리자
titanic['survived'].value_counts().plot.pie(
    explode=[0, 0.05], # 조각들 멀어지기
    autopct='%1.1f%%', # 소수점 첫째 자리까지 수치 입력
    ax=ax[0], # ax를 첫번째로 그려줘
    shadow=True # 그림자 생김
)
ax[0].set_title('Pie plot - survived')
ax[0].set_ylabel('')

sns.countplot(x='survived', data=titanic, ax=ax[1])
ax[1].set_title('Count plot - survived')

plt.show()

2) 성별

f, ax = plt.subplots(1,2,figsize=(18,8))

sns.countplot(x='sex', data=titanic, ax=ax[0])
ax[0].set_title('Count of Passengers of Sex')
ax[0].set_ylabel('')

sns.countplot(x='sex', data=titanic, hue='survived', ax=ax[1])
ax[1].set_title('Sex ; survived and Unsurvived')

plt.show()

3) 경제력

crosstab : 2번째 컬럼을 구분지어 주고, 인덱스에 1번째 컬럼을 담아 줌

margins=True : 합계

pd.crosstab(titanic['pclass'], titanic['survived'], margins=True)

4) 등급/성별 _FacetGrid

# FacetGrid(변수 지정, 행, 컬럼, 높이, 넓이)
grid = sns.FacetGrid(titanic, row='pclass', col='sex', height=4, aspect=2)

# hist을 넣어라, 나이를 기준으로, 투명도는 0.8로, 수평축의 간격)
grid.map(plt.hist, 'age', alpha=.8, bins=20)

# 각 격자 안의 색상에 대한 범레 지정
grid.add_legend();

5) 나이

import plotly.express as px

# px에 히스토그램을 그려줘(데이터는 타이타닉, 컬럼은 나이)
fig = px.histogram(titanic, x='age')
fig.show()

6) 선실 등급별

grid = sns.FacetGrid(titanic, col='survived', row='pclass', height=4, aspect=2)
grid.map(plt.hist, 'age', alpha=.5, bins=20)
grid.add_legend();

7) 나이 5단계 정리

# age_cat :라는 새로운 (컬럼) 만들
titanic['age_cat'] = pd.cut(
    titanic['age'], # titanic 데이터의 age 컬 
    bins = [0,7,15,30,60,100],
    include_lowest = True,
    labels = ['baby', 'teen', 'young', 'adult', 'old']
    # 0-7:baby, 7-15:teen, 15-30:young, 30-60:adult, 60-100:old
)

titanic.head(2)

8) 나이/성별/등급

plt.figure(figsize=(12,4))

plt.subplot(131) #1행3열 중 1번째
sns.barplot(x='pclass', y='survived', data=titanic)

plt.subplot(132)
sns.barplot(x='age_cat', y='survived', data=titanic)

plt.subplot(133)
sns.barplot(x='sex', y='survived', data=titanic)

# plt.subplots_adjust(top=1, bottom=0.1, left=0.1, right=1, hspace=0.5, wspace=0.5)

9) 남여/나이

# 남여의 나이별 생존 현황
f, ax = plt.subplots(nrows=1, ncols=2, figsize=(14, 6))

women = titanic[titanic['sex'] == 'female']
men = titanic[titanic['sex'] == 'male']

sns.distplot(women[women['survived'] == 1]['age'],
                  bins=20, label='survived',
                  ax=ax[0], kde=False)

sns.distplot(women[women['survived'] == 0]['age'],
                  bins=40, label='not survived',
                  ax=ax[0], kde=False)

ax[0].legend()
ax[0].set_title('Female')

sns.distplot(men[men['survived'] == 1]['age'],
                 bins=18, label='survived',
                 ax=ax[1], kde=False)

sns.distplot(men[men['survived'] == 0]['age'],
                 bins=40, label='not survived',
                 ax=ax[1], kde=False)

ax[1].legend()
ax[1].set_title('Male')

10) 이름-신분

(1) 데이터 확인

import re

for idx, dataset in titanic.iterrows():
    tmp = dataset['name']
print(re.search('\,\s\w+(\s\w+)?\.', tmp).group())

, Mr.

(2) 데이터 형태 가공

import re

title = []
for idx, dataset in titanic.iterrows():
  tmp = dataset['name'] # 일시저장

  # ,로 시작 - \s한칸을 띄우고 - \w글자들이 나오다가 - ?몇글자 인지 모르겠지만 - .으로 끝남
  # 대상은 tmp
  # [2:-1] 두번째 ~ 마지막 -> , Mr.
  title.append(re.search('\,\s\w+(\s\w+)?\.', tmp).group()[2:-1])

title

['Miss', 'Master', 'Miss', 'Mr', 'Mrs', 'Mr',

(3) 컬럼으로 추가

import re

title = []
for idx, dataset in titanic.iterrows():
  tmp = dataset['name']
  title.append(re.search('\,\s\w+(\s\w+)?\.', tmp).group()[2:-1])

titanic['title'] = title
titanic.head(1)

(4) 타이틀:인덱스, 성별:컬럼

pd.crosstab(titanic['title'], titanic['sex'])

(5-1) 호칭 정리

titanic['title'] = titanic['title'].replace('Mlle', 'Miss')
titanic['title'] = titanic['title'].replace('Mme', 'Miss')
titanic['title'] = titanic['title'].replace('Ms', 'Miss')

#여성 귀족
Rare_f = ['Dona', 'Lady', 'the Countess']
#남성 귀족
Rare_m = ['Capt', 'Col', 'Don', 'Dr', 'Jonkheer',
          'Major', 'Master', 'Rev', 'Sir']

for each in Rare_f:
  titanic['title'] = titanic['title'].replace(each, 'Rare_f')

for each in Rare_m:
  titanic['title'] = titanic['title'].replace(each, 'Rare_m')

(5-2) 호칭 정리

for each in Rare_f: # 여성용 호칭에서 하나씩 가져와서
    titanic['title'] = titanic['title'].replace(each, 'Rare_f') # 각가을 전부다 Rare_f로 바꾸겠다

for each in Rare_m: # 여성용 호칭에서 하나씩 가져와서
    titanic['title'] = titanic['title'].replace(each, 'Rare_m') # 각가을 전부다 Rare_f로 바꾸겠다

(5-3) 호칭 확인
```
titanic['title'].unique()
```
array(['Miss', 'Rare_m', 'Mr', 'Mrs', 'Rare_f'], dtype=object)

(5-4) groupby

# [groupby] https://trading-for-chicken.tistory.com/134
# 특정 열을 지정하여 groupby할 경우 해당 열이 인덱스가 되는데, as_index=False로 하여 기존 인덱스 유지
titanic[['title', 'survived']].groupby(['title'], as_index=False).mean()

2. ML을 이용한 주인공 생존율 예측

⭐ 1) str -> int

머신 러닝을 위해서 컬럼은 모두 숫자로 바꿔야 함

# 컬럼들 형태 확인
titanic.info()

titanic['sex'].unique()

array(['female', 'male'], dtype=object)

# 숫자 형태로 변경
# 3   sex        1309 non-null   object 

# LabelEncoder 모듈
# 라벨 인코더 모듈 : 문자 -> 숫자 로 만들어 주는 것
from sklearn.preprocessing import LabelEncoder

# 변수 지정
le = LabelEncoder()

# fit 훈련 : (데이터, 정답)
le.fit(titanic['sex'])

# gender 컬럼 생성 + transform(변환)
titanic['gender'] = le.transform(titanic['sex'])

titanic.head(2)

⭐ 2) 결측치 버리기

위와 같이 컬럼 마다 데이터수 가 다름

ML을 위해 결측치는 버리고 가기로!

titanic = titanic[titanic['age'].notnull()] # 1046
titanic = titanic[titanic['fare'].notnull()] # 1308

⭐ 3) 훈련/테스트 나누기

titanic.columns

Index(['pclass', 'survived', 'name', 'sex', 'age', 'sibsp', 'parch', 'ticket', 'fare', 'cabin', 'embarked', 'boat', 'body', 'home.dest', 'age_cat', 'title', 'gender'], dtype='object')

from sklearn.model_selection import train_test_split

X = titanic[['pclass','age', 'sibsp', 'parch','fare','gender']]
y = titanic['survived']

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=13)

⭐ 4) Decision tree

# DecisionTreeClassifier 모듈
from sklearn.tree import DecisionTreeClassifier
# 성능 확인 모듈
from sklearn.metrics import accuracy_score

dt = DecisionTreeClassifier(max_depth=4, random_state=13)

# 훈련(특성, 라벨)
dt.fit(X_train, y_train)

# 훈련을 완료한 dt에 예측(성능) 명령
pred = dt.predict(X_test)

# (참값, 예측값)
accuracy_score(y_test, pred)

0.7655502392344498

⭐ 5) 두 주인공의 생존확률?

import numpy as np

# Jack
# 3등석, 18살, 부모형제 없음, 자녀없음, 탑승료, 남성
Deca = np.array([[3, 18, 0, 0, 5, 1]])
print('Deca :', dt.predict_proba(Deca))
print('Deca :', dt.predict_proba(Deca)[0, 1]) # 위 값의 첫,두번째 값만 출력해줘

# Rose
# 1등석, 16살, 
Wins = np.array([[1, 16, 1, 1, 100, 0]])
print('Rose :', dt.predict_proba(Wins))
print('Rose :', dt.predict_proba(Wins)[0, 1])

Deca : [[0.83271375 0.16728625]] Deca : 0.16728624535315986 Rose : [[0. 1.]] Rose : 1.0

ML - 1. Iris의 품종 분류

Mon, 15 Jan 2024 11:41:28 GMT

iris 데이터 불러오기

모듈 insatall

(1) 데이터 불러오기

sklearn 에 올라와 있는 데이터 이용

from sklearn.datasets import load_iris
iris = load_iris()
iris

(2) 데이터 타입 확인

각각의 데이터 확인

iris.keys()

# 줄 바꿈을 위해 print 사용
# 'DESCR' 칼럼은 데이터의 설명이 들어있음
print(iris['DESCR'])

print(iris['target'])
len(iris['target'])

# 위의 데이터와 함께 보면, 0번이 setosa, 1번이 versicolor, 2번이 virginica

print(iris['target_names'])

(3) DataFrame 만들기

  import pandas as pd

  iris_pd = pd.DataFrame(iris.data, columns=iris.feature_names)
  iris_pd.head()

(4) 품종 정보 column에 포함¶

  iris_pd['species'] = iris.target
  iris_pd.head()

(5) 그래프를 통해 데이터 확인

import matplotlib.pyplot as plt
import seaborn as sns

sepal length 와 species 의 관계
- 관계가 나쁨?
- 3개가 모두 겹쳐 있어, 구분이 어려움
sepal width (cm) 와 species 관계
- 3개가 겹쳐 있어 구분이 어려움
petal length (cm) 와 species
- 분류됨
pairplot
- 구분되는 그래프가 있는지 확인하기
```
sns.pairplot(iris_pd, hue='species')
```

1. Decision Tree

나머지 인덱스1,2 를 어떻게 구분할 것인가?

📌 df[df['column(class)']] : df데이터를 슬라이싱 : 데이터를 선택해라 📌 class가 0은 다 빼라 : 컬럼 0을 제외한 데이터를 보여줘

iris_pd[iris_pd['species'] != 0]

iris_12 = iris_pd[iris_pd['species'] != 0]
iris_12.info()

(1) Split Criterion (분할기준)

📌직선 하나로 두개를 나눠야 함 📌어디 경계선이 최고 일까? 를 찾아야 함

plt.figure(figsize=(4,2))
sns.scatterplot(x='petal length (cm)', y='petal width (cm)', data=iris_12, hue='species', palette='Set2');

(2) 엔트로피

📌 -pi log2 pi

p는 해당 데이터가 해당 클래스에 속할 확률이고 위 식을 그려보면 다음과 같다
어떤 확률 분포로 일어나는 사건을 표현하는 데 필요한 정보의 양이며 이 값이 커질수록 확률 분포의 불확실성이 커지며 결과에 대한 예측이 어려워짐

📌 엔트로피 = (-pi log2 pi)의 모든 합

무질서할수록 엔트로피 값은 높다 (불확실 성이 높을 수록)
엔트로피 값이 내려갈수록, 질서가 잡혀가는 것!!!

import numpy as np

p = np.arange(0.001, 1, 0.001)
plt.grid()
plt.title('$-p \log_{2}{p}$')
plt.plot(p, -p*np.log2(p));

(2)-1 예제

📌 기본

파란공(10개) 빨간공(6개)
```
-(10/16)*np.log2(10/16) - 6/16*np.log2(6/16)
```
0.954434002924965

📌 정 중앙에 선을 하나 만들어서 나눔

(왼쪽) 파란공(1) 빨간공(7), (오른쪽) 파란공(5) 빨간공(3)
```
0.5*(-(7/8)*np.log2(7/8) -1/8*np.log2(1/8)) + \
0.5*(-(3/8)*np.log2(3/8) - 5/8*np.log2(5/8))
```
0.7489992230622807 ✅ 엔트로피가 내려갔으므로, 분할 하는 것이 좋음!!!!

(3) 지니계수

Gini index 혹은 불순도율
엔트로피의 계산량이 많아서 비슷한 개념이면서 보다 게산량이 적은 지니계수를 사용하는 경우가 많다.

(3)-1 예제

📌 기본

파란공(10개) 빨간공(6개)

# 1 - 파란색의 확률 - 빨간색의 확률
1 - (6/16)**2 - (10/16)**2

0.46875

📌 정 중앙에 선을 하나 만들어서 나눔

(왼쪽) 파란공(1) 빨간공(7), (오른쪽) 파란공(5) 빨간공(3)
```
0.5*(1 - (7/8)**2 - (1/8)**2) + 0.5*(1 - (3/8)**2 - (5/8)**2)
```
0.34375 ✅ 지니계수 값이 내려갔으므로, 분할 하는 것이 좋음!!!!

2. Scikit Learn

📌 모듈

from sklearn.tree import DecisionTreeClassifier

iris_tree = DecisionTreeClassifier()

📌 data 확인

150개의 행, 4개의 열
```
iris.data.shape
```
(150, 4)
첫번째 행 불러오기. 리스트 값으로 반환됨
```
iris.data[0]
```
array([5.1, 3.5, 1.4, 0.2])
컬럼 확인
```
iris_pd.head(1)
```
[모든행, petal length (cm) petal width (cm) 만 따오고 싶음]
```
iris.data[:, 2:]
```

(1) 학습

📌학습 시킬 모델명 : iris_tree 📌fit 명령을 써서 정답과 함께 학습을 완료 시키고 싶음

fit : 학습해라 (데이터, 정답)

iris_tree.fit(iris.data[:, 2:], iris.target)

(2) 성능 확인

📌 Accuracy 확인

y_pred_tr : 예측 결과 변수
iris.target : 참 값 (정답)

📌 99.3 % 의 정확성 도출

accuracy_score 모듈

from sklearn.metrics import accuracy_score

학습이 완료된 iris_tree에게 예측(predict)을 시킴 (원하는 데이터(값))
```
y_pred_tr = iris_tree.predict(iris.data[:, 2:])
```
accuracy_score 함수 사용
(정답 알려주고, 예측한 결과도 알려줌)
```
accuracy_score(iris.target, y_pred_tr)
```

0.9933333333333333

3. 과적합

(1) 지도학습

Label(Y, 정답)을 붙여 학습 시킴
새로운 데이터를 학습시킨 것에 넣음
예측 결과를 뽑아줌

(2) plot tree

plot_tree 모듈
```
from sklearn.tree import plot_tree
```

iris_tree 가 어떻게 생겼는지 보여줘~

plt.figure(figsize=(10,7))
plot_tree(iris_tree);

(3) mlxtend.plotting

데이터의 경계선을 그려주는 함수
쓸수 있는 상황이 많진 않음

📌 mlxtend 설치

# !pip install mlxtend

📌 plot_tree 데이터 확인 iris의 품종을 분류하는 결정나무 모델이 어떻게 데이터를 분류했는지 확인해보자

mlxtend 모듈

from mlxtend.plotting import plot_decision_regions

X 는 대문자로 써야함....?
clf모델 : iris_tree에 학습되어 저장되어 있음

legend : 범례

plt.figure(figsize=(14,8))
plot_decision_regions(X=iris.data[:, 2:], y=iris.target, clf=iris_tree, legend=2)
plt.show()

- 저 경계면은 올바른 걸까?
- 저 결과는 내가 가진 데이터를 벗어나서 일반화할 수 있는 걸까?
- 어차피 얻은(혹은 구한) 데이터는 유한하고 내가 얻은 데이터를 이용해서 일반화를 추구하게 된다.
- 이때 복잡한 경계면은 모델의 성능을 결국 나쁘게 만든다.

4. 데이터 분리

1. 데이터 훈련/테스트로 분리

from sklearn.datasets import load_iris
import pandas as pd

iris = load_iris()

# train_test_split 함수(나눠주는) 모듈
from sklearn.model_selection import train_test_split

# features : iris.data[:, 2:] 변수
# labels : iris.target (정답) 변수
features = iris.data[:, 2:]
labels = iris.target

# 4개의 변수를 반환 받을 것임 : train_test_split 라는 변수로
# 지정해야 할 것들 : features, labels, test_size (훈련용80%, 랜덤용20%), random_state
X_train, X_test, y_train, y_test = train_test_split(
    features, labels, test_size=0.2, random_state=13
)

X_train.shape, X_test.shape

((120, 2), (30, 2))

2. np.unique 검사

📌 (필수..! 잘 분리되었는지 확인)

((120, 2), (30, 2))에 iris 3개 종이 각각 몇개 들어갔을까?
꼭 확인하는 작업이 필요함

# 모듈
import numpy as np

np.unique(y_test, return_counts=True)

(array([0, 1, 2]), array([ 9, 8, 13], dtype=int64))

3. stratify

문제가 각 클래스(setosa, versicolor, verginica) 별로 동일 비율이 아니다
이럴때, class의 옵션을 맞춰주는 것이 좋음
내가 맞춰야 될 특성이 있는 라벨로 넣어줘야 함

from sklearn.model_selection import train_test_split

features = iris.data[:, 2:]
labels = iris.target

# 📌 stratify=labels 추가 : class 별 분포를 맞춰 줌
X_train, X_test, y_train, y_test = train_test_split(
    features, labels, test_size=0.2, random_state=13, stratify=labels
)

import numpy as np

np.unique(y_test, return_counts=True)

(array([0, 1, 2]), array([10, 10, 10], dtype=int64))

4. 결정나무모델(DecisionTreeClassifier)

(1) max_depth : 과적합을 위해 제한해야 함

깊을 수 록 내가 준 데이터의 성능이 100%에 다가감
성능이 높은 것이 꼭 좋지 않음
제한 시킬 필요가 있음

# DecisionTreeClassifier 모듈
from sklearn.tree import DecisionTreeClassifier

# max_depth 설정
iris_tree = DecisionTreeClassifier(max_depth=2, random_state=13)

# fit 훈련 : (데이터, 정답)
iris_tree.fit(X_train, y_train)

(2) plot_tree

iris_tree 가 어떻게 생겼는지 보여줘

# plot_tree 모듈
from sklearn.tree import plot_tree
import matplotlib.pyplot as plt

# iris_tree 가 어떻게 생겼는지 보여줘~
plt.figure(figsize=(5,5))
plot_tree(iris_tree);

(3) Accuracy 확인

성능 확인

# accuracy_score 모듈
from sklearn.metrics import accuracy_score

# 학습이 완료된 iris_tree에게 예측(predict)을 시킴 (훈련된값)
y_pred_tr = iris_tree.predict(X_train)

# accuracy_score 함수 사용
# (정답 알려주고, 예측한 결과도 알려줌)
accuracy_score(y_train, y_pred_tr)

0.95

5. X_train의 결정경계 확인

# plot_decision_regions 모듈
from mlxtend.plotting import plot_decision_regions
import matplotlib.pyplot as plt

plt.figure(figsize=(12,5))
plot_decision_regions(X=X_train, y=y_train, clf=iris_tree, legend=2)
plt.show()

6. test data(위 쿼리s)에 accuracy(정확도 확인)

test 결과 96.6% 도출

y_pred_test = iris_tree.predict(X_test)
accuracy_score(y_test, y_pred_test)

0.9666666666666667

7. 잔기술

150개 데이터 전체를 train과 test를 분리해 결정경계 까지 넣고자 함

scatter_highlight_kwargs = {'s':150, 'label':'Test data', 'alpha':0.9}
scatter_kwargs = {'s':120, 'edgecolor':None, 'alpha':0.7}

plt.figure(figsize=(12,8))
plot_decision_regions(X=features, y=labels,
                      X_highlight=X_test,
                      clf=iris_tree,
                      legend=2,
                      scatter_highlight_kwargs=scatter_highlight_kwargs,
                      scatter_kwargs=scatter_kwargs,
                      contourf_kwargs={'alpha':0.2})
plt.show()

8. 모델 사용 방법

새로운 데이터를 가지고 예측 결과를 도출

(1) 새 데이터로 결과 도출해보기

features 4개를 새로 지정

features = iris.data
labels = iris.target

X_train, X_test, y_train, y_test = train_test_split(
    features, labels, test_size=0.2, stratify=labels, random_state=13
)

iris_tree = DecisionTreeClassifier(max_depth=2, random_state=13)
iris_tree.fit(X_train, y_train)

주운 꽃의 데이터 : 4.3,2.,1.2,1.0

# 값으로 정답 도출
test_data = [[4.3,2.,1.2,1.0]]
iris_tree.predict(test_data)

array([1])

# 문자로 정답 도출
iris.target_names[iris_tree.predict(test_data)]

array(['versicolor'], dtype='

# predict_proba : 각 데이터일 확률 확인
iris_tree.predict_proba(test_data)

array([[0. , 0.97222222, 0.02777778]])

# list 형태로, shape을 보고 싶으면 np.array()로 감사줄 것

test_data = np.array([[4.3,2.,1.2,1.0]])
test_data.shape

(1, 4)

(2) zip

zip 모델
```
iris_clf_model = dict(zip(iris.feature_names, iris_tree.feature_importances_))
iris_clf_model
```
{'sepal length (cm)': 0.0, 'sepal width (cm)': 0.0, 'petal length (cm)': 0.421897810218978, 'petal width (cm)': 0.578102189781022}

리스트를 튜플로 만들기

list1 = ['a','b','c']
list2 = [1,2,3]

pairs = [pair for pair in zip(list1, list2)]
pairs

[('a', 1), ('b', 2), ('c', 3)]

튜플을 dict 으로
```
dict(pairs)
```
{'a': 1, 'b': 2, 'c': 3}