===========================ML 모델 만드는법 정의(학습용 데이터)====================================================

##머신러닝 모델 만드는 법.

1. 모듈들을 불러온다.
   import numpy as np
   import pandas as pd
   from sklearn.datasets import load_iris

2. 내가 만들고싶은 예측 모델의 모델이 될 붓꽃 정보를 불러온다.
   iris = load_iris()

3. 붓꽃 데이터 안에 어떤 정보들이 들었는지 확인한다.
   iris.keys()
   iris.data , iris.feature_names, iris.target, iris.target_names 등등

4.pd로 df를 만들어 데이터를 정형한다. 이때 종속변인은 컬럼에 들어오게 하고 독립변인은 인덱스와 컬럼의 내용이
되게 만들어준다.
iris_df = pd.DataFrame(iris.data, columns = iris.feature_names)
#여기서 iris.feature_names는 ML에게 학습시킬 iris.data의 이름이다.
이렇게 표가 만들어지고 나면 컬럼에 종속변인을 추가해준다. 그래서 데이터마다 어떤 종류의 종속변인인지
확인가능하게 해야한다.
iris_df['target']= iris.target

5. 데이터가 표로 정형 되었으면 각각다른 종속 변인마다 어떤 데이터가 있는지 한번씩 확인해준다.
   #여기선 붓꽃품종 0~2번까지 있는데 0번은 49번까지, 1번은 99번까지, 2번은 149번 까지 순서대로 나열되어있다.
   iris_df[:10], iris_df[50:60], iris_df[100:110]

6. 이제 학습(train) 데이터와 실전(test) 데이터로 쪼개준다.
   #쪼갤 데이터에는 붓꽃의 데이터(독립변인)와 종속변인이 들어가면 된다.
   #test_size를 안정해주면 default 값으로 0.25로 설정된다 3:1
   from sklearn.model_selection import train_test_split
   X_train, X_test, y_trian, y_test = train_test_split(iris.data, iris.target, stratify = iris.target,
   random_state = 11, test_size =0.2)

7. 자, 이제는 학습을 시킬 차례다. 멍청한 컴터야 일해라.

이렇게 학습시킨 값들을 predict를 통해서 예측할 수 있고 score를 통해 정확도를 측정 할 수 있다.

from sklearn.tree import DecisionTreeClassifier
dt_model = DecisionTreeClassifier(random_state = 11)
dt_model.fit(X_train, y_train)
dt_model.predict([[7.3, 2.9, 6.3, 1.8]])
dt_model.score(X_text, y_test)

======================================머신러닝 수업========================================

#보통 내장데이터 보다는 pd.load_csv로 데이터를 가져와서 df를 만든다.
#어제는 데이터가 완벽해서 데이터전처리를 안해줬다. (학습용 데이터)
#train과 test를 스플릿할때 stratify의 중요성을 알 수 있다. (골고루 학습 시키는 것.)
#정확도 측정할때 학습모델에서 100점이 나오면 오히려 의심 해봐야 한다. 과적합일 가능성이 크다.
( 그래서 보통 개발자들은 보통 학습 데이터와 실제 데이터를 다룰때 정확도 측정 시 2~3%오류가 적당하다고 봄.)

dt_model.score(X_train, y_train) (비교할때 학습모델과 실제 모델을 비교해주면 좋음. / 과적합 비교)
dt_model.score(X_test, y_test) (정확도를 측정하는 모델.)
//output 0.9333333333333333

^
| 둘 다 결과가 똑같음. 다른 형식으로 정확도를 측정 할 수 있음.
v

from sklearn.metrics import accuracy_score
accuracy_score(y_test, dt_model.predict(X_test))
//output 0.9333333333333333

##과적합##
#과대적합 - overfitting : 모델이 학습할 때, 훈련(train) 데이터에 과도하게 최적화되어
실제(test) 데이터 예측 성능이 과도하게 떨어지는 것.
#과소적합 - underfitting :

%p.92 싸이킷 런의 주요 모듈
Estimator : 판단기

회귀 : 연속적인 값이 나오는 자료
분류 : 판단을 할 수 있는 자료

