• AI 서비스가 생활과 산업 전반에 확대됨에 따라 처리해야 하는 데이터양이 늘어나고 AI 데이터센터의 성능향상이 시급해졌다.
• 현재 대다수 기업은 기존 반도체(GPU)를 활용해 AI데이터 센터를 운영한다
• 그러나 GPU로는 속도의 한계와 비용의 문제가 발생한다.
• 이 문제를 해결하기 위해 AI반도체가 떠오르고있다, 이는 기존의 GPU보다 대규모 연산을 초고속&저전력으로 실행할 수 있다.

• 국내에서는 SK텔레콤이 지난 해 첫 국산 AI반도체인 '사피온 X220'을 공개한바 있다.

• 이는 기존의 GPU와 비교해 전력 사용량은 80%, 연산 속도는 1.5배를 자랑했으며 또한 가격은 기존의 절반수준을 자랑했다.

• KT 또한 최근 클라우드 기반의 GPU 인프라 제공 서비스 '하이퍼스케일 AI컴퓨팅'을 출시했다.

• 이를 계기로 2022년까지 소프트웨어 기반 클라우드 서비스를 강화하고 2023년 하반기에 전용 AI 반도체 칩을 제작하려 기획중이다.

• 이처럼 AI 반도체는 성장가능성이 높으나 현재까지 AI 반도체 시장을 선점한 업체는 없다

기사 원문 - DAILY_BYTE

네트워크의 기본 규칙

Introduction

⚙세상이 질서있게 돌아가기 위해 우리들은 모두 특정한 규칙 하에 살아간다. 서로 다른 규칙, 약속하에 살아가게 되면 상당히 불편하고 소통도 되지 않을 것이다 ㅜㅜ.

• 이와 마찬가지로 네트워크에서도 문제없이 통신을 하려면 규칙을 지켜야한다. 이 규칙에 대해 알아보자!

프로토콜

• 위와 같이 컴퓨터간에도 모두 규칙을 정하였는데 이를 프로토콜이라 한다.

• 프로토콜 : 컴퓨터 간에 정보를 주고받을 때의 통신 방법에 대한 규칙이나 표준

OSI 모델과 TCP/IP 모델

네트워크에서는 데이터를 주고받기 위한 통신 규격이 정해져있다. 이 통신규격은 무엇일까?

• 표준 규격을 정하는 여러단체 중 ISO(International Organization for Standardization)라는 국제표준화기구가 존재한다. 이 단체에서 OSI 모델이라는 표준 규격을 제정하였다.
• OSI 모델 : 네트워크 기술의 기본이 되는 모델로써 7개의 레이어(계층)이 존재한다. 이는 아래 표와 같다

• 통신할 때 데이터는 맨 위의 응용 계층에서 순차적으로 아래 계층으로 전달된다.
• 데이터를 전송하는 쪽(송신)은 상위 계층에서 하위 계층으로 전달하고 각 계층은 독립적이므로 데이터가 전달되는 동안에 다른 계층의 영향을 받지 않는다.
• 데이터는 받는 쪽(수신 측)은 하위 계층에서 상위 계층으로 각 계층을 통해 전달된 데이터를 받는다.

TCP/IP 모델

• TCP/IP는 인터넷 네트워크의 핵심 프로토콜으로 OSI모델의 7계층을 4계층으로 바꿔서 이해하면 편하다.
• (응용,표현,세션 => 응용), (전송 => 전송), (네트워크 => 인터넷), (데이터 링크, 물리 => 네트워크 엑세스)
• OSI와 TCP/IP를 비교해보면 아래와 같다

캡슐화와 역캡슐화

데이터를 송수신할 때는 캡슐화와 역캡슐화가 이루어진다 이 것이 무엇일까?

• 정의는 아래와 같다

• 캡슐화(Encapsulation) : 컴퓨터 통신에서 상위 곆층의 통신 규약 정보를 하위 통신 규약 프레임 사용자 정보 영역에 내장시켜 전송하는 기술. 복수의 프로토콜층에서 정보를 하나로 종합하여 통신망에 보내는 프로세스.

• 풀어쓰자면, 데이터를 송신할 때는 데이터 앞부분에 전송하는데 필요한 정보(헤더)를 붙여 다음 계층으로 보내는데 헤더를 붙여 나가는 것을 캡슐화라고하고 수신 측에서 헤더를 제거해 나가는 과정을 역캡슐화 라고 한다.

  • 헤더: 데이터 전송에 필요한 정보
  • 트레일러 : 데이터 전달 시, 데이터의 마지막에 추가하는 정보

• 캡슐화, 역캡슐화의 과정은 아래와 같다.

오늘은 낮에 책을 읽기만 하고 정리를 안했는데 정리하고 자는 나 칭찬해....

• 네이버클라우드가 5G 이동통신 특화망 주파수 할당과 기간통신사업이 28일에 등록됐다고 밝혔다

• 이는 경기 성남시에 들어서는 네이버 제 2사옥 내에 5G 특화망을 구축할 예정이다

  아래는 기사 중 발췌내용이다.

  네이버랩스가 개발한 자율주행 ‘브레인리스 로봇’을 운용하기 위해서다. 이 로봇은 상황 판단에 쓰인 내장 컴퓨팅 처리 장치가 없다. 대신 5G 초저지연 네트워크를 통해 클라우드를 로봇 두뇌로 쓴다. 제작 비용과 배터리 소모량이 적은 게 특징이다. 네이버는 브레인리스 로봇을 사옥 내 택배·음료 배달 등에 쓸 예정이다.

• 통신사업자가 아닌 기업이 직접 5G망을 구축한다는 점에서 아주 놀랍다....

  뉴스링크 : https://n.news.naver.com/mnews/article/015/0004645826?sid=105

(네트워크 기본지식)

Introduction

🧱🔨 아무것도 모르는 바보인 나는 오늘부터 컴퓨터 네트워크를 공부하기로 했다.

처음부터 전공서적을 보면 화가 나니 easy한 책으로 시작해보자!

읽을 책은 모두의 네트워크(미즈구치 카츠야 지음, 이승룡 옮김)이다!

컴퓨터 네트워크란?

• 위키백과상에는 노드들이 자원을 공유할 수 있게 하는 디지털 전기통신망, 분산되어 있는 컴퓨터를 통신망으로 연결한 것을 말한다. 기술되어있다.

Q) 그럼 네트워크는 뭔데?

A) 많은 내용들을 정리해보면 결국 어떤 것들을 연결시키는 관계의 묶음이다.

• 즉, 컴퓨터 네트워크란 컴퓨터 간의 네트워크를 연결한 것이다.

• 네트워크를 통해 할 수 있는 것은?

  • 컴퓨터 간의 데이터 전송, 웹 사이트 열람, 메일 송수신 etc..
  • cf) 인터넷 : 전 세계의 모든 네트워크를 연결해 놓은 거대 네트워크

패킷이란?

네트워크나 인터넷에서 데이터를 주고 받으려면 규칙이 있어야한다.

• 이 규칙에서 패킷(packet)을 사용

• 패킷의 정의

  • 네트워크를 통해 전송하기 쉽도록 자른 데이터의 전송단위이다.

    Q) 작게 자르는 이유는? A) 큰 데이터를 그대로 보내게 되면 네트워크 대역폭을 많이 점유해서 다른 패킷의 흐름을 막을 위험이 발생한다. 이를 방지 위해 패킷을 작게 나누어서 전송한다.

• 그러나 작게 자른 패킷을 무작정 보내기만 하면 받았을 때 원본이 무엇인지 모르는 문제가 발생

• 따라서 목적지에서는 잘게 나누어서 온 패킷을 나누기 전 상태로 돌리는 작업이 필요함

• => 송신측에서 수신 측으로 패킷을 보낼 때 각 패킷에 순서대로 번호를 붙여서 보냄

• 이는 디지털 데이터라 가능하다아아

디지털 데이터란?

• 0과 1의 집합
• 0과 1의 정보를 나타내는 최소 단위를 비트(bit)라 한다.
• 이러한 비트를 8개를 모은 것을 바이트(byte)라고 한다. (즉, 8비트 = 1바이트)
• 컴퓨터는 기본적으로 바이트 단위로 데이터를 읽고 쓴다.

Q) 0과 1로만 이루어져 있는 디지털 데이터로 문자등을 어떻게 입력할까?

• 숫자와 문자의 대응표를 미리 만들어놓았기 때문(문자코드, character code)
• 대표적으로 ASCII(아스키)코드가 있음.

LAN and WAN

• 네트워크는 접속할 수 있는 범위에 따라 크게 두 종류로 분류 가능
  • LAN(Local Area Network) : 가정, 사무실같이 지리적으로 특정 지역을 범위로 하는 네트워크
  • WAN(Wide Area Network) : 지리적으로 넓은 범위에 구축된 네트워크
• WAN은 인터넷 서비스 제공자(ISP, Internet Service Provider)가 제공하는 서비스를 사용하여 구축된 네트워크라고도 말할 수 있음, 랜과 랜을 연결하는 것으로 생각해도 OK.

Q) ISP가 모에요?

A) 인터넷 상용 서비스 사업을 하고 있는 KT, U+, SK와 같은 사업자.

가정에서 하는 랜 구성

• 가정에서 인터넷을 사용하기 위해서는 ISP, 인터넷 회선을 결정해야함
• ISP(인터넷 서비스 제공자와 네트워크 연결을 위해서는 공유기가 필요!
• 인터넷 공유기를 통해 내부 인터넷망을 구성하고 다양한 기기를 연결하여 사용 가능
  • 연결방식은 랜케이블의 필요여부에 따라 유선과 무선으로 나뉨
  • 이를 유선랜, 무선랜이라 칭함

회사에서 하는 랜 구성

• 가정에서의 랜 구성과 다르게 DMZ라는 네트워크 영역이 추가 됨

Q) DMZ?

A) Demilitarized Zone의 약어로 외부에 공개하기 위한 네트워크,

주로 웹 서버, 메일 서버, DNS 서버를 공개

• 회사에서 서버를 운영하기 위해서 서버를 사내에 설치하거나 데이터센터에 두거나 클라우드에 둘 수 있다.

