당신은 주제를 찾고 있습니까 “머신러닝 예측 예제 – ㄹㅇ쉬운 딥러닝 7강 : Tensorflow 2로 해보는 간단한 Linear Regression 선형회귀 예측“? 다음 카테고리의 웹사이트 sk.taphoamini.com 에서 귀하의 모든 질문에 답변해 드립니다: https://sk.taphoamini.com/wiki. 바로 아래에서 답을 찾을 수 있습니다. 작성자 코딩애플 이(가) 작성한 기사에는 조회수 17,163회 및 좋아요 206개 개의 좋아요가 있습니다.
Table of Contents
머신러닝 예측 예제 주제에 대한 동영상 보기
여기에서 이 주제에 대한 비디오를 시청하십시오. 주의 깊게 살펴보고 읽고 있는 내용에 대한 피드백을 제공하세요!
d여기에서 ㄹㅇ쉬운 딥러닝 7강 : Tensorflow 2로 해보는 간단한 Linear Regression 선형회귀 예측 – 머신러닝 예측 예제 주제에 대한 세부정보를 참조하세요
Tensorflow 2 설치가 안되었다면 https://codingapple.com/unit/tensorflow-2-setting-up-mac-window/?id=4205 이걸 참고해 설치합니다.
Tensorflow 2로 해보는 간단한 예측입니다.
linear regression 선형회귀 그런 느낌이 나는데 그거 맞습니다.
전체 강의는 https://codingapple.com/course/python-deep-learning/ 에서 이용가능합니다.
파이썬 패키지 반값 할인 중
머신러닝 예측 예제 주제에 대한 자세한 내용은 여기를 참조하세요.
3.6 주택 가격 예측: 회귀 문제
앞의 두 예제는 분류 문제입니다. 입력 데이터 포인트의 개별적인 레이블 하나를 예측하는 것이 목적입니다. 또 다른 종류의 머신 러닝 문제는 개별적인 레이블 대신에 …
Source: tensorflow.blog
Date Published: 1/27/2021
View: 6114
[머신러닝] 머신러닝 기초 정리 예제 – AI Platform / Web
머신러닝 데이터 분석을 하기 위해서 컴퓨터 알고리즘이 이해할 수 … 변수 X 값이 주어졌을 때 거기에 대응되는 종속 변수 Y 값을 예측이 가능하다.
Source: han-py.tistory.com
Date Published: 1/1/2022
View: 3417
머신러닝을 활용한 수요예측 사례와 KPI 모델링 방법
머신러닝은 일반적으로 빅데이터를 분석하여 추정된 패턴을 토대로 미래 결과를 예측하는 데에 쓰입니다. 예를 들어 금융분야에서는 과거 고객 재무 …
Source: davincilabs.ai
Date Published: 10/9/2022
View: 1442
4.1 회귀분석 예제 – 데이터 사이언스 스쿨
보스턴 집값 예측¶ · 독립변수 · CRIM : 범죄율 · INDUS : 비소매상업지역 면적 비율 · NOX : 일산화질소 농도 · RM : 주택당 방 수 · LSTAT : 인구 중 하위 계층 비율 · B : 인구 …
Source: datascienceschool.net
Date Published: 11/28/2021
View: 4201
머신러닝 – 강의 02 현대 자동차 가격 예측 모델 학습
강의 02 현대 자동차 가격 예측 모델 학습. import pandas as pd from sklearn.preprocessing import OneHotEncoder from sklearn.compose import …
Source: wikidocs.net
Date Published: 9/12/2021
View: 9885
딥러닝 수치를 예측해보자 (feat 선형 회귀 분석) – Developer Blog
이게 딥러닝의 핵심이다. 딥러닝 예제 중 가장 유명한 보스턴 집값. 예측 모형을 가지고 실제 모델을. 설계해보자. 데이터를 로드해서, …
Source: incomeplus.tistory.com
Date Published: 8/12/2022
View: 7646
Tensorflow: regression 기본 예제 (연료 효율성 예측) – Voyager
저장 시 각 데이터의 이름을 칼럼으로 지정해준다. url = ‘http://archive.ics.uci.edu/ml/machine-learning-databases/auto-mpg/auto …
Source: gmnam.tistory.com
Date Published: 8/9/2021
View: 4980
[python/ML] 머신러닝(Machine Learning) – 회귀
x는 독립변수가 되고 x에 의해 y가 정해지기 때문에 y는 x의 종속변수가 됩니다. 회귀 예제 – 학습 시간에 따른 시험 점수 예측. 오늘은 회귀 예제로 학습 …
Source: wonhwa.tistory.com
Date Published: 1/16/2022
View: 651
머신러닝 시계열 예측 | [이것이 데이터 분석이다 With 파이썬
전통적으로 대부분의 머신러닝(ML) 모델은 일부 관찰(샘플/예제)을 입력 피쳐로 사용하지만 데이터에 시간 차원은 없다. 시계열 예측 모형은 이전에 …
Source: you.maxfit.vn
Date Published: 11/13/2021
View: 7806
간단한 딥러닝으로 삼성전자 주가 예측하기
사실, 여러 강의나 구글링을 해보시면 LSTM의 구조도를 볼 수 있는데, 이번 포스팅에서는 LSTM이 중점이 아닌 이를 활용한 시계열 데이터셋의 예측 예제를 …
Source: dsstudy.tistory.com
Date Published: 11/22/2022
View: 420
주제와 관련된 이미지 머신러닝 예측 예제
주제와 관련된 더 많은 사진을 참조하십시오 ㄹㅇ쉬운 딥러닝 7강 : Tensorflow 2로 해보는 간단한 Linear Regression 선형회귀 예측. 댓글에서 더 많은 관련 이미지를 보거나 필요한 경우 더 많은 관련 기사를 볼 수 있습니다.
주제에 대한 기사 평가 머신러닝 예측 예제
- Author: 코딩애플
- Views: 조회수 17,163회
- Likes: 좋아요 206개
- Date Published: 2020. 11. 21.
- Video Url link: https://www.youtube.com/watch?v=PwYnZ2RwyJw
텐서 플로우 블로그 (Tensor ≈ Blog)
3.5 뉴스 기사 분류: 다중 분류 문제 | 목차 | 3.7 요약
앞의 두 예제는 분류 문제입니다. 입력 데이터 포인트의 개별적인 레이블 하나를 예측하는 것이 목적입니다. 또 다른 종류의 머신 러닝 문제는 개별적인 레이블 대신에 연속적인 값을 예측하는 회귀regression입니다. 예를 들어 기상 데이터가 주어졌을 때 내일 기온을 예측하거나, 소프트웨어 명세가 주어졌을 때 소프트웨어 프로젝트가 완료될 시간을 예측하는 것입니다.
Note: 회귀와 로지스틱 회귀logistic regression 알고리즘을 혼동하지 마세요. 로지스틱 회귀는 회귀 알고리즘이 아니라 분류 알고리즘입니다.37
3.6.1 보스턴 주택 가격 데이터셋
1970년 중반 보스턴 외곽 지역의 범죄율, 지방세율 등의 데이터가 주어졌을 때 주택 가격의 중간 값을 예측해 보겠습니다. 여기서 사용할 데이터셋은 이전 2개의 예제와 다릅니다. 데이터 포인트가 506개로 비교적 개수가 적고 404개는 훈련 샘플로, 102개는 테스트 샘플로 나뉘어 있습니다. 입력 데이터에 있는 각 특성feature(예를 들어 범죄율)은 스케일이 서로 다릅니다. 어떤 값은 0과 1 사이의 비율을 나타내고, 어떤 것은 1과 12 사이의 값을 가지거나 1과 100 사이의 값을 가집니다.
from keras.datasets import boston_housing (train_data, train_targets), (test_data, test_targets) = boston_housing.load_data()
데이터를 살펴보겠습니다.
>>> train_data.shape (404, 13) >>> test_data.shape (102, 13)
여기서 볼 수 있듯이 404개의 훈련 샘플과 102개의 테스트 샘플이 있고 모두 13개의 수치 특성이 있습니다. 이 특성들은 1인당 범죄율, 주택당 평균 방의 개수, 고속도로 접근성 등입니다.
타깃은 주택의 중간 가격으로 천 달러 단위입니다.
>>> train_targets [ 15.2, 42.3, 50. .. . 19.4, 19.4, 29.1]
이 가격은 일반적으로 1만 달러에서 5만 달러 사이입니다. 저렴하게 느껴질 텐데 1970년대 중반이라는 것을 기억하세요. 아직 인플레이션에 영향을 받지 않은 가격입니다.
3.6.2 데이터 준비
상이한 스케일을 가진 값을 신경망에 주입하면 문제가 됩니다. 네트워크가 이런 다양한 데이터에 자동으로 맞추려고 할 수 있지만 이는 확실히 학습을 더 어렵게 만듭니다.38 이런 데이터를 다룰 때 대표적인 방법은 특성별로 정규화를 하는 것입니다. 입력 데이터에 있는 각 특성(입력 데이터 행렬의 열)에 대해서 특성의 평균을 빼고 표준 편차로 나눕니다.39 특성의 중앙이 0 근처에 맞추어지고 표준 편차가 1이 됩니다. 넘파이를 사용하면 간단하게 할 수 있습니다.
mean = train_data.mean( axis = 0 ) train_data -= mean std = train_data.std( axis = 0 ) train_data /= std test_data -= mean test_data /= std
테스트 데이터를 정규화할 때 사용한 값이 훈련 데이터에서 계산한 값임을 주목하세요. 머신 러닝 작업 과정에서 절대로 테스트 데이터에서 계산한 어떤 값도 사용해서는 안 됩니다. 데이터 정규화처럼 간단한 작업조차도 그렇습니다.40
3.6.3 모델 구성
샘플 개수가 적기 때문에 64개의 유닛을 가진 2개의 은닉 층으로 작은 네트워크를 구성하여 사용하겠습니다. 일반적으로 훈련 데이터의 개수가 적을수록 과대적합이 더 쉽게 일어나므로 작은 모델을 사용하는 것이 과대적합을 피하는 한 방법입니다.
from keras import models from keras import layers def build_model (): 동일한 모델을 여러 번 생성할 것이므로 함수를 만들어 사용합니다. model = models.Sequential() model.add(layers.Dense( 64 , activation = ‘relu’ , input_shape =(train_data.shape[ 1 ],))) model.add(layers.Dense( 64 , activation = ‘relu’ )) model.add(layers.Dense( 1 )) model.compile( optimizer = ‘rmsprop’ , loss = ‘mse’ , metrics =[ ‘mae’ ]) return model
이 네트워크의 마지막 층은 하나의 유닛을 가지고 있고 활성화 함수가 없습니다(선형 층이라고 부릅니다). 이것이 전형적인 스칼라 회귀(하나의 연속적인 값을 예측하는 회귀)를 위한 구성입니다. 활성화 함수를 적용하면 출력 값의 범위를 제한하게 됩니다. 예를 들어 마지막 층에 sigmoid 활성화 함수를 적용하면 네트워크가 0과 1 사이의 값을 예측하도록 학습될 것입니다. 여기서는 마지막 층이 순수한 선형이므로 네트워크가 어떤 범위의 값이라도 예측하도록 자유롭게 학습됩니다.
이 모델은 mse 손실 함수를 사용하여 컴파일합니다. 이 함수는 평균 제곱 오차mean squared error의 약어로 예측과 타깃 사이 거리의 제곱입니다. 회귀 문제에서 널리 사용되는 손실 함수입니다.
훈련하는 동안 모니터링을 위해 새로운 지표인 평균 절대 오차Mean Absolute Error, MAE를 측정합니다. 이는 예측과 타깃 사이 거리의 절댓값입니다. 예를 들어 이 예제에서 MAE가 0.5면 예측이 평균적으로 500달러 정도 차이가 난다는 뜻입니다.
3.6.4 K-겹 검증을 사용한 훈련 검증
(훈련에 사용할 에포크의 수 같은) 매개변수들을 조정하면서 모델을 평가하기 위해 이전 예제에서 했던 것처럼 데이터를 훈련 세트와 검증 세트로 나눕니다. 데이터 포인트가 많지 않기 때문에 검증 세트도 매우 작아집니다(약 100개의 샘플). 결국 검증 세트와 훈련 세트로 어떤 데이터 포인트가 선택되었는지에 따라 검증 점수가 크게 달라집니다. 검증 세트의 분할에 대한 검증 점수의 분산이 높습니다. 이렇게 되면 신뢰 있는 모델 평가를 할 수 없습니다.
이런 상황에서 가장 좋은 방법은 K-겹 교차 검증K-fold cross-validation을 사용하는 것입니다(그림 3–11 참고). 데이터를 K개의 분할(즉 폴드(fold))로 나누고(일반적으로 K = 4 또는 5), K개의 모델을 각각 만들어 K – 1개의 분할에서 훈련하고 나머지 분할에서 평가하는 방법입니다. 모델의 검증 점수는 K개의 검증 점수 평균이 됩니다. 코드로 보면 이해하기 쉽습니다.41
import numpy as np k = 4 num_val_samples = len (train_data) // k num_epochs = 100 all_scores = [] for i in range (k): print ( ‘ 처리중인 폴드 #’ , i) val_data = train_data[i * num_val_samples: (i + 1 ) * num_val_samples] # 검증 데이터 준비: k번째 분할 val_targets = train_targets[i * num_val_samples: (i + 1 ) * num_val_samples] partial_train_data = np.concatenate( # 훈련 데이터 준비: 다른 분할 전체 [train_data[:i * num_val_samples], train_data[(i + 1 ) * num_val_samples:]], axis = 0 ) partial_train_targets = np.concatenate( [train_targets[:i * num_val_samples], train_targets[(i + 1 ) * num_val_samples:]], axis = 0 ) model = build_model() # 케라스 모델 구성(컴파일 포함) model.fit(partial_train_data, partial_train_targets, # 모델 훈련(verbose=0이므로 훈련 과정이 출력되지 않습니다.) epochs =num_epochs, batch_size = 1 , verbose = 0 ) val_mse, val_mae = model.evaluate(val_data, val_targets, verbose = 0 ) # 검증 세트로 모델 평가 all_scores.append(val_mae)
num_epochs = 100으로 실행하면 다음 결과를 얻습니다.
>>> all_scores [2.0956787838794217, 2.220593797098292, 2.859968412040484, 2.40535704039111] >>> np.mean(all_scores) 2.3953995083523267
검증 세트가 다르므로 확실히 검증 점수가 2.1에서 2.9까지 변화가 큽니다. 평균값(2.4)이 각각의 점수보다 훨씬 신뢰할 만합니다. 이것이 K–겹 교차 검증의 핵심입니다. 이 예에서는 평균적으로 3,000달러 정도 차이가 납니다. 주택 가격의 범위가 1만 달러에서 5만 달러 사이인 것을 감안하면 비교적 큰 값입니다.
신경망을 조금 더 오래 500 에포크 동안 훈련해 보죠. 각 에포크마다 모델이 얼마나 개선되는지 기록하기 위해 훈련 루프를 조금 수정해서 에포크의 검증 점수를 로그에 저장하겠습니다.
num_epochs = 500 all_mae_histories = [] for i in range (k): print ( ‘ 처리중인 폴드 #’ , i) val_data = train_data[i * num_val_samples: (i + 1 ) * num_val_samples] #검증 데이터 준비: k번째 분할 val_targets = train_targets[i * num_val_samples: (i + 1 ) * num_val_samples] partial_train_data = np.concatenate( # 훈련 데이터 준비: 다른 분할 전체 [train_data[:i * num_val_samples], train_data[(i + 1 ) * num_val_samples:]], axis = 0 ) partial_train_targets = np.concatenate( [train_targets[:i * num_val_samples], train_targets[(i + 1 ) * num_val_samples:]], axis = 0 ) model = build_model() # 케라스 모델 구성(컴파일 포함) history = model.fit(partial_train_data, partial_train_targets, # 모델 훈련(verbose=0이므로 훈련 과정이 출력되지 않습니다.) validation_data =(val_data, val_targets), epochs =num_epochs, batch_size = 1 , verbose = 0 ) mae_history = history.history[ ‘val_mean_absolute_error’ ] all_mae_histories.append(mae_history)
그다음 모든 폴드에 대해 에포크의 MAE 점수 평균을 계산합니다.42
average_mae_history = [ np.mean([x[i] for x in all_mae_histories]) for i in range (num_epochs)]
그래프로 나타내면 그림 3–12와 같습니다.
import matplotlib.pyplot as plt plt.plot( range ( 1 , len (average_mae_history) + 1 ), average_mae_history) plt.xlabel( ‘Epochs’ ) plt.ylabel( ‘Validation MAE’ ) plt.show()
이 그래프는 범위가 크고 변동이 심하기 때문에 보기가 좀 어렵습니다. 다음과 같이 해 보죠.
곡선의 다른 부분과 스케일이 많이 다른 첫 10 개의 데이터 포인트를 제외시킵니다.
개의 데이터 포인트를 제외시킵니다. 부드러운 곡선을 얻기 위해 각 포인트를 이전 포인트의 지수 이동 평균 exponential moving average 으로 대체합니다. 43
결과는 그림 3–13과 같습니다.
def smooth_curve ( points , factor = 0.9 ): smoothed_points = [] for point in points: if smoothed_points: previous = smoothed_points[- 1 ] smoothed_points.append(previous * factor + point * ( 1 – factor)) else : smoothed_points.append(point) return smoothed_points smooth_mae_history = smooth_curve(average_mae_history[ 10 :]) plt.plot( range ( 1 , len (smooth_mae_history) + 1 ), smooth_mae_history) plt.xlabel( ‘Epochs’ ) plt.ylabel( ‘Validation MAE’ ) plt.show()
이 그래프를 보면 검증 MAE가 80번째 에포크 이후에 줄어드는 것이 멈추었습니다. 이 지점 이후로는 과대적합이 시작됩니다.
모델의 여러 매개변수에 대한 튜닝이 끝나면(에포크 수뿐만 아니라 은닉 층의 크기도 조절할 수 있습니다) 모든 훈련 데이터를 사용하고 최상의 매개변수로 최종 실전에 투입될 모델을 훈련시킵니다. 그다음 테스트 데이터로 성능을 확인합니다.
model = build_model() # 새롭게 컴파일된 모델을 얻습니다. model.fit(train_data, train_targets, # 전체 데이터로 훈련시킵니다. epochs = 80 , batch_size = 16 , verbose = 0 ) test_mse_score, test_mae_score = model.evaluate(test_data, test_targets)
최종 결과는 다음과 같습니다.
>>> test_mae_score 2.675027286305147
아직 2,675달러 정도 차이가 나네요.
3.6.5 정리
다음은 이 예제에서 배운 것들입니다.
회귀는 분류에서 사용했던 것과는 다른 손실 함수를 사용합니다. 평균 제곱 오차 ( MSE ) 는 회귀에서 자주 사용되는 손실 함수입니다.
는 회귀에서 자주 사용되는 손실 함수입니다. 비슷하게 회귀에서 사용되는 평가 지표는 분류와 다릅니다. 당연히 정확도 개념은 회귀에 적용되지 않습니다. 일반적인 회귀 지표는 평균 절대 오차 ( MAE ) 입니다.
적용되지 않습니다. 일반적인 회귀 지표는 평균 절대 오차 입력 데이터의 특성이 서로 다른 범위를 가지면 전처리 단계에서 각 특성을 개별적으로 스 케일 조정해야 합니다.
케일 조정해야 합니다. 가용한 데이터가 적다면 K- 겹 검증을 사용하는 것이 신뢰할 수 있는 모델 평가 방법입니다.
가용한 훈련 데이터가 적다면 과대적합을 피하기 위해 은닉 층의 수를 줄인 모델이 좋습니 다(일반적으로 1 개 또는 2 개).
37 역주 로지스틱 회귀는 선형 회귀(linear regression)의 분류 버전으로 중간층이 없고 하나의 유닛과 시그모이드 활성화 함수를 사용한 출력층만 있는 네트워크와 비슷합니다.
38 역주 특성의 스케일이 다르면 전역 최소 점을 찾아가는 경사 하강법의 경로가 스케일이 큰 특성에 영향을 많이 받습니다.
39 역주 정규화는 여러 가지 다른 의미로도 사용되기 때문에 오해하기 쉽습니다. 표준화(standardization)라고 하면 정확히 이 방식을 가리킵니다.
40 역주 쉽게 생각해서 훈련 데이터와 테스트 데이터를 각각 다른 스케일로 변환하게 되면 훈련 데이터에서 학습한 정보가 쓸모없게 되는 셈입니다. 마찬가지로 실전에 투입하여 새로운 데이터에 대한 예측을 만들 때도 훈련 데이터에서 계산한 값을 사용하여 정규화해야 합니다.
41 역주 사실 훈련 데이터의 통계 값으로 테스트 데이터를 전처리했듯이 검증 데이터도 훈련 데이터의 통계 값을 사용하여 전처리해야 합니다. 이렇게 하려면 앞선 전처리 과정이 K-겹 검증 루프 안으로 들어와야 합니다.
42 역주 파이썬에 익숙하지 않다면 이 코드가 낯설지도 모르겠습니다. 파이썬에서는 리스트 안에 for 문장을 놓는 리스트 내포(list comprehension) 형식이 있습니다. all_mae_histories는 4개의 폴드에 대한 검증 점수를 담고 있으므로 (4, 500) 크기입니다. 첫 번째 리스트 내포에서 폴드별로 i번째 에포크의 점수를 평균하고, 두 번째 리스트 내포에서 전체 에포크를 순회시킵니다. average_mae_ history의 크기는 (500,)이 됩니다. 넘파이를 사용하면 np.mean(all_mae_histories, axis=0)처럼 첫 번째 축을 따라 간단하게 평균을 구할 수 있습니다.
43 역주 지수 이동 평균은 시계열 데이터를 부드럽게 만드는 기법 중 하나입니다. 코드 3-31의 6번째 줄에서 이전에 계산된 이동 평균에 factor를 곱하고 현재 포인트에 (1 – factor)를 곱해 합산한 것을 가리킵니다
3.5 뉴스 기사 분류: 다중 분류 문제 | 목차 | 3.7 요약
이 글은 도서출판 길벗에서 출간한 “케라스 창시자에게 배우는 딥러닝“의 1장~3장입니다. 이 책의 저작권은 (주)도서출판 길벗에 있으므로 무단 복제 및 무단 전제를 금합니다.
[머신러닝] 머신러닝 기초 정리 예제
반응형
머신러닝에 대한 기초적인 개념을 정리하고, 데이터를 가져와서 판다스로 전처리 후에 사이킷런을 이용하여 모델을 만들고 분석을 해볼 것이다. 출퇴근하면서 핸드폰으로 쭉 보는 것을 추천한다.
머신러닝 프로세스
머신러닝 데이터 분석을 하기 위해서 컴퓨터 알고리즘이 이해할 수 있도록 관측값(observation)을 속성(feature)기준으로 정리가 필요하다. 따라서 판다스를 이용하여 정리가 필요하다. 데이터프레임에서 열은 속성을 나타내는 변수고, 행은 하나의 관측값이다.
데이터프레임으로 정리를 했으면, 모형을 학습하기 위해 사용되어지는 훈련 데이터(train data)와, 학습이 마친 모형의 예측 능력을 평가하기 위한 검증 데이터(test data)로 나눠줘야 한다.
기본적으로 판다스에 대한 설명은 아래의 url을 참고하여 공부하고 넘어오자. 여러가지 알고리즘을 통해 분석을 시작해 보자.
회기분석(regression)
회기분석에는 기본적으로 단순회귀분석과 다항회귀분석으로 나뉜다. 회기분석에 대해 조금 더 알고 싶다면 여기를 누르자. 아래에서는 단순회귀분석, 다항회귀분석, 다중회귀분석을 사이킷런을 활용하여 구현해보자.
단순회기분석(Simple Linear Regression)
어떤 변수(독립 변수X)가 다른 변수(종속 변수Y)에 영향을 준다면 두 변수 사이에 선형 관계가 있다고 할 수 있다. 단순회기분석을 활용하면, 새로운 독립변수 X 값이 주어졌을 때 거기에 대응되는 종속 변수 Y 값을 예측이 가능하다. 우선 아래의 csv파일을 받자.
auto-mpg.csv 0.02MB
우선 데이터를 불러오자.
import pandas as pd import numpy as np import matplotlib.pyplot as plt import seaborn as sns df = pd.read_csv(‘./auto-mpg.csv’, header=None) df.columns = [‘mpg’,’cylinders’,’displacement’,’horsepower’,’weight’, ‘acceleration’,’model year’,’origin’,’name’] #데이터 확인 코드 print(df.head()) print(df.info()) ”’
RangeIndex: 398 entries, 0 to 397 Data columns (total 9 columns): mpg 398 non-null float64 cylinders 398 non-null int64 displacement 398 non-null float64 horsepower 398 non-null object weight 398 non-null float64 acceleration 398 non-null float64 model year 398 non-null int64 origin 398 non-null int64 name 398 non-null object dtypes: float64(4), int64(3), object(2) memory usage: 28.1+ KB None ”’ print(df.describe()) 앞의 예제에서 봤듯, horsepower는 숫자에 ‘?’가 섞여있어서 object라고 뜬다. 따라서 변경해주자.
print(df[‘horsepower’].unique()) # horsepower 열의 고유값 확인 ”’ [‘130.0’ ‘165.0’ ‘150.0’ ‘140.0’ ‘198.0’ ‘220.0’ ‘215.0’ ‘225.0’ ‘190.0’ ‘170.0’ ‘160.0’ ‘95.00’ ‘97.00’ ‘85.00’ ‘88.00’ ‘46.00’ ‘87.00’ ‘90.00’ ‘113.0’ ‘200.0’ ‘210.0’ ‘193.0’ ‘?’ ‘100.0’ ‘105.0’ ‘175.0’ ‘153.0’ ‘180.0’ ‘110.0’ ‘72.00’ ‘86.00’ ‘70.00’ ‘76.00’ ‘65.00’ ‘69.00’ ‘60.00’ ‘80.00’ ‘54.00’ ‘208.0’ ‘155.0’ ‘112.0’ ‘92.00’ ‘145.0’ ‘137.0’ ‘158.0’ ‘167.0’ ‘94.00’ ‘107.0’ ‘230.0’ ‘49.00’ ‘75.00’ ‘91.00’ ‘122.0’ ‘67.00’ ‘83.00’ ‘78.00’ ‘52.00’ ‘61.00’ ‘93.00’ ‘148.0’ ‘129.0’ ‘96.00’ ‘71.00’ ‘98.00’ ‘115.0’ ‘53.00’ ‘81.00’ ‘79.00’ ‘120.0’ ‘152.0’ ‘102.0’ ‘108.0’ ‘68.00’ ‘58.00’ ‘149.0’ ‘89.00’ ‘63.00’ ‘48.00’ ‘66.00’ ‘139.0’ ‘103.0’ ‘125.0’ ‘133.0’ ‘138.0’ ‘135.0’ ‘142.0’ ‘77.00’ ‘62.00’ ‘132.0’ ‘84.00’ ‘64.00’ ‘74.00’ ‘116.0’ ‘82.00’] ”’ df[‘horsepower’].replace(‘?’, np.nan, inplace=True) # ‘?’을 np.nan으로 변경 df.dropna(subset=[‘horsepower’], axis=0, inplace=True) # 누락데이터 행을 삭제 df[‘horsepower’] = df[‘horsepower’].astype(‘float’) # 문자열을 실수형으로 변환
# 분석에 활용할 열(속성)을 선택 (연비, 실린더, 출력, 중량) ndf = df[[‘mpg’, ‘cylinders’, ‘horsepower’, ‘weight’]] print(ndf.head()) ”’ mpg cylinders horsepower weight 0 18.0 8 130.0 3504.0 1 15.0 8 165.0 3693.0 2 18.0 8 150.0 3436.0 3 16.0 8 150.0 3433.0 4 17.0 8 140.0 3449.0 ”’
### 종속 변수 Y인 “연비(mpg)”와 다른 변수 간의 선형관계를 그래프(산점도)로 확인 # Matplotlib으로 산점도 그리기 ndf.plot(kind=’scatter’, x=’weight’, y=’mpg’, c=’coral’, s=10, figsize=(10, 5)) # 컬러, 점크기 plt.show() plt.close()
# seaborn으로 산점도 그리기 fig = plt.figure(figsize=(10, 5)) ax1 = fig.add_subplot(1, 2, 1) ax2 = fig.add_subplot(1, 2, 2) sns.regplot(x=’weight’, y=’mpg’, data=ndf, ax=ax1) # 회귀선 표시 sns.regplot(x=’weight’, y=’mpg’, data=ndf, ax=ax2, fit_reg=False) #회귀선 미표시 plt.show() plt.close()
# seaborn 조인트 그래프 – 산점도, 히스토그램 sns.jointplot(x=’weight’, y=’mpg’, data=ndf) # 회귀선 없음 sns.jointplot(x=’weight’, y=’mpg’, kind=’reg’, data=ndf) # 회귀선 표시 plt.show() plt.close()
# seaborn pariplot으로 두 변수 간의 모든 경우의 수 그리기 ## info, describe 같은 여러개의 데이터를 한눈에 볼 수 있게 한다. sns.pairplot(ndf) plt.show() plt.close()
위에 부분은 사실 배웠던 내용이다.
데이터셋 구분
기본적으로 입력값(X)과 결과값(y)를 정해준다. 그 후에 사이킷런을 이용해서 train값과 test 값으로 나눠준다. 이 부분은 머신러닝 기초 부분을 확인하고 오자.
# 속성(변수) 선택 #독립 변수 X => 여러개가 뽑을 수 있으니, 시리즈로 하나하나 뽑아서 들어간다. # 어떠한 변수를 넣든 시리즈로 계산되어 나온다. #즉, 나중에 결과물이 나올 때 weight로 나오는 것인데, 굳이 ndf[‘weight’]를 빼고해도 ndf[[‘weight’]]로 해도 되긴한다. X=ndf[[‘weight’]] y=ndf[‘mpg’] #종속 변수 Y => 하나 print(type(X)) ”’
”’ print(type(y)) ”’ ”’ train_test_split함수를 활용하면 자동으로 train과 test를 나눠준다. 지도학습은 train_test_splilt를 사용한다.
# train data 와 test data로 구분(7:3 비율) from sklearn.model_selection import train_test_split # 트레인과 테스트를 알아서 나눠죠 X_train, X_test, y_train, y_test = train_test_split(X, #독립 변수 y, #종속 변수 test_size=0.3, #검증 30% => 트레인 사이트는 70으 된다. random_state=10) #랜덤 추출 값 -> 무자기로 10번 섞는다. print(‘train data 개수: ‘, len(X_train)) print(‘test data 개수: ‘, len(X_test)) ”’ train data 개수: 274 test data 개수: 118 ”’
사이킷런을 활용하여 회귀분석 모듈(LinearRegression)을 가져와 사용할 것이다.
# sklearn 라이브러리에서 선형회귀분석 모듈 가져오기 from sklearn.linear_model import LinearRegression # 단순회귀분석 모형 객체 생성 lr = LinearRegression() # train data를 가지고 모형 학습 # 훈련은 fit 함수로 진행한다. # fit함수로 모델구축할 때는 test가 아니라 train data로 한다. lr.fit(X_train, y_train) # 학습을 마친 모형에 test data를 적용하여 결정계수(R-제곱) 계산 / 결정계수가 높을 수록 성능이 높다. r_square = lr.score(X_test, y_test) print(r_square) # 성능이 얼마나 좋은지? ”’ 0.6822458558299325 ”’ # 회귀식의 기울기 print(‘기울기 a: ‘, lr.coef_) # Weight를 보자. ”’ 기울기 a: [-0.00775343] ”’ # 회귀식의 y절편 print(‘y절편 b’, lr.intercept_) # 절편을 보자. y절편을 가로질러서 인터셉트 ”’ y절편 b 46.710366257280086 ”’ # 모형에 전체 X 데이터를 입력하여 예측한 값 y_hat을 실제 값 y와 비교 y_hat = lr.predict(X) # 예측 함수. 예측해서 와이 햇을 구하자. plt.figure(figsize=(10, 5)) # 2개 그려죠 ax1 = sns.distplot(y, hist=False, label=”y”) # 예측모델 넣어서 해죠. ax2 = sns.distplot(y_hat, hist=False, label=”y_hat”, ax=ax1) plt.show() plt.close() # 결론 보니 비선형을 선형으로 그려서 안나오네. 선형모델로 못풀겠네.
다항회기분석(Polynomial Regression)
위에서 구현해본 단순회귀분석은 두 변수 간의 관계를 직선 형태로 설명하는 알고리즘이었다. 따라서 직선보다는 곡선으로 설명하는 것이 적합할 때는 단순회귀분석 보다는 다항 함수를 사용하여 복잡한 곡선 형태의 회귀선을 표현할 수 있다. 즉 다항회귀분석은 2차함수 이상의 다항 함수를 이용하여 두 변수 간의 선형관계를 설명하는 알고리즘이다.
Y = aX^2 +bX+c
학습을 통해 3개의 계수 a,b,c를 찾아서 모형을 완성한다.
실습을 해보자. 위에서 겹치는 부분은 빠르게 넘어가겠다.
import pandas as pd import numpy as np import matplotlib.pyplot as plt import seaborn as sns df = pd.read_csv(‘./auto-mpg.csv’, header=None) df.columns = [‘mpg’,’cylinders’,’displacement’,’horsepower’,’weight’, ‘acceleration’,’model year’,’origin’,’name’] df[‘horsepower’].replace(‘?’, np.nan, inplace=True) df.dropna(subset=[‘horsepower’], axis=0, inplace=True) df[‘horsepower’] = df[‘horsepower’].astype(‘float’) ndf = df[[‘mpg’, ‘cylinders’, ‘horsepower’, ‘weight’]] X=ndf[[‘weight’]] y=ndf[‘mpg’] from sklearn.model_selection import train_test_split X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=10)
다항회귀분석을 사용하기 위해서는 선형회귀분석에서 사용한 LinearRegression을 같게 사용하지만, PolynomialFeatures를 활용하여, 학습에서 사용하는 X값을들 이차원으로 바꾼 후에 fit에 넣어준다. 코드를 확인하다.
from sklearn.linear_model import LinearRegression from sklearn.preprocessing import PolynomialFeatures # 다항함수를 변환해준다. # preprocessing은 전처리하겠다는 말이다. # 전처리 중에 PolynomialFeatures은 비선형 feature에 복잡한 계산을 알아서 해준다. poly = PolynomialFeatures(degree=2) # degree는 차원을 의미한다 X_train_poly=poly.fit_transform(X_train) # x-train을 다항식으로 변환할 수 있도록 fit_transform을 해줌 print(‘원 데이터: ‘, X_train.shape) print(‘2차항 변환 데이터: ‘, X_train_poly.shape) ”’ 원 데이터: (274, 1) 2차항 변환 데이터: (274, 3) ”’
PolynomialFeatures를 이용하여 2차항으로 변환하겠다고 지정을 한 후에 poly 객체를 만든다. 그리고 poly 객체에 fit_transform 매소드에 X_train를 전달하면 2차항 회귀분석에 맞게 변환된다. 정리하면, x_train의 1개 열이 x_train_poly에서는 3개의 열로 늘어난다.
이제 fit 메소드를 활용하여 학습을 시작해 보자.
pr = LinearRegression() pr.fit(X_train_poly, y_train)
이제 학습을 마쳤으니, score 메소드로 모형의 결정계수(R-제곱)을 구한다. 이때 X_test도 fit_transform 매소드를 활용하여 2차항 회귀분석에 맞게 변환해야한다.
X_test_poly = poly.fit_transform(X_test) r_square = pr.score(X_test_poly,y_test) print(r_square) ”’ 0.7087009262975685 ”’
위에서 보면 70프로라는 정확도가 나온 것을 알 수 있다.
이제 train data의 산점도와 test data로 예측한 회귀선을 그래프로 출력해 보자. y_hat_test의 산점도와 test data로 예측한 회귀선을 그래프로 출력하자. predict() 메소드에 입력하여 예측한 결과인 y_hat_test를 빤간 점으로 표시하면 회귀선이 된다.
y_hat_test = pr.predict(X_test_poly) fig = plt.figure(figsize=(10, 5)) ax = fig.add_subplot(1, 1, 1) ax.plot(X_train, y_train, ‘o’, label=’Train Data’) ax.plot(X_test, y_hat_test, ‘r+’, label=’Predicted Value’) ax.legend(loc=’best’) # loc는 최고에다가 알아서 찍어죠. plt.xlabel(‘weight’) plt.ylabel(‘mpg’) plt.show() plt.close()
이제 실제 값과 예측 값을 비교해 보자. Seaborn 라이브러리의 distplot() 함수를 사용하여 실제 값 y와 d예측값 y_hat의 분포 차이를 비교한다.
X_ploy = poly.fit_transform(X) y_hat = pr.predict(X_ploy) plt.figure(figsize=(10, 5)) ax1 = sns.distplot(y, hist=False, label=”y”) ax2 = sns.distplot(y_hat, hist=False, label=”y_hat”, ax=ax1) plt.show() plt.close()
단순 회기분석의 결과와 비교할 때 데이터가 어느한 쪽으로 편향되는 경향이 감소한 것을 보면, 더 적합한 모형이라고 할 수 있다.
다중회귀분석(Multivariate Regression)
여러 개의 독립 변수가 종속 변수에 영향을 주고 선형 관계를 갖는 경우를 다중회귀분석이라 한다. 우선은 위랑 동일한 코드를 우선 작성해 보자.
import pandas as pd import numpy as np import matplotlib.pyplot as plt import seaborn as sns df = pd.read_csv(‘./auto-mpg.csv’, header=None) df.columns = [‘mpg’,’cylinders’,’displacement’,’horsepower’,’weight’, ‘acceleration’,’model year’,’origin’,’name’] df[‘horsepower’].replace(‘?’, np.nan, inplace=True) df.dropna(subset=[‘horsepower’], axis=0, inplace=True) df[‘horsepower’] = df[‘horsepower’].astype(‘float’) ndf = df[[‘mpg’, ‘cylinders’, ‘horsepower’, ‘weight’]]
아래와 같이 X 값에는 독립변수 3개를 넣고 data를 구분해 주자.
X=ndf[[‘cylinders’, ‘horsepower’, ‘weight’]] # 독립변수 y=ndf[‘mpg’] # 종속 변수 from sklearn.model_selection import train_test_split X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=10) print(‘훈련 데이터: ‘, X_train.shape) print(‘검증 데이터: ‘, X_test.shape) ”’ 훈련 데이터: (274, 3) 검증 데이터: (118, 3) ”’
이 후에는 LinearRegression() 함수를 사용하여 회귀분석 모형 객체를 생성하고 앞에서 진행한 부분과 동일하게 진행한다.
from sklearn.linear_model import LinearRegression lr = LinearRegression() lr.fit(X_train, y_train) r_square = lr.score(X_test, y_test) print(r_square) # 결정계수 ”’ 0.6939048496695599 ”’ print(‘X 변수의 계수 a: ‘, lr.coef_) ”’ X 변수의 계수 a: [-0.60691288 -0.03714088 -0.00522268] ”’ print(‘상수항 b’, lr.intercept_) ”’ 상수항 b 46.414351269634025 ”’ y_hat = lr.predict(X_test) plt.figure(figsize=(10, 5)) ax1 = sns.distplot(y_test, hist=False, label=”y_test”) ax2 = sns.distplot(y_hat, hist=False, label=”y_hat”, ax=ax1) plt.show() plt.close()
그래프를 보면 한쪽으로 편향되는 경향은 그대로 남아 있지만 그래프의 첨도(뾰족한 정도)가 약간 누그러진 것을 볼 수 있다.
분류(classification)
분류는 대상의 속성을 입력 받고, 목표 변수가 갖고 있는 케테고리(범주형) 값 중에서 분류하여 예측한다. 목표 변수 값을 함께 입력하기 때문에 지도 학습 유형에 속하는 알고리즘이다. KNN, SVM, Decision Tree, Logistic Regression 등의 알고리즘이 존재한다.
KNN(k-Nearest-Neighbors)
KNN은 k개의 가까운 이웃이라는 뜻이다. 관측값이 주어지면 관측값을 기준으로 가까운 순서로 k개의 속성을 찾고, 가장 많은 속성으로 분류한다. 이때 k값에 따라 정확도가 달라지므로 적절한 k값을 찾는 것이 매우 중요하다.
데이터는 Seaborn 라이브러리에서 ‘titanic’ 데이터셋을 활용한다. 이전 블로그에서 다뤘으므로 데이터에 설명은 생락한다.
import pandas as pd import seaborn as sns df = sns.load_dataset(‘titanic’) print(df.head()) ”’ survived pclass sex age sibsp parch fare embarked class \ 0 0 3 male 22.0 1 0 7.2500 S Third 1 1 1 female 38.0 1 0 71.2833 C First 2 1 3 female 26.0 0 0 7.9250 S Third 3 1 1 female 35.0 1 0 53.1000 S First 4 0 3 male 35.0 0 0 8.0500 S Third who adult_male deck embark_town alive alone 0 man True NaN Southampton no False 1 woman False C Cherbourg yes False 2 woman False NaN Southampton yes True 3 woman False C Southampton yes False 4 man True NaN Southampton no True ”’ print(df.info()) ”’
RangeIndex: 891 entries, 0 to 890 Data columns (total 15 columns): # Column Non-Null Count Dtype — —— ————– —– 0 survived 891 non-null int64 1 pclass 891 non-null int64 2 sex 891 non-null object 3 age 714 non-null float64 4 sibsp 891 non-null int64 5 parch 891 non-null int64 6 fare 891 non-null float64 7 embarked 889 non-null object 8 class 891 non-null category 9 who 891 non-null object 10 adult_male 891 non-null bool 11 deck 203 non-null category 12 embark_town 889 non-null object 13 alive 891 non-null object 14 alone 891 non-null bool dtypes: bool(2), category(2), float64(2), int64(4), object(5) memory usage: 80.6+ KB None ”’ 데이터에서 NaN값이 많은 열을 삭제하고 전처리를 진행하자.
rdf = df.drop([‘deck’, ’embark_town’], axis=1) # axis=1 열 기준 연산 print(rdf.columns.values) ”’ [‘survived’ ‘pclass’ ‘sex’ ‘age’ ‘sibsp’ ‘parch’ ‘fare’ ’embarked’ ‘class’ ‘who’ ‘adult_male’ ‘alive’ ‘alone’] ”’ rdf = rdf.dropna(subset=[‘age’], how=’any’, axis=0) most_freq = rdf[’embarked’].value_counts(dropna=True).idxmax() # print(rdf.describe(include=’all’)) rdf[’embarked’].fillna(most_freq, inplace=True)
분석에 사용할 속성을 지정하고, get_dummies를 활용하여 원핫인코딩을 적용하고 prefix 옵션을 사용하여 접두어를 붙여주자.
ndf = rdf[[‘survived’, ‘pclass’, ‘sex’, ‘age’, ‘sibsp’, ‘parch’, ’embarked’]] onehot_sex = pd.get_dummies(ndf[‘sex’]) ndf = pd.concat([ndf, onehot_sex], axis=1) onehot_embarked = pd.get_dummies(ndf[’embarked’], prefix=’town’) ndf = pd.concat([ndf, onehot_embarked], axis=1) ndf.drop([‘sex’, ’embarked’], axis=1, inplace=True)
독립변수를 지정하고 StandardScaler()preprocessing.StandardScaler().fit(X).transform(X)을 활용하여 데이터의 상대적 크기 차이를 없애기 위하여 데이터 정규화(normalization)을 진행한다.
X=ndf[[‘pclass’, ‘age’, ‘sibsp’, ‘parch’, ‘female’, ‘male’, ‘town_C’, ‘town_Q’, ‘town_S’]] #독립 변수 X y=ndf[‘survived’] from sklearn import preprocessing X = preprocessing.StandardScaler().fit(X).transform(X) # standardScaler => 통계화 시킴. from sklearn.model_selection import train_test_split X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=10)
사이킷런에서 KNeighborsClassifier를 통해 KNN 분류 모형을 가져오자. 이때 k값을 넣어준다. 비지도라 k값은 알 수가 없고 여러개 해보고 제일 좋은 것을 선택한다. 그리고 학습을 진행하고 예측값과 결과값을 비교해 보자.
from sklearn.neighbors import KNeighborsClassifier # 최근접 분류모델을 쓴다. knn = KNeighborsClassifier(n_neighbors=5) knn.fit(X_train, y_train) y_hat = knn.predict(X_test) print(y_hat[0:10]) print(y_test.values[0:10]) ”’ [0 0 1 0 0 1 1 1 0 0] [0 0 1 0 0 1 1 1 0 0] ”’
모형의 예측 능력을 평가해 보자. metrics 모듈의 confusion_matrix() 함수를 사용하여 Confusion Matrix를 계산하자. 그리고 classification_report() 함수를 사용하여 precision, recall, f1-score 지표를 출력해 준다. 관련 개념은 코드 아래부분을 참고하자.
from sklearn import metrics knn_matrix = metrics.confusion_matrix(y_test, y_hat) # 메트릭스 => 평가 측정 지표… print(knn_matrix) knn_report = metrics.classification_report(y_test, y_hat) # 정리해서 도출되기 때문에 R보다 좋다 print(knn_report) # confusion_matrix는 헷갈리고 시험도 많이 나온다. ”’ [[109 16] [ 25 65]] precision recall f1-score support 0 0.81 0.87 0.84 125 1 0.80 0.72 0.76 90 avg / total 0.81 0.81 0.81 215 ”’
위의 내용에 대한 설명은 아래와 같다.
분류 모형의 예측력을 평가하는 지표
1. Confusion Matrix
모형을 예측하는 값에는 True와 False가 있다. 그리고 아래의 그림과 같이 모형의 예측값과 실제 값을 각각 축으로 하는 2×2 매트릭스로 표현한 것을 Confusion Matrix라고 부른다.
T
예측값
F
TP
(True Positive)
FP
(False Positive)
FN
(False Negative)
TN
(True Negative)
T F
실제값
2. 정확도(Precision)
True로 예측한 분석대상 중에서 실제 값이 True인 비율을 말하며, 모형의 정확성을 나타내는 지표가 된다. 정확도가 높다는 것은 False Positive(실제 False를 True로 잘못 예측) 오류가 적다는 말이다.
Precision = TP / (TP+FP)
3. 재현율(Recall)
실제 값이 True인 분석대상 중에서 True로 예측하여 모형이 적중한 비율을 말하며, 모형의 완전성을 나타내는 지표이다. 재현율이 높다는 것은 False Negative(실제 True를 False로 잘못 예측) 오류가 낮다는 뜻이다.
Recall = TP / (TP+FN)
4. F1 지표(F1-score)
정확도와 재현율이 균등하게 반영될 수 있도록 정확도와 재현율의 조화평균을 계산한 값으로, 모형의 예측력을 종합적으로 평가하는 지표이다. 값이 높을수록 분류 모형의 예측력이 좋다고 말할 수 있다.
F1 score = 2* ( Precision * Recall ) / ( Precision + Recall )
SVM(Support Vector Machine)
분류모델 중 하나로 벡터(vector) 개념을 가져와서 사용한다. 데이터프레임의 각 열이 고유의 축을 가지는 벡터공간을 만들고, 각각의 개별의 모든 속성이 축의 좌표로 표시되어 벡터 공간에서 위치를 나타낸다. 속성(열)이 2개가 존재하면 2차원, 4개가 존재하면 4차원 평면 공간에 데이터 셋이 좌표로 표시된다.
같은 분류 값인 데이터끼리 같은 공간에 위치시켜 벡터 공간을 여러 조각으로 나누고, 새로운 데이터에 대하여 어느 공간에 위치하는지 분류할 수 있게 한다.
위에서 반복되는 코드는 빠르게 넘어가 보자.
import pandas as pd import seaborn as sns df = sns.load_dataset(‘titanic’) # NaN값이 많은 deck 열을 삭제, embarked와 내용이 겹치는 embark_town 열을 삭제 rdf = df.drop([‘deck’, ’embark_town’], axis=1) # age 열에 나이 데이터가 없는 모든 행을 삭제 – age 열(891개 중 177개의 NaN 값) rdf = rdf.dropna(subset=[‘age’], how=’any’, axis=0) # embarked 열의 NaN값을 승선도시 중에서 가장 많이 출현한 값으로 치환하기 most_freq = rdf[’embarked’].value_counts(dropna=True).idxmax() rdf[’embarked’].fillna(most_freq, inplace=True) ndf = rdf[[‘survived’, ‘pclass’, ‘sex’, ‘age’, ‘sibsp’, ‘parch’, ’embarked’]] onehot_sex = pd.get_dummies(ndf[‘sex’]) ndf = pd.concat([ndf, onehot_sex], axis=1) onehot_embarked = pd.get_dummies(ndf[’embarked’], prefix=’town’) ndf = pd.concat([ndf, onehot_embarked], axis=1) ndf.drop([‘sex’, ’embarked’], axis=1, inplace=True) X=ndf[[‘pclass’, ‘age’, ‘sibsp’, ‘parch’, ‘female’, ‘male’, ‘town_C’, ‘town_Q’, ‘town_S’]] #독립 변수 X y=ndf[‘survived’] #종속 변수 Y from sklearn import preprocessing X = preprocessing.StandardScaler().fit(X).transform(X) from sklearn.model_selection import train_test_split X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=10)
사이킷런에서 svm을 불러과서 구현을 해주자. 이때 kernel=’rbf’를 넣어주자. 안 넣어주면 에러가 뜬다.
from sklearn import svm # kernel 이란? 데이터를 벡터 공간으로 매핑하는 함수 # rbf : radial basis function svm_model = svm.SVC(kernel=’rbf’) svm_model.fit(X_train, y_train) y_hat = svm_model.predict(X_test) print(y_hat[0:10]) print(y_test.values[0:10]) ”’ [0 0 1 0 0 0 1 0 0 0] [0 0 1 0 0 1 1 1 0 0] ”’
위의 결과를 보면 첫 10개 데이터 중에서 8개만 일치한다. 이제 모형의 예측 능력을 지표로 뽑아보자.
### True False 문제이기 때문에 분류문제는 confusion_matrix를 쓴다. ### from sklearn import metrics svm_matrix = metrics.confusion_matrix(y_test, y_hat) print(svm_matrix) ”’ [[120 5] [ 35 55]] ”’ svm_report = metrics.classification_report(y_test, y_hat) print(svm_report) ”’ precision recall f1-score support 0 0.77 0.96 0.86 125 1 0.92 0.61 0.73 90 accuracy 0.81 215 macro avg 0.85 0.79 0.80 215 weighted avg 0.83 0.81 0.81 215 ”’
confusion_matrix를 보면 215명의 승객 중에서 미생존자를 정확히 예측한 TP는 120명, 미생존자를 생존자로 잘못 분류한 FP는 5명, 생존자를 미생존자로 잘못 분류한 FN은 35명, 생존자를 정확하게 예측한 TN은 55명이다. 이때, 미생존자는 0의 값을 가져 False고, 생존자가 1의 값을 가져서 True가 되어 confusion_matrix를 계산한 것이다.
classification_report() 함수로 출력된 precision, recall, f1-score 지표를 보자. f1-score 지표를 보면 미생존자(0) 예측의 정확도가 0.86이고, 생존자(1) 예측의 정확도는 0.73으로 예측 능력에 차이가 있다. 사실 KNN 모형과 예측 능력에는 큰 차이가 없다.
의사결정 나무 (Decision Tree)
컴퓨터 알고리즘에서 즐겨 사용하는 트리(tree) 구조를 사용하고, 각 분기점(node)에는 목표 값을 가장 잘 분류할 수 있는 분석대상의 속성(설명 변수)들이 위치한다.
각각의 분기점에서 최적 속성을 선택 시 속성을 기준으로 분류한 값들이 구분되는 정도를 측정한다. 이 때 Entropy를 주로 활용하는데, Entropy가 낮을수록 분류가 잘 된 것이고, Entropy가 일정 수준 이하로 낮아질 때까지 앞의 과정을 반복한다. 즉, 각 분기점에서 최적의 속성을 찾기 위해 분류 정도를 평가하는 기준이 entropy이다.
바로 코드를 보자.
import pandas as pd import numpy as np # Breast Cancer 데이터셋 가져오기 (출처: UCI ML Repository) uci_path = ‘https://archive.ics.uci.edu/ml/machine-learning-databases/\ breast-cancer-wisconsin/breast-cancer-wisconsin.data’ df = pd.read_csv(uci_path, header=None) df.columns = [‘id’,’clump’,’cell_size’,’cell_shape’, ‘adhesion’,’epithlial’, ‘bare_nuclei’,’chromatin’,’normal_nucleoli’, ‘mitoses’, ‘class’] print(df.head()) ”’ id clump cell_size cell_shape adhesion epithlial bare_nuclei \ 0 1000025 5 1 1 1 2 1 1 1002945 5 4 4 5 7 10 2 1015425 3 1 1 1 2 2 3 1016277 6 8 8 1 3 4 4 1017023 4 1 1 3 2 1 chromatin normal_nucleoli mitoses class 0 3 1 1 2 1 3 2 1 2 2 3 1 1 2 3 3 7 1 2 4 3 1 1 2 ”’ print(df.info()) ”’
RangeIndex: 699 entries, 0 to 698 Data columns (total 11 columns): # Column Non-Null Count Dtype — —— ————– —– 0 id 699 non-null int64 1 clump 699 non-null int64 2 cell_size 699 non-null int64 3 cell_shape 699 non-null int64 4 adhesion 699 non-null int64 5 epithlial 699 non-null int64 6 bare_nuclei 699 non-null object 7 chromatin 699 non-null int64 8 normal_nucleoli 699 non-null int64 9 mitoses 699 non-null int64 10 class 699 non-null int64 dtypes: int64(10), object(1) memory usage: 60.2+ KB None ”’ print(df.describe()) ”’ id clump cell_size cell_shape adhesion \ count 6.990000e+02 699.000000 699.000000 699.000000 699.000000 mean 1.071704e+06 4.417740 3.134478 3.207439 2.806867 std 6.170957e+05 2.815741 3.051459 2.971913 2.855379 min 6.163400e+04 1.000000 1.000000 1.000000 1.000000 25% 8.706885e+05 2.000000 1.000000 1.000000 1.000000 50% 1.171710e+06 4.000000 1.000000 1.000000 1.000000 75% 1.238298e+06 6.000000 5.000000 5.000000 4.000000 max 1.345435e+07 10.000000 10.000000 10.000000 10.000000 epithlial chromatin normal_nucleoli mitoses class count 699.000000 699.000000 699.000000 699.000000 699.000000 mean 3.216023 3.437768 2.866953 1.589413 2.689557 std 2.214300 2.438364 3.053634 1.715078 0.951273 min 1.000000 1.000000 1.000000 1.000000 2.000000 25% 2.000000 2.000000 1.000000 1.000000 2.000000 50% 2.000000 3.000000 1.000000 1.000000 2.000000 75% 4.000000 5.000000 4.000000 1.000000 4.000000 max 10.000000 10.000000 10.000000 10.000000 4.000000 ”’ 위의 값을 보면 ‘bare_nuclei’ 열을 제외한 나머지 열은 모두 숫자다. unique() 를 이용해서 확인해 보고 replace와 dropna를 이용해서 누락행을 지워보자.
print(df[‘bare_nuclei’].unique()) ”’ [‘1′ ’10’ ‘2’ ‘4’ ‘3’ ‘9’ ‘7’ ‘?’ ‘5’ ‘8’ ‘6’] ”’ df[‘bare_nuclei’].replace(‘?’, np.nan, inplace=True) df.dropna(subset=[‘bare_nuclei’], axis=0, inplace=True) df[‘bare_nuclei’] = df[‘bare_nuclei’].astype(‘int’)
이제 설명 변수 X와 예측 변수로 사용할 열을 분리한다. 그 후에 설명 변수를 정규화(서로 다른 데이터 값들을 모음)하고 훈련 데이터와 검증 데이터를 분리한다.
X=df[[‘clump’,’cell_size’,’cell_shape’, ‘adhesion’,’epithlial’, ‘bare_nuclei’,’chromatin’,’normal_nucleoli’, ‘mitoses’]] #설명 변수 X y=df[‘class’] from sklearn import preprocessing X = preprocessing.StandardScaler().fit(X).transform(X) from sklearn.model_selection import train_test_split X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=10)
이제 DecisionTreeClassifier() 함수를 사용하여 모형 객체를 생성하자. 각 분기점에서 최적의 속성을 찾기 위한 평가 기준으로 ‘entropy’ 값을 사용한다. 그리고 ‘max_depth’으로 트리 레벨을 지정가능하다. 아래처럼 5로 지정을 하면 5단계까지 가지를 확장할 수 있어진다. 레벨이 많아 질수록 예측은 정확해지지만, 너무 많은 트리는 훈련과정에서 train_data에만 지나치게 최적화되어 실제 데이터 예측 능력이 떨어진다. 따라서 적정한 레벨값을 찾는 것이 중요하다.
그리고 fit() 으로 모형을 학습시키고, predict() 매소드에 검증 데이터(x_test)를 전달하여 예측된 결과를 y_hat에 저장한다.
from sklearn import tree tree_model = tree.DecisionTreeClassifier(criterion=’entropy’, max_depth=5) # 5단계까지 가지 확장 tree_model.fit(X_train, y_train) y_hat = tree_model.predict(X_test) # 2: benign(양성), 4: malignant(악성) print(y_hat[0:10]) print(y_test.values[0:10]) ”’ [4 4 4 4 4 4 2 2 4 4] [4 4 4 4 4 4 2 2 4 4] ”’
성능 평가를 통해 Confusion Matrix를 계산해보자.
from sklearn import metrics tree_matrix = metrics.confusion_matrix(y_test, y_hat) print(tree_matrix) ”’ [[127 4] [ 2 72]] ”’ tree_report = metrics.classification_report(y_test, y_hat) print(tree_report) ”’ precision recall f1-score support 2 0.98 0.97 0.98 131 4 0.95 0.97 0.96 74 accuracy 0.97 205 macro avg 0.97 0.97 0.97 205 weighted avg 0.97 0.97 0.97 205 ”’
Confusion Matrix를 보면 양성을 정확히 예측한 TP는 127개, 양성을 악성으로 잘못 분류한 FP는 4개, 악성을 양성으로 잘못 분류한 FN은 2개, 악성을 정확하게 예측한 TN은 72개이다. f1-csore 지표를 보면 양성 종량(2) 예측 정확도가 0.98이고, 악성 종양(4) 예측의 정확도는 0.96으로 예측 능력에 큰 차이가 없다. 평균적으로 0.97의 정확도를 가진다고 볼 수 있다.
군집(clustering)
군집 분석은 비지도학습 유형으로 데이터셋의 관측값이 갖고 있는 여러 속성을 분석하여 서로 비슷한 특징을 갖는 관측값끼리 같은 클러스트(집단)로 묶는 알고리즘이다. 각각의 클러스트는 서로 완전하게 구분되는 특징을 가지기 때문에 어느 클러스트에도 속하지 못하는 관측값이 존재할 수 있다. 따라서 이런 특성을 이용하여 특이 데이터(이상값, 중복값 등)을 찾는데 활용되기도 한다.
비지도학습이기 때문에 군집 분석은 정답이 없는 상태에서 데이터 자체의 유사성만을 기준으로 판단한다. 군집 알고리즘은 신용카드 부정 사용 탐지, 구매 패턴 분석 등 소비자 행동 특성을 그룹화 하는데 사용된다. 어떤 소비자와 유사한 특성을 갖는 집단을 구분하게 되면, 새로운 소비자의 구매 패턴이나 행동 등을 예측하는데 활용할 수 있다. 여기서는 k-means 알고리즘과 DBSCAN 알고리즘에 대해 알아보자.
k-Means
데이터 간의 유사성을 측정하는 기준으로 각 클러스터의 중심까지의 거리를 이용한다. k개의 클러스터가 주어진다면, 각각의 클러스터에서 거리가 가까운 클러스터로 해당 데이터를 할당한다. 그리고 클러스트는 완전한 구분을 위해서 일정한 거리 이상 떨어져야 한다. k 값이 클수록 일반적으로 모형의 정확도는 개선이 되지만, 너무 커지면 선택지가 많아지기 때문에 분석의 효과가 떨어진다.
데이터는 UCI ML Repository의 도매업 고객(wholesale customers) 데이터 셋을 사용한다. URL을 입력하여 다운받아서 실습을 해보자. ‘Channel’ 열은 호텔/레스토랑 또는 소매점 등 판매채너러 값이고, ‘Region’ 열은 고객 소재지를 나타낸다.
import pandas as pd import matplotlib.pyplot as plt uci_path = ‘https://archive.ics.uci.edu/ml/machine-learning-databases/\ 00292/Wholesale%20customers%20data.csv’ df = pd.read_csv(uci_path, header=0) print(df.head()) ”’ Channel Region Fresh Milk Grocery Frozen Detergents_Paper Delicassen 0 2 3 12669 9656 7561 214 2674 1338 1 2 3 7057 9810 9568 1762 3293 1776 2 2 3 6353 8808 7684 2405 3516 7844 3 1 3 13265 1196 4221 6404 507 1788 4 2 3 22615 5410 7198 3915 1777 5185 ”’ print(df.info()) ”’
RangeIndex: 440 entries, 0 to 439 Data columns (total 8 columns): # Column Non-Null Count Dtype — —— ————– —– 0 Channel 440 non-null int64 1 Region 440 non-null int64 2 Fresh 440 non-null int64 3 Milk 440 non-null int64 4 Grocery 440 non-null int64 5 Frozen 440 non-null int64 6 Detergents_Paper 440 non-null int64 7 Delicassen 440 non-null int64 dtypes: int64(8) memory usage: 27.6 KB None ”’ print(df.describe()) ”’ Channel Region Fresh Milk Grocery \ count 440.000000 440.000000 440.000000 440.000000 440.000000 mean 1.322727 2.543182 12000.297727 5796.265909 7951.277273 std 0.468052 0.774272 12647.328865 7380.377175 9503.162829 min 1.000000 1.000000 3.000000 55.000000 3.000000 25% 1.000000 2.000000 3127.750000 1533.000000 2153.000000 50% 1.000000 3.000000 8504.000000 3627.000000 4755.500000 75% 2.000000 3.000000 16933.750000 7190.250000 10655.750000 max 2.000000 3.000000 112151.000000 73498.000000 92780.000000 Frozen Detergents_Paper Delicassen count 440.000000 440.000000 440.000000 mean 3071.931818 2881.493182 1524.870455 std 4854.673333 4767.854448 2820.105937 min 25.000000 3.000000 3.000000 25% 742.250000 256.750000 408.250000 50% 1526.000000 816.500000 965.500000 75% 3554.250000 3922.000000 1820.250000 max 60869.000000 40827.000000 47943.000000 ”’ 비지도 학습 모형이므로 예측 변수를 지정할 필요가 없고 필요한 속성을 모두 설명 변수로 활용한다. StandardScaler() 함수 등을 이용하여 학습 데이터를 정규화하여 상대적 크기 차이를 줄여준다.
X = df.iloc[:, :] from sklearn import preprocessing X = preprocessing.StandardScaler().fit(X).transform(X) print(X[:5]) ”’ [[ 1.44865163 0.59066829 0.05293319 0.52356777 -0.04111489 -0.58936716 -0.04356873 -0.06633906] [ 1.44865163 0.59066829 -0.39130197 0.54445767 0.17031835 -0.27013618 0.08640684 0.08915105] [ 1.44865163 0.59066829 -0.44702926 0.40853771 -0.0281571 -0.13753572 0.13323164 2.24329255] [-0.69029709 0.59066829 0.10011141 -0.62401993 -0.3929769 0.6871443 -0.49858822 0.09341105] [ 1.44865163 0.59066829 0.84023948 -0.05239645 -0.07935618 0.17385884 -0.23191782 1.29934689]] ”’
사이킷런에서 cluster 무듈을 import 한다. 그리고 KMeans() 함수로 모형 객체를 생성하는데 n_clusters 옵션을 사용하여 클러스터 개수를 5로 지정해 주잔 후에 fit()으로 학습을 하자.
from sklearn import cluster kmeans = cluster.KMeans(init=’k-means++’, n_clusters=5, n_init=10) # 클러스터 개수: 5개 cluster.KMeans() kmeans.fit(X) cluster_label = kmeans.labels_ print(cluster_label) ”’ [1 1 1 2 1 1 1 1 2 1 1 1 1 1 1 2 1 2 1 2 1 2 2 0 1 1 2 2 1 2 2 2 2 2 2 1 2 1 1 2 2 2 1 1 1 1 1 3 1 1 2 2 1 1 2 2 3 1 2 2 1 3 1 1 2 3 2 1 2 2 2 0 2 1 1 2 2 1 2 2 2 1 1 2 1 3 3 0 2 2 2 2 3 0 1 2 1 2 2 2 1 1 1 0 2 2 1 1 1 1 2 1 2 2 2 2 2 2 2 2 2 2 2 1 2 0 2 1 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 1 2 2 2 2 2 2 2 2 2 1 1 2 1 1 1 2 2 1 1 1 1 2 2 2 1 1 2 1 2 1 2 2 2 2 2 0 2 0 2 2 2 2 1 1 2 2 2 1 2 2 4 1 4 4 1 1 4 4 4 1 4 4 4 1 4 3 4 4 1 4 1 4 1 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 1 4 4 4 4 4 3 4 4 4 4 4 4 4 4 4 4 4 4 1 4 1 4 1 4 4 4 4 2 2 2 2 2 2 1 2 1 2 2 0 2 2 2 2 2 2 2 2 1 4 1 4 1 1 4 1 1 1 1 1 1 1 4 4 1 4 4 1 4 4 1 4 4 4 1 4 4 4 4 4 0 4 4 4 4 4 1 4 3 4 1 4 4 4 4 1 1 2 1 2 2 1 1 2 1 2 1 2 1 2 2 2 1 2 2 2 2 2 2 2 1 2 2 2 2 1 2 2 1 2 2 1 2 2 1 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 1 2 2 2 2 2 2 2 2 2 2 1 1 2 2 2 2 2 2 1 1 2 1 2 2 1 2 1 1 2 2 2 2 2 2 2 2 2 2 2 2 1 2 2] ”’ df[‘Cluster’] = cluster_label
위의 결과를 보면 모형은 8개의 속성을 활용하여 관측값을 5개의 클러스터로 구분하여 준다. 이제 그래프를 그려보자. 8개의 변수를 하나의 그래프로 표현할 수 없어서 2개의 변수한 선택해서 해보자.
df.plot(kind=’scatter’, x=’Grocery’, y=’Frozen’, c=’Cluster’, cmap=’Set1′, colorbar=False, figsize=(10, 10)) df.plot(kind=’scatter’, x=’Milk’, y=’Delicassen’, c=’Cluster’, cmap=’Set1′, colorbar=True, figsize=(10, 10)) plt.show() plt.close()
그래프를 보면 자나치게 큰 값으로 구성되는 클러스터인 라벨이 0과 4를 제외하고 1, 2, 3에 속하는 데이터만으로 다시 그려보자.
mask = (df[‘Cluster’] == 0) | (df[‘Cluster’] == 4) ndf = df[~mask] # not ndf.plot(kind=’scatter’, x=’Grocery’, y=’Frozen’, c=’Cluster’, cmap=’Set1′, colorbar=False, figsize=(5, 5)) ndf.plot(kind=’scatter’, x=’Milk’, y=’Delicassen’, c=’Cluster’, cmap=’Set1′, colorbar=True, figsize=(5, 5)) plt.show() plt.close()
반응형
강의 02 현대 자동차 가격 예측 모델 학습
토닥토닥 sklearn – 머신러닝
01 장 머리말 ——————–
섹션 01 머리말
강의 01 머리말
섹션 02 선수 과목
강의 01 토닥토닥 파이썬 – 데이터 분석 (링크)
강의 02 토닥토닥 파이썬 – 웹 프로그램 만들기 (플라스크) (링크)
02 장 머신러닝 ——————–
섹션 00 인공 지능
강의 01 인공 지능
강의 02 인공 지능의 역사
섹션 01 머신러닝
강의 01 머신러닝
강의 01 인공지능
섹션 02 머신러닝 활용 사례
강의 01 머신러닝 활용 사례
추가자료및 임시 이미지
강의 02 이미지를 위한 머신러닝 활용 사례 (링크)
강의 03 텍스트를 위한 머신러닝 활용 사례 (링크)
강의 04 검색 기반 챗봇을 위한 머신러닝 활용 사례 (링크)
강의 05 글쓰기를 위한 머신러닝 활용 사례 (링크)
강의 06 번역을 위한 머신러닝 활용 사례 (링크)
강의 07 생성 챗봇을 위한 머신러닝 활용 사례 (링크)
강의 08 사운드를 위한 머신러닝 활용 사례 (링크)
강의 09 음성 챗봇을 위한 머신러닝 활용 사례 (링크)
강의 10 시계열 회귀를 위한 머신러닝 활용 사례 (링크)
강의 11 추천 시스템을 위한 머신러닝 활용 사례 (링크)
섹션 03 머신러닝 절차
강의 01 머신러닝 절차
섹션 04 머신러닝 모델
강의 01 머신러닝 모델
03 장 sklearn ——————–
섹션 01 프로그램 설치
강의 03 pandas 패키지 설치 (링크)
강의 04 xlrd 패키지 설치 (링크)
강의 05 sklearn 패키지 설치
강의 06 matplotlib 패키지 설치 (링크)
강의 07 seaborn 패키지 설치 (링크)
섹션 02 sklearn
강의 01 sklearn
04 장 기학습 모델 ——————–
섹션 01 기학습 모델
강의 01 기학습 모델
섹션 02 실전 문제
강의 01 붗꽃 종류 데이터셋 소개 (링크)
강의 02 붗꽃 종류 분류 모델 다운로드 (링크)
강의 03 붗꽃 종류 분류 (링크)
05-2 장 웹 서버 프로그램 만들기 ——————–
섹션 01 프로그램 설치
강의 01 flask 패키지 설치 (링크)
섹션 02 웹 서버 프로그램 만들기
강의 01 웹 서버 프로그램 만들기 (링크)
섹션 03 로컬 서버 실행
강의 01 로컬 서버 실행 (링크)
강의 02 웹 페이지 접속 (링크)
섹션 04 HTML 템플릿
강의 01 HTML 템플릿 (링크)
강의 02 템플릿으로 데이터 보내기 (링크)
섹션 05 정적 페이지
강의 01 정적 페이지 (링크)
섹션 06 REST API 만들기
강의 01 REST API 만들기 (링크)
섹션 07 REST API 만들기 (매개 변수)
강의 01 REST API 만들기 (링크)
강의 02 REST API 사용 (링크)
강의 03 REST API 사용 (jQuery) (링크)
섹션 08 REST API 만들기 (json 매개 변수)
강의 01 REST API 만들기 (링크)
강의 02 REST API 사용 (링크)
강의 03 REST API 사용 (jQuery) (링크)
07 장 인공지능 웹 사이트 만들기 ——————–
섹션 01 실전 문제
강의 01 붗꽃 종류 분류 REST API 만들기–임시이미지
섹션 02 실전 문제 (json 매개 변수)
강의 01 붗꽃 종류 분류 REST API 만들기
강의 02 REST API 사용
강의 03 REST API 사용 (jQuery)
08 장 회귀 ——————–
섹션 01 회귀
강의 01 회귀
강의 02 회귀 모델
섹션 02 선형 회귀 모델
강의 01 선형 회귀 모델
강의 01 회귀 (Regression) 문제
참고
강의 02 최소 제곱법 학습
강의 03 선형 회귀 모델 (시각화)
LinearRegression 선그리기
강의 04 단일 특성
강의 04 단일 특성
강의 05 계수
강의 06 다중 특성
강의 07 넘파이
강의 08 앞에 배치 차원 추가
섹션 03 회귀 모델 검증
강의 01 모델 검증을 위해 데이터를 학습 데이터와 테스트 데이터로 나누기
강의 02 수작업으로 데이터 나누기
old 강의 07 시험 점수 예측 모델 학습 (수작업으로 데이터 나누기)
강의 03 train_test_split으로 데이터 나누기
강의 04 zip
강의 05 검증 척도
강의 11 회귀 모델 검증 척도
강의 06 검증 척도 (make_scorer 함수)
강의 07 검증 척도 (SCORERS 사전)
강의 08 검증 척도 (score 메서드)
강의 09 기타 검증 척도
구현
강의 10 사용자 정의 검증 척도
섹션 04 하이퍼파라미터 튜닝 ——————–
강의 01 하이퍼파라미터 튜닝
섹션 05 데이터 전처리
강의 01 데이터 전처리
강의 02 결측치 대치
강의 03 결측치 대치 (특성별)
강의 04 범주 특성을 원핫 인코딩으로 변환
강의 05 정규화–특성 스케일링
강의 06 최소 최대 정규화 ([0, 1])
임시 이미지
강의 07 표준 정규화 ([-1, 1])
강의 08 표준 정규화 (RobustScaler)
강의 09 표준 정규화 (Nomalizer)
섹션 06 데이터 전처리 (특성 선택)
강의 01 특성 선택
임시 이미지
강의 02 단변량 특성 선택
강의 03 모델 기반 특성 선택 (수동)
강의 04 모델 기반 특성 선택 (자동)
강의 05 반복적 특성 선택
강의 05 부분 의존도
섹션 07 데이터 전처리 (특성 합성)
강의 01 특성 합성
강의 02 구간화
강의 03 차원 축소
섹션 08 데이터 전처리 (트랜스포머 연결)
강의 01 트랜스포머 연결
섹션 09 파일에서 데이터 읽기
강의 01 엑셀 파일에서 데이터 읽기 (xlsx) (링크)
강의 02 CSV 파일에서 데이터 읽기 (csv) (링크)
섹션 09-2 구글 드라이브
강의 01 엑셀 파일에서 데이터 읽기 (xlsx) (링크)
섹션 10 데이터 전처리 (pandas)
강의 01 독립 변수와 종속 변수 나누기
강의 02 특성 삭제 (불필요 특성)
강의 03 특성 삭제 (다중 공선성)
강의 04 결측치 (링크)
강의 05 결측치 확인 (링크)
강의 06 결측치 삭제 (링크)
강의 07 특성 합성
섹션 11 실전 문제
강의 01 검증 척도 측정
강의 02 아들 키 데이터셋 소개 (링크)
강의 04 아들 키 예측 모델 학습
강의 04 아들 키 예측 모델 학습
섹션 99 old
04 과제
99 과제
강의 05 현대 자동차 가격 데이터셋 소개 (링크)
강의 07 현대 자동차 가격 예측 모델 학습
강의 07 현대 자동차 가격 예측 모델 학습
강의 08 네이버 쇼핑 TV 가격 데이터셋 소개 (링크)
강의 10 네이버 쇼핑 TV 가격 예측 모델 학습
섹션 12 데이터 전처리 (트랜스포머와 모델 연결)
강의 01 트랜스포머와 모델 연결
강의 10 전처리 연결
강의 10 전처리 연결
강의 11 전처리와 모델 연결
강의 11 전처리와 모델 연결
섹션 13 실전 문제
강의 01 현대 자동차 가격 예측 모델 학습
섹션 14 두 데이터 사이의 거리
강의 01 두 데이터 사이의 거리
강의 02 맨하탄 거리
참고
강의 03 유클리드 거리
참고
강의 04 민코스키 거리
참고
섹션 15 라쏘 모델
강의 01 과대적합
강의 02 과대적합 방지
강의 03 라쏘 모델
강의 03 가중치 규제 (과대적합 방지)
강의 02 가중치 규제 (모델 일반화)
섹션 16 실전 문제
강의 01 아들 키 예측 모델 학습
강의 02 현대 자동차 가격 예측 모델 학습
강의 03 네이버 쇼핑 TV 가격 예측 모델 학습
섹션 17 릿지 모델
강의 01 릿지 모델
섹션 18 실전 문제
강의 01 아들 키 예측 모델 학습
강의 02 현대 자동차 가격 예측 모델 학습
강의 03 네이버 쇼핑 TV 가격 예측 모델 학습
09 장 이진 분류 ——————–
섹션 01 분류
강의 01 분류
강의 02 분류 모델
섹션 02 이진 분류
강의 01 이진 분류
섹션 03 로지스틱 회귀 모델
강의 01 로지스틱 회귀 모델
강의 02 로지스틱 회귀 모델 (시각화)
강의 03 과대적합
강의 04 과대적합 방지
섹션 04 이진 분류 모델 검증
강의 01 train_test_split으로 데이터 나누기 (stratify=y_data 옵션)
강의 02 zip
강의 03 검증 척도
강의 04 검증 척도 (make_scorer 함수)
강의 05 검증 척도 (SCORERS 사전)
강의 06 검증 척도 (score 메서드)
강의 07 기타 검증 척도
metrics
강의 08 혼합 행렬
강의 09 분류 보고서
강의 10 사용자 정의 검증 척도
섹션 05 데이터 전처리
강의 01 라벨 인코더
섹션 03-2 ㅌ 데이터 전처리 (sklearn)
강의 01 라벨 이진화
섹션 06 데이터 전처리 (특성 선택)
강의 01 단변량 특성 선택
강의 02 트랜스포머 연결
강의 03 트랜스포머와 모델 연결
강의 02 모델 기반 특성 선택 (수동)
강의 03 모델 기반 특성 선택 (자동)
강의 04 반복적 특성 선택
섹션 07 프로그램 설치
강의 01 tensorflow 패키지 설치 (링크)
강의 02 tensorflow 패키지 설치 (GPU) (링크)
섹션 08 실전 문제
강의 01 검증 척도 측정
강의 02 타이타닉 승객 생존 여부 데이터셋 소개 (링크)
강의 04 타이타닉 승객 생존 여부 분류 모델 학습
강의 06 당뇨병 발병 여부 데이터셋 소개 (링크)
강의 08 당뇨병 발병 여부 분류 모델 학습
강의 09 은행 대출 승인 여부 데이터셋 소개 (링크)
강의 11 은행 대출 승인 여부 분류 모델 학습
강의 12 신용카드 이상 거래 여부 데이터셋 소개 (링크)
강의 12 신용카드 이상 거래 여부 데이터셋 소개
강의 14 신용카드 이상 거래 여부 분류 모델 학습
강의 01 v 신용카드 이상 거래 여부 예측 사이트 제작
섹션 09 프로그램 설치
강의 01 graphviz 설치
강의 02 graphviz 패키지 설치
섹션 10 의사 결정 나무 모델
강의 01 나무(트리) 구성 알고리즘
강의 02 정보 획득량
강의 03 의사 결정 나무 모델
강의 04 특성 중요도 (링크)
강의 05 과대적합 방지
강의 06 결정 규칙 (구글 콜랩)
강의 06 시험 합격 여부 예측 모델 훈련 (결정 규칙)
01 graphviz 패키지 설치
강의 06 나무 가지 시각화 (Decision Rule)
랜덤 포레스트 모델 나무 가지 시각화 (Decision Rule)
강의 09 시험 합격 여부 예측 모델 훈련 (결정 규칙)
강의 07 결정 규칙, 과대적합 방지
섹션 11 실전 문제
강의 01 타이타닉 승객 생존 여부 분류 모델 학습
강의 02 당뇨병 발병 여부 분류 모델 학습
강의 03 은행 대출 승인 여부 분류 모델 학습
강의 04 신용카드 이상 거래 여부 분류 모델 학습
섹션 12 K 최근접 이웃 모델
강의 01 K 최근접 이웃 모델
강의 02 과대적합 방지
섹션 13 실전 문제
강의 01 타이타닉 승객 생존 여부 분류 모델 학습
강의 02 타이타닉 승객 생존 여부 분류 모델 학습 (특성 스케일링)
강의 03 당뇨병 발병 여부 분류 모델 학습
강의 04 당뇨병 발병 여부 분류 모델 학습 (특성 스케일링)
강의 05 은행 대출 승인 여부 분류 모델 학습
강의 06 은행 대출 승인 여부 분류 모델 학습 (특성 스케일링)
강의 07 신용카드 이상 거래 여부 분류 모델 학습
강의 08 신용카드 이상 거래 여부 분류 모델 학습 (특성 스케일링)
섹션 14 서포트 벡터 머신 모델
강의 01 서포트 벡터 머신 모델
강의 02 과대적합 방지
섹션 15 실전 문제
강의 01 타이타닉 승객 생존 여부 분류 모델 학습
강의 02 타이타닉 승객 생존 여부 분류 모델 학습 (특성 스케일링)
강의 03 당뇨병 발병 여부 분류 모델 학습
강의 04 당뇨병 발병 여부 분류 모델 학습 (특성 스케일링)
강의 05 은행 대출 승인 여부 분류 모델 학습
강의 06 은행 대출 승인 여부 분류 모델 학습 (특성 스케일링)
강의 07 신용카드 이상 거래 여부 분류 모델 학습
강의 08 신용카드 이상 거래 여부 분류 모델 학습 (특성 스케일링)
10 장 다중 클래스 분류 ——————–
섹션 01 다중 클래스 분류
강의 01 다중 클래스 분류
섹션 02 로지스틱 회귀 모델
강의 01 로지스틱 회귀 모델
강의 02 로지스틱 회귀 모델 (시각화)
섹션 03 다중 클래스 분류 모델 검증
강의 01 train_test_split으로 데이터 나누기 (stratify=y_data 옵션)
강의 02 zip
강의 03 검증 척도
강의 04 검증 척도 (make_scorer 함수)
강의 05 검증 척도 (SCORERS 사전)
강의 06 검증 척도 (score 메서드)
강의 07 기타 검증 척도
metrics
강의 08 사용자 정의 검증 척도
섹션 04 데이터 전처리
강의 01 라벨 인코더
섹션 05 실전 문제 (로지스틱 회귀 모델)
강의 01 붗꽃 종류 데이터셋 소개 (링크)
강의 04 붗꽃 종류 분류 모델 학습
강의 05 와인 등급 데이터셋 소개 (링크)
강의 07 와인 등급 분류 모델 학습
강의 08 자동차 평가 등급 데이터셋 소개 (링크)
강의 10 자동차 평가 등급 분류 모델 학습
강의 26-17 자동차 평가 등급 예측 모델 학습
섹션 06 실전 문제 (의사 결정 나무 모델)
강의 01 붗꽃 종류 분류 모델 학습
강의 02 와인 등급 분류 모델 학습
강의 03 자동차 평가 등급 분류 모델 학습
강의 08 자동차 평가 등급 예측 모델 학습
강의 08 자동차 평가 등급 예측 모델 학습2
섹션 07 실전 문제 (K 최근접 이웃 모델)
강의 01 붗꽃 종류 분류 모델 학습
강의 02 붗꽃 종류 분류 모델 학습 (특성 스케일링)
강의 03 와인 등급 분류 모델 학습
강의 04 와인 등급 분류 모델 학습 (특성 스케일링)
강의 05 자동차 평가 등급 분류 모델 학습
강의 06 v 자동차 평가 등급 분류 모델 학습 (특성 스케이링) – MaxAbsScaler
섹션 08 실전 문제 (서포트 벡터 머신 모델)
강의 01 붗꽃 종류 분류 모델 학습
강의 02 붗꽃 종류 분류 모델 학습 (특성 스케일링)
강의 03 와인 등급 분류 모델 학습
강의 04 와인 등급 분류 모델 학습 (특성 스케일링)
강의 05 자동차 평가 등급 분류 모델 학습
강의 06 자동차 평가 등급 분류 모델 학습 (특성 스케일링)
11 장 다중 라벨 분류 ——————–
섹션 01 다중 라벨 분류
강의 01 다중 라벨 분류
섹션 02 데이터 전처리
강의 01 다중 라벨 이진화
섹션 03 데이터 전처리 (pandas)
강의 01 df.apply (링크)
강의 02 df.applymap (링크)
강의 03 ser.apply (ser.map) (링크)
섹션 04 실전 문제
강의 01 효모 다중 라벨 데이터셋 소개
강의 02 효모 다중 라벨 분류 모델 학습
12 장 군집화 ——————–
섹션 01 군집화
강의 01 군집화
섹션 02 군집화 모델
강의 01 k-평균 군집화 (KMeans) 모델
03 클러스터의 중심 위치시키기
05 한계점
k-평균 군집화-y
섹션 03 실전 문제
강의 01 붗꽃 종류 군집화
섹션 04 군집화 모델 검증
강의 01 검증 척도
강의 02 검증 척도 (score 메서드)
강의 03 기타 검증 척도
강의 04 기타 검증 척도 (make_scorer 함수)
강의 05 기타 검증 척도 (SCORERS 사전)
강의 06 사용자 정의 검증 척도–수정요
섹션 05 실전 문제
강의 01 붗꽃 종류 군집화
섹션 06 적정 군집수 판단
강의 01 적정 군집수 판단
섹션 07 실전 문제
강의 01 붗꽃 종류 군집화
섹션 08 시각화
강의 01 시각화
섹션 09 실전 문제
강의 01 붗꽃 종류 군집화
강의 02 붗꽃 종류 군집화 (PCA)
13 장 앙상블 ——————–
섹션 01 앙상블
강의 01 앙상블
섹션 02 평균
강의 01 평균
섹션 03 실전 문제
강의 01 아들 키 예측 모델 학습
강의 02 현대 자동차 가격 예측 모델 학습
강의 03 네이버 쇼핑 TV 가격 예측 모델 학습
섹션 04 최빈값
강의 01 최빈값
섹션 05 다수결 투표
강의 01 직접 투표 (hard voting)
강의 02 간접 투표 (soft voting)
섹션 06 VotingClassifier
강의 01 직접 투표 (hard voting)
강의 02 간접 투표 (soft voting)
섹션 07 실전 문제
강의 01 타이타닉 승객 생존 여부 분류 모델 학습 (직접 투표)
강의 02 타이타닉 승객 생존 여부 분류 모델 학습 (간접 투표)
강의 03 당뇨병 발병 여부 분류 모델 학습 (직접 투표)
강의 04 당뇨병 발병 여부 분류 모델 학습 (간접 투표)
강의 05 은행 대출 승인 여부 분류 모델 학습 (직접 투표)
강의 06 은행 대출 승인 여부 분류 모델 학습 (간접 투표)
강의 07 신용카드 이상 거래 여부 분류 모델 학습 (직접 투표)
강의 08 신용카드 이상 거래 여부 분류 모델 학습 (간접 투표)
강의 09 붗꽃 종류 분류 모델 학습 (직접 투표)
강의 10 붗꽃 종류 분류 모델 학습 (간접 투표)
강의 11 와인 등급 분류 모델 학습 (직접 투표)
강의 12 와인 등급 분류 모델 학습 (간접 투표)
강의 13 자동차 평가 등급 분류 모델 학습 (직접 투표)
강의 14 자동차 평가 등급 분류 모델 학습 (간접 투표)
섹션 08 배깅 모델
강의 01 배깅 모델
01 배깅 (Bagging) 과 페이스팅 (Pasting)
강의 02 BaggingRegressor 모델
강의 03 BaggingClassifier 모델
섹션 09 랜덤 포레스트 모델
강의 01 랜덤 포레스트 모델
강의 02 RandomForestRegressor 모델
강의 03 RandomForestClassifier 모델
섹션 10 실전 문제
강의 01 아들 키 예측 모델 학습
강의 02 현대 자동차 가격 예측 모델 학습
강의 03 네이버 쇼핑 TV 가격 예측 모델 학습
강의 04 타이타닉 승객 생존 여부 분류 모델 학습
강의 05 당뇨병 발병 여부 분류 모델 학습
강의 06 은행 대출 승인 여부 분류 모델 학습
강의 07 신용카드 이상 거래 여부 분류 모델 학습
강의 08 붗꽃 종류 분류 모델 학습
강의 09 와인 등급 분류 모델 학습
강의 10 자동차 평가 등급 분류 모델 학습
섹션 11 부스팅 모델
강의 01 부스팅 모델
02 부스팅 (Boosting)
x 01 아다부스트 (AdaBoost)
강의 02 AdaBoostRegressor 모델
강의 03 AdaBoostClassifier 모델
섹션 12 그레디언트 부스팅 모델
강의 01 그레디언트 부스팅 모델
02 그레디언트 부스팅 (Gradient Boosting)
강의 02 GradientBoostingRegressor 모델
강의 03 GradientBoostingClassifier 모델
14 장 k 겹 교차 검증 ——————–
섹션 01 k 겹
강의 01 K겹
섹션 02 k 겹 교차 검증
강의 01 v k 겹 교차 검증
섹션 03 회귀 모델 k 겹 교차 검증
강의 01 회귀 모델 k 겹 교차 검증
강의 02 회귀 모델 k 겹 교차 검증 (cross_validate)
강의 03 회귀 모델 k 겹 교차 검증 (return_estimator=True)
강의 04 scoring 옵션 (기타 검증 척도)
강의 05 scoring 옵션 (사용자 정의 검증 척도)
섹션 04 실전 문제
강의 01 아들 키 예측 모델 학습
강의 02 현대 자동차 가격 예측 모델 학습
강의 03 네이버 쇼핑 TV 가격 예측 모델 학습
섹션 05 분류 모델 계층별 k 겹 교차 검증
강의 01 분류 모델 계층별 k 겹 교차 검증
강의 02 분류 모델 계층별 k 겹 교차 검증 (cross_validate)
강의 03 scoring 옵션 (기타 검증 척도)
강의 04 scoring 옵션 (사용자 정의 검증 척도)
섹션 06 실전 문제
강의 01 타이타닉 승객 생존 여부 분류 모델 학습
강의 02 당뇨병 발병 여부 분류 모델 학습
강의 03 은행 대출 승인 여부 분류 모델 학습
강의 04 신용카드 이상 거래 여부 분류 모델 학습
강의 05 붗꽃 종류 분류 모델 학습
강의 06 와인 등급 분류 모델 학습
강의 07 자동차 평가 등급 분류 모델 학습
15 장 그리드 서치 ——————–
섹션 01 그리드 서치
강의 01 그리드 서치
섹션 02 회귀 모델 그리드 서치
강의 01 회귀 모델 그리드 서치
참고
강의 02 회귀 모델 그리드 서치 (GridSearchCV)
강의 03 scoring 옵션 (기타 검증 척도)
강의 04 scoring 옵션 (사용자 정의 검증 척도)
강의 05 param_grid 옵션
강의 06 param_grid 옵션 (모델)
섹션 03 실전 문제
강의 01 아들 키 예측 모델 학습
강의 01 현대 자동차 가격 예측 모델 학습
강의 03 네이버 쇼핑 TV 가격 예측 모델 학습
섹션 04 분류 모델 그리드 서치
강의 01 분류 모델 그리드 서치
강의 02 분류 모델 그리드 서치 (GridSearchCV)
강의 03 scoring 옵션 (기타 검증 척도)
강의 04 scoring 옵션 (사용자 정의 검증 척도)
강의 05 param_grid 옵션
강의 06 param_grid 옵션 (모델)
섹션 05 실전 문제
강의 01 타이타닉 승객 생존 여부 분류 모델 학습
강의 02 당뇨병 발병 여부 분류 모델 학습
강의 03 은행 대출 승인 여부 분류 모델 학습
강의 04 신용카드 이상 거래 여부 분류 모델 학습
강의 05 붗꽃 종류 분류 모델 학습
강의 06 와인 등급 분류 모델 학습
강의 07 자동차 평가 등급 분류 모델 학습
이전 패턴
섹션 06 전처리 그리드 서치
강의 01 전처리 그리드 서치
섹션 07 실전 문제
강의 01 현대 자동차 가격 예측 모델 학습
강의 02 타이타닉 승객 생존 여부 분류 모델 학습
강의 03 은행 대출 승인 여부 분류 모델 학습
강의 04 자동차 평가 등급 분류 모델 학습
16 장 모델 저장 ——————–
섹션 02 피클
강의 01 객체 저장 (링크)
강의 02 객체 읽어 오기 (링크)
섹션 03 모델 저장
강의 01 모델 저장
강의 02 저장된 모델 사용
섹션 04 실전 문제
강의 01 아들 키 예측 모델 저장
강의 02 아들 키 예측
강의 03 현대 자동차 가격 예측 모델 저장
강의 04 현대 자동차 가격 예측
강의 05 네이버 쇼핑 TV 가격 예측 모델 저장
강의 06 네이버 쇼핑 TV 가격 예측
강의 07 타이타닉 승객 생존 여부 분류 모델 저장
강의 08 타이타닉 승객 생존 여부 분류
강의 09 당뇨병 발병 여부 분류 모델 저장
강의 10 당뇨병 발병 여부 분류
강의 11 은행 대출 승인 여부 분류 모델 저장
강의 12 은행 대출 승인 여부 분류
강의 13 신용카드 이상 거래 여부 분류 모델 저장
강의 14 신용카드 이상 거래 여부 분류
강의 15 붗꽃 종류 분류 모델 저장
강의 16 붗꽃 종류 분류
강의 17 와인 등급 분류 모델 저장
강의 18 와인 등급 분류
강의 19 자동차 평가 등급 분류 모델 저장
강의 20 자동차 평가 등급 분류
섹션 05 구글 콜랩 파일 다운로드
강의 01 구글 콜랩 파일 다운로드
섹션 06 모델 다운로드
강의 01 모델 다운로드
강의 01 붗꽃 종류 분류 모델 다운로드 (링크)
17 장 부록 ——————–
섹션 01 참고 자료
강의 01 참고 자료
참고 동영상 정리요
검토전
영어
검토전
통계
섹션 to do
99 머신러닝편 핵심 요약
섹션 99-5 7 22 수업 내용
정리할거
더 작업 할거
앱
추가 데이터셋
섹션 03 참고 논문
강의 01 논문 검색 웹 사이트
강의 02 참고 논문
파트 99 종합 문제–정리요 ——————–
섹션 01 종합 문제
강의 01 개봉 영화 첫 주 누적 관객수 예측 모델 학습 (데이터 수집)
강의 02 개봉 영화 첫 주 누적 관객수 예측 모델 학습 (데이터셋 분석)
강의 03 개봉 영화 첫 주 누적 관객수 예측 모델 학습 (데이터 전처리)
강의 04 개봉 영화 첫 주 누적 관객수 예측 모델 학습 (모델 저장)
참고
딥러닝 수치를 예측해보자 (feat 선형 회귀 분석)
반응형
딥러닝 수치 예측 모델
참 거짓을 판별하는 모델에서 한발
더 나아가서 수치를 예측하는 모델이
필요하다.
현실에서 수치를 예측하는 것이 더
필요한 경우가 많다. 구체적인 수치를
예측하기 위해서 우리한테 필요한
알고리즘은 선현회귀 분석이다.
선형회귀분석이란?
복잡하게 생각할 필요 없다. 독립변수
x와 기울기 a 그리고 절편 b를 더한
종속변수 y를 구하는 1차 방정식이
선형회귀분석이다.
우리가 딥러닝에서 조정해야 하는건,
이 기울이 a와 절편 b의 값이다. 학습
데이터를 가지고 두개의 변수를 계속
조정하면서 오차를 줄여나가는 과정,
이게 딥러닝의 핵심이다.
딥러닝 예제 중 가장 유명한 보스턴 집값
예측 모형을 가지고 실제 모델을
설계해보자.
데이터를 로드해서, 데이터셋을 구분하고,
학습데이터와 테스트데이터를 구분하는
작업은 아래 글에서 참고하길 바란다.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 from keras.models import Sequential from keras.layers import Dense from sklearn.model_selection import train_test_split import numpy import pandas as pd import tensorflow as tf # seed값 설정 seed = 0 numpy.random.seed(seed) tf.compat.v1.set_random_seed(seed) # 파일 읽어들이기 df = pd.read_csv( ‘./dataset/housing.csv’ , delim_whitespace = True , header = None ) dataset = df.values X = dataset[:, 0 : 13 ] Y = dataset[:, 13 ] # 학습 + 테스트 분리 X_train, X_test, Y_train, Y_test = train_test_split(X, Y, test_size = 0. 3 , random_state = seed) Colored by Color Scripter cs
선형회귀 분석에서 모델링은 다음과 같이 한다.
먼저 모델층을 생성한다. Sequential()함수 사용
은닉층에 노드수와 입력값, 그리고 활성화 함수를
사용한다.
활성화 함수는 가장 유명한 ReLU 함수를 사용한다.
출력층에는 추가적으로 활성화 함수를 지정하지
않는다.
참 거짓을 판단하거나 다항분류를 하는 모델에서는
sigmoid()함수를 사용하거나, softmax() 함수를
사용하지만 선형회귀에서는 수치를 예측하는 모델
이기 때문에 이런 활성화 함수를 필요로 하지 않는다.
1 2 3 4 5 # 모델링 작업 model = Sequential() model.add(Dense( 30 , input_dim = 13 , activation = ‘relu’ )) model.add(Dense( 6 , activation = ‘relu’ )) model.add(Dense( 1 )) Colored by Color Scripter cs
모델 컴파일에는 평균 제곱 오차함수와
adam 을 최적화 함수로 사용한다.
adam 함수를 사용해서 기울기 a(딥러닝
에서는 가중치라 표현한다.)와 절편 b(
딥러닝에서는 bias[편차]라 표현한다.)
를 추정하면서 실제값에 가까운 예측 모델을
만든다.
1 model.compile(loss = ‘mean_squared_error’ , optimizer = ‘adam’ ) cs
이제 모델학습을 진행한다.
아래 예제에서는 에포크를 1000번 반복하고,
10개의 샘플데이터를 넣으면서 학습을
진행한다.
1 2 # 모델 학습 진행 model.fit(X_train, Y_train, epochs = 1000 , batch_size = 10 ) cs
모델로 예측값 구하기
keras에서는 predict() 함수를 지원한다.
독립변수를 가지고 실제값을 예측을 지원
하는 함수다.
flatten()함수는 N차원의 배열을 1차원
배열로 변형해주는 함수다. 아래 예제에서
Y_prediction 변수를 출력해보면 1차원
배열을 얻는다.
예측 데이터를 1차원 배열로 정리
이제 for loop를 돌면서 실제값과 예측값을
출력한다.
1 2 3 4 5 6 7 8 # 예측값과 실제값 비교 # flatten()은 배열의 다중 디멘션을 1차원으로 변경해준다. Y_prediction = model.predict(X_test).flatten() for i in range ( 10 ): label = Y_test[i] prediction = Y_prediction[i] print ( “실제가격 : {:.3f}, 예상가격 : {:.3f}” . format (label, prediction)) cs
반응형
Tensorflow: regression 기본 예제 (연료 효율성 예측)
728×90
반응형
Tensorflow: regression 기본 예제 (연료 효율성 예측)
이 포스트는 텐서플로우를 이용한 기본적인 regression을 공부한 것을 정리한 것이다. 사용한 데이터는 엔진의 연료 효율성이다. 실린더의 개수, 이동거리, 마력, 가속력, 출시년도, 출시 국가 등의 feature 데이터가 있고, MPG(miles per gallon)가 예측값 (label)이다. 우선 데이터를 다운로드하여 신경망에 대입할 수 있는 형태로 처리할 것이다. linear regression와 뉴럴 네트워크 모델을 이용해서 MPG를 예측해 볼 것이다. 그리고 두 모델의 결과를 비교해본다. 내용은 텐서플로우 튜토리얼을 참고하였다.
목표
Multiple feature를 이용한 예측 모델을 공부한다.
Linear regression(LR)과 DNN 모델로 예측하고 두 결과를 비교해 본다.
두 방법 (LR and DNN)에서 single feature를 사용했을 때와 multiple feature를 사용했을 때의 결과를 비교한다.
필요한 라이브러리들을 import한다.
import numpy as np import tensorflow as tf import matplotlib.pyplot as plt import pandas as pd import seaborn as sns
반드시 필요한 것은 아니지만 결과 출력을 알아보기 쉽게 하기 위해 소수점 이하 세째자리까지만 출력하도록 설정해 주었다.
np.set_printoptions(precision=3, suppress=True)
텐서플로어 관련 라이브러리도 import 주었다. 각각의 모듈에 대한 내용은 아래에서 사용될 때 알아보도록 하자.
from tensorflow import keras from tensorflow.keras import layers from tensorflow.keras.layers.experimental import preprocessing print(tf.__version__)
사용된 tensorflow 버전은 2.3.0 이다.
1. Get the Auto MPG (miles per gallon) data
모델의 훈련시키기 위한 데이터를 다음의 주소로부터 다운로드하여 pandas dataframe으로 저장한다. 저장 시 각 데이터의 이름을 칼럼으로 지정해준다.
url = ‘http://archive.ics.uci.edu/ml/machine-learning-databases/auto-mpg/auto-mpg.data’ column_names = [‘MPG’, ‘Cylinders’, ‘Displacement’, ‘Horsepower’, ‘Weight’, ‘Acceleration’, ‘Model Year’, ‘Origin’] raw_dataset = pd.read_csv(url, names=column_names, na_values=’?’, comment=’\t’, sep=’ ‘, skipinitialspace=True)
데이터를 확인해본다.
display(raw_dataset.head()) display(raw_dataset.tail())
출력 결과
칼럼명을 보면, MPG는 miles per gallon이고, displacement는 이동거리, Horsepower는 마력이 되겠다. 마지막에 Origin은 엔진을 만든 국가를 나타낸다. 1은 USA, 2는 Europe, 그리고 3은 Japan이다. 이것은 preprocessing 과정에서 원 핫 형태로 변형시킬 것이다.
2. Clean the data
raw데이터를 새 변수로 복사하고, shape으로 dimension을 확인한다.
dataset = raw_dataset.copy() dataset.head() print(“before cleaning dataset:”, dataset.shape)
이 dataset에 NA와 같은 값을 가지는 요소가 있는지 확인한다. 이것은 타당한 값을 가지는 데이터를 모델 훈련에 쓰기 위함이다. isna() 매소드를 이용해 NA 데이터를 찾아내고 dropna()으로 드롭시킨다.
display(dataset.isna().sum()) dataset = dataset.dropna() print(“after cleaning dataset:”, dataset.shape)
그리고 dataset의 크기가 398에서 392로 줄었다. 즉, NA를 포함하는 6개의 열이 삭제되었다.
3. Expand ‘Origin’ to three countries
Origin 컬럼의 index를 국가명으로 map을 이용해 바꾸어준다.
dataset[‘Origin’] = dataset[‘Origin’].map({1: ‘USA’, 2: ‘Europe’, 3: ‘Japan’}) display(dataset.head())
위의 결과와 같이 바뀐 것을 확인한 후, get_dummies를 이용해 Origin을 3개의 feature를 갖는 one-hot encoding 형태로 변환해준다.
dataset = pd.get_dummies(dataset, prefix=”, prefix_sep=”) dataset.tail()
위 결과에서 가장 오른쪽에 유럽 일본 미국의 세 칼럼이 생긴 것을 확인한다.
4. Split the data into train and test
자 다음으로는 데이타를 훈련과 검증 세트로 나누어 준다. 대개 훈련과 검증 각각 80%과 20%의 비율로 나눈다. 여기에서는 pandas dataframe의 sample 매서드를 이용해 dataset의 80%를 train_dataset으로 할당하였고, 이때 random_state는 0으로 주었다. 따라서 dataset의 앞 80%가 훈련 세트로 지정된다. 나머지 20%은 검증을 위한 세트가 된다.
train_dataset = dataset.sample(frac=0.8, random_state=0) test_dataset = dataset.drop(train_dataset.index) print(“size of train_dataset is “, train_dataset.shape) print(“size of test_dataset is “,test_dataset.shape)
dataset[‘Origin’] = dataset[‘Origin’].map({1: ‘USA’, 2: ‘Europe’, 3: ‘Japan’})
다음으로는 feature와 예측하는 label를 나누어준다.
# separate target values and the label from the features train_features = train_dataset.copy() test_features = test_dataset.copy() train_labels = train_features.pop(‘MPG’) test_labels = test_features.pop(‘MPG’)
5. Create a normalization layer
데이터를 훈련과 검증셋으로 나누고 feature와 label 셋으로 분리했으면, 이제 feature 데이터를 규격화만 하면 훈련 준비가 모두 끝이 난다.
입력 데이터의 규격화는 preprocessing.Normalization()을 이용해할 것이다. 이것에 대한 설명은 이 링크를 참고하기 바란다.
우선 normalizer layer를 만든다.
normalizer = preprocessing.Normalization()
그리고 train_features 데이타를 layer에 adapt(적용) 시켜준다. 이 과정에서 각 feature별 평균과 표준편차 값이 계산된다.
normalizer.adapt(np.array(train_features))
Linear regression
1. Single inputs
horsepower만을 이용해 MPG를 예측하는 모델을 만들고 결과를 확인한다. 신경망 모델을 만들기 전에 규격화 layer를 정의하고, horsepower 데이터로 adapt 해준다.
horsepower = np.array(train_features[‘Horsepower’]) horsepower_normalizer = preprocessing.Normalization(input_shape=[1,]) horsepower_normalizer.adapt(horsepower)
단일 뉴런을 가지는 모델을 만들고 summary()로 구조를 확인한다.
horsepower_model = tf.keras.Sequential([horsepower_normalizer,layers.Dense(units=1)]) horsepower_model.summary()
아래의 결과에서 Dense layer에서 훈련 가능한 매개변수가 2개인 것을 확인할 수 있다. 이것은 weight과 bias이다. 또한, normalization layer에 3개의 훈련 대상이 아닌 변수를 확인할 수 있다. 규격화 층에서 변수의 개수가 어떻게 정해지에 대해서는 나중에 공부하기로 하자.
모델을 만들었으니 최적화 방법과 loss함수를 정의하여 컴파일한다. Adam를 optimizer로 사용하고, loss 함수는 ‘mean_absolute_error’로 주었다.
horsepower_model.compile( optimizer=tf.optimizers.Adam(learning_rate=0.1), loss=’mean_absolute_error’)
이제 모델을 훈련시킬 수 있다. validation_split을 20%로 주어 훈련과 검증이 동시에 진행되도록 한다. 100번의 반복으로 모델을 훈련시켰고 verbose=0을 주어 훈련 중간 과정 출력을 생략하도록 한다.
%%time history = horsepower_model.fit( train_features[‘Horsepower’], train_labels, epochs=100, verbose=0, validation_split = 0.2)
훈련이 끝났다.
결과를 확인한다. loss와 validation loss가 epoch에 대해서 어떻게 변했는지 확인하기 위해 다음의 함수를 만들고 두 값을 그려본다.
def plot_loss(history): plt.plot(history.history[‘loss’], label=’loss’) plt.plot(history.history[‘val_loss’], label=’val_loss’) plt.ylim([0, 10]) plt.xlabel(‘Epoch’) plt.ylabel(‘Error [MPG]’) plt.legend() plt.grid(True) plot_loss(history)
loss와 validation loss 모두 안정적으로 감소하여 최소화 되었다.
훈련 결과를 horsepower vs. MPG 데이타에 피팅을 통해 확인해 볼 수 있다.
def plot_horsepower(x, y): plt.figure(figsize=(10,5)) plt.subplot(1,2,1) plt.scatter(train_features[‘Horsepower’], train_labels, label=’Data’) plt.plot(x, y, color=’k’, label=’Predictions’) plt.xlabel(‘Horsepower’) plt.ylabel(‘MPG’) plt.legend() plt.subplot(1,2,2) test_predictions = horsepower_model.predict(test_features[‘Horsepower’]).flatten() plt.scatter(test_labels, test_predictions) plt.xlabel(‘True Values [MPG]’) plt.ylabel(‘Predictions [MPG]’) lims = [0, 50] plt.xlim(lims) plt.ylim(lims) _ = plt.plot(lims, lims) x = tf.linspace(0.0, 250, 251) y = horsepower_model.predict(x) plot_horsepower(x,y)
(왼쪽) 피팅 결과 (오른쪽) 예측과 정답과 비교
위 두 결과로부터 단일 feature로는 MPG의 예측의 정확도가 떨어지는 것을 확인할 수 있다.
2. Multiple inputs
이제는 다운 받은 데이터의 모든 feature를 이용해 MPG를 예측해 보도록 하자. 우선 모든 feature를 규격화 층에서 읽어 들이는 모델을 만든다.
linear_model = tf.keras.Sequential([ normalizer, layers.Dense(units=1) ])
여기에서 normalizer는 앞에서 만들어 두었던 규격화 층이다.
linear_model.summary()
위와 같이 모델의 구조를 보면 규격화 층의 출력 변수의 개수가 9개이고 변수는 19로 늘어났다. 이것은 총 9개의 feature를 사용한다는 것이고 19개의 훈련하지 않아도 되는 변수가 생성되었음을 뜻한다.
이제 모델을 컴파일 하고 훈련시킨다.
linear_model.compile( optimizer=tf.optimizers.Adam(learning_rate=0.1), loss=’mean_absolute_error’) %%time history = linear_model.fit( train_features, train_labels, epochs=100, verbose=0, validation_split = 0.2)
(왼쪽) loss 함수 profile (오른쪽) 예측값과 정답 비교
위의 결과로 부터 훈련이 안정적으로 이루어졌으며, 검증 데이터를 이용한 예측 결과도 정답과 비교적 잘 맞는 것을 확인하였다. 비록 몇 개의 outlier가 보이지만 단일 feature 모델 결과에 비해 정확도가 크게 향상한 것을 알 수 있다.
A DNN regression
이번엔 여러층으로 이루어진 Deep Neural Network 모델로 MPG를 예측해보도록 하자. 이것은 많은 뉴런을 가지는 모델로써 예측 정확도를 크게 향상 시킬 것이다.
def build_and_compile_model(norm): model = keras.Sequential([ norm, layers.Dense(64, activation=’relu’), layers.Dense(64, activation=’relu’), layers.Dense(1) ]) model.compile(loss=’mean_absolute_error’, optimizer=tf.keras.optimizers.Adam(0.001)) return model
위와 같이 모델을 만들고 컴파일까지 한꺼번에 해주는 함수를 정의한다. 모델은 세 개의 layer로 이루어져 있고 첫 두 층엔 64개의 unit이 있고 마지막은 출력층으로 1개의 unit을 가진다.
모든 feature를 이용하는 모델을 만들고 구조를 확인한다.
dnn_model = build_and_compile_model(normalizer) dnn_model.summary()
모델의 변수가 굉장히 많아진 것을 볼 수 있다. 약 5천개의 훈련해야 할 변수가 있다.
모델을 훈련 시키고 결과를 확인해 보자
%%time history = dnn_model.fit( train_features, train_labels, validation_split=0.2, verbose=0, epochs=100)
다음의 결과에서 볼 수 있듯이 훈련이 안정적으로 이루어졌으며, 예측 정확도도 향상되었다.
마지막으로 모델을 평가로 앞선 linear regression 결과와 loss 값을 비교해 본다.
test_results[‘dnn_model’] = dnn_model.evaluate(test_features, test_labels, verbose=0)
많은 층과 뉴런을 가지는 DNN_model의 성능이 가장 좋은 것을 확인할 수 있다.
이 모델을 저장했다가, 나중에 다시 불러와 사용할 수 있다.
dnn_model.save(‘dnn_model’)
다시 불러와 검증해 본다.
reloaded = tf.keras.models.load_model(‘dnn_model’) test_results[‘reloaded’] = reloaded.evaluate( test_features, test_labels, verbose=0)
저장전과 동일한 결과를 준다.
pd.DataFrame(test_results, index=[‘Mean absolute error [MPG]’]).T
728×90
반응형
[python/ML] 머신러닝(Machine Learning) – 회귀
반응형
오늘은 머신러닝의 기초가 되는 알고리즘 중 하나인 회귀를 사용하여 문제를 해결하는 방법을 알아보도록 하겠습니다.
머신 러닝(Machine Learning)이란?
머신러닝은 기계학습이라고도 합니다.
수많은 데이터를 컴퓨터에게 학습시켜 그 속에 있는 패턴을 찾아내서 데이터를 사람의 도움 없이 분류하거나 미래를 예측하는 방법이라고도 할 수 있습니다.
머신러닝에서는 지도학습 비지도 학습, 강화학습 등으로 나뉘는데
회귀는 그 중에서도 지도학습에 속합니다.
머신러닝의 흐름
기계학습을 할 때는 보통 아래와 같은 흐름을 가지고 진행합니다.
데이터 수집 전처리 데이터 저장 데이터 학습(학습방법 선택, 매개변수 조정, 학습반복 등) 평가 및 검증
지도학습 이란?
지도학습은 간단히 말해서 기계를 학습할 때 정답을 같이 알려주어 학습하는 방법입니다.
사람이 공부를 할 때 문제지를 읽고 답을 채점하여 학습하는 것처럼
기계도 마찬가지로 어떤 데이터가 있으면 그것의 답을 같이 알려주어 학습을 시키는 방법입니다.
그리고 학습된 내용을 토대로 하여 다른 데이터의 답을 스스로 구할 수 있도록 합니다.
문제와 그에대한 답이 있는 지도학습
회귀(Regression)란?
지도학습에서 회귀(Regression)는 수치예측을 할때 쓰입니다.
정확히는 선형회귀(Linear Regression)가 쓰이는데 선형회귀는 아래와 같은 수식으로 나타낼 수 있습니다.
여기서 a는 기울기(slope), b는 절편(intercept)을 의미합니다.
회귀는 바로 위의 1차함수의 a,b값을 찾아 y값을 찾아내는 방법을 말합니다.
x는 독립변수가 되고 x에 의해 y가 정해지기 때문에 y는 x의 종속변수가 됩니다.
회귀 예제 – 학습 시간에 따른 시험 점수 예측
오늘은 회귀 예제로 학습시간에 따른 시험점수를 예측해 보도록 하겠습니다.
이번에 사용할 데이터는 kaggle에서 제공하는 단순한 공부 시간 및 점수를 가지고 학습 및 예측을 진행해 보겠습니다.
1. 데이터 준비
아래의 링크에서 csv파일을 다운받아 주세요.
https://www.kaggle.com/jahidsizansani/students-study-hour
2. 데이터 확인
그럼 이제 pandas의 .shape() 와 head()를 사용하여 데이터를 확인해 보도록 하겠습니다.
## 판다스로 데이터 확인 ## import pandas as pd study = pd.read_csv(‘Student Study Hour V2.csv’) print(study.shape) study.head()
Student Study Hour V2.csv 는 28개의 행을 가지고 2개의 열(Hours(공부시간), Scores(점수))을 가졌음을 확인 가능합니다.
3. 독립 및 종속변수 설정
회귀를 사용할 때는 x, y값을 정해 주어야 하기 때문에 x(독립변수)는 공부시간, 우리가 구하고자 하는 점수를 y(종속변수)로 사용하도록 하겠습니다.
## 독립 및 종속변수 설정 ## x_study = study[[‘Hours’]] y_study = study[[‘Scores’]] print(x_study.shape, y_study.shape) print(x_study.head(2)) print(y_study.head(2))
이렇게 28행 x 1열의 독립(x) 변수 및 종속(y) 변수를 설정하였습니다.
4. 모델 생성
이제 예측 값을 구하기위한 학습을 진행해 보겠습니다.
학습을 진행하려면 모델을 만들어 그 모델로 학습을 진행하게 됩니다.
우리는 간단히 경력이라는 데이터를 넣어 연봉 값을 구하고자 하기 때문에,
입력 = 1 크기의 층을 넣어주어 출력값(점수) 1개를 가지는 모델을 만들어 주도록 하겠습니다.
그리고 만들어진 모델에 대한 평가 함수로 MSE(Mean Squared Error, 평균 제곱 오차)를 사용하여 이 오차를 최소로 하는 a(기울기)와 b(절편값)를 찾아보도록 하겠습니다.
MSE는 수치예측 모델 평가 시에 주로 사용하며
x에 대한 (실제 y값- 예측값) 을 제곱하고 모두 더하여 평균을 구하는 함수입니다.
MSE 수식
tensorflow를 사용하여 모델을 만들어 보겠습니다.
tensorflow가 설치가 안되어있다면
!pip install tensorflow 를 입력하여 설치 후 사용해 주세요.
#!pip install tensorflow # 모델을 생성합니다. import tensorflow as tf X = tf.keras.layers.Input(shape=[1]) Y = tf.keras.layers.Dense(1)(X) model = tf.keras.models.Model(X, Y) model.compile(loss=”mse”)
그럼 이제 학습을 위한 모델 생성이 완료되었습니다.
5. 학습
이제 위에서 만들어진 모델을 가지고 학습을 진행하여 보겠습니다.
학습을 진행할 때에는 tensorflow의 .fit()메서드를 사용하여 학습을 진행합니다.
위에서 정한 독립, 종속 변수를 위에서 만든 모델을 넣고 15000번 학습을 진행해 보겠습니다.
verbose = 0으로 넣어주어 프로그레스를 생략하도록 하겠습니다.
시간이 오래 걸리지만 에포크당 손실이 어떻게 변하는지 확인하고 싶은 분은 verbose=1로 바꾸어 주세요.
# 모델에 데이터를 학습합니다. model.fit(x_study, y_study, epochs=15000, verbose=0)
학습된 모델이 어떻게 기울기와 절편이 설정되었는지 확인해 보고 싶으면, get_weights()를 사용하여 확인 가능합니다.
model.get_weights()
[array([[9.676896]], dtype=float32), array([3.2012239], dtype=float32)]위의 모델은 기울기(a)가 9.676896, 절편(b)가 3.2012239 입니다.
이것을 수식으로 나타내면
y(점수) = 9.676896 * x(공부시간) + 3.2012239 로 나타낼 수 있습니다.
6. 예측
이제 학습된 모델로 예측을 해 보겠습니다.
원래는 테스트셋을 학습, 테스트로 나누어 진행하여야 하지만 데이터셋의 양 자체가 적어 x값을 넣어 주고 그 결과를 잘 맞추었는지 확인하도록 하겠습니다.
# 모델을 이용합니다. model.predict(x_study)
위의가 공부시간(x)에따른 y (점수)값입니다.
실제 y값은 아래와 같습니다.
#실제 y 값 y_salary
실제와 똑같지는 않지만 비슷하게 예측한 것을 확인할 수 있습니다. 더욱 정확한 예측값을 원한다면
epochs 를 더 늘려서 학습을 진행해 주시면 됩니다 🙂
전체 코드
## 판다스로 데이터 확인 ## import pandas as pd study = pd.read_csv(‘Student Study Hour V2.csv’) print(study.shape) study.head() ## 독립 및 종속변수 설정 ## x_study = study[[‘Hours’]] y_study = study[[‘Scores’]] print(x_study.shape, y_study.shape) print(x_study.head(2)) print(y_study.head(2)) ## 모델을 생성합니다. X = tf.keras.layers.Input(shape=[1]) Y = tf.keras.layers.Dense(1)(X) model = tf.keras.models.Model(X, Y) model.compile(loss=”mse”) # 모델에 데이터를 학습합니다. model.fit(x_study, y_study, epochs=15000, verbose=0) #가중치 확인 model.get_weights() # 모델을 이용합니다. model.predict(x_study) #실제 y 값 y_salary
코드 파일
Linear_regression.ipynb 0.02MB
참고 자료
– https://opentutorials.org/course/4548
– (책) 정직하게 코딩하며 배우는 딥러닝입문
반응형
간단한 딥러닝으로 삼성전자 주가 예측하기
인공지능 알고리즘으로 과연 주가 예측이 가능할까요? 정답은 YES! 그러나 수익 장담은 NO! 입니다.
물론, 월가에 있는 퀀트 투자자들이 인공지능을 활용하여 주가 예측 및 AI를 활용하여 퀀트시스템을 구축하여 시장대비 높은 수익률을 올리기도 하지만, 수많은 feature engineering과 도메인 지식이 결합되어야 시장 대비 목표 수익률에 도달할 수 있을 것입니다.
이번 포스팅에서는 LSTM 알고리즘을 활용하여 삼성전자 주가를 재미로 분석해보고 예측해보도록 하겠습니다.
LSTM 이란
LSTM 은 Recurrent Neural Networks의 한 종류로써, 순서가 중요한 feature의 요소일 때 흔히 적용하는 RNN의 한 종류로써, 쉬운 예를 들어 설명하자면, 문장과 같은 단어가 문장 안에서의 순서가 중요한 경우나, 주가와 같은 시계열 데이터셋에서 효과적인 모델입니다. 특히, 최근에는 자연어 처리 분야에서 활발히 사용되어지는 알고리즘 입니다.
LSTM의 가장 중요한 특징은 앞서 말한바와 같이, squence 를 저장하고 이를 학습에 활용한다는 점입니다. 사실, 여러 강의나 구글링을 해보시면 LSTM의 구조도를 볼 수 있는데, 이번 포스팅에서는 LSTM이 중점이 아닌 이를 활용한 시계열 데이터셋의 예측 예제를 설명하기 위함이 주 목적이기 때문에, 자세한 설명은 이미 잘 설명되어 있는 ratsgo님의 블로그를 참고해 보시기 바랍니다.
데이터셋 생성 및 전략
우선, 삼성전자 주가 데이터를 받아 옵니다. 가장 최신 파일을 받고 싶으신 분들은 yahoo finance에서 csv 파일로 다운로드 받으실 수 있습니다. 혹시 샘플 csv 데이터가 필요하신 분들은 제가 활용한 데이터의 다운로드 링크를 걸어드립니다.
df_price = pd.read_csv(os.path.join(data_path, ’01-삼성전자-주가.csv’), encoding=’utf8′) df_price.describe()
주가 데이터 통계
컬럼은 [일자, 시가, 고가, 저가, 종가, 거래량]으로 구성된 매우 단순한 데이터 셋입니다. 총 9,288개의 row로 구성되어 있네요. 우리는 일자, 시가, 고가, 저가, 거래량을 토대로 미래의 주가인 “종가”를 예측해 보도록 하겠습니다.
날짜 datetime 포맷으로 변환
pd.to_datetime(df_price[‘일자’], format=’%Y%m%d’) # 0 2020-01-07 # 1 2020-01-06 # 2 2020-01-03 # 3 2020-01-02 # 4 2019-12-30 df_price[‘일자’] = pd.to_datetime(df_price[‘일자’], format=’%Y%m%d’) df_price[‘연도’] =df_price[‘일자’].dt.year df_price[‘월’] =df_price[‘일자’].dt.month df_price[‘일’] =df_price[‘일자’].dt.day
1990년도 이후의 주가 시각화
df = df_price.loc[df_price[‘연도’]>=1990] plt.figure(figsize=(16, 9)) sns.lineplot(y=df[‘종가’], x=df[‘일자’]) plt.xlabel(‘time’) plt.ylabel(‘price’)
삼성전자 주가
Normalization
딥러닝 모델이 학습을 잘하기 위해서는 정규화 해주는 작업이 필요합니다. sklearn 패키지에 있는 MinMaxScaler 를 활용하여 전체 학습 데이터를 Normalize 해 주도록 하겠습니다.
from sklearn.preprocessing import MinMaxScaler scaler = MinMaxScaler() scale_cols = [‘시가’, ‘고가’, ‘저가’, ‘종가’, ‘거래량’] df_scaled = scaler.fit_transform(df[scale_cols]) df_scaled = pd.DataFrame(df_scaled) df_scaled.columns = scale_cols print(df_scaled)
정규화된 데이터
MinMaxScaler 를 해주면 전체 데이터는 0, 1사이의 값을 갖도록 해줍니다.
학습을 시킬 데이터 셋 생성
여기서 window_size 를 정의하여 학습 데이터를 생성할 예정입니다. window_size 는 내가 얼마동안(기간)의 주가 데이터에 기반하여 다음날 종가를 예측할 것인가를 정하는 parameter 입니다. 즉 내가 과거 20일을 기반으로 내일 데이터를 예측한다라고 가정했을 때는 window_size=20 이 됩니다.
저는 과거 20일을 기준으로 그 다음날의 데이터를 예측해 보도록 하겠습니다.
TEST_SIZE = 200 은 학습은 과거부터 200일 이전의 데이터를 학습하게 되고, TEST를 위해서 이후 200일의 데이터로 모델이 주가를 예측하도록 한 다음, 실제 데이터와 오차가 얼마나 있는지 확인해 보도록 하겠습니다.
train = df_scaled[:-TEST_SIZE] test = df_scaled[-TEST_SIZE:]
dataset을 만들어 주는 함수
def make_dataset(data, label, window_size=20): feature_list = [] label_list = [] for i in range(len(data) – window_size): feature_list.append(np.array(data.iloc[i:i+window_size])) label_list.append(np.array(label.iloc[i+window_size])) return np.array(feature_list), np.array(label_list)
위의 함수는 정해진 window_size 에 기반하여 20일 기간의 데이터 셋을 묶어 주는 역할을 합니다.
즉, 순차적으로 20일 동안의 데이터 셋을 묶고, 이에 맞는 label (예측 데이터)와 함께 return해 줍니다.
feature 와 label 정의
feature_cols = [‘시가’, ‘고가’, ‘저가’, ‘거래량’] label_cols = [‘종가’] train_feature = train[feature_cols] train_label = train[label_cols] # train dataset train_feature, train_label = make_dataset(train_feature, train_label, 20) # train, validation set 생성 from sklearn.model_selection import train_test_split x_train, x_valid, y_train, y_valid = train_test_split(train_feature, train_label, test_size=0.2) x_train.shape, x_valid.shape # ((6086, 20, 4), (1522, 20, 4)) # test dataset (실제 예측 해볼 데이터) test_feature, test_label = make_dataset(test_feature, test_label, 20) test_feature.shape, test_label.shape # ((180, 20, 4), (180, 1))
자, 이제 학습해야할 데이터 셋은 모두 준비가 되었습니다. 이젠 모델에 학습을 시켜보고 evaluation을 해볼 차례입니다.
Keras를 활용한 LSTM 모델 생성
from keras.models import Sequential from keras.layers import Dense from keras.callbacks import EarlyStopping, ModelCheckpoint from keras.layers import LSTM model = Sequential() model.add(LSTM(16, input_shape=(train_feature.shape[1], train_feature.shape[2]), activation=’relu’, return_sequences=False) ) model.add(Dense(1))
모델은 매우 간단한 모델을 적용하였습니다. 이미 우리의 feature 데이터의 복잡도가 그렇게 크지 않고 학습해야할 데이터도 10,000개 이하 수준이기 때문에 아주 단순한 모델로도 충분히 좋은 성능을 기대해 볼 수 있습니다. 오히려 너무 복잡한 모델이 과적합을 유발하고, 학습도 잘 되지 못하는 결과를 낳을 수 있습니다.
모델의 학습
model.compile(loss=’mean_squared_error’, optimizer=’adam’) early_stop = EarlyStopping(monitor=’val_loss’, patience=5) filename = os.path.join(model_path, ‘tmp_checkpoint.h5′) checkpoint = ModelCheckpoint(filename, monitor=’val_loss’, verbose=1, save_best_only=True, mode=’auto’) history = model.fit(x_train, y_train, epochs=200, batch_size=16, validation_data=(x_valid, y_valid), callbacks=[early_stop, checkpoint]) # … # … # Epoch 00015: val_loss did not improve from 0.00002 # Epoch 16/200 # 6086/6086 [==============================] – 12s 2ms/step – loss: 3.1661e-05 – val_loss: 4.1063e-05 # Epoch 00016: val_loss did not improve from 0.00002 # Epoch 17/200 # 6086/6086 [==============================] – 13s 2ms/step – loss: 2.4644e-05 – val_loss: 4.0085e-05 # Epoch 00017: val_loss did not improve from 0.00002 # Epoch 18/200 # 6086/6086 [==============================] – 13s 2ms/step – loss: 2.2936e-05 – val_loss: 2.4692e-05 # Epoch 00018: val_loss did not improve from 0.00002
Epoch 18번 기준으로 0.00002 의 평균 오차를 확인할 수 있습니다. 그럼, 학습한 모델로 미래 주가 예측을 해보도록 하겠습니다.
# weight 로딩 model.load_weights(filename) # 예측 pred = model.predict(test_feature)
실제데이터와 예측한 데이터 시각화
plt.figure(figsize=(12, 9)) plt.plot(test_label, label=’actual’) plt.plot(pred, label=’prediction’) plt.legend() plt.show()
실제데이터 vs 예측데이터
실제 데이터와 어느 정도 비슷한 트렌드를 따라가는 모습입니다.
더 많은 데이터, window 사이즈 변경, feature 추가, 모델 수정으로 더 좋은 성능의 모델을 기대해 볼수 있습니다.
최근에는 자연어 처리를 통하여 뉴스 키워드와 주가의 상관관계 분석을 통해 이를 수치화하여 모델에 반영한다면, 훨씬 더 좋은 성능의 예측 모델을 완성할 수 있습니다.
키워드에 대한 정보 머신러닝 예측 예제
다음은 Bing에서 머신러닝 예측 예제 주제에 대한 검색 결과입니다. 필요한 경우 더 읽을 수 있습니다.
이 기사는 인터넷의 다양한 출처에서 편집되었습니다. 이 기사가 유용했기를 바랍니다. 이 기사가 유용하다고 생각되면 공유하십시오. 매우 감사합니다!
사람들이 주제에 대해 자주 검색하는 키워드 ㄹㅇ쉬운 딥러닝 7강 : Tensorflow 2로 해보는 간단한 Linear Regression 선형회귀 예측
- 텐서플로우
- tensorflow
- 텐서플로우2
- 딥러닝
- 머신러닝
- 텐서플로우 기초
- 텐서플로우 강좌
- 텐서플로우 문법
- 경사하강
ㄹㅇ쉬운 #딥러닝 #7강 #: #Tensorflow #2로 #해보는 #간단한 #Linear #Regression #선형회귀 #예측
YouTube에서 머신러닝 예측 예제 주제의 다른 동영상 보기
주제에 대한 기사를 시청해 주셔서 감사합니다 ㄹㅇ쉬운 딥러닝 7강 : Tensorflow 2로 해보는 간단한 Linear Regression 선형회귀 예측 | 머신러닝 예측 예제, 이 기사가 유용하다고 생각되면 공유하십시오, 매우 감사합니다.