%p.102
cv 값 : 5 (데이터 세트 수)

%p.110
cv 값 : 3 (데이터 세트 수)

%p.111 GridSearchCV - 교차검증과 최적 하이퍼 파라미터 튜닝을 한번에.
%p.116 데이터 전처리
ML 파이프라인

y_pred = dt_model.predict(X_test) (이렇게 X_test의 예측값과 y_test의 값을 비교해보고 무엇이)
y_pred.shape, y_pred, y_test 틀렸는지 볼 수 있음.
//output ↓ 예측 성공 갯수 / 테스트 데이터 갯수 = score
((30,),
array([2, 2, 1, 1, 2, 0, 1, 0, 0, 1, 1, 1, 1, 2, 2, 0, 2, 1, 2, 2, 1, 0,
0, 1, 0, 0, 2, 1, 0, 1]),
array([2, 2, 2, 1, 2, 0, 1, 0, 0, 1, 2, 1, 1, 2, 2, 0, 2, 1, 2, 2, 1, 0,
0, 1, 0, 0, 2, 1, 0, 1]))

iris.data[50:53] #1번라벨 어디에서 틀렸는지 직접 비교해보고 사람 눈으로 봤을때
iris.data[100:103] #2번라벨 헷갈릴만 하다고 생각하면 그냥 넘어가면? 됨.

%p.153 오차행렬 or 혼동행렬 (confusion matrix)
True 는 예측 성공 값
False 는 예측 실패 값.
FN = positive
정밀도 = TP / (FP + TP)
재현율 = TP / (FN + TP)
(정밀도와 재현율은 상호보완적인 관계이다.)
어느 한쪽의 수치를 높이면 다른 한쪽은 내려가기 때문에 양쪽 모두 결과를 보고 판단 하는게 맞다.

각 상황에 따라 어떤게 손실이 더 적을 지 생각해서 정밀도와 재현율을 선택 할 수 있다.

%p.181 분류(Classification)

%p.183 결정 트리 (Decision Tree)
#!pip install mglearn
import mglearn
mglearn.plots.plot_tree_progressive() (학습용 데이터를 트리 깊이에 따라 시각화 해서 보여줌.)
규칙노드는 계속 가지가 뻗어 감.
리프 노드는 트리의 끝임 (결정된 노드)
깊이가 깊어질수록 성능이 저하 될 가능성이 높다.
지니계수를 사용해서 균일도(스케일링)를 높일 수 있다.
트리 자체는 아주 좋은 툴이지만 과적합 때문에 혼자서는 잘 사용하지 않는다.
#트리의 크기를 사전에 제한하는 것 이 오히려 성능 튜닝에 더 도움이 됩니다.
#트리 능력을 개선할 수 있는 옵션 = max_depth

%p.188 결정트리 모델의 시각화
graphviz 설치 / 5.0.0 windows 버전
#!pip install graphviz
from sklearn.tree import export_graphviz (sklearn에서 tree모듈중에 그래프 비즈 임포트)

export_graphviz(dt_model, out_file ='dt_model_tree.dot', class_names=iris.target_names,
feature_names=iris.feature_names, impurity = True, filled=True)
#dt_model에 대하여 학습하는 ML을 시각화 해주겠다는 의미
#파일 이름을 dt_model_tree.dot 으로 저장 해주겠다.
#클래스 네임을 종속변인 붓꽃 품종으로 해주고, 피쳐 네임을 붓꽃의 각 피쳐 네임으로 해준다.

import graphviz (그래프 비즈 임포트)
with open('dt_model_tree.dot') as f: (아까 그래프비즈.dot 으로 문서화 해준걸 읽어준다.)
dg = f.read()
graphviz.Source(dg) (시각화 함수)

%p.208
dtmodel.feature_importances (어떤 feature을 주로 사용해서 예측모델을 만들었는가?)
//output ↓
array([0.02500521, 0. , 0.04867657, 0.92631822])
#sepal length를 2.5%정도 활용, sepal width를 0% 사용, petal length를 5%정도 활용,
#petal width를 93% 정도 활용.
(tree의 depth가 깊어질수록 다른 피쳐들 활용, 하지만 과적합 가능성이 늘어난다.)