데이터 센터 : 대량의 데이터를 보관하기 위해 데이터 센터 서버나 네트워크 기기를 설치한 전용 시설

클라우드 : 인터넷을 통해 SW나 하드웨어 등의 컴퓨팅 서비스를 제공하는 것으로 인터넷에 접속하기만 하면 언제 어디서든 사용 가능

사내 또는 데이터 센터에 서버를 두고 운영하는 것을 온프레미스(on-premise)라 칭함.

문제

어떤 수와 그 수의 숫자 순서를 뒤집은 수가 일치하는 수를 팰린드롬이라 부른다. 예를 들어 79,197과 324,423 등이 팰린드롬 수이다.

입력

어떤 수 N (1 ≤ N ≤ 1,000,000)이 주어졌을 때, N보다 크거나 같고, 소수이면서 팰린드롬인 수 중에서, 가장 작은 수를 구하는 프로그램을 작성하시오.

소스코드

n = int(input())
arr = [True] * (1004001)
arr[0] = False
arr[1] = False
for i in range(2, int(1004000 ** 0.5) + 1):
    if arr[i] == True:
        j = 2
        while i * j <= 1004000 :
            arr[i * j] = False
            j += 1

for i in range(n, 1004000):
    if (arr[i] == True) and (str(i) == str(i)[::-1]):
        print(i)
        break

해당 문제는 소수판별, 팰린드롬여부 두가지를 체크해야한다.

📌소수의 판별여부는 2중 for문을 사용하는 법, n의 제곱근까지의 범위내에서 판별하는 법 등이 있지만 시간복잡도가 가장 낮은에라토스테네스의 체를 사용하여 판별하였다.

📌 팰린드롬 check : 뒤집었을 때 원래 문자와 똑같으면 팰린드롬이라 하는데 파이썬의 경우 [::-1]을 사용하면 문자가 거꾸로 뒤집혀 이를 사용하였다.

⏰ 회고 : 처음엔 문제의 제한 범위인 1<=n<=1,000,000을 보고 백만까지만 리스트를 생성하였는데 계속틀렸다길래 맞왜틀 시전했는데 입력은 100만까지여도 n보다 큰 소수 출력이 목표이기에 백만보다 큰 소수의 범위까지 리스트 생성을 해줘야한다 !

마이데이터💰

마이데이터 사업이란 ?

• '본인신용정보관리업'으로 개인이 본인의 데이터를 관리하고 주체적으로 이용할 수 있께 한 제도이다.
• 즉, 이제부터는 개인이 자신의 어떤 데이터를 제공할지 선택이 가능하다.
• 이전까지는 기업이 고객의 ID/PW를 통해 금융기관에 대신 접속해 데이터를 얻었지만 마이데이터 사업이 시작되면서 허가를 받은 기업만 API형태로 가져오는 방식으로 개인 정보가 기업에 제공된다.
• 12/1일부터 은행, 금융사, 카드사, 핀테크 회사 등이 마이데이터 사업을 시작했으며 주로 맞춤형 금융 서비스에 집중하여있다.

민간인증서

마이데이터 사업에는 인증서가 필수 !

• 마이데이터 서비스는 공동인증서를 제외한 1개이상의 민간인증서를 연동해야한다.
• 따라서 민간인증서 시장도 커질 전망인데, 현재 네이버가 가장 두각을 드러내고 있다.

정리

내년부터는 국세청, 행안부, 건강보험공단 등 공공기관의 데이터도 마이데이터 사업자들에게 제공될 계획이다, 점점 더 많은 데이터들이 모일텐데 어떤 차별화된 서비스가 제공될지 기대해보는 것도 재미있을 것 같다.

• 아래는 일반적인 문제해결 절차이다

• 기반이 데이터라면?

• 모델 스스로 데이터를 기반으로 변화에 대응가능

• 심지어 머신러닝을 통해 우리가 배울수도 있다!

만약 주택의 넓이와 가격이라는 데이터가 있고 주택가격을 예측한다면?

=> 학습데이터에 라벨이 있으므로 지도학습이고, 주택 가격을 연속된 값으로 예측하는 것이므로 회귀(Regression)문제임.

• 입력변수 x가 하나인 경우, 선형회귀(Linear Regression)문제는 주어진 학습데이터와 가장 잘 맞는 Hypothesis 함수 h를 찾는 문제가 됨.

OLS

OLS : Ordinary Linear Least Square

• Y = AX를 풀어서 구함

• n by n 매트릭스가 아닌경우 그냥 트랜스포즈된걸 곱함.(곱해서 n by n 으로 사이즈 맞춰주려고)

• 성능은 E(error)를 사용해 파악가능.

import pandas as pd
import statsmodels.formula.api as smf

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

lm_model = smf.ols(formula='y ~ x', data=df).fit()
# 'y ~ x'  : y=ax+b 

lm_model.params
# output : 
Intercept    0.5
x            1.1
dtype: float64

import matplotlib.pyplot as plt
import seaborn as sns
%matplotlib inline

plt.figure(figsize=(12,10))
sns.lmplot(x='x', y='y', data=df);
plt.xlim([0, 5])

잔차 평가(residue)

• 잔차는 평균이 0인 정규분포를 따르는 것이어야함
• 잔차 평가는 잔차의 평균이 0이고 정규분포를 따르는지 확인

resid = lm_model.resid
resid
# output : 
0   -0.6
1    0.3
2    0.2
3    1.1
4   -1.0

결정계수 R-Squared

• 초록선이 평균 (mu)

• y_hat은 예측된 값

• 예측 값과 실제 값(y)가 일치하면 결정계수는 1이 됨(즉, 결정계수가 높을 수록 좋은 모델)

  import numpy as np
  

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

y_hat = lm_model.predict() np.sum((y_hat -mu) ** 2) / np.sum((y - mu) ** 2)

라이브러리 사용

lm_model.rsquared sns.distplot(resid, color='black')

교차검증

• 고정된 train, test set을 가지고 모델을 학습시키는 과정을 반복하면 결국 오버피팅이 일어난다

• 이를 해결하고자 train set을 다시 train+validaion으로 분리 후 validation set을 이용해 검증한다

• 장점

  • 모든 데이터셋을 훈련에 활용할 수 있다
  • 모든 데이터셋을 평가에 활용할 수 있다, 즉 데이터의 편중 방지 가능

• 단점

  • 반복회수가 많아 모델의 훈련/평가 시간이 오래 걸린다.

(단순히 train, test로만 데이터를 나누는건 hold out이라함)

• train data를 k등분해서 k-1개로 train하고 1개로 validation하고 평균을 취함

import numpy as np
from sklearn.model_selection import KFold

X = np.array([[1, 2], [3, 4], [1, 2], [3, 4]])
y = np.array([1, 2, 3, 4])
kf = KFold(n_split=2)

print(kf.get_n_splitx(X))
print(kf)
for train_idx, test_idx in kf.split(X):
    print('Train idx : ', train_idx) # 2,3 번인덱스를 처음 그다음 0, 1 
    print('Test idx : ', test_idx)
    print('-----train data-----')
    print(X[train_idx])
    print('-----validation data-----')
    print(X[test_idx])

• 와인데이터로 K-fold!

import pandas as pd
red_wine = pd.read_csv('./data/winequality-red.csv', sep=';')
white_wine = pd.read_csv('./data/winequality-white.csv', sep=';')
red_wine['color'] = 1
white_wine['color'] = 0
wine = pd.concat([red_wine, white_wine])

wine['taste'] = [1. if grade>5 else 0 for grade in wine['quality']]
X = wine.drip(['taste', 'quality'], axis=1)
y = wine['taste']

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_mms_pd, y, test_size=0.2, random_state=42)
wine_tree = DecisionTreeClassifier(max_depth=2, random_state=42)
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('Train Acc : ', accuracy_score(y_test, y_pred_test))

데이터를 이렇게 분리하는게 최선인가? 저 정확도를 어떻게 신뢰할 수 있는가?

from sklearn.model_selection import KFold

kfold = KFold(n_split=5)
wine_tree_cv = DecisionTreeClassifier(max_daepth=2, random_state=42)
# KFold는 인덱스를 반환함

for train_idx, test_idx in kfold.split(X):
    print(len(train_idx), len(test_idx))

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_acvvuracy.append(accuracy_score(y_test, pred))

cv_accuracy

• 각 acc의 분산이 크지 않다면 평균을 대표값으로 한다

np.mean(cv_accuracy)

from sklearn.model_selection from StratifiedKFold
skfold = StratifiedKFold(n_splits=5)
wine_tree_cv = DecisionTreeClassifier(max_daepth=2, random_state=42)

cv_accuracy = []
# 어떤걸 기준으로 stratified하는지 설정해야함 여기서는 y
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_acvvuracy.append(accuracy_score(y_test, pred))

• cross validation을 보다 간편히 하는 법!

from sklearn.model_selection import cross_val_score

skfold = StratifiedKFold(n_solits=5)
wine_tree_cv = DecisionTreeClassifier(max_depth=2, random_state=42)

cross_val_score(wine_tree_cv, X, y, scoring=None, cv=skfold)

• train score와 함께 보고 싶다면

from sklearn.model_selection import cross_validate
cross_validate(wine_tree_cv, X, y, scoring=None, cv=skfod, return_train_score=True)

하이퍼파라미터 튜닝

• 모델의 성능을 확보하기 위해 조절하는 설정 값

• GridSearchCV : 결과를 확인하고 싶은 파라미터만 정의하면 됨

from sklearn.model_selection import GridSearchCV
from sklearn.tree import DecisionTreeClassfier

prarams = {'max_depth' : [2, 4, 7, 10]}
wine_tree = DecisionTreeClassifier(max_depth=2, random_state=42)

# train_test_split도 알아서 해줌
gridsearch = GridSearchCV(estimator=wine_tree, param_grid=params, cv=5)
gridsearch.fit(X, y)

# GridSearchCV의 결과
import pprint

pp = pprint.PrettyPrinter(indent=4)
pp.pprint(gridsearch.cv_results_)

# 최적의 성능을 가진 모델은?
gridsearch.best_estimator_
# 최고의 정확도는?
gridsearch.best_score_
# 최고의 파라미터는?
gridsearch.best_params_

