# 데이터베이스 만들기
CREATE DATABASE pokemon;
# 데이터베이스 목록 보기
SHOW DATABASES;
# 데이터베이스 사용하기
USE pokemon;
4. 테이블 쿼리문법
- 테이블 만들기
# 테이블 만들기
CREATE TABLE idol(
name VARCHAR(20),
age INT,
group VARCAHR(50)
);
# 새로운 컬럼 추가하기
ALTER TABLE idols ADD COLUMN age INT;
# 기존 컬럼 타입 변경하기
ALTER TABLE idols MODIFY COLUMN age FLOAT;
# 기존 컬럼 이름과 타입 변경하기
ALTER TABLE idols
CHANGE COLUMN age new_age FLOAT;
# 데이터베이스 지우기
DROP DATABASE pokemon
# 테이블 지우기
DROP TABLE idols;
# 테이블 값만 지우기
TRUNCATE TABLE idols;
# 컬럼 지우기
ALTER TABLE idols DROP COLUMN new_age;
# 데이터베이스/테이블이 존재한다면 지우기
DROP DATABASE IF EXISTS pokemon;
DROP TABLE IF EXISTS idols;
5. 데이터 삽입, 삭제 수정하기
# 데이터 하나 삽입하기
INSERT INTO idol (name, age, group)
VALUES ('제니', 27, '블랙핑크');
# 데이터 여러개 삽입하기
INSERT INTO idol (name, age, group)
VALUES ('제니', 27, '블랙핑크'),
('지수', 28, '블랙핑크');
# 데이터 삭제하기
DELETE FROM [테이블 이름]
WHERE [조건 값];
# 데이터 수정하기
UPDATE [테이블 이름]
SET [컬럼 이름] = [새 값]
WHERE [조건 값];
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from sklearn.naive_bayes import GaussianNB, BernoulliNB, MultinomialNB
from sklearn.datasets import fetch_covtype, fetch_20newsgroups
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler, MinMaxScaler
from sklearn.feature_extraction.text import CountVectorizer, HashingVectorizer, TfidfVectorizer
from sklearn import metrics
#In[]
#나이브 베이스 기본 동작 모형
prior = [0.45, 0.3, 0.15, 0.1] #발생확률 가정
likelihood = [[0.3, 0.3, 0.4], [0.7, 0.2, 0.1], [0.15, 0.5, 0.35], [0.6,0.2,0.2]]
idx = 0
for c, xs in zip(prior, likelihood):
result = 1.
for x in xs :
result *= x
result *= c
idx += 1
print(f"{idx}번째 클래스의 가능성 : {result}")
#Out[]
1번째 클래스의 가능성 : 0.0162
2번째 클래스의 가능성 : 0.0042
3번째 클래스의 가능성 : 0.0039375
4번째 클래스의 가능성 : 0.0024000000000000002
#In[]
covtype = fetch_covtype()
print(covtype.DESCR)
#Out[]
.. _covtype_dataset:
Forest covertypes
-----------------
The samples in this dataset correspond to 30×30m patches of forest in the US,
collected for the task of predicting each patch's cover type,
i.e. the dominant species of tree.
There are seven covertypes, making this a multiclass classification problem.
Each sample has 54 features, described on the
`dataset's homepage <https://archive.ics.uci.edu/ml/datasets/Covertype>`__.
Some of the features are boolean indicators,
while others are discrete or continuous measurements.
**Data Set Characteristics:**
================= ============
Classes 7
Samples total 581012
Dimensionality 54
Features int
================= ============
:func:`sklearn.datasets.fetch_covtype` will load the covertype dataset;
it returns a dictionary-like 'Bunch' object
with the feature matrix in the ``data`` member
and the target values in ``target``. If optional argument 'as_frame' is
set to 'True', it will return ``data`` and ``target`` as pandas
data frame, and there will be an additional member ``frame`` as well.
The dataset will be downloaded from the web if necessary.
#In[]
covtype_X = covtype.data
covtype_y = covtype.target
covtype_X_train, covtype_X_test, covtype_y_train, covtype_y_test = train_test_split(covtype_X, covtype_y, test_size=0.2)
print("전체 데이터 크기 : {}".format(covtype_X.shape))
print("학습 데이터 크기 : {}".format(covtype_X_train.shape))
print("평가 데이터 크기 : {}".format(covtype_X_test.shape))
#Out[]
전체 데이터 크기 : (581012, 54)
학습 데이터 크기 : (464809, 54)
평가 데이터 크기 : (116203, 54)
#In[]
hash_vectorizer = HashingVectorizer(n_features=1000) #1000개로 제한
X_train_hash = hash_vectorizer.fit_transform(X_train)
X_test_hash = hash_vectorizer.transform(X_test)
X_train_hash
#Out[]
<11314x1000 sparse matrix of type '<class 'numpy.float64'>'
with 1550687 stored elements in Compressed Sparse Row format>
import pandas as pd
import numpy as np
import multiprocessing
import matplotlib.pyplot as plt
plt.style.use(['seaborn-whitegrid'])
from sklearn.neighbors import KNeighborsClassifier, KNeighborsRegressor
from sklearn.manifold import TSNE
from sklearn.datasets import load_iris, load_breast_cancer
from sklearn.datasets import load_boston, fetch_california_housing
from sklearn.model_selection import train_test_split, cross_validate, GridSearchCV
from sklearn.preprocessing import StandardScaler
from sklearn.pipeline import make_pipeline, Pipeline
#In[]
print("학습 데이터 점수 : {}".format(model.score(X_train, y_train)))
print("평가 데이터 점수 : {}".format(model.score(X_test, y_test)))
학습 데이터 점수 : 0.9583333333333334
평가 데이터 점수 : 1.0
데이터 전처리후 점수
#In[1]
model = KNeighborsClassifier()
model.fit(X_train_scale, y_train)
#Out[1]
KNeighborsClassifier()
#In[2]
print("학습 데이터 점수 : {}".format(model.score(X_train_scale, y_train)))
print("평가 데이터 점수 : {}".format(model.score(X_test_scale, y_test)))
#Out[2]
학습 데이터 점수 : 0.9583333333333334
평가 데이터 점수 : 0.9666666666666667
#In[1]
scaler = StandardScaler()
X_train_scale = scaler.fit_transform(X_train)
X_test_scale = scaler.transform(X_test)
model = KNeighborsClassifier()
model.fit(X_train, y_train)
#Out[1]
#In[2]
print("학습 데이터 점수 : {}".format(model.score(X_train, y_train)))
print("평가 데이터 점수 : {}".format(model.score(X_test, y_test)))
#Out[2]
학습 데이터 점수 : 0.9516483516483516
평가 데이터 점수 : 0.9035087719298246
#In[1]
model = KNeighborsClassifier()
model.fit(X_train_scale, y_train)
#Out[1]
KNeighborsClassifier()
#In[2]
print("학습 데이터 점수 : {}".format(model.score(X_train_scale, y_train)))
print("평가 데이터 점수 : {}".format(model.score(X_test_scale, y_test)))
#Out[2]
학습 데이터 점수 : 0.978021978021978
평가 데이터 점수 : 0.9473684210526315
#In[1]
scaler = StandardScaler()
X_train_scale = scaler.fit_transform(X_train)
X_test_scale = scaler.transform(X_test)
model = KNeighborsRegressor()
model.fit(X_train, y_train)
#Out[1]
KNeighborsRegressor()
#In[2]
print("학습 데이터 점수 : {}".format(model.score(X_train, y_train)))
print("평가 데이터 점수 : {}".format(model.score(X_test, y_test)))
#Out[2]
학습 데이터 점수 : 0.6850536552455034
평가 데이터 점수 : 0.44632061414558033
#In[1]
model = KNeighborsRegressor()
model.fit(X_train_scale, y_train)
#Out[1]
KNeighborsRegressor()
#In[2]
print("학습 데이터 점수 : {}".format(model.score(X_train_scale, y_train)))
print("평가 데이터 점수 : {}".format(model.score(X_test_scale, y_test)))
#Out[2]
학습 데이터 점수 : 0.8399528467697587
평가 데이터 점수 : 0.7240482286290111
클래스 사이의 경계에 위치한 데이터 포인트를 서포트 벡터(support vector)라고 함
각 지지 벡터가 클래스 사이의 결정 경계를 구분하는데 얼마나 중요한지를 학습
각 지지 벡터 사이의 마진이 가장 큰 방향으로 학습
지지 벡터 까지의 거리와 지지 벡터의 중요도를 기반으로 예측을 수행
H3은 두 클래스의 점들을 제대로 분류하고 있지 않음
H1과 H2는 두 클래스의 점들을 분류하는데, H2가 H1보다 더 큰 마진을 갖고 분류하는 것을 확인할 수 있음
import multiprocessing
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
plt.style.use(['seaborn-whitegrid'])
from sklearn.svm import SVR, SVC
from sklearn.datasets import load_boston, load_diabetes
from sklearn.datasets import load_breast_cancer, load_iris, load_wine
from sklearn.pipeline import make_pipeline, Pipeline
from sklearn.model_selection import train_test_split, cross_validate, GridSearchCV
from sklearn.preprocessing import StandardScaler, MinMaxScaler
from sklearn.manifold import TSNE
SVM을 이용한 회귀 모델과 분류 모델
SVM을 사용한 회귀 모델 (SVR)
#In[]
X, y = load_boston(return_X_y=True)
X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=123)
model = SVR()
model.fit(X_train, y_train)
print("학습 데이터 점수 : {}".format(model.score(X_train, y_train)))
print("평가 데이터 점수 : {}".format(model.score(X_test, y_test)))
#Out[]
학습 데이터 점수 : 0.2177283706374875
평가 데이터 점수 : 0.13544178468518187
SVM을 사용한 분류 모델 (SVC)
#In[]
X, y = load_breast_cancer(return_X_y=True)
X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=123)
model = SVC()
model.fit(X_train, y_train)
print("학습 데이터 점수 : {}".format(model.score(X_train, y_train)))
print("평가 데이터 점수 : {}".format(model.score(X_test, y_test)))
#Out[]
학습 데이터 점수 : 0.9014084507042254
평가 데이터 점수 : 0.9230769230769231
커널 기법
입력 데이터를 고차원 공간에 사상해서 비선형 특징을 학습할 수 있도록 확장하는 방법
scikit-learn에서는 Linear, Polynomial, RBF(Radial Basis Function)등 다양한 커널 기법을 지원
#In[]
X, y = load_boston(return_X_y=True)
X_train, X_test, y_train, y_test = train_test_split(X,y,random_state=123)
linear_svr = SVR(kernel='linear')
linear_svr.fit(X_train, y_train)
print('Linear SVR 학습 데이터 점수 : {}'.format(linear_svr.score(X_train, y_train)))
print('Linear SVR 평가 데이터 점수 : {}'.format(linear_svr.score(X_test, y_test)))
print()
polynomial_svr = SVR(kernel='poly')
polynomial_svr.fit(X_train, y_train)
print('Polynomial SVR 학습 데이터 점수 : {}'.format(polynomial_svr.score(X_train, y_train)))
print('Polynomial SVR 평가 데이터 점수 : {}'.format(polynomial_svr.score(X_test, y_test)))
print()
rbf_svr = SVR(kernel='rbf')
rbf_svr.fit(X_train, y_train)
print('RBF SVR 학습 데이터 점수 : {}'.format(rbf_svr.score(X_train, y_train)))
print('RBF SVR 평가 데이터 점수 : {}'.format(rbf_svr.score(X_test, y_test)))
#Out[]
Linear SVR 학습 데이터 점수 : 0.715506620496448
Linear SVR 평가 데이터 점수 : 0.6380398541506058
Polynomial SVR 학습 데이터 점수 : 0.2024454261446289
Polynomial SVR 평가 데이터 점수 : 0.133668450367462
RBF SVR 학습 데이터 점수 : 0.2177283706374875
RBF SVR 평가 데이터 점수 : 0.13544178468518187
#In[]
X, y = load_breast_cancer(return_X_y=True)
X_train, X_test, y_train, y_test = train_test_split(X,y,random_state=123)
linear_svc = SVC(kernel='linear')
linear_svc.fit(X_train, y_train)
print('Linear SVC 학습 데이터 점수 : {}'.format(linear_svc.score(X_train, y_train)))
print('Linear SVC 평가 데이터 점수 : {}'.format(linear_svc.score(X_test, y_test)))
print()
polynomial_svc = SVC(kernel='poly')
polynomial_svc.fit(X_train, y_train)
print('Polynomial SVC 학습 데이터 점수 : {}'.format(polynomial_svc.score(X_train, y_train)))
print('Polynomial SVC 평가 데이터 점수 : {}'.format(polynomial_svc.score(X_test, y_test)))
print()
rbf_svc = SVC(kernel='rbf')
rbf_svc.fit(X_train, y_train)
print('RBF SVC 학습 데이터 점수 : {}'.format(rbf_svc.score(X_train, y_train)))
print('RBF SVC 평가 데이터 점수 : {}'.format(rbf_svc.score(X_test, y_test)))
#Out[]
Linear SVC 학습 데이터 점수 : 0.960093896713615
Linear SVC 평가 데이터 점수 : 0.986013986013986
Polynomial SVC 학습 데이터 점수 : 0.9014084507042254
Polynomial SVC 평가 데이터 점수 : 0.9230769230769231
RBF SVC 학습 데이터 점수 : 0.9014084507042254
RBF SVC 평가 데이터 점수 : 0.9230769230769231
매개변수 튜닝
SVM은 사용하는 커널에 따라 다양한 매개변수 설정 가능
매개변수를 변경하면서 성능변화를 관찰
#In[]
X, y = load_breast_cancer(return_X_y=True)
X_train, X_test, y_train, y_test = train_test_split(X,y,random_state=123)
polynomial_svc = SVC(kernel='poly', degree=2, C=0.1, gamma='auto')
polynomial_svc.fit(X_train, y_train)
print("kernel=poly, degree={}, C={}, gamma={}".format(2, 0.1, 'auto'))
print('Polynomial SVC 학습 데이터 점수 : {}'.format(polynomial_svc.score(X_train, y_train)))
print('Polynomial SVC 평가 데이터 점수 : {}'.format(polynomial_svc.score(X_test, y_test)))
#Out[]
kernel=poly, degree=2, C=0.1, gamma=auto
Polynomial SVC 학습 데이터 점수 : 0.9835680751173709
Polynomial SVC 평가 데이터 점수 : 0.993006993006993
#In[]
rbf_svc = SVC(kernel='rbf', C=2.0, gamma='scale')
rbf_svc.fit(X_train, y_train)
print("kernel=poly, C={}, gamma={}".format(2.0, 'scale'))
print('RBF SVC 학습 데이터 점수 : {}'.format(rbf_svc.score(X_train, y_train)))
print('RBF SVC 평가 데이터 점수 : {}'.format(rbf_svc.score(X_test, y_test)))
#Out[]
kernel=poly, C=2.0, gamma=scale
RBF SVC 학습 데이터 점수 : 0.9154929577464789
RBF SVC 평가 데이터 점수 : 0.9370629370629371
데이터 전처리
SVM은 입력 데이터가 정규화 되어야 좋은 성능을 보임
주로 모든 특성 값을 [0, 1] 범위로 맞추는 방법을 사용
scikit-learn의 StandardScaler 또는 MinMaxScaler를 사용해 정규화
#In[]
X, y = load_breast_cancer(return_X_y=True)
X_train, X_test, y_train, y_test = train_test_split(X,y,random_state=123)
model = SVC()
model.fit(X_train, y_train)
print('SVC 학습 데이터 점수 : {}'.format(model.score(X_train, y_train)))
print('SVC 평가 데이터 점수 : {}'.format(model.score(X_test, y_test)))
#Out[]
SVC 학습 데이터 점수 : 0.9014084507042254
SVC 평가 데이터 점수 : 0.9230769230769231
전처리후 (StandardScaler)
#In[]
scaler = StandardScaler()
X_train = scaler.fit_transform(X_train)
X_test = scaler.transform(X_test)
model = SVC()
model.fit(X_train, y_train)
print('SVC 학습 데이터 점수 : {}'.format(model.score(X_train, y_train)))
print('SVC 평가 데이터 점수 : {}'.format(model.score(X_test, y_test)))
#Out[]
SVC 학습 데이터 점수 : 0.9835680751173709
SVC 평가 데이터 점수 : 0.986013986013986
전처리후 (MinMaxScaler)
#In[]
scaler = MinMaxScaler()
X_train = scaler.fit_transform(X_train)
X_test = scaler.transform(X_test)
model = SVC()
model.fit(X_train, y_train)
print('SVC 학습 데이터 점수 : {}'.format(model.score(X_train, y_train)))
print('SVC 평가 데이터 점수 : {}'.format(model.score(X_test, y_test)))
#Out[]
SVC 학습 데이터 점수 : 0.9812206572769953
SVC 평가 데이터 점수 : 0.986013986013986
#In[]
print('SVC 학습 데이터 점수 : {}'.format(model.score(X_train, y_train)))
print('SVC 평가 데이터 점수 : {}'.format(model.score(X_test, y_test)))
#Out[]
SVC 학습 데이터 점수 : 0.7049306073822006
SVC 평가 데이터 점수 : 0.7305576277109267
#In[]
print('SVC 학습 데이터 점수 : {}'.format(model.score(X_train, y_train)))
print('SVC 평가 데이터 점수 : {}'.format(model.score(X_test, y_test)))
#Out[]
SVC 학습 데이터 점수 : 0.6785031123396097
SVC 평가 데이터 점수 : 0.6548972350224054
#In[]
print('SVC 학습 데이터 점수 : {}'.format(model.score(X_train, y_train)))
print('SVC 평가 데이터 점수 : {}'.format(model.score(X_test, y_test)))
#Out[]
SVC 학습 데이터 점수 : 0.989010989010989
SVC 평가 데이터 점수 : 0.956140350877193
#In[]
print('SVC 학습 데이터 점수 : {}'.format(model.score(X_train, y_train)))
print('SVC 평가 데이터 점수 : {}'.format(model.score(X_test, y_test)))
#Out[]
SVC 학습 데이터 점수 : 0.989010989010989
SVC 평가 데이터 점수 : 0.9473684210526315
로지스틱 회귀는 이름에 회귀라는 단어가 들어가지만, 가능한 클래스가 2개인 이진 분류를 위한 모델
로지스틱 회귀의 예측 함수 정의
𝜎 : 시그모이드 함수
로지스틱 회귀 모델은 선형 회귀 모델에 시그모이드 함수를 적용
로지스틱 회귀의 학습 목표는 다음과 같은 목적 함수를 최소화 하는 파라미터𝑤w를 찾는 것
로지스틱 회귀 예제
import numpy as np
import matplotlib.pyplot as plt
plt.style.use(['seaborn-whitegrid'])
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split, cross_val_score
from sklearn.linear_model import LogisticRegression
#In[]
fig, ax = plt.subplots(1, 1, figsize=(10,6))
ax.grid()
ax.set_xlabel('X')
ax.set_ylabel('y')
for i in range(samples):
if y[i] == 0:
ax.scatter(X[i,0], X[i, 1], edgecolors='k', alpha=0.5, marker='^', color='r')
else:
ax.scatter(X[i,0], X[i, 1], edgecolors='k', alpha=0.5, marker='v', color='b')
plt.show()
#Out[]
#In[]
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)
model = LogisticRegression()
model.fit(X_train, y_train)
#Out[]
LogisticRegression()
#In[1]
print("학습 데이터 점수 : {}".format(model.score(X_train, y_train)))
print("평가 데이터 점수 : {}".format(model.score(X_test, y_test)))
#Out[1]
학습 데이터 점수 : 0.905
평가 데이터 점수 : 0.89
#In[2]
scores = cross_val_score(model, X, y, scoring='accuracy', cv=10)
print("CV 평균 점수 : {}".format(scores.mean()))
#Out[2]
CV 평균 점수 : 0.9030000000000001
#In[]
from sklearn.linear_model import LogisticRegression
model = LogisticRegression(solver='lbfgs', multi_class='auto', C=100.0, random_state=1)
model.fit(X_train, y_train)
#Out[]
LogisticRegression(C=100.0, random_state=1)
#In[]
print("학습 데이터 점수 : {}".format(model.score(X_train, y_train)))
print("평가 데이터 점수 : {}".format(model.score(X_test, y_test)))
#Out[]
학습 데이터 점수 : 0.9666666666666667
평가 데이터 점수 : 0.9666666666666667
#In[]
import numpy as np
X = np.vstack((X_train, X_test))
y = np.hstack((y_train, y_test))
#In[]
from sklearn.datasets import load_breast_cancer
cancer = load_breast_cancer()
print(cancer.keys())
print(cancer.DESCR)
#Out[]
dict_keys(['data', 'target', 'frame', 'target_names', 'DESCR', 'feature_names', 'filename', 'data_module'])
.. _breast_cancer_dataset:
Breast cancer wisconsin (diagnostic) dataset
--------------------------------------------
**Data Set Characteristics:**
:Number of Instances: 569
:Number of Attributes: 30 numeric, predictive attributes and the class
:Attribute Information:
- radius (mean of distances from center to points on the perimeter)
- texture (standard deviation of gray-scale values)
- perimeter
- area
- smoothness (local variation in radius lengths)
- compactness (perimeter^2 / area - 1.0)
- concavity (severity of concave portions of the contour)
- concave points (number of concave portions of the contour)
- symmetry
- fractal dimension ("coastline approximation" - 1)
The mean, standard error, and "worst" or largest (mean of the three
worst/largest values) of these features were computed for each image,
resulting in 30 features. For instance, field 0 is Mean Radius, field
10 is Radius SE, field 20 is Worst Radius.
- class:
- WDBC-Malignant
- WDBC-Benign
#In[]
from sklearn.linear_model import LogisticRegression
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import train_test_split
X, y = load_breast_cancer(return_X_y=True)
X_train, X_test, y_train, y_test = train_test_split(X,y)
model = LogisticRegression(max_iter=3000)
model.fit(X_train, y_train)
#Out[]
LogisticRegression(max_iter=3000)
#In[]
print("학습 데이터 점수 : {}".format(model.score(X_train, y_train)))
print("평가 데이터 점수 : {}".format(model.score(X_test, y_test)))
#Out[]
학습 데이터 점수 : 0.960093896713615
평가 데이터 점수 : 0.965034965034965
확률적 경사 하강법 (Stochastic Gradient Descent)
모델을 학습 시키기 위한 간단한 방법
학습 파라미터에 대한 손실 함수의 기울기를 구해 기울기가 최소화 되는 방향으로 학습
scikit-learn에서는 선형 SGD 회귀와 SGD 분류를 지원
SGD를 사용한 선형 회귀 분석
#In[]
from sklearn.linear_model import SGDRegressor
from sklearn.datasets import load_boston
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.pipeline import make_pipeline
X, y = load_boston(return_X_y=True)
X_train, X_test, y_train, y_test = train_test_split(X,y)
model = make_pipeline(StandardScaler(), SGDRegressor(loss='squared_loss'))
model.fit(X_train, y_train)
#Out[]
Pipeline(steps=[('standardscaler', StandardScaler()),
('sgdregressor', SGDRegressor(loss='squared_loss'))])
#In[]
print("학습 데이터 점수 : {}".format(model.score(X_train, y_train)))
print("평가 데이터 점수 : {}".format(model.score(X_test, y_test)))
#Out[]
학습 데이터 점수 : 0.7325588416046254
평가 데이터 점수 : 0.7358013246276491
붓꽃 데이터에 대한 SGD 분류
#In[]
from sklearn.linear_model import SGDClassifier
from sklearn.datasets import load_iris, load_breast_cancer
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.pipeline import make_pipeline
X, y = load_iris(return_X_y=True)
X_train, X_test, y_train, y_test = train_test_split(X,y)
model = make_pipeline(StandardScaler(), SGDClassifier(loss='log'))
model.fit(X_train, y_train)
#Out[]
Pipeline(steps=[('standardscaler', StandardScaler()),
('sgdclassifier', SGDClassifier(loss='log'))])
#In[]
print("학습 데이터 점수 : {}".format(model.score(X_train, y_train)))
print("평가 데이터 점수 : {}".format(model.score(X_test, y_test)))
#Out[]
학습 데이터 점수 : 0.9464285714285714
평가 데이터 점수 : 0.9210526315789473
#In[]
print("학습 데이터 점수 : {}".format(model.score(X_train, y_train)))
print("평가 데이터 점수 : {}".format(model.score(X_test, y_test)))
#Out[]
학습 데이터 점수 : 0.9812206572769953
평가 데이터 점수 : 0.972027972027972
주택 가격 데이터는 도시에 대한 분석과 부동산, 경제적인 정보 분석 등 많은 활용 가능한 측면들이 존재
보스턴 주택 가격 데이터는 카네기 멜론 대학교에서 관리하는 StatLib 라이브러리에서 가져온 것
헤리슨(Harrison, D.)과 루빈펠트(Rubinfeld, D. L.)의 논문 "Hedonic prices and the demand for clean air', J. Environ. Economics & Management"에서 보스턴 데이터가 사용
1970년도 인구 조사에서 보스턴의 506개 조사 구역과 주택 가격에 영향을 주는 속성 21개로 구성
#In[]
from sklearn.datasets import load_boston
boston = load_boston()
print(boston.keys())
print(boston.DESCR)
#Out[]
dict_keys(['data', 'target', 'feature_names', 'DESCR', 'filename', 'data_module'])
.. _boston_dataset:
Boston house prices dataset
---------------------------
**Data Set Characteristics:**
:Number of Instances: 506
:Number of Attributes: 13 numeric/categorical predictive. Median Value (attribute 14) is usually the target.
:Attribute Information (in order):
- CRIM per capita crime rate by town
- ZN proportion of residential land zoned for lots over 25,000 sq.ft.
- INDUS proportion of non-retail business acres per town
- CHAS Charles River dummy variable (= 1 if tract bounds river; 0 otherwise)
- NOX nitric oxides concentration (parts per 10 million)
- RM average number of rooms per dwelling
- AGE proportion of owner-occupied units built prior to 1940
- DIS weighted distances to five Boston employment centres
- RAD index of accessibility to radial highways
- TAX full-value property-tax rate per $10,000
- PTRATIO pupil-teacher ratio by town
- B 1000(Bk - 0.63)^2 where Bk is the proportion of black people by town
- LSTAT % lower status of the population
- MEDV Median value of owner-occupied homes in $1000's
#In[]
for i, col in enumerate(boston_df.columns):
plt.figure(figsize=(8,4))
plt.plot(boston_df[col])
plt.title(col)
plt.xlabel('Town')
plt.tight_layout()
#Out[]
각 feature에 대한 그래프 출력
#In[]
for i, col in enumerate(boston_df.columns):
plt.figure(figsize=(8,4))
plt.scatter(boston_df[col], boston_df['MEDV'])
plt.ylabel('MEDV', size = 12)
plt.xlabel(col, size = 12)
plt.tight_layout()
#Out[]
각 feature에 대한 그래프 출력
#In[]
import seaborn as sns
sns.pairplot(boston_df)
#Out[]
13 X 13 에 대한 그래프 출력
#In[]
print("학습 데이터 점수 : {}".format(model.score(X_train, y_train)))
print("평가 데이터 점수 : {}".format(model.score(X_test, y_test)))
#Out[]
학습 데이터 점수 : 0.720438846769244
평가 데이터 점수 : 0.7741844698985254
데이터를 두개로 분리하고 모델을 생성 및 검증하였지만, 데이터를 분리하였기 때문에 훈련에 사용할 수 있는 양도 작아지고, 분리가 잘 안된 경우에는 잘못된 검증이 될 수 있음
이럴 경우에는 테스트셋을 여러개로 구성하여 교차 검증을 진행
cross_val_score()함수는 교차 검증을 수행하여 모델을 검증
다음 예제에서는 모델 오류를 측정하는 점수로 NMSE(Negative Mean Squared Error)를 사용
#In[]
from sklearn.datasets import fetch_california_housing
california = fetch_california_housing()
print(california.keys())
print(california.DESCR)
#Out[]
dict_keys(['data', 'target', 'frame', 'target_names', 'feature_names', 'DESCR'])
.. _california_housing_dataset:
California Housing dataset
--------------------------
**Data Set Characteristics:**
:Number of Instances: 20640
:Number of Attributes: 8 numeric, predictive attributes and the target
:Attribute Information:
- MedInc median income in block group
- HouseAge median house age in block group
- AveRooms average number of rooms per household
- AveBedrms average number of bedrooms per household
- Population block group population
- AveOccup average number of household members
- Latitude block group latitude
- Longitude block group longitude
:Missing Attribute Values: None
This dataset was obtained from the StatLib repository.
https://www.dcc.fc.up.pt/~ltorgo/Regression/cal_housing.html
The target variable is the median house value for California districts,
expressed in hundreds of thousands of dollars ($100,000).
#In[]
import matplotlib.pyplot as plt
for i, col in enumerate(california_df.columns):
plt.figure(figsize=(8,5))
plt.plot(california_df[col])
plt.title(col)
plt.tight_layout()
#Out[]
각 feature마다 그래프 출력
#In[]
import matplotlib.pyplot as plt
for i, col in enumerate(california_df.columns):
plt.figure(figsize=(8,5))
plt.scatter(california_df[col], california_df['Target'])
plt.ylabel('Target', size=12)
plt.xlabel(col,size=12)
plt.title(col)
plt.tight_layout()
#Out[]
각 feature마다 그래프 출력
#In[]
import seaborn as sns
sns.pairplot(california_df.sample(1000))
#Out[]
9 X 9개의 그래프 출력
이러한 방법은 각각의 특성(feature)이 출력 값에 주는 영향을 최소한으로 만들도록 규제(regularization)를 거는 것
규제를 사용하면 다중공선성(multicollinearity) 문제를 방지하기 때문에 모델의 과대적합을 막을 수 있게 됨
다중공선성 문제는 두 특성이 일치에 가까울 정도로 관련성(상관관계)이 높을 경우 발생
릿지 회귀는 다음과 같은 함수를 최소화 하는 파라미터𝑤를 찾음
𝛼: 사용자가 지정하는 매개변수
𝛼가 크면 규제의 효과가 커지고,𝛼가 작으면 규제의 효과가 작아짐
보스턴 주택 가격에 대한 릿지 회귀
#In[]
from sklearn.linear_model import Ridge
from sklearn.datasets import load_boston
from sklearn.model_selection import train_test_split
X, y = load_boston(return_X_y=True) #data와 target을 분리해줌!
X_train, X_test, y_train, y_test = train_test_split(X,y)
model = Ridge(alpha=0.2)
model.fit(X_train, y_train)
#Out[]
Ridge(alpha=0.2)
#In[]
print("학습 데이터 점수 : {}".format(model.score(X_train, y_train)))
print("평가 데이터 점수 : {}".format(model.score(X_test, y_test)))
#Out[]
학습 데이터 점수 : 0.7368424082987279
평가 데이터 점수 : 0.7444343121697423
릿지 회귀는 가중치에 제약을 두기 때문에 선형 회귀 모델보다 훈련 데이터 점수가 낮을 수 있음
일반화 성능은 릿지 회귀가 더 높기 때문에 평가 데이터 점수는 릿지 회귀가 더 좋음
일반화 성능에 영향을 주는 매개 변수인𝛼α값을 조정해 보면서 릿지 회귀 분석의 성능이 어떻게 변하는지 확인 필요
캘리포니아 주택 가격에 대한 릿지 회귀
#In[]
from sklearn.datasets import fetch_california_housing
california = fetch_california_housing()
X_train, X_test, y_train, y_test = train_test_split(california.data, california.target, test_size=0.3)
model = Ridge(alpha=0.1)
model.fit(X_train, y_train)
#Out[]
Ridge(alpha=0.1)
#In[]
print("학습 데이터 점수 : {}".format(model.score(X_train, y_train)))
print("평가 데이터 점수 : {}".format(model.score(X_test, y_test)))
#Out[]
학습 데이터 점수 : 0.604057267179928
평가 데이터 점수 : 0.6107536986926523
#In[]
from sklearn.linear_model import Lasso
from sklearn.datasets import load_boston
from sklearn.model_selection import train_test_split
X, y = load_boston(return_X_y=True)
X_train, X_test, y_train, y_test = train_test_split(X, y)
model = Lasso(alpha=0.003)
model.fit(X_train, y_train)
#Out[]
Lasso(alpha=0.003)
#In[]
print("학습 데이터 점수 : {}".format(model.score(X_train, y_train)))
print("평가 데이터 점수 : {}".format(model.score(X_test, y_test)))
#Out[]
학습 데이터 점수 : 0.7272293998519503
평가 데이터 점수 : 0.771712660021631
#In[]
from sklearn.datasets import fetch_california_housing
california = fetch_california_housing()
X_train, X_test, y_train, y_test = train_test_split(california.data, california.target, test_size=0.3)
model = Lasso(alpha=0.001)
model.fit(X_train, y_train)
#Out[]
Lasso(alpha=0.001)
#In[]
print("학습 데이터 점수 : {}".format(model.score(X_train, y_train)))
print("평가 데이터 점수 : {}".format(model.score(X_test, y_test)))
#Out[]
학습 데이터 점수 : 0.6142220442075574
평가 데이터 점수 : 0.5805641764424498
데이터 특성이 많거나 서로 상관 관계가 높은 특성이 존재 할 때 위의 두 모델보다 좋은 성능을 보여 줌
신축망은 다음과 같은 함수를 최소화 하는 파라미터𝑤를 찾음
𝛼: 규제의 강도를 조절하는 매개변수
𝜌: 라쏘 규제와 릿지 규제 사이의 가중치를 조절하는 매개변수
보스턴 주택 가격에 대한 신축망
#In[]
from sklearn.linear_model import ElasticNet
from sklearn.datasets import load_boston
from sklearn.model_selection import train_test_split
X, y = load_boston(return_X_y=True)
X_train, X_test, y_train, y_test = train_test_split(X, y)
model = ElasticNet(alpha=0.01, l1_ratio=0.5)
model.fit(X_train, y_train)
#Out[]
ElasticNet(alpha=0.01)
#In[]
print("학습 데이터 점수 : {}".format(model.score(X_train, y_train)))
print("평가 데이터 점수 : {}".format(model.score(X_test, y_test)))
#Out[]
학습 데이터 점수 : 0.7267947849019141
평가 데이터 점수 : 0.7183794503068747
#In[]
from sklearn.linear_model import ElasticNet
from sklearn.datasets import fetch_california_housing
from sklearn.model_selection import train_test_split
california = fetch_california_housing()
X_train, X_test, y_train, y_test = train_test_split(california.data, california.target, test_size=0.3)
model = ElasticNet(alpha=0.01, l1_ratio=0.5)
model.fit(X_train, y_train)
#Out[]
ElasticNet(alpha=0.01)
#In[]
print("학습 데이터 점수 : {}".format(model.score(X_train, y_train)))
print("평가 데이터 점수 : {}".format(model.score(X_test, y_test)))
#Out[]
학습 데이터 점수 : 0.6020991031939832
평가 데이터 점수 : 0.6116388975222378
이러한 방법은 모델이 필요 없는 데이터 특성을 훈련 과정에서 자동으로 제거 하도록 만들 수 있음
보스턴 주택 가격에 대한 직교 정합 추구
#In[]
from sklearn.linear_model import OrthogonalMatchingPursuit
from sklearn.datasets import load_boston
from sklearn.model_selection import train_test_split
X, y = load_boston(return_X_y=True)
X_train, X_test, y_train, y_test = train_test_split(X,y)
model = OrthogonalMatchingPursuit(n_nonzero_coefs=7)
model.fit(X_train, y_train)
#Out[]
OrthogonalMatchingPursuit(n_nonzero_coefs=7)
#In[]
print("학습 데이터 점수 : {}".format(model.score(X_train, y_train)))
print("평가 데이터 점수 : {}".format(model.score(X_test, y_test)))
#Out[]
학습 데이터 점수 : 0.7067701687499545
평가 데이터 점수 : 0.7647457085035291
#In[1]
model = OrthogonalMatchingPursuit(tol=1.)
model.fit(X_train, y_train)
#Out[1]
OrthogonalMatchingPursuit(tol=1.0)
#In[2]
print("학습 데이터 점수 : {}".format(model.score(X_train, y_train)))
print("평가 데이터 점 수 : {}".format(model.score(X_test, y_test)))
#Out[2]
학습 데이터 점수 : 0.7255197300235632
평가 데이터 점수 : 0.7831647013824865
#In[3]
predicted = model.predict(X_test)
expected = y_test
plot_boston_prices(expected, predicted)
#Out[3]
캘리포니아 주택 가격에 대한 직교 정합 추구
#In[]
from sklearn.linear_model import OrthogonalMatchingPursuit
from sklearn.datasets import fetch_california_housing
from sklearn.model_selection import train_test_split
california = fetch_california_housing()
X_train, X_test, y_train, y_test = train_test_split(california.data, california.target, test_size=0.3)
model = OrthogonalMatchingPursuit(n_nonzero_coefs=7)
model.fit(X_train, y_train)
#Out[]
OrthogonalMatchingPursuit(n_nonzero_coefs=7)
#In[]
print("학습 데이터 점수 : {}".format(model.score(X_train, y_train)))
print("평가 데이터 점 수 : {}".format(model.score(X_test, y_test)))
#Out[]
학습 데이터 점수 : 0.6043415390059861
평가 데이터 점 수 : 0.6097795468666676
#In[1]
model = OrthogonalMatchingPursuit(tol=1.)
model.fit(X_train, y_train)
#Out[1]
OrthogonalMatchingPursuit(tol=1.0)
#In[2]
print("학습 데이터 점수 : {}".format(model.score(X_train, y_train)))
print("평가 데이터 점수 : {}".format(model.score(X_test, y_test)))
#Out[2]
학습 데이터 점수 : 0.6043682122857658
평가 데이터 점수 : 0.6097528736622835
#In[3]
predicted = model.predict(X_test)
expected = y_test
plot_california_prices(expected, predicted)
#Out[3]
다항 회귀 (Polynomial Regression)
입력 데이터를 비선형 변환 후 사용하는 방법
모델 자체는 선형 모델
차수가 높아질수록 더 복잡한 데이터 학습 가능
보스턴 주택 가격에 대한 다항 회귀
#In[]
from sklearn.preprocessing import PolynomialFeatures, StandardScaler
from sklearn.linear_model import LinearRegression
from sklearn.pipeline import make_pipeline
from sklearn.model_selection import train_test_split
from sklearn.datasets import load_boston
X, y = load_boston(return_X_y=True)
X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=123) #고정된 형태
#In[]
print("학습 데이터 점수 : {}".format(model.score(X_train, y_train)))
print("평가 데이터 점수 : {}".format(model.score(X_test, y_test)))
#Out[]
학습 데이터 점수 : 0.9346787783950696
평가 데이터 점수 : 0.825786471800239
#In[]
print("학습 데이터 점수 : {}".format(model.score(X_train, y_train)))
print("평가 데이터 점수 : {}".format(model.score(X_test, y_test)))
#Out[]
학습 데이터 점수 : 0.6846989126772143
평가 데이터 점수 : 0.6705076858975946
교차 검증을 위해 데이터를 학습/테스트용으로 분리, 최적 파라미터를 추출하는 API 제공 (GridSearch 등)
sklearn.metrics
분류, 회귀, 클러스터링, Pairwise에 대한 다양한 성능 측정 방법 제공 (Accuracy, Precision, Recall, ROC-AUC, RMSE 등)
sklearn.pipeline
특징 처리 등의 변환과 ML 알고리즘 학습, 예측 등을 묶어서 실행할 수 있는 유틸리티 제공
sklearn.linear_model
선형 회귀, 릿지(Ridge), 라쏘(Lasso), 로지스틱 회귀 등 회귀 관련 알고리즘과 SGD(Stochastic Gradient Descent) 알고리즘 제공
sklearn.svm
서포트 벡터 머신 알고리즘 제공
sklearn.neighbors
최근접 이웃 알고리즘 제공 (k-NN 등)
sklearn.naive_bayes
나이브 베이즈 알고리즘 제공 (가우시안 NB, 다항 분포 NB 등)
sklearn.tree
의사 결정 트리 알고리즘 제공
sklearn.ensemble
앙상블 알고리즘 제공 (Random Forest, AdaBoost, GradientBoost 등)
sklearn.cluster
비지도 클러스터링 알고리즘 제공 (k-Means, 계층형 클러스터링, DBSCAN 등)
estimatorAPI
일관성: 모든 객체는 일관된 문서를 갖춘 제한된 메서드 집합에서 비롯된 공통 인터페이스 공유
검사(inspection): 모든 지정된 파라미터 값은 공개 속성으로 노출
제한된 객체 계층 구조
알고리즘만 파이썬 클래스에 의해 표현
데이터 세트는 표준 포맷(NumPy 배열, Pandas DataFrame, Scipy 희소 행렬)으로 표현
매개변수명은 표준 파이썬 문자열 사용
구성: 많은 머신러닝 작업은 기본 알고리즘의 시퀀스로 나타낼 수 있으며, Scikit-Learn은 가능한 곳이라면 어디서든 이 방식을 사용
합리적인 기본값: 모델이 사용자 지정 파라미터를 필요로 할 때 라이브러리가 적절한 기본값을 정의
API 사용 방법
Scikit-Learn으로부터 적절한estimator클래스를 임포트해서 모델의 클래스 선택
클래스를 원하는 값으로 인스턴스화해서 모델의 하이퍼파라미터 선택
데이터를 특징 배열과 대상 벡터로 배치
모델 인스턴스의fit()메서드를 호출해 모델을 데이터에 적합
모델을 새 데이터에 대해서 적용
지도 학습: 대체로predict()메서드를 사용해 알려지지 않은 데이터에 대한 레이블 예측
비지도 학습: 대체로transform()이나predict()메서드를 사용해 데이터의 속성을 변환하거나 추론
# API 예제
import numpy as np
import matplotlib.pyplot as plt
plt.style.use(['seaborn-whitegrid']
x = 10 * np.random.rand(50)
y = 2 * x + np.random.rand(50)
plot.scatter(x,y)
#1. 적절한 extimator 클래스를 임포트해서 모델의 클래스 선택
from sklearn.linear_model import LinearRegression
#2. 클래스를 원하는 값으로 인스턴스화해서 모델의 하이퍼파라미터 선택
model = LinearRegression(fit_intercept=True)
model
# out : LinearRegreesion(copy_X=True, fit_intercept=True, n_jobs=None, normalize=False)
copy_X X를 복사해서 사용할 것인가
fit_intercept 상수인가
n_jobs CPU를 병렬로 사용할것인가
normalize 정규화가 되어있냐
# 3.데이터를 특징 배열과 대상 벡터로 배치
X = x[:, np.newaxis]
X
# out : (50,1) 인 2차원 행렬 생성
# 4. 모델 인스턴스의 fit() 메서드를 호출해 모델을 데이터에 적합
model.fit(X,y)
model.coef_
# out : array([1.99630302])
model.intercept_
# out : 0.4759856348626279
#5. 모델을 새 데이터에 대해서 적용
xfit = np.linspace(-1,11)
Xfit = xfit[:, np.newaxis]
yfit = model.predict(Xfit)
plt.scatter(x,y)
plt.plot(xfit,yfit, '--r')
# 예제 데이터 세트
분류 또는 회귀용 데이터 세트
API
설명
datasets.load_boston()
미국 보스턴의 집에 대한 특징과 가격 데이터 (회귀용)
datasets.load_breast_cancer()
위스콘신 유방암 특징들과 악성/음성 레이블 데이터 (분류용)
datasets.load_diabetes()
당뇨 데이터 (회귀용)
datasets.load_digits()
0에서 9까지 숫자 이미지 픽셀 데이터 (분류용)
datasets.load_iris()
붓꽃에 대한 특징을 가진 데이터 (분류용)
온라인 데이터 세트
데이터 크기가 커서 온라인에서 데이터를 다운로드 한 후 에 불러오는 예제 데이터 세트
API
설명
fetch_california_housing()
캘리포니아 주택 가격 데이터
fetch_covtype()
회귀 분석용 토지 조사 데이터
fetch_20newsgroups()
뉴스 그룹 텍스트 데이터
fetch_olivetti_faces()
얼굴 이미지 데이터
fetch_lfw_people()
얼굴 이미지 데이터
fetch_lfw_paris()
얼굴 이미지 데이터
fetch_rcv1()
로이터 뉴스 말뭉치 데이터
fetch_mldata()
ML 웹사이트에서 다운로드
분류와 클러스터링을 위한 표본 데이터 생성
API
설명
datasets.make_classifications()
분류를 위한 데이터 세트 생성. 높은 상관도, 불필요한 속성 등의 노이즈를 고려한 데이터를 무작위로 생성
datasets.make_blobs()
클러스터링을 위한 데이터 세트 생성. 군집 지정 개수에 따라 여러 가지 클러스터링을 위한 데이터 셋트를 무작위로 생성