#tree의 각 피쳐들의 활용률
import matplotlib.pyplot as plt
import seaborn as sns

irisimp = pd.Series(dt_model.feature_importances, index= iris.feature_names) (판다스 시리즈데이터로 만들어줌.)
plt.figure(figsize=(8,3))
plt.title('Feature importance of iris dataset') (타이틀 정해주기)
sns.barplot(x=iris_imp, y=iris_imp.index) (x는 독립변인 y는 종속변인)
plt.show()

%p.210 앙상블 학습 (오버피팅의 문제를 해결하는데에 앙상블의 역할이 가장 크다.(과소적합))
그래디언트 부스트(gradient boost)
랜덤 포레스트(random forest) - 병렬방식 (boosting)

앙상블 학습에는 대표적으로 보팅, 배깅, 부스팅 3가지가 있다.
voting 학습방법 : 다수의 여러 ML모델들을 사용해서 각각 모델의 예측값을 모아서 최종예측값을 결정하는 것.
bagging 방식 : 학습 데이터를 다르게 해서 학습시킨뒤 보팅 방법으로 최종예측값을 결정한다.
boosting 방식 : 활용하는 데이터중에서 그 데이터들을 중첩시키면서 순차적으로 학습시킨다.
그 다음에 중복된 값에 대해서는 가중치를 더해주면서 결과값을 출력해주기 때문에
부스팅 방식이라고 불린다.
대표적으로 사용하는 부스팅 방식 - XGBoost(eXtra Gradient Boost), LightGBM(Light Gradient Boost)

%p.212 하드보팅, 소프트보팅
하드 보팅 : 1과 3중에 다수의 선택일 경우에만 결과값으로 출력함, 선택을 못받으면 소외됨.
소프트 보팅 : 모두의 결과를 평균치로 계산하고 그 평균치끼리 비교해서 출력해줌 (하드보팅보다 예측정확도 높음)

%p.350 로지스틱 리그레션 (LogisticRegression) - 이름은 회귀인데 분류기로 들어감. (분류장치)
%p.214 앙상블 학습 (로지스틱 리그레션, KNN)
from sklearn.linear_model import LogisticRegression
lr_model = LogisticRegression(solver = 'liblinear') (로지스틱리그레션 객체)
knn_model = KNeighborsClassifier(n_neighbors = 8)
X_train, X_test, y_train, y_test = train_test_split(cancer.data, cancer.target,
testsize=0.2, randomstate = 156)

knn_model.fit(X_train, y_train)
knn_model.score(X_train, y_train), knn_model.score(X_test, y_test)
(knn 모델의 스코어를 측정)

lr_model.fit(X_train, y_train)
lr_model.score(X_train, y_train), lr_model.score(X_test, y_test)
(lr 모델의 스코어를 측정)

from sklearn.ensemble import VotingClassifier (앙상블에서 보팅분류기 임포트)
vo_hard_model = VotingClassifier(estimators = [('LR', lr_model),('KNN', knn_model)])
vo_soft_model = VotingClassifier(estimators = [('LR', lr_model),('KNN', knn_model)],
voting ='soft')
#voting의 default값은 'hard'
#이름을 LR로 하고 lr_model과 이름을 KNN으로 하고 knn_model을 보팅분류기로 앙상블 해주겠다.

vo_hard_model.fit(X_train, y_train)
vo_soft_model.fit(X_train, y_train)

vo_hard_model.score(X_train, y_train), vo_hard_model.score(X_test, y_test) (하드가 정확도가 낮게나옴)
vo_soft_model.score(X_train, y_train), vo_soft_model.score(X_test, y_test) (소프트가 정확도가 젤 높음.)

%p.216 랜덤포레스트
from sklearn.ensemble import RandomForestClassifier
from sklearn.datasets import make_moons (moons인 이유는 초승달 두개가 포개진 모양)

X, y= make_moons(n_samples = 100, noise = 0.25, random_state = 3)
mglearn.discrete_scatter(X[:,0], X[:,1], y)
plt.show()