• 만약 pipeline을 적용한 모델에 GridSearch를 적용하고 싶으면?

from sklearn.pipeline import Pipeline
from sklearn.tree import DecisionTreeClassifier
from sklearn.preprocessing import StandardScaler

estimators = [('scaler', StandardScaler()),
             ('clf', DecisionTreeClassifier())]
pipe = Pipeline(estimators)

param_grid = [{'max__depth' : [2, 4, 7, 10]}]
Gridsearch = GridSearchCV(estimator=pipe, param_grid=param_grid, cv=5)
Gridsearch.fit(X, y)

• 표로 성능 확인해보자

import pandas as pd

score_df = pd.DataFrame(GridSearch.cv_results_)
score_df['params', 'rank_test_score', 'mean_test_score', 'std_test_score']

우리가 만든 모델은 얼마나 좋은 것일까?

• 데이터 수집/가공/변환 ↔ 모델학습/예측 ↔ 평가

• 모델을 좋다, 그저그렇다, 나쁘다 등으로 평가할 방법은 없다.

• 대부분 다양한 모델, 다양한 파라미터를 두고, 상대적으로 비교한다.

• 회귀모델들은 실제 값과의 error를 가지고 계산

• 분류 모델은 평가 항목이 조금 많음

• 이진 분류 모델의 평가

• FP는 type 1 error FN은 type 2 error이고 정확도는 아래와 같다. (전체 데이터 중 맞게 예측한 것의 비율)

$$ accuracy = {TP + TN \over \ TP + TN + FP + FN} $$

• Precision : 양성이라고 예측한 것 중에서 실제 양성의 비율
  • 정밀도를 높이려면 확실할 때만 정답이라고 하면 됨
  • Threshold를 높게 설정하면됨
  • 대표적 예시 : 중요한메일을 스팸메일이라고 예측하면 안됨, 그럴 떄 봐야하는게 Precision

$$ precision = {TP\over\ TP + FP} $$

• Recall(TPR, True Positive Ratio, sensitivity) : 참인 데이터들 중에서 참이라고 예측한 것

  • 싹다 참이라고 말하면 올라감

  • Threshold를 낮게 설정하면됨

  • 대표적 예시 : 암인 환자를 암이라 맞출확률을 볼 때

$$ Recall = {TP\over\ TP + FN} $$

• Fall-Out(FPR, False position ratio) : 실제 양성이 아닌데, 양성이라고 잘못 예측한 경우

$$ fallout = {FP \over \ FP+TN} $$

분류모델은 그 결과를 속할 비율(확률)을 반환한다

• predict_prob는 0.5를 기준으로 작으면 0 크면 1을 반환
• 기준이되는 0.5를 threshold라고 함.
• Recall과 Precision은 서로 영향을 주기 때문에 한 쪽을 극단적으로 높게 설정하면 안됨.

F1- Score

• 조화평균임 !

ROC 와 AUC

• ROC 곡선

• fall-out이 여러개라면 recall값이 작은걸 선택해서 그림
• 완벽하게 분류했다면 아래와 같은 곡선을 그림, AUC는 그래프의 면적을 뜻함

• 적당히 맞췄다면 아래와 같은 곡선이 나타난다

지금까지 불편한 점은?

• 코드를 하나씩 실행하다보면 혼돈이 크다
• Jupyter Notebook 상황에서 데이터의 전처리와 여러 알고리즘의 반복실행, 하이퍼 파라미터의 튜닝을 과정을 번갈아 하다 보면 코드의 실행 순서에 혼돈이 있을 수 있다.
• 이런 경우 Class로 만들어 진행해도 되지만 sklearn에는 Pipeline이라는 기능이 있다.

import pandas as pd

red_wine = pd.read_csv('./data/winequality-red.csv', sep=';')
white_wine = pd.read_csv('./data/winequality-white.csv', 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']

레드/화이트 와인 분류기의 동작 Process

• 여기서 test_train_split은 Pipeline 내부가 아니다.

  이 Pipeline을 코드로 구현한다면?

from sklearn.pipeline import Pipeline
from sklearn.tree import DecisionTreeClassifier
from sklearn.preprocessing import StandardScaler

estimators = [('scaler', StandardScaler()),
             ('clf', DecisionTreeClassifier())]
pipe = Pipeline(estimators)

pipe.steps

#output:
[('scaler', StandardScaler()), ('clf', DecisionTreeClassifier())]

# setparams를 이용해 파라미터를 바꿀 수 있다

pipe.set_params(clf__max_depth=2)
pipe.set_params(clf__random_state=42)

# '스탭이름' + __(언더바 2개) + 속성이름 

• Pipeline을 이용한 분류기 구성

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=42, stratify=y)

pipe.fit(X_train, y_train)

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))

# output: 
    Train Acc :  0.9545891860688859
    Test Acc :  0.9584615384615385

Wine

• 분류 문제에서 많이 사용하는 iris만큼 알려지지는 않았지만, 그래도 많이 사용함!
• 인류 역사에서 최초의 술로 알려져 있다
• 플라톤이 와인 짱 좋아함

import pandas as pd

red_wine = pd.read_csv('./data/winequality-red.csv', sep=';')
white_wine = pd.read_csv('./data/winequality-white.csv', sep=';')

# 레드와인과 화이트와인 합치기
red_wine['color'] = 1
white_wine['color'] = 0

wine = pd.concat([red_wine, white_wine])
wine['quality'].unique()
#output : 
    array([5, 6, 7, 4, 8, 3, 9], dtype=int64)

# 퀄리티를 기준으로 개수를 알아보자     
import plotly.express as px
fig = px.histogram(wine, x='quality')
fig.show()    

# 레드, 화이트 각각 봐보자

fig = px.histogram(wine, x='quality', color='color')
fig.show()

# 라벨 분리
X = wine.drop(['color'], axis=1)
y = wine['color']

# 데이터셋 분리
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 = 42)
np.unique(y_train, return_counts=True)

# output:
(array([0, 1], dtype=int64), array([3939, 1258], dtype=int64))

# 훈련용과 테스트용이 레드/화이트 와인에 따라 어느정도 구분됐는지 확인
import plotly.graph_objects as go

fig = go.Figure()
fig.add_trace(go.Histogram(x=X_train['quality'], name='Train'))
fig.add_trace(go.Histogram(x=X_test['quality'], name='Test'))

fig.update_layout(barmode='overlay') #두개 겹쳐그린다
fig.update_traces(opacity=0.75) # 투명도
fig.show()

from sklearn.tree import DecisionTreeClassifier

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

# 결과는 ?
from sklearn.metrics import accuracy_score

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))
# output : 
Train Acc :  0.957475466615355
Test Acc :  0.9476923076923077

데이터 전처리 - MinMAxsScaler 와 StandardScaler

• 근데 사실 Decision Tre에서는 영향 없음

• 주로 Cost Function을 최적화할 때 유효할 때가 있음.

• 어떤 스케일러가 좋은지는 해봐야 안다

fig = go.Figure()
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()

• 이렇게 피쳐들 사이의 범위 격차가 크면 ML에선 학습이 안될 수도 있음, 안된다는건 아님

from sklearn.preprocessing import MinMaxScaler, StandardScaler

MMS= MinMaxScaler()
SS = StandardScaler()

SS.fit(X)
MMS.fit(X)

X_ss = SS.transform(X)
X_mms = MMS.transform(X)

X_ss_pd = pd.DataFrame(X_ss, columns=X.columns)
X_mms_pd = pd.DataFrame(X_mms, columns=X.columns)

fig = go.Figure()
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()

• 근데 어차피 결정나무에서는 이런 전처리 효과가 거의 없다, 그냥 해봄!

레드와인과 화이트와인을 구분하는 중요한 특성은 무엇일까?

dict(zip(X_train.columns, wine_tree.feature_importances_))
# output : 
{'fixed acidity': 0.0,
 'volatile acidity': 0.0,
 'citric acid': 0.0,
 'residual sugar': 0.0,
 'chlorides': 0.23383167646371428,
 'free sulfur dioxide': 0.0,
 'total sulfur dioxide': 0.7661683235362857,
 'density': 0.0,
 'pH': 0.0,
 'sulphates': 0.0,
 'alcohol': 0.0,
 'quality': 0.0}

맛의 이진분류를 하고 quality 컬럼을 이진화 해보자!

wine['taste'] = [1. if grade>5 else 0 for grade in wine['quality']]

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

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

wine_tree = DecisionTreeClassifier(max_depth=2, random_state=42)
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('Train Acc : ', accuracy_score(y_test, y_pred_test))

# output :
    Train Acc :  1.0
    Train Acc :  1.0

100%가 나오면 의심해봐야한다, 왜 이렇게 나왔을까?

import matplotlib.pyplot as plt
import sklearn.tree as tree
plt.figure(figsize=(12, 8))
tree.plot_tree(wine_tree, feature_names=X.columns);

• 이진분류를 퀄리티 기준으로 했는데 정작 데이터프레임에 그 기준이 된 퀄리티가 남아있었고, 그걸로 학습시켜서 백프로가 됨

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=42)

wine_tree = DecisionTreeClassifier(max_depth=2, random_state=42)
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('Train Acc : ', accuracy_score(y_test, y_pred_test))
# output: 
    Train Acc :  0.7383105637868
    Train Acc :  0.7084615384615385

그럼 어떤 와인을 맛있다고 한걸까?

plt.figure(figsize=(12, 8))
tree.plot_tree(wine_tree, feature_names=X.columns,
              rounded=True,
               filled=True,
              );

• 알콜 도수로 가오부려땅~

Label-encoder

• 사이킷런에서 라벨은 숫자여야함
• label Encoder란?
• 문자를 숫자로 바꿔줌

import pandas as pd
df = pd.DataFrame({
    'A' : ['a', 'b', 'c', 'a', 'b'], 
    'B': [1, 2, 2, 1, 0]
})

from sklearn.preprocessing import LabelEncoder
le = LabelEncoder()
le.fit(df['A'])
# df 의 A컴럼기준으로 fit

le.classes_
le.transform(df['A'])

# output : array([0, 1, 2, 0, 1])

df['le_A'] = le.transform(df['A'])

• fit과 transform을 한번에 실행

le.fit_transform(df['A'])

> output : array([0, 1, 2, 0, 1])

# 해당 문자가 어떻게 바뀌었는지 알려줌
le.transform(['a'])

# output : array([0])

# 역으로 원래 라벨을 보여줌
le.inverse_transform(df['B'])
> output : array(['b', 'c', 'c', 'b', 'a'], dtype=object)

min-max scaler

• min-max scaling 이란?

  서로 다른 크기를 통일하기 위해 크기를 변환하는 개념, 여기는 최소를 0 최대를 1로 변환

  원데이터 분포를 유지하면서 정규화, outlier에 대응 잘 안됨

  $$ x' = {x - min(x)\over \max(x) - min(x)} $$ 의미 : 전체길이로 나눠준다 !

💍 레이텍 분수 사용법 {X\over\Y}

df = pd.DataFrame({
    'A':[10, 20, -10, 0 ,25],
    'B':[1, 2, 3, 1, 0]
})

from sklearn.preprocessing import MinMaxScaler
mms = MinMaxScaler()
mms.fit(df)

df_mms = mms.transform(df)
df_mms

# output : 
array([[0.57142857, 0.33333333],
       [0.85714286, 0.66666667],
       [0.        , 1.        ],
       [0.28571429, 0.33333333],
       [1.        , 0.        ]])

# 역변환
mms.inverse_transform(df_mms)

# output:
array([[ 10.,   1.],
       [ 20.,   2.],
       [-10.,   3.],
       [  0.,   1.],
       [ 25.,   0.]])

# 한번에 적용
mms.fit_transform(df)

Standard Scaler

• 표준정규분포를 사용하여 표준화 시킴!

from sklearn.preprocessing import StandardScaler

ss = StandardScaler()
ss.fit(df)

# 평균과 표준편차
ss.mean_, ss.scale_
# transform
df_ss = ss.transform(df)
df_ss
# output :
array([[ 0.07808688, -0.39223227],
       [ 0.85895569,  0.58834841],
       [-1.48365074,  1.56892908],
       [-0.70278193, -0.39223227],
       [ 1.2493901 , -1.37281295]])

# 한번에 하기
ss.fit_transfrom(df)

Robust Scaler

• 중간값(median)과 사분위수를 이용한 스케일 방법
• 이상치에 강하게 대응 가능!

$$ {x_i - Q_2 \over \ Q_3 - Q_1} $$

df = pd.DataFrame({
    'A':[-0.1, 0., 0.1, 0.2, 0.3, 0.4, 1.0, 1.1, 5.0]
})

# 해당 df를 다 스케일 해보자!
from sklearn.preprocessing import MinMaxScaler, StandardScaler, RobustScaler
mm = MinMaxScaler()
ss = StandardScaler()
rs = RobustScaler()

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

• MinMax는 이상치에 많은 영향을받아 이상치가 있는 데이터에 적합하진 않음
• Standard도 ...
• Robust는 이상치에 잘 대응

• 머신러닝에서 거의 연습문제 1번같은 느낌
• 타이타닉배는 1910년대 당시 최대 여객선이고 영국에서 미국 뉴욕으로 가던 국제선
• 아래는 해당 데이터 칼럼의 의미이다.

타이타닉 생존자분석 (EDA)

import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
tatanic = pd.read_excel('./data/titanic.xls')
tatanic.head()

# 생존자 비율의 파이그래프, autopic : 숫자를 보여줌, shoadow : 그림자, explode : 구분되게 조금 띄어놓음 

# 1행에 2열 생성, ax는 subplot에서 반환받은거
f ,ax = plt.subplots(1, 2, figsize=(16, 8))
tatanic['survived'].value_counts().plot.pie(ax=ax[0], autopct='%1.1f%%', shadow=True, explode =[0, 0.05]);
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()

• 성별에 따른 생존 현황

f ,ax = plt.subplots(1, 2, figsize=(16, 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 Unservived')
plt.show()

• 남성의 생존 가능성이 더 낮음, 거의 1/4만 살아남음

# 경제력 대비 생존률
# crosstab : 첫 번째는 인덱스, 두번째는 컬럼으로 생성해줌, margins: 합계
pd.crosstab(titanic['pclass'], titanic['survived'], margins=True)

• 1등실의 생존률이 다른 두군데보다 매우 높음

• 그럼 1등실에는 여성이 많이 타고 있나?

grid = sns.FacetGrid(titanic, row='pclass', col='sex', heigt=3, aspect =1)
grid.map(plt.his, 'age', alpha=0.8, bins=20)
grid.add_legend()

• 3등실에 남성이 많았음, 특히 20대
• 나이별 승객 현황 확인

import plotly.express as px
fig = px.histogram(titanic, x='age')
fig.show()

• 등실별 생존률 확인

grid = sns.FacetGrid(titanic, row='pclass', col='survived', height=3, aspect=1)
grid.map(plt.his, 'age', alpha=0.5, bins=20)
gird.add_legend();

• 선실 등급이 높으면 생존률이 높은 경향을 보인다
• 나이를 5단계로 정리하기

titanicp['age_catg'] = pd.cut(titanic['age'], bins=[0, 7, 15, 30, 60, 100],
                             include_lowest=True,
                             labels = ['baby', 'teen', 'young', 'adult', 'old'])

• 나이, 성별, 등급별 생존자 수를 한번에 파악 하기

plt.figure(figsize=(12, 4))
plt.subplot(131)
sns.barplot('pclass', 'survived', data=titanic)
plt.subplot(132)
sns.barplot('age_catg', 'survived', data=titanic)
plt.subplot(133)
sns.barplot('sex', 'survived', data=titanic)
# 신뢰구간
plt.subplots_adjus(top=1, bottom=0.1, left=0.1, right=1, hspace=0.5, wspace=0.5)

• 과연 어리고 여성이고 1등실일수록 생존하기 유리했을까?
• 남/여 나이별 생존 상황을 살펴보자

fig, axes = flt.subplots(nrows=1, ncols=2, figsize=(14, 6))

women = titanic[titanic['sex']=='female']
men = titanic[titanic['sex']=='men']

# bins가 다를 때 높이가 다르다고 다른거 아님, 구간에 맞춰서 합해야함
ax = sns.distplot(women[women['survived']==1]['age'], bins=20,label='survived', ax=axes[0], kde=False)
ax = sns.distplot(women[women['survived']==0]['age'], bins=40, label='not survived', ax=axes[0], kde=False)
ax.legend(); ax.set_title('Female')

ax = sns.distplot(men[men['survived']==1]['age'], bins=18, label='survived', ax=axes[1], kde=False)
ax = sns.distplot(men[men['survived']==0]['age'], bins=40, label='not survived', ax=axes[1], kde=False)
ax.legend(); ax.set_title('Male')

• 계급층에 따라 알아보자!

import re
title = []
for idx, dataset in tatanic.itterrowsd():
    tmp = dataset['name']
    title.append(re.search("\,\s\w+(\s\w+)?\.", tmp).group()[2:-1])
    # ,로 시작하고 한칸띄우고 어떤 글자들이 나오다가 단어가 몇개일지는 모르고 .로 마침
titanic['title'] = title

pd.crosstab(titanic['title'], titanic['sex'])

# 계급이 여러개라 이름을 합침, MLLe, Ms, Mme는 Miss랑 똑같은거라 이름 바꿈
titanic['title'] = titanic['title'].replace('Mlle', 'Miss')
titanic['title'] = titanic['title'].replace('Ms', 'Miss')
titanic['title'] = titanic['title'].replace('Mme', 'Miss')
Rare_f = ['Dona', 'Lady', 'the Countess']
Rare_m = ['Capt', 'Col', 'Don', 'Major', 'Rev', 'Sir', 'Dr', 'Master', 'Jonkheer']

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')

titanic[['title', 'survived']].groupby(['title'], as_index=False).mean()

• 평민남성 -> 귀족남성 -> 평민여성 -> 귀족여성 순으로 생존률이 높음

머신 러닝을 이용한 생존자 예측

• 머신러닝을 하려면 데이터가 숫자여야한다, 그러나 성별이 숫자가 아님 -> 변경필요

from sklearn.preprocessing import LabelEncoder

le = LabelEncoder()
le.fit(titanic['sex'])
# le.classes_ 하면 클래스 나옴
titanic['gender'] = le.transfor(titanic['sex'])

# 결측치는 그냥 패쓰
titanic = titanic[titanic['age'].notnull()]
titanic = titanic[titanic['fare'].notnull()]

# 상관관계
correlation_matrix = titanic.corr().round(1)
sns.heatmap(data=correlation_matrix, annot=True, cmap='bwr')

titanic.columns

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.8, random_state=42)

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

dt = DecisionTreeClassifier(max_depth=4, random_state=42)
dt.fit(X_train, y_train)
pred = dt.predict(X_test)
print(accuracy_score(y_test, pred))

# 디카프리오와 윈슬릿의 생존가능 확률은?

import numpy as np
# 클래스 : [['pclass', "age", 'sibsp', 'parch', 'fare', 'gender']] 
dicaprio = np.array([3, 18, 0, 0, 5, 1])
print('Dicaprio :', dt.predict_proba(dicaprio)[0][1])

# 윈슬릿은?
winslet = np.array([[1, 16, 1, 1, 100, 0]])
print('Winslet :', dt.predict_proba(winslet)[0][1])

윈슬릿은 100% !

• 명시적으로 프로그래밍하지 않고도 컴퓨터에 학습할 수 있는 능력을 부여하는 학문
• 즉, 명시적인 프로그램에 의해서가 아니라 기계가 주어진 데이터를 통해 규칙을 찾는 것.

• IRIS 데이터 분류
  • 꽃잎, 꽃받침의 길이/너비를 이용해서 품종구분이 가능할까?
• 데이터 관찰

from sklearn.datasets import load_iris
iris = load_iris()

iris.keys()
# 데이터 설명들
print(iris["DESCR"])

print(iris['target'])
print(iris['target_names'])

# 차례대로 0번째가 setosa, 1이 versicolor, 2가 virginica를 의미

• 먼저 상황을 파악해야한다 ! ex) 품종 구분을 위한 특성공부