#랜덤 포레스트의 활동을 시각화 해서 관찰하기.
forest_model = RandomForestCla(ssifier(n_estimators =5, random_state = 2)
forest_model.fit(X, y) (랜덤포레스트 모델 학습)

fig, axes = plt.subplots(2,3, figsize = (20,10))
for i, (ax,tree) in enumerate(zip(axes.ravel(), forestmodel.estimators)):
ax.set_title(f'{i}th Tree') (for 문을 이용해서 각 fig에 넣어주면 된다)
mglearn.plots.plot_tree_partition(X, y, tree, ax=ax)
mglearn.plots.plot_2d_separator(forest_model, X, fill =True, ax= axes[-1,-1], alpha = 0.4)
plt.show()

#######데이터 셋 학습 정확도 ######

content = [[knn_model.score(X_train, y_train), knn_model.score(X_test, y_test)],
[lr_model.score(X_train, y_train),lr_model.score(X_test, y_test)],
[vo_hard_model.score(X_train, y_train),vo_hard_model.score(X_test, y_test)],
[vo_soft_model.score(X_train, y_train),vo_soft_model.score(X_test, y_test)]]
df = pd.DataFrame(content, index =['knn_model', 'lr_model', 'hard', 'soft'], columns = ['train','test'])
df
//output ↓
train test
knn_model 0.938462 0.938596
lr_model 0.956044 0.947368
hard 0.942857 0.929825
soft 0.951648 0.956140

============================ML 모듈 ===========================================

!!# dt모듈
from sklearn.tree import DecisionTreeClassifier

!!# knn모듈
from sklearn.neighbors import KNeighborsClassifier
knn_model = KNeighborsClassifier(n_neighbors = 3)

#mse = mean_squared_error 실업에서는 mse로 회귀분석을 한다.
r2는 r의 제곱이라는 뜻으로 r2라는값은 분류에서 정확도와 비슷한 양상을 가진다.

#비선형 그래프의 안쪽 그래프를 맞춰주는걸 내삽한다고 하고 바깥쪽에 있는 그래프를 맞춰주는걸 내삽이라고 한다.
데이터가 그래프의 바깥쪽으로 나가면 예측을 할 수 없다. (이럴땐 비선형이 효율이 떨어진다.)

#분류에 대해서는 수학적이냐 수학적이지 않느냐로 나눌 수 있고
회귀에서는 선형이냐 비선형이냐가 나뉠 수 있겠다.

#프로젝트 규모가 너무 커서 안끝날 것 같으면 주제를 축소 해야한다.

다음 수업은 스파크 언어로 진행된다.

#나중에 딥러닝 할때 실험을 위해서 '구글 터처블'을 사용하면 좋다.

#프로젝트때 데이터 수집할때 라벨을 구하기 어려우면 클러스터 방식을 사용하는것도 하나의 방법이다.

#회귀 같은 경우는 중고폰이나 중고차 거래 사이트에 가서 어떤 조건에 얼마더라 하는걸 모아서 내놓을 수 있음.
#분류 데이터는 진짜 찾기 힘듦, 하려면 노가다 해야함.

#회귀 할때는 거의 LinearRegression으로 분석 하고 ridge나 lasso 알파 값을 줘서 오버피팅을 피해볼 수도 있다.
================================머신러닝:회귀=====================================

%p.338 릿지 회귀
ridge_model_over1= Ridge(alpha = 100000000000000)
ridge_model_over2= Ridge(alpha = 0.000000001) (알파값이 회귀에 대한 규제임.)
(r2값이 1에 가까울 수록 정확도가 높은건데 규제가 높으면
릿지회귀 모델이 학습을 잘 못함)
ridge_model_over1.fit(X_train, y_train) (데이터의 차원이 높을수록 오버피트가 나기 쉬움.)
ridge_model_over2.fit(X_train, y_train) (alpha값을 낮췄을 때.)

y_pred = ridge_model_over1.predict(X_test)
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse) (규제를 강하게 걸었을때 - 모든 기능이 다 수치가 떨어짐)
r2 = r2_score(y_test, y_pred)
mse, rmse, r2