import pandas as pd
iris_pd =pd.DataFrame(iris.data, columns=iris['feature_names'])
iris_pd['species'] = iris.target

import seaborn as sns
import matplotlib.pyplot as plt

plt.figure(figsize=(12,6))
sns.boxplot(x='sepal length (cm)', y='species', data=iris_pd, orient='h')
# orient : 수평바로 그려라 

sns.pairplot(iris_pd, hue='species')

plt.figure(figsize=(12,6))
sns.scatterplot(x='petal length (cm)', y='petal width (cm)', data=iris_pd, hue='species', palette='Set2');

• 품종을 구분하는 선을 어떻게 그을까?

• 첫번째 setosa 구분은 너무 잘 되니 두번째 선을 어떻게 그을까?

Decision Tree

# 데이터 변경
iris_12 = iris_pd[iris_pd['species']!=0]
sns.scatterplot(x='petal length (cm)', y='petal width (cm)', data=iris_12, hue='species', palette='Set2');

# 과연이제 어떻게 선을 정할 것인가?

Decision Tree의 분할 기준(Split Criterion)

• Decision Tree : 분류, 회귀 모두 가능한 지도 학습 모델 중 하나. 스무고개처럼 질문을 이어가며 학습

• 정보 획득(Information Gain)

  • 정보의 가치를 반환하는 데 발생하는 사전의 확률이 작을수록 정보의 가치는 커진다.
  • 정보 이득이란 어떡 속성을 선택함으로 인해서 데이터를 더 잘 구분하게 되는 것

• 엔트로피 : 불순도를 수치화한 지표 중 하나, 확률 변수의 불확실성을 수치로 나타낸 것

• 엔트로피가 큰쪽에서 낮은쪽으로 이동해야함(무질서도를 낮춰야 함)

# p:해당 데이터가 해당 클래스에 속할 확률
# 어떤 확률 분포로 일어나는 사건을 표현하는데 필요한 정보의 양이며 이 값이 커질수록 확률 분포의 불확실성이 커지며 결과에 대한 예측이 어려워짐
import numpy as np
p = np.arange(0.001, 1, 0.001)
plt.plot(p, -p*np.log2(p))

# 엔트로피는 이확률들의 합
# 그러다 계산이 어려워서 지니계수라는 것이 등장

Scikit Learn

• 현재 파이썬에서 가장 유명한 기계학습 오픈소스 라이브러리

from sklearn.tree import DecisionTreeClassifier
iris_tree = DecisionTreeClassifier()
iris_tree.fit(iris.data[:, 2:], iris.target)

# 성능확인
from sklearn.metrics import accuracy_score
y_pred_tr = iris_tree.predict(iris.data[:, 2:])
accuracy_score(iris.target, y_pred_tr)

과적합(Overfiting)

# 트리보기 
from sklearn.tree import plot_tree
plt.figure(figsize=(12,8))
plot_tree(iris_tree)

# 결정경계
from mlxtend.plotting import plot_decision_regions

plt.figure(figsize=(14,8))
plot_decision_regions(X=iris.data[:,2:], y=iris.target, clf=iris_tree, legend=2)
plt.show()

• plot_tree

• plot_decision_regions

• Accuracy가 높다고 과연 믿을 수 있을까?

• 내가 가진 데이터를 벗어나서 일반화할 수 있을까?

• 어차피 얻은 데이터는 유한하고 내가 얻은 데이터를 이용해서 일반화를 추구하게 된다.

• 이때 복잡한 경계면은 모델의 성능을 결국 나쁘게 한다.

데이터 분리

• 훈련, 검증, 테스트 데이터로 분리해서 오버피팅을 방지해야함.

# 데이터를 훈련/ 테스트로 분리
from sklearn.datasets import load_iris
iris = load_iris()

from sklearn.model_selection import train_test_split
features = iris.data[:, 2:]
labels = iris.target
X_train, X_test, y_train, y_test = train_test_split(features, labels, test_size=0.2, random_state=13)

# 훈련용/테스트용이 잘 분리 되었을까?
import numpy as np
np.unique(y_test, return_counts=True)

-> 고르게 분포 안됨

# 고르게 나눠주는 옵션 : stratify
X_train, X_test, y_train, y_test = train_test_split(features, labels, test_size=0.2, stratify=labels, random_state=13)

# 위에 처럼 다시 train 데이터만 대상으로 결정나무 모델 생성
# 학습할 때 마다 일관성을 위해 random_state고정, 모델 단순화를 위해 max_depth조정
from sklearn.tree import DecisionTreeClassifier
iris_tree = DecisionTreeClassifier(max_depth=2, random_state=13)
iris_tree.fit(X_train, y_train)

plt.figure(figsize=(12,8))
plot_tree(iris_tree)

# 정확도 계산
y_pred_tr = iris_tree.predict(iris.data[:, 2:])
accuracy_score(iris.target, y_pred_tr)
# 결정경계 확인
from mlxtend.plotting import plot_decision_regions
plt.figure(figsize=(14,8))
plot_decision_regions(X=x_train, y=y_train, clf=iris_tree, legend=2)
plt.show()
# 정확도 측정
y_pred_tr = iris_tree.predict(X_test)
accuracy_score(y_test, y_pred_tr)

scatter_highlight_kwargs = {'s':150, 'label':'Test data', 'alpha':0.9}
scatter_kwargs = {'s':120, 'edgecolor':None, 'alpha':0.9}
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})
# 아래처럼하면 라벨이 바로 나오는 효오과
iris.target_names[iris_tree.predict(test_data)]
# 주요 특성 확인
iris_tree.feature_importances_
dict(zip(iris.feature_names, iris_tree.feature_importances_))

네이버 영화 평점 사이트 분석

• 영화랭킹에서 평점순(현재상영영화) 선택
• 접근 URL 확인
• 웹 페이지의 주소에 많은 정보가 담겨있음, 원하는 정보를 얻기 위해 변화시켜야하는 주소의 규칙이 보이기도 함
• 이 경우 날짜 정보를 변경해주면 해당 페이지에 접근이 가능하다

import pandas as pd
from bs4 import BeautifulSoup
from urllib.request import urlopen

url ="https://movie.naver.com/movie/sdb/rank/rmovie.naver?sel=cur&date=20180315"
page = urlopen(url)

soup = BeautifulSoup(page, "html.parser")
# soup

• 매 페이지마다 가져오는 영화의 갯수가 다르다, 따라서 end 변수에 한 페이지의 영화제목 갯수를 넣고 0 부터 갯수만큼 for을 돌려준다.

# 영화 제목 태그, 클래스
end = len(soup.find_all("div", "tit5"))
movie_name = [soup.find_all("div", "tit5")[n].a.text for n in range(0, end)]
movie_name

end = len(soup.find_all("td", "point"))
movie_point = [soup.find_all("td", "point")[n].string for n in range(0, end)]
movie_point

영화 평점 데이터 확보

• pandas의 date_range를 이용해 날짜를 쉽게 생성가능(freq="D" : day가 주기)

date = pd.date_range("2017.12.01", periods=100, freq="D")
date

• 날짜형 데이터들은 원하는 형태로 출력이 가능하다

date[0]
output : Timestamp('2017-12-01 00:00:00', freq='D')
date[0].strftime("%Y-%m-%d")
output : '2017-12-01'
date[0].strftime("%Y.%m..%d")
output : '2017.12..01'

for today in tqdm_notebook(date):
    html ="https://movie.naver.com/movie/sdb/rank/rmovie.naver?sel=cur&date={date}"
    response = urlopen(html.format(date=today.strftime("%Y%m%d")))
    soup = BeautifulSoup(response, "html.parser")

    end = len(soup.find_all("td", "point"))

    movie_date.extend([today for _ in range(0, end)])
    movie_name.extend([soup.find_all("div", "tit5")[n].a.string for _ in range(0, end)])
    movie_point.extend([soup.find_all("td", "point")[n].string for _ in range(0, end)])

    #sleep 안주면 속도 너무 빨라서 서버에서 차단당할 수도 있음 ㅜㅜ
    time.sleep(0.5)

• 데이터프레임으로 만들기, 이 데이터가 raw data가 된다.

movie = pd.DataFrame({
    "data": movie_date,
    "name": movie_name,
    "point": movie_point
})
movie.head()
movie.info()

• point가 숫자가 아니라 object 타입!

movie["point"] = movie["point"].astype(float)
movie.info()

영화 평점 데이터 정리

import numpy as np
import pandas as pd

movie = pd.read_csv("./data/04_naver_movie_raw_data.csv")
movie.head()

• 영화 이름으로 인덱스를 잡고 점수의 합산을 구함, 100일 간 네이버 영화 평점 합산기준 베스트 10

movie_unique = pd.pivot_table(movie, index=["name"], aggfunc=np.sum)
movie_best = movie_unique.sort_values(by="point", ascending=False)
movie_best.head(10)

• 아래처럼 쓸 때 큰따옴표(" "), 작은따옴표(' ') 를 안과 밖 서로 다르게 구분해서 줘야 오류안생김

tmp = movie.query('name ==["1987"]')
tmp
#더블인덱스 제거
movie_pivot = pd.pivot_table(movie, index=["date"], columns=["name"], values=["point"])
movie_pivot.columns = movie_pivot.columns.droplevel()movie_pivot.head()

시각화

import numpy as np
import pandas as pd

import matplotlib.pyplot as plt
from matplotlib import rc

rc("font", family="Malgun Gothic")
%matplotlib inline

plt.figure(figsize=(20, 8))
plt.plot(tmp["date"], tmp["point"]);
plt.title("날짜별 평점")
plt.xlabel("날짜")
plt.ylabel("평점")
plt.xticks(rotation="vertical")
plt.legend(labels=['평점추이'], loc="best")
plt.show()

target_col = ["12 솔져스", "1987", "50가지 그림자: 해방"]
plt.figure(figsize=(20, 8))
plt.title("날짜별 평점")
plt.xlabel("날짜")
plt.ylabel("평점")
plt.xticks(rotation="vertical")
# 조금 더 보기 편하게 선이 생김
plt.tick_params(bottom="off", labelbottom="off")
plt.plot(movie_pivot[target_col])
plt.legend(target_col, loc="best")
plt.grid(True)

위키백과 문서정보 가져오기

• 한글이 포함된 웹페이지(URL)을 복사해 메모장이나 주피터셀에 복붙하면 이상하게 바뀌어서 나타난다, 웹주소는 UTF-8로 인코딩되어야 한다. => 구글에 URL Decode 검색해서 사용 또는 아래처럼 포맷팅!

• 스트링에서 중괄호( {} ),로 감싸주면 변수취급된다.

• quote : 한글로된걸 UTF-8로 변환해줌

import urllib
from bs4 import BeautifulSoup
from urllib.request import Request, urlopen

html = "https://ko.wikipedia.org/wiki/{search_words}"
req = Request(html.format(search_words=urllib.parse.quote("여명의_눈동자")))

response = urlopen(req)

soup = BeautifulSoup(response, "html.parser")
soup

인물정보 찾기

replace() : 특정문자열을 내가 원하는대로 변경해줌

n = 0
for each in soup.find_all("ul"):
    print("=>" + str(n) + "====================")
    print(each.get_text())
    n += 1

soup.find_all("ul")[15].text.strip().replace("\xa0","").replace("\n","")

List 데이터형

• List 형은 대괄호로 생성한다
• .extend() : 제일 뒤에 다수의 자료를 추가
• insert() : 원하는 위치에 자료를 삽입
• isinstance(data, type) : 자료형 True/False로 확인해줌

colors = ['red', 'blue', 'green']
b = colors    #주소값 참조한거라 b내용을 변경하면 colors 내용도 바뀜
b[1] = 'black'
colors
# deep copy
c = colors.copy()

# in 연산자 사용
if 'black' in colors:
    print("True")

colors.extend(['pink', 'yellow'])

colors.insert(1, "purple")

isinstance(colors, list)
ouput : True

시카고 맛집 데이터 분석

• 총 51개의 페이지에서 각 가게의 정보를 가져온다
  • 가게이름, 대표메뉴, 대표메뉴의 가격, 가게주소

from bs4 import BeautifulSoup
from urllib.request import Request, urlopen
from fake_useragent import UserAgent
# http에서 https로 바껴서 오류생김, 의존성 추가하면 됨
import ssl
context = ssl._create_unverified_context()

url_base = "https://www.chicagomag.com"
url_sub = "/Chicago-Magazine/November-2012/Best-Sandwiches-Chicago/"
url = url_base + url_sub

ua = UserAgent()
ua.ie

req = Request(url, headers={"User-Agent" : ua.ie})

response = urlopen(req, context=context)
response.status

soup = BeautifulSoup(response, "html.parser")

# print(soup.prettify())

• bs4.elment.Tag 타입이면 find 명령을 사용할 수 있다는 의미

tmp_one = soup.find_all("div", "sammy")[0]
type(tmp_one)

tmp_one.find(class_="sammyRank")

tmp_one.find(class_="sammyRank").get_text()

tmp_one.find(class_="sammyListing").get_text()
tmp_one.find("a")["href"]

output:'/Chicago-Magazine/November-2012/Best-Sandwiches-in-Chicago-Old-Oak-Tap-BLT/'
# 연결되는 홈페이지 주소가 상대경로임 

import re
tmp_string = tmp_one.find(class_="sammyListing").get_text()
re.split(("\n|\r\n"),tmp_string)

output : ['BLT', 'Old Oak Tap', 'Read more ']

# 상대주소 절대주소 대응을 위한 모듈
from urllib.parse import urljoin

url_base = "http://www.chicagomag.com"

rank = []
main_menu = []
cafe_name = []
url_add = []    
#필요한 내용을 담을 빈 리스트를 준비 리스트로 하나씩 컬럼만들어 DataFrame으로 합칠예정

list_soup = soup.find_all("div", "sammy")

#urljoin : 두번째 항목이 절대주소면 url_base를 붙이지 않고 상대주소면 붙임 
for item in list_soup:
    rank.append(item.find(class_="sammyRank").get_text())
    tmp_string = item.find(class_="sammyListing").get_text()
    main_menu.append(re.split(("\n|\r\n"), tmp_string)[0])
    cafe_name.append(re.split(("\n|\r\n"), tmp_string)[1])
    url_add.append(urljoin(url_base, item.find("a")["href"]))

• 데이터프레임으로 합치기

import pandas as pd

data = {"Rank": rank, "Menu":main_menu, "Cafe":cafe_name, "URL": url_add}
df = pd.DataFrame(data)
df.head()

df = pd.DataFrame(data, columns=["Rank", "Cafe", "Menu", "URL"])
df.head()
# 칼럼 순서 변경

# 저장
df.to_csv(
    "./data/03. best_sandwiches_list_chicago.csv",
    sep=",",
    encoding="UTF-8"
)

하위페이지 분석

df["URL"][0]

req = Request(df["URL"][0], headers={"User-Agent" : "Chrome"})
html = urlopen(req, context=context).read()
soup_tmp = BeautifulSoup(html, "html.parser")
print(soup_tmp.find("p", "addy"))

output : <p class="addy">
<em>$10. 2109 W. Chicago Ave., 773-772-0406, <a href="http://www.theoldoaktap.com/">theoldoaktap.com</a></em></p>

• 가격만 가져오고 싶은데 주소랑 같이 있음 => Regular Expression 사용

price_tmp = soup_tmp.find("p", "addy").get_text()
price_tmp

import re

re.split(".,", price_tmp)

price_tmp = re.split(".,", price_tmp)[0]
price_tmp

tmp = re.search("\$\d+\.(\d+)?", price_tmp).group()
price_tmp[len(tmp) + 2:]
#$가 반드시 와야하고 d+ : 숫자가 여러개 있을 수 있고 꼭 .을 만나고 그 뒤에 숫자가 있을수도 있고 아닐수도 있다
#가격이 끝나는 지점의 위치를 이용해서 그 뒤는 주소로 생각한다

• for 문을 사용할 때 이게 동작중인지 시간이 얼마 남은건지 모를 떄 => TQDM

from tqdm import tqdm
price = []
address = []

for idx, row in df.iterrows():
    req = Request(row["URL"], headers={"User-Agent" : "Chrome"})
    html = urlopen(req, context=context).read()

    soup_tmp = BeautifulSoup(html, "html.parser")

    gettings = soup_tmp.find("p", "addy").get_text()

    price_tmp = re.split(".,", gettings)[0]
    tmp = re.search("\$\d+\.(\d+)?", price_tmp).group()

    price.append(tmp)
    address.append(price_tmp[len(tmp) + 2 :])
    print(idx)

• 데이터프레임 정리

df["Price"] = price
df["Address"] = address
df = df.loc[:,["Rank", "Cafe", "Menu", "Price", "Address"]]
df.set_index("Rank", inplace=True)
df.head()

시카고 맛집 데이터 지도 시각화

import folium
import pandas as pd
import googlemaps
import numpy as np
from tqdm import tqdm

df = pd.read_csv("./data/03. best_sandwiches_list_chicago2.csv", index_col=0)
df.head()

gmaps_key = "key 값"
gmaps = googlemaps.Client(key=gmaps_key)

lat = []
lng = []
for idx, row in tqdm(df.iterrows()):
    if not row["Address"] == "Multiple location":
        target_name = row["Address"] + ", " + "Chicago"
        gmaps_output = gmaps.geocode(target_name)
        location_output = gmaps_output[0].get("geometry")
        lat.append(location_output["location"]["lat"])
        lng.append(location_output["location"]["lng"])
    else:
        lat.append(np.nan)
        lng.append(np.nan)
df["lat"] = lat
df["lng"] = lng
df.head()
mapping = folium.Map(location=[41.895558, -87.679967], zoom_start=11)
for idx, row in df.iterrows():
    if not row["Address"] == "Multiple location":
        folium.Marker([row["lat"], row["lng"]], popup=row["Cafe"]).add_to(mapping)
mapping

• open(), read(), write(), close() 를 이용해 텍스트 파일을 다룬다.
• 각각 이름 그대로 열기, 읽기, 쓰기, 닫기 역할을 수행한다.

open()을 통해 파일을 다양한 방식으로 열 수 있다.

'w' : 쓰기전용(파일이 있으면 덮어씌움)

'a' : 쓰기전용(파일이 있으면 덧붙임)

'x' : 쓰기전용(파일이 있으면 에러 발생)

'r' : 읽기전용(파일이 없으면 에러발생)

write()를 통해 파일 쓰기

file = open('C:/pythonTxt/test.txt', 'w')

# write는 글자개수를 int형으로 반환
# w모드는 기존에 있던 글 새로 덮어버림 
strCnt = file.write('Hello world~')
print(f"strCnt : {strCnt}")

# 외부자원 연결 해제 
file.close()

read()를 통해 파일 읽기

file = open('C:/pythonTxt/test.txt', 'r')
str = file.read()
print(f"str : {str}")
file.close()

• strftime 을 통해 간단하게 형식 맞출 수 있음
• %H를 하면 13시처럼 24시 기준, %I를 하면 오전, 오후 12시간을 기준으로 출력

import time

lt = time.localtime()
# p : AM/PM 
dateStr = time.strftime('%Y-%m-%d %H:%M:%S %p')
dateStr

with ~ as 문

• with ~ as 문을 이용하면 파일 닫기(close)를 생략할 수 있다.

uri = "C:/pythonTxt/"

file = open(uri + 'hello.txt', 'a')
file.write("Hello")
file.close()

# 위의 내용을 with ~ as로 변경

with open(uri + "hello.txt", 'a') as f:
    f.write("안뇽~~")

writelines()

• 반복 가능한 자료형의 데이터를 파일에 쓰자!

uri = "C:/pythonTxt/"

languages = ["c/c++", "java", "c#", "python", "javascript"]

for item in languages:
    with open(uri + 'languages.txt', 'a') as f:
        f.write(item)
        f.write('\n')

# for문 대신 writelines()를 사용!        

with open(uri + 'languages.txt', 'a') as f:
    f.writelines(languages)
# 개행 추가    
with open(uri + 'languages.txt', 'a') as f:
    f.writelines(item + '\n' for item in languages)