y_pred = ridge_model_over2.predict(X_test)
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
r2 = r2_score(y_test, y_pred) (규제를 풀었을때는 학습이 수월하게 잘 된걸 확인 가능.)
mse, rmse, r2

import warnings (워닝이 자꾸 나와서 거슬릴때 워닝을 꺼줄 수 있음.)
warnings.filterwarnings(action ='ignore')

%p.342 라쏘 회귀
from sklearn.linear_model import Lasso, ElasticNet (엘라스틱넷은 L1,L2규제를 반반 섞어서 사용하는 것.)

lasso_model_1= Lasso(alpha = 1) (라쏘도 릿지와 마찬가지로 규제를 쎄게주면 정확도가 낮아지고)
lasso_model_1.fit(X_train, y_train) (규제를 풀어주면 오버피트가 날 수 있다.)

y_pred = lasso_model_1.predict(X_test) (보통 규제도 L1을 많이 사용한다.)
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
r2 = r2_score(y_test, y_pred)
mse, rmse, r2

%p.350 로지스틱 회귀- LogisticRegression(LR) (분류에 적합함. 이름만 회귀임)
직선인 함수를 휘게 하는게 중요함. (LR은 보통 분류에서 많이 쓰임)

==============================비 선형 회귀 : KNN, tree======================================

#KNN Regression
mglearn.plots.plot_knn_regression(n_neighbors=1)
(n_neighbors= n 이 다수일 경우에 y값의 위치를 가지고 평균으로 구해주면됨)

from sklearn.neighbors import KNeighborsRegressor
X, y = mglearn.datasets.make_wave(n_samples=40)
X_train, X_test, y_train, y_test = train_test_split(X,y , random_state = 11)
knn_reg_model = KNeighborsRegressor(n_neighbors=3)
knn_reg_model.fit(X_train, y_train)
y_pred = knn_reg_model.predict(X_test)
r2 = r2_score(y_test, y_pred)
r2

#직선은 뻣뻣 했는데 knn 모델은 각 별의좌표마다 가까운 것에 표적을 두기 때문에 스코어가 잘 나옴.

fig, axes = plt.subplots(1,3, figsize = (15,4))
line = np.linspace(-3,3,1000).reshape(-1,1)
for n_neighbors, ax in zip([1,3,9], axes): (n_neighbors가 1,3,9를따라가면서 피팅 함.)
reg_model = KNeighborsRegressor(n_neighbors=n_neighbors)
reg_model.fit(X_train, y_train)
ax.plot(line, reg_model.predict(line))
ax.plot(X_train, y_train, '^r')
ax.plot(X_test, y_test, 'vb')
plt.show()
#어떤 식으로 knn이 작동하는지 시각화로 보여준 것.

1번째 그래프는 오버피팅 됐음.

2번째 그래프는 과적합을 그래도 피하려고 노력한 모습이 보임

3번째 그래프는 선형회귀와 비슷하게 큰 그림을 쫒아가는 모습을 보여줌

%p.355 회귀 트리 (비선형 방식이라 유연해서 정확도가 높게나옴.)
from sklearn.ensemble import RandomForestRegressor
mpg_df_no_na = mpg_df.dropna(axis=0)
y = mpg_df_no_na["mpg"].to_numpy()
X = mpg_df_no_na.drop(['mpg', 'origin', 'name'], axis=1)
X = X.to_numpy()

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

rf_model_mpg = RandomForestRegressor()
rf_model_mpg.fit(X_train, y_train)

y_pred = rf_model_mpg.predict(X_test)
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
r2 = r2_score(y_test, y_pred)
mse, rmse, r2, rf_model_mpg.score(X_train,y_train), rf_model_mpg.score(X_test,y_test)

============================경제지표확인 : 로그함수이용 ======================
import os
ram_price = pd.read_csv(os.path.join(mglearn.datasets.DATA_PATH, 'ram_price.csv'))
plt.semilogy(ram_price['price']) #세미로그 와이