# 아래처럼 하면 score가 그대로 입력됨
score = {"kor" : 85, "eng" : 90}
with open(uri + "score.txt", 'a') as f:
    print(score, file=f)

readlines(), readlinse()

• 여러줄 읽기와 한 줄 읽기
• readlines() : 파일의 모든 데이터를 읽어서 리스트 형태로 반환한다.
• readline() : 한 행을 읽어서 문자열로 반환 한다.

uri = "C:/pythonTxt/"

with open(uri + "lans.txt", 'r') as f:
    lanList = f.readlines()
print(f"lanList : {lanList}")

아래는 텍스트파일, 파이썬 실행결과 순이다

uri = "C:/pythonTxt/"

with open(uri + "lans.txt", 'r') as f:
    line = f.readline()

    while line != '':
        print(f"line : {line}")
        line = f.readline()

HTML(Hyper Text Markup Language) : 웹 문서를 만들기 위하여 사용하는 기본적인 웹 언어의 한 종류. 인터넷에서 웹을 통해 접근되는 대부분의 웹 페이지들은 HTML로 작성된다. 각종 태그들로 이루어져있으며 요새는 HTML5 표준을 사용!

HEAD tag : 눈에 보이진 않지만 문서에 필요한 헤더 정보를 보관
title : 탭 제목
BODY tag: 눈에 보이는 정보를 보관
p(paragraph) : 문장

html태그는 아래와 같이 이루어져있다.

<!DOCTYPE html>
<html>
    <head>
        <title>Very Simple HTML Code By ZeroBase</title> 
    </head>
    <body>
        <div>
            <p class="inner-text first-item" id="first">
                Happy ZeroBase.
                <a href="http://www.pinkwink.kr" id="pw-link">PinkWink</a>
            </p>
            <p class="inner-text second-item">
                Happy Data Science.
                <a href="https://www.python.org"target="_blink" id="py-link">Python</a>
            </p>
        </div>
        <p class="outer-text first-item" id="second">
            <b>Data Sience if funny.</b>
        </p>
        <p class="outer-text">
            <i>All I need is Love</i>
        </p>
    </body>
</html>

BeautifulSoup

• HTML, XML 문서를 구조적으로 분석하여 원하는 데이터를 쉽게 추출하게 도와주는 모듈
• open : 파일명과 함께 읽기(r), 쓰기(w) 속성을 지정
• html.parser : BeautifulSoup의 html을 읽는 엔진 중 하나, 더 빠른 lxml도 사용가능
• prettify() : html 출력을 예쁘게 만들어 줌

from bs4 import BeautifulSoup
page = open("./data/03. test_first.html","r").read()
soup = BeautifulSoup(page,"html.parser")
print(soup.prettify())

.body : body태그가 속한 부분을 반환

• 특정 태그 찾기

  • find("찾을 태그, 속성") : 가장 먼저 찾은 태그 하나를 출력
    id의 경우 HTML 내에 하나만 존재한다!

  • find_all("찾을 태그, 속성") : 찾은 태그 모두를 출력, id나 클래스(class_="찾을클래스")처럼 지정가능, list형태로 반환함

  • select_one : find와 같은 기능

  • select : find_all과 같은기능, >를 이용해 내부 1단계 뎁스에서 찾기 가능, .을 이용해 클래스찾기 가능

    soup.select("head > title")

    soup.selet(".value")

soup.p
soup.find("p")
soup.find("p", class_="inner-text first-item")
soup.find("p",{"class":"outer-text first-item", "id":"first"})

• 텍스트 부분 출력

  • .text()
  • .get_text()

• 태그에서 속성 출력

  • .get("속성명")
  • ["속성"] 으로도 접근 가능!

soup.find_all("a")

soup.find_all("a")[0].get("href")

soup.find_all("a")[0]["href"]

for each in soup.find_all("a"):
    href = each.get("href")
    text = each.get_text()
    print(text + " => " + href)

크롬 개발자 도구

크롬설정 - 도구 - 도구더보기 - 개발자도구 또는 ctrl + shift + i 또는 F12를 사용해 실행가능.

선택을 이용해 특정 html위치 찾기 용이

환율정보 가져오기

urllib.request : 웹주소(URL)에 접근할 때 필요한 모듈

from urllib.request import urlopen
from bs4 import BeautifulSoup

url = "https://finance.naver.com/marketindex/"
page = urlopen(url)
# response, res라는 변수명도 많이 사용 !, page.status를 사용해 http상태코드 출력가능 
soup = BeautifulSoup(page, "html.parser")
print(soup.prettify)

# 환율 정보를 찾기
soup.find_all("span",class_="value")  
# class 생략해도 됨
soup.find_all("span","value")

import requests
url = "https://finance.naver.com/marketindex/"
response = requests.get(url)
response  #request 모듈은 바로 http 상태코드 출력됨
soup = BeautifulSoup(response.text,"html.parser")

# id => # 
# class => . 

exchangeList = soup.select("#exchangeList > li")

#내부에 알고싶은 정보를 찾기
title = exchangeList[0].select_one(".h_lst").text
exchange = exchangeList[0].select_one(".value").text
change = exchangeList[0].select_one(".change").text
updown = exchangeList[0].select_one("div.head_info> .blind").text
baseUrl = "https://finace.naver.com"
baseUrl + exchangeList[0].select_one("a").get("href")
# 띄어쓰기는 클래스 속성값 2개가 있다로 생각하면됨, 그래서 . 으로 써줘야됨

import pandas as pd

exchange_datas = []
baseUrl = "https://finace.naver.com"

for item in exchangeList:
    data = {
        "title":item.select_one(".h_lst").text,
        "exchange":item.select_one(".value").text,
        "change":item.select_one(".change").text,
        "updown":item.select_one("div.head_info> .blind").text,
        "link" : baseUrl + item.select_one("a").get("href")
    }
    exchange_datas.append(data)
df = pd.DataFrame(exchange_datas)
df.to_excel("./naverfiance.xlsx",encoding="utf-8")

sns.pairplot(data=crime_anal_norm, vars=['살인','강도','폭력'],kind='reg', height=3)
# reg : regression,

• 인구수,CCTV와 살인,강도의 상관관계 확인

def drawGraph():
    sns.pairplot(
        data=crime_anal_norm,
        x_vars=['인구수','CCTV'], 
        y_vars=['살인','강도'],
        kind="reg",
        height=4
    )
    plt.show()

• 인구수, CCTV와 살인검거율,폭력검거율 상관관계 확인

def drawGraph():
    sns.pairplot(
        data=crime_anal_norm,
        x_vars=['인구수','CCTV'], 
        y_vars=['살인검거율','폭력검거율'],
        kind="reg",
        height=4
    )
    plt.show()

• 검거율 heatmap, '검거' 컬럼을 기준으로 정렬

def drawGraph():
    target_col = ['강간검거율', '강도검거율', '살인검거율', '절도검거율', '폭력검거율','검거']

    crime_anal_norm_sort = crime_anal_norm.sort_values(by='검거', ascending =False)

    plt.figure(figsize=(10, 10))
    sns.heatmap(crime_anal_norm_sort[target_col],
                annot=True,
                fmt='f',
                linewidths=0.5, #간격설정
                cmap="RdPu"
    )
    plt.title("범죄 검거 비율 (정규화된 검거의 합으로 정렬)")
    plt.show()

지도 시각화 (Folium)

• 현재 사용의 편의성이나 활발한 기능 개선 등으로 Folium이 만족도가 높은 편
• 기본적으로 크롬에서 원활하게 동작함

기본적으로 그냥 위도, 경도를 알려주면 동작한다. (구글지도에서 우클릭시 위도,경도 나옴)

기본 지도 그리기 : folium.Map(location = [위도, 경도], zoom_size = 크기, tiles="option")

# 지도를 html로 저장가능하다.
지도.svae("./경로/뭐뭐.html")

tiles option : 지도의 스타일 옵션 선택

tiles option

- "OpenStreetMap"
- "Mapbox Bright" (Limited levels of zoom for free tiles)
- "Mapbox Control Room" (Limited levels of zoom for free tiles)
- "Stamen" (Terrain, Toner, and Watercolor)
- "Cloudmade" (Must pass API key)
- "Mapbox" (Must pass API key)
- "CartoDB" (positron and dark_matter)

import folium
import pandas as pd
import json

m = folium.Map(location = [37.54, 127.05],
               zoom_start = 15,
               tiles="OpenStreeMap",) 
#0~18 까지를 권장, 0이 가장 큼
folium.Marker(location=(37.547123, 127.047219169),
              popup = "Subway",
             tooltip = "성수역",
             icon =folium.Icon(color="black", 
                               icon_color = "green",
                               icon = 'bookmark',angle = 50, prefix='fa') ).add_to(m)
m

folium.Marker()

• Marker : 지도에서 지정한 위치에 마커를 표시해줌
• folium.Marker(location,popup=option,tooltip=option,icon=option,draggable=option,**kwargs)
  popup : 마커를 누르면 말풍선마냥 팝업창으로 뜸, html문법 적용가능
  tooltip : 마커에 갖다내면 설정문구 뜸, html문법 적용가능
  icon : 마커 아이콘의 꾸밈가능(색깔, 안의 모양) , font-awesome홈피 들어가서 icon탭 - free에서 보이는 것들은 prefix='fa' 설정해줘야 됨
  

m = folium.Map(
    location=[37.544564958079896, 127.05582307754338], # 성수역 
    zoom_start=14,
    tiles="OpenStreetMap"
) # 0 ~ 18 

# tooltip 
folium.Marker(
    location=[37.544564958079896, 127.05582307754338],
    popup="<b>Subway</b>",
    tooltip="<i>성수역</i>"
).add_to(m)

# html  
folium.Marker(
    location=[37.54558642069953, 127.05729705810472],
    popup="<a href='https://zero-base.co.kr/' target=_'blink'>제로베이스</a>",
    tooltip="<i>Zerobase</i>"
).add_to(m)

# Icon custom 
folium.Marker(
    location=[37.54035903907497, 127.06913328776446], # 건대입구역
    popup="건대입구역",
    tooltip="Icon custom",
    icon=folium.Icon(
        color="purple",
        icon_color="white",
        icon="glyphicon glyphicon-cloud",
        angle=50,
        prefix="glyphicon") # glyphicon
).add_to(m)
m