#렘의 가격에 대한 연도별 가격차이를 시각화 해서 나타내줌, 그냥 나타내면 너무 급격하게 떨어져서
그래프가 완전 'ㄴ'자로 꺾여서 보이기 때문에 로그를 씌워줘서 볼만하게 만들어준다.

#이제 이 시계열 데이터를 가지고 회귀 분석을 해서 미래 동향을 예측ㅎ ㅐ본다.
data_train = ram_price[ram_price.date < 2000]
data_test = ram_price[ram_price.date > 2000]
X_train = data_train.date.to_numpy()[:,np.newaxis] (리그레서 모델이 다차원을 요구하기 때문에)
Y_train = np.log(data_train.price) (차원을 하나 더 만들어줬음. - date는 1차원)
tree_model = RandomForestRegressor().fit(X_train, y_train) (각각 트리모델과 lr 모델로 학습시켜줌)
linear_model = LinearRegressoin().fit(X_train, y_train)

#np.newaxis = [1,2,3] -> [[1,2,3]] 으로 변환 해줌.

X_all = ram_price.date.to_numpy()[:,np.newaxis] (모든 date에 대하여 X_all로 묶어줌)
y_pred_tr = tree_model.predict(X_all) (모든date에 대해 예측 해준다.)
y_pred_lr = linear_model.predict(X_all)

price_tr = np.exp(y_pred_tr) (로그를 지수로 변환 해주는 식)
price_lr = np.exp(y_pred_lr)

plt.semilogy(data_train.date, data_train.price, label='train_data') (2000년 이전까지의 램가격)
plt.semilogy(data_test.date, data_test.price, label='test_data') (2000년 이후의 램가격)
plt.semilogy(ram_price.date, price_tr, label='regression by tree') (tree모델 예측)
plt.semilogy(ram_price.date, price_lr, label='regression by linear') (linear모델 예측)
plt.legend
plt.show()

#트리모델은 내삽은 잘되는데 외삽이 안되어서 2000년 이후 램 가격에 대해 예측 해달라고 하면
할수가 없다.

==========================차원축소=========================================
#우리는 눈뜬 장님이다. (ex. 장님 코끼리 만지기.)
#우리가 여러 칼럼을 보고 분석하는 이유 : 코끼리의 몸 각 부분들을 만져보면서 분석하는 것임.
#우리가 해야 할 역할 : 좋은 칼럼을 선정해야함.
#다리, 귀, 꼬리, 어금니 ...
#왼쪽 앞다리, 오른쪽 앞다리, 왼쪽 뒷다리, 오른쪽 뒷다리 <- 이것만 가지고는 코끼리인지 알 수 없음.

%p.401 차원축소 PCA (Principal Component Analysis)
주성분 : 가장 높은 분산을 가지는 데이터의 축을 찾아서 그 축으로 차원을 축소하는데 그것이 PCA의 주성분임.
기존 칼럼이 2개가 있었다면 1개의 중요 성분으로 압축해서 추출하는 것. (수학적)

import mglearn
mglearn.plots.plot_pca_illustration() (차원축소를 시각화 해서 설명한 것)

================================ 군집화 : 비지도학습 ========================================

%p.431 군집화 (땅따먹기 게임같음.)
k- means

import mglearn
mglearn.plots.plot_kmeans_algorithm() (군집화를 시각화 한 것.)

%p.432 iris군집화.
from sklearn.datasets import load_iris
import pandas as pd

iris = loadiris()
irisDF = pd.DataFrame(iris.data, columns = iris.feature_names)
from sklearn.cluster import KMeans
kmeans_model = KMeans(n_clusters = 3, random_state = 0) (클러스터를 3개를 주겠다는 뜻.)
kmeans_model.fit(irisDF) (여기서는 iris품종이 3개이기 때문.)
kmeans_model.labels (라벨을 확인해주는데 라벨 순서가 바뀔 수도 있음. - 군집화 때문에)
(그냥 타겟 번호를 무시하고 kmeans가 다시 군집화 이름을 지어준거임.)

%p.432 실루엣 분석

from sklearn.datasets import make_blobs
import matplotlib.pyplot as plt