• ClickForMarker() : 지도위에 마우스를 클릭했을 때 마커를 생성해 줌, 안에 popup 옵션 설정가능 없으면 위도,경도 반환

m = folium.Map(location = [37.54, 127.05],
               zoom_start = 15,
               tiles="OpenStreetMap")
m.add_child(folium.ClickForMarker())

LatLngPopup() : 지도를 마우스로 클릭했을 때 위도, 경도 반환

m = folium.Map(location = [37.54, 127.05],
               zoom_start = 15,
               tiles="OpenStreetMap")
m.add_child(folium.LatLngPopup())

• folium.Circle(), folium.CircleMarker()

Circle() :

fill : 안에 색 채우기 여부, color picker로 색깔 고를 수 있음

m = folium.Map(location = [37.54, 127.05],
               zoom_start = 15,
               tiles="OpenStreetMap")
folium.Circle(location=[37.5417,127.0444],
             radius=100,
             fill=True,
             color="#eb9e34",
              fill_color="red",
              popup="circle",
              tooltip="circle"
             ).add_to(m)
m

CircleMarker() : radius가 조금 다르고 나머진 Circle이랑 똑같음

folium.Choropleth

Choropleth() :

import json 
state_data = pd.read_csv("./data/02. US_Unemployment_Oct2012.csv")
m = folium.Map([43, -102], zoom_start=3)

folium.Choropleth(
    geo_data="./data/02. us-states.json", # 경계선 좌표값이 담긴 데이터
    data=state_data, # Series or DataFrame 
    columns=["State", "Unemployment"], # DataFrame columns 
    key_on="feature.id", #json 파일 까봐야함!
    fill_color="BuPu",
    fill_opacity=0.5, # 0~1 
    line_opacity=0.2, # 0~1
    legend_name="Unemployment rate (%)"    
).add_to(m)

m

지도 시각화

import json
import folium
import pandas as pd 
crime_anal_norm = pd.read_csv("./data/02. crime_in_Seoul_final.csv", index_col=0, encoding="utf-8")
geo_path = "./data/02. skorea_municipalities_geo_simple.json"
geo_str = json.load(open(geo_path, encoding="utf-8"))

my_map = folium.Map(location=[37.5502, 126.982], zoom_start=11, tiles="Stamen Toner")

my_map.choropleth(geo_data=geo_str,
                 data=crime_anal_norm["살인"],
                 columns=[crime_anal_norm.index, crime_anal_norm["살인"],],
                 fill_color="PuRd",
                 key_on="feature.id",
                 fill_opacity=0.7,
                 line_opacity=0.2,
                 legend_name="정규화된 살인 발생 건수")
my_map

# 인구 대비 범죄 발생 건수 시각화

tmp_criminal = crime_anal_norm["범죄"] / crime_anal_norm["인구수"]

my_map = folium.Map(location=[37.5502, 126.982], zoom_start=11, tiles="Stamen Toner")

my_map.choropleth(geo_data=geo_str,
                 data=tmp_criminal,
                 columns=[crime_anal_norm.index, tmp_criminal],
                 fill_color="PuRd",
                 key_on="feature.id",
                 fill_opacity=0.7,
                 line_opacity=0.2,
                 legend_name="인구 대비 범죄 발생 건수")
my_map

# 경찰서별 정보를 가지고 범죄발생과 함께 정리

crime_anal_station = pd.read_csv("./data/02. crime_in_Seoul_1st.csv", index_col=0, encoding="utf-8")
col = ["살인검거", "강도검거", "강간검거", "절도검거", "폭력검거"]
tmp = crime_anal_station[col] / crime_anal_station[col].max()
crime_anal_station["검거"] = np.mean(tmp, axis=1)  # numpy 에서 axis=1은 행(가로), pandas에서는 열(세로)
crime_anal_station.head()

# 경찰서 위치를 지도에 표시
my_map = folium.Map(location=[37.5502, 126.982], zoom_start=11)

for idx, rows in crime_anal_station.iterrows():
    folium.Marker([rows["lat"], rows["lng"]]).add_to(my_map)

# 검거율로 동그라미! 
my_map = folium.Map(location=[37.5502, 126.982], zoom_start=11)

for idx, rows in crime_anal_station.iterrows():
    folium.CircleMarker(
        [rows["lat"], rows["lng"]],
        radius=rows["검거"] * 50,
        popup=rows["구분"] + " : " + "%.2f" % rows["검거"],
        color="#3186cc",
        fill=True,
        fill_color="#3186cc").add_to(my_map)
my_map

my_map = folium.Map(location=[37.5502, 126.982], zoom_start=11)
my_map.choropleth(geo_data=geo_str,
                 data=crime_anal_norm["범죄"],
                 columns=[crime_anal_norm.index, crime_anal_norm["범죄"]],
                 fill_color="PuRd",
                 key_on="feature.id",
                 fill_opacity=0.7,
                 line_opacity=0.2)
for idx, rows in crime_anal_station.iterrows():
    folium.CircleMarker(
        [rows["lat"], rows["lng"]],
        radius=rows["검거"] * 50,
        popup=rows["구분"] + " : " + "%.2f" % rows["검거"],
        color="#3186cc",
        fill=True,
        fill_color="#3186cc").add_to(my_map)

my_map

• 강남의 범죄 발생이 많은 것은 혹시 유흥업소의 밀집과 관련이 있지 않을까?
• 확인을 위해 최초 받았던 장소별 데이터를 읽어보자

crime_loc_raw = pd.read_csv("./data/02. crime_in_Seoul_location.csv", thousands=",", encoding="euc-kr")
crime_loc = crime_loc_raw.pivot_table(crime_loc_raw, index=["장소"], columns=["범죄명"], aggfunc=[np.sum])
crime_loc.columns = crime_loc.columns.droplevel([0, 1])
crime_loc.head()

# 정규화
col = ["살인", "강도", "강간", "절도", "폭력"]
crime_loc_norm = crime_loc / crime_loc.max()
crime_loc_norm.head()

crime_loc_norm["종합"] = np.mean(crime_loc_norm, axis=1)
crime_loc_norm.tail(2)

crime_loc_norm_sort = crime_loc_norm.sort_values(by="종합", ascending=False)

def drawGraph():
    plt.figure(figsize=(10, 10))
    sns.heatmap(crime_loc_norm_sort, annot=True, fmt="f", linewidth=0.5, cmap="RdPu")
    plt.title("범죄와 발생 장소")
    plt.show()

drawGraph()

matplotlib같은 시각화 도구 라이브러리

import matplotlib.pyplot as plt
import seaborn as sns
%matplotlib inline
get_ipython().run_line_magic("matplotlib","inline")

• seaborn은 import하는 것만으로도 효과가 있음

x = np.linspace(0, 14, 100)
y1 = np.sin(x)
y2= 2 * np.sin(x + 0.5)
y2= 3 * np.sin(x + 1.0)
y2= 4 * np.sin(x + 1.5)
plt.figure(figsize=(10, 6))
plt.plot(x, y1, x, y2, x, y3, x, y4)
plt.show()

• set_style : 바탕색 지정
• despint(offest=size) : 왼쪽과 아래쪽 테두리만 생성, offset하면 왼쪽아래가 조금 떨어짐

sns.set_style("white")
plt.figure(figsize=(10, 6))
plt.plot(x, y1, x, y2, x, y3, x, y4)
sns.despine()
plt.show()

• seaborn 에는 실습용 데이터 몇 개가 내장되어있다. tips, flights, iris 등..
  • boxplot

tips = sns.load_dataset("tips")
plt.figure(figsize=(8, 6))
sns.boxplot(x=tips["total_bill"])
plt.show()
tips.head()

hue : 컬럼지정시 구분지어줌

palette : 색상

plt.figure(figsize=(8, 6))
sns.boxplot(x='day', y='total_bill', hue='smoker', data=tips, palette='Set3')
plt.show()

• swarmplot

# swarmplot 
# color: 0~1 사이 검은색부터 흰색 사이 값을 조절 
plt.figure(figsize=(8, 6))
sns.swarmplot(x="day", y="total_bill", data=tips, color="0.5") 
plt.show()

• lmplot : 직선으로 표현

# lmplot: total_bil과 tip 사이 관계 파악 
sns.set_style("darkgrid")
sns.lmplot(x='total_bill',y="tip", data=tips, height=7)
plt.show()

• hue 옵션을 준 직선 그래프

# hue option 

sns.set_style("darkgrid")
sns.lmplot(x="total_bill", y="tip", data=tips, height=7, hue="smoker")
plt.show()

• heatmap을 이용하면 전체 경향을 알 수 있다

flights = sns.load_dataset("flights")
flights.head()
flights = sns.load_dataset("flights")
flights.head()

• annot : 안에 내용 적어줌

• fmt : d는 정수,f는 실수

# heatmap 
plt.figure(figsize=(10, 8))
sns.heatmap(flights, annot=True, fmt="d", cmap="YlGnBu")
plt.show()

• pariplot : 다수의 컬럼 비교

sns.set(style='ticks')   # 격자? 같은거 생성
iris = sns.load_dataset("iris")
sns.pariplot(iris)
plt.show()

# hue option 

sns.pairplot(iris, hue="species")
plt.show()

원하는 컬럼만 pariplot

# 원하는 컬럼만 pairplot 
sns.pairplot(iris, 
             x_vars=["sepal_width", "sepal_length"], 
             y_vars=["petal_width", "petal_length"])
plt.show()

anscombe = sns.load_dataset("anscombe")
sns.set_style("darkgrid")
sns.lmplot(x='x', y='y', data=anscombe.query("dataset == 'I'"), ci=None, size=7)
plt.show()

• order : 점에 따라 함수order 바꿈

• robust : 경향에서 많이 벗어난 아웃라이어는 무시

• ci : 신뢰구간선택 옵션

anscombe = sns.load_dataset("anscombe")
sns.set_style("darkgrid")
sns.lmplot(x='x', y='y', data=anscombe.query("dataset == 'II'"), ci=None,scatter_kws={"s":80},order=2, robust = True, size=7)
plt.show()