X, y = make_blobs(random_state=1)
plt.scatter(X[:,0],X[:,1]) (mglearn말고 plt를 자주써야함.)
plt.show()

kmeans3 = KMeans(n_clusters= 3)
kmeans_3.fit(X) (비지도학습은 라벨이 없어서 X하나만 넣으면 된다.)
kmeans_3.labels

mglearn.discretescatter(X[:,0],X[:,1], kmeans_3.labels) (클러스터 시각화.)
plt.show()

%p.446 실루엣 그래프
그래프 안에서 각 요소별로 높이 폭이 일정하면 제일 좋은 군집화 예시이다.

%p.463 DBSCAN
kmeans = KMeans(n_clusters = 2)
kmeans.fit(X)
y_pred = kmeans.predict(X)

plt.scatter(X[:,0],X[:,1], c=y_pred) (클러스터들이 땅따먹기를 하다보니까 우리가 생각했던 군집화와)
plt.show() (모양이 많이 다름.)

from sklearn.cluster import DBSCAN
db = DBSCAN(eps=0.2) (eps는 거리인데 각 초승달간의 제일 가까운 거리를 찾아서 입력해줘야 함.)
y_pred = db.fit_predict(X) (각 군집화끼리의 거리가 0.2보다 크면 다른 군집군으로 분류)
plt.scatter(X[:,0],X[:,1], c=y_pred)
plt.show()

=============================== 텍스트분석 =======================================

%p.488 텍스트분석
피쳐 백터화 : 텍스트를 숫자로 표현 하는 것.
I love you 1 2 3
you love me 3 2 4
I love doge 1 2 5

!pip install nltk (텍스트 분석 모델 install)

from nltk import sent_tokenize
import nltk
nltk.download('punkt')

text_sample = '''
This logo image consists only of simple geometric shapes or text.
It does not meet the threshold of originality needed for copyright protection,
and is therefore in the fucking public domain. Although it is free of copyright restrictions,
this image may still be subject to other restrictions. fucking ass hole.
See WP:PD#Fonts and typefaces or Template talk:PD-textlogo for more information.
'''

sentenses = sent_tokenize(text_sample) (문장별로 토큰화 해주겠다.)
type(sentenses), len(sentenses), sentenses

from nltk import word_tokenize
words = word_tokenize(text_sample) (단어별로 토큰화 해주겠다.)
type(words), len(words), words

#english, german, french
nltk.download('stopwords') (stopword 기능을 가져오겠다.)
len(nltk.corpus.stopwords.words('english')) 179개의 금지어 있음.
(corpus는 말뭉치라는 뜻임.)

eng_stopwords = nltk.corpus.stopwords.words('english')
my_stop_words = eng_stopwords.copy() (기존 금지어에서 카피해서 내 금지어에 추가)
my_stop_words.append('ass') (금지어 추가해주기.)
my_stop_words.append('hole')
my_stop_words.append('fucking')
all_token = []

for word in words:
word = word.lower() (꼭 소문자화 해줘야함.)
if word not in my_stop_words:
all_token.append(word) (각 word마다 금지어 필터링해서 올 토큰에 어펜드)
len(all_token), all_token

============================== bag of words ==============================================

%p.498 단어의 백터화.
자주 나오는 단어들에 가중치 부여.
tf-idf & CountVectorizer

%p.509 텍스트 분류 실습 - 뉴스그룹 분류

from sklearn.datasets import fetch_20newsgroups
news_data = fetch_20newsgroups(subset = 'all', random_state = 156) (subset= all 은 모든 데이터를 가져옴)
news_data.keys() (저 데이터그룹 안에 test와 train이 있음.)

train_news = fetch_20newsgroups(subset = 'train', (텍스트 비지도는 따로 test_size 해줄 필요가 없다.)
remove=('headers', 'footers', 'quotes'),
random_state = 156)
X_train = train_news.data
y_train = train_news.target

test_news = fetch_20newsgroups(subset = 'test',
remove=('headers', 'footers', 'quotes'),
random_state = 156)
X_test = test_news.data
y_test = test_news.target (알아서 잘 만들어 줌.)

len(X_train), len(X_test)