DAY62. Tensorflow LinearRegression (2)회귀모델

선형회귀(Linear Regression) 개요

회귀분석(Regression Analysis)

특정 변수(독립변수)가 다른 변수(종속변수)에 어떠한 영향을 미치는가 (인과관계 분석)

ex) 가격은 제품 만족도에 영향을 미치는가? -> 한 변수의 값으로 다른 변수의 값 예언

 

상관관계분석 : 변수 간의 관련성 분석

회귀분석 : 변수 간의 인과관계 분석

 

‘통계분석의 꽃’ ➔ 가장 강력하고, 많이 이용

종속변수에 영향을 미치는 변수를 규명(변수 선형 관계 분석)

독립변수와 종속변수의 관련성 강도

독립변수의 변화에 따른 종속변수 변화 예측

회귀 방정식(Y=a+βX → Y:종속변수, a:상수, β:회귀계수, X:독립변수) 을 도출하여 회귀선 추정

독립변수와 종속변수가 모두 등간척도 또는 비율척도 구성

 

 

회귀 방정식 (1차 함수) -> 회귀선 추정

Y=a+βX : Y:종속변수, a:상수, β:회귀계수, X:독립변수

* 회귀계수(β) : 단위시간에 따라 변하는 양(기울기)이며, 회귀선을 추정함에 있 어 최소자승법 이용

 

 

최소제곱법 적용 회귀선

회귀방정식에 의해서 그려진 y의 추세선 산포도 각 점의 위치를 기준으로 정중앙 통과하는 회귀선 추정 방법

 

 

 

 

 

Tensorflow 회귀방정식

회귀방정식 & 오차

X, y 변수 : 상수 정의 -> 수정 불가

X = tf.constant(6.5) # 독립변수

y = tf.constant(5.2) # 종속변수

 

w, b 변수 : 변수 정의 -> 수정 가능

w = tf.Variable(0.5) #가중치

b = tf.Variable(1.5) #편향

 

y_pred = tf.math.multiply(X, w) + b #회귀방정식(Y 예측치)

err = tf.math.subtract(y, y_pred) #오차 = 관측치-예측치

loss = tf.reduce_mean(tf.square(err)) #손실함수 : MSE

 

 

 

 

 

경사하강(GradientDesent) 알고리즘

오차(loss)를 최소화하는 딥러닝 최적화 알고리즘

딥러닝 모델을 학습하는데 이용되는 알고리즘

학습률(step) 단위로 경사를 따라서 최솟점 이동

* 예측치와 실제값 간의 차이가 최소가 되도록 최적의 가중치(weight)와 편향(bias)를 찾아서 업데이트

 

 

경사하강법(Gradient Descent algorithm)

역전파 알고리즘의 표준(딥러닝 프레임워크 필수 라이브러리)

일정한 step 단위로 경사(기울기) 따라 하강하면서 w 조정 → loss 최소화

손실(loss) 최소화를 위해서 최적의 w(가중치)를 찾는 알고리즘

- 손실(loss) : 예측값와 실제값 간의 차이

- 손실(loss)를 가중치(weight)로 편미분 → 접선의 기울기 계산

- 계산된 기울기(Gradient) 이용 → W 업데이트

 

 

Linear Regression 신경망 예

* Hidden layer 없음

w: 가중치(weight)

b : 편향(bias)

 

 

 

 

 

선형회귀 모델(Linear Regression model)

1. 회귀방정식 y_pred = (X * w) + b -> Y 예측치 (w:가중치, b : 편향)

2. 손실함수 = 차(실제값-예측치)의 제곱에 대한 평균값

loss = tf.reduce_mean(tf.square(Y – y_pred)) -> 평균제곱오차(MSE)

3. 경사하강법 : 오차 최소화 [최적의 w(가중치), b(편향) 수정]

optimizer=tf.optimizers.Adam(0.1) -> 알고리즘 객체

optimizer.minimize(loss) -> 학습에 의한 오차 최소화

 

 

손실함수(loss function)

예측치와 실제값 사이의 차이(loss)를 계산하는 함수=MSE

1. 회귀방정식

y_pred = (X * w) + b -> y 예측치(w:가중치, b : 편향)

2. 손실함수 = 차(실제값-예측치)의 제곱에 대한 평균값

loss = tf.reduce_mean(tf.square( model - Y )) -> 평균제곱오차(MSE)

* MSE = 평균(실제값 -예측치)^2 -> 제곱 적용 부호양수, Penalty 반영

 

 

다중회귀방정식에서 행렬곱 함수 : 입력(X)와 가중치(w) 계산

tf.matmul(X, w) : 두 텐서 행렬곱 연산(입력 : 2개, 기울기 : 2개)

 

 

 

 

 

regression formula

단순선형회귀방정식 
X : 독립변수(1), y : 종속변수(1)
 y_pred = X * w + b (w:가중치(weight), b:편향(bias))

import tensorflow as tf  #ver 2.3

X, y변수 : 상수 정의(수정 불가)

X = tf.constant(value=6.5) # 독립변수 
y = tf.constant(value=5.2) # 종속변수(정답)

w, b변수 : 변수 정의(수정 가능)

w = tf.Variable(0.5) # 가중치(기울기)
b = tf.Variable(1.5) # 편향(절편)

회귀모델 함수 : y예측치 반환

def linear_model(X) :
    #y_pred = X * w + b # 회귀방정식(기호) 
    y_pred = tf.math.multiply(X, w) + b # 회귀방정식(함수)
    return y_pred

model 오차 함수 : 오차 반환(err = y - y_pred) 

def model_err(X, y) :
    y_pred = linear_model(X) # y 예측치 
    err = tf.math.subtract(y, y_pred) # err = y - y_pred
    return err

손실/비용 함수(loss/cost function) : 손실반환(MSE) 

def loss_fn(X, y) :
    err = model_err(X, y) # model 오차 
    loss = tf.reduce_mean(tf.square(err)) # MSE 
    return loss # 손실값

tf.square(err) : +부호, 오차 패널티 
tf.reduce_mean() : 각 관측치의 오차의 산술평균\
    

print("<가중치, 편향 초기값>")
print('가중치(w) = %.3f, 편향(b) = %.3f'%(w, b))    

print('y_pred = %.3f'%(linear_model(X)))
print('model error = %.3f'%(model_err(X, y)))
print('loss value = %.3f'%(loss_fn(X, y)))

<가중치, 편향 초기값>
가중치(w) = 0.500, 편향(b) = 1.500
y_pred = 4.750
model error = 0.450(5.2 - 4.75)
loss value = 0.202

    
가중치와 편향 수정(update) 

w.assign(value=0.6) # 0.5 -> 0.6 
b.assign(value=1.2) # 1.5 -> 1.2 

print("<가중치, 편향 수정된 값>")
print('가중치(w) = %.3f, 편향(b) = %.3f'%(w, b))    

print('y_pred = %.3f'%(linear_model(X)))
print('model error = %.3f'%(model_err(X, y)))
print('loss value = %.3f'%(loss_fn(X, y)))

<가중치, 편향 수정된 값>
가중치(w) = 0.600, 편향(b) = 1.200
y_pred = 5.100
model error = 0.100
loss value = 0.010


딥러닝 최적화 알고리즘 : SGD, Adam
- 최적의 가중치와 편향 update -> 손실(loss) 0에 수렴 
- 조절변수 : 가중치와 편향 

 

 

 

 

regression formula2

다중선형회귀방정식

X : 독립변수(2), y : 종속변수(1)
 y_pred = (X1 * w1 + X2 * w2) + b (w:가중치(weight), b:편향(bias))
 y_pred = tf.linalg.matmul(X, w) + b

import tensorflow as tf  # ver 2.3

X, y변수 : 상수 정의(수정 불가)

X = tf.constant(value=[[1.0, 2.0]]) # 독립변수(1, 2) 
y = tf.constant(value=2.5) # 종속변수(정답)

w, b변수 : 변수 정의(수정 가능)

w = tf.Variable(tf.random.normal(shape=[2, 1])) # 가중치(기울기)
b = tf.Variable(tf.random.normal(shape=[1])) # 편향(절편)

회귀모델 함수 : y예측치 반환

def linear_model(X) :
    y_pred = tf.linalg.matmul(X, w) + b # 회귀방정식 : 행렬곱 
    return y_pred

model 오차 함수 : 오차 반환(err = y - y_pred) 

def model_err(X, y) :
    y_pred = linear_model(X) # y 예측치 
    err = tf.math.subtract(y, y_pred) # err = y - y_pred
    return err

손실/비용 함수(loss/cost function) : 손실반환(MSE) 

def loss_fn(X, y) :
    err = model_err(X, y) # model 오차 
    loss = tf.reduce_mean(tf.square(err)) # MSE 
    return loss # 손실값
    
print("<가중치와 절편 초기값 ")
print("가중치(w) : ", w.numpy(), "\n 편향(b) : ", b.numpy())

<가중치와 절편 초기값 
가중치(w) :  [[-0.16868056]
 [ 1.0764664 ]] 
 편향(b) :  [-0.19150431]

print('model err : ', model_err(X, y).numpy())
print('loss_fn : ', loss_fn(X, y).numpy())

<가중치와 절편 초기값 
가중치(w) :  [[-0.97801447]
 [-0.74548423]] 
 편향(b) :  [-1.0766629]
model err :  [[6.0456457]]
loss_fn :  36.54983

<가중치와 절편 초기값 
가중치(w) :  [[1.3209214]
 [1.0085039]] 
 편향(b) :  [-0.43631306]
model err :  [[-0.4016161]]
loss_fn :  0.16129549

 

 

 

 

 

regression model

회귀모델 : 딥러닝 최적화 알고리즘 적용

tensorflow가상환경에서 numpy설치
(base) > conda activate tensorflow
(tensorflow) > conda install numpy

* R, python에서 지원하지 않는 deep neural network model을 만들 수 있다

import tensorflow as tf #딥러닝 최적화 알고리즘
import numpy as np #dataset 생성

1. X, y변수 : numpy이용 - 단순 선형회귀

X = np.array([1, 2, 3]) #독립변수(입력) : [n] -> n:관측치
y = np.array([2, 4, 6]) #종속변수(출력) : [n] -> n:관측치
#X,y 좌표를 표현할 때, 입력1 -> 정답2, 입력2 -> 정답4
X.shape #(3, ) -> 독립변수 : 1개
y.shape #(, 3) -> 종속변수 : 1개

tf.random.set_seed(seed = 12) #난수 고정 -> 동일 model 생성
#seed값에 의해 난수값이 생성, 동일한 학습모델이 생성된다.

2. w, b변수 정의 : 조절변수(난수 -> 수정)

w = tf.Variable(tf.random.normal(shape=[1])) #가중치(=기울기)
b = tf.Variable(tf.random.normal(shape=[1])) #편향(=절편)
#초기값 : 난수. shape=[1] : 난수의 개수는 독립변수의 개수와 같다

3. 회귀모델 함수 정의 : y의 예측치를 반환하는 역할

def linear_model(X) :
    y_pred = tf.math.multiply(X, w) + b #y_pred = X * w + b
    return y_pred

4. 손실/비용 함수(loss/cost function) : 손실값(MSE) 반환

def loss_fn() : #인수 없음
    y_pred = linear_model(X) #y예측치
    err = y - y_pred #오차(error)
    loss = tf.reduce_mean(tf.square(err)) #MSE식
    return loss

5. model최적화 (=Optimizer) : 오차의 최소점을 찾는 과정

opt = tf.optimizers.SGD(learning_rate = 0.01) #최적화 객체
print('가중치(w) 초기값 ', w.numpy(), '편향(b) 초기값 ', b.numpy())

SGD : 경사하강법 알고리즘 (최적화)

Adam : 경사하강법 최신 알고리즘 (기존 모델의 문제점 개선 알고리즘)
learning_rate : 학습 속도, 학습률. 오차의 최소점 수렴속도 (클수록 빠름)

2) 반복학습 : 손실값 이용 ->  w, b 수정

for step in range(100) : #100회 반복
    opt.minimize(loss = loss_fn, var_list=[w, b]) #(손실값, 조절변수) -> 딥러닝 최적화 코드
    
    #step단위 -> 손실값 -> w, b 수정
    print('step : ', (step+1), '손실값 = ', loss_fn().numpy())
    #w, b변수 update
    print('가중치(w) ', w.numpy(), '편향(b) ', b.numpy())

step :  1 손실값 =  13.138714
가중치(w)  [-0.108078] 편향(b)  [1.0261636]
    :
step :  100 손실값 =  0.23863406
가중치(w)  [1.4326231] 편향(b)  [1.2897477]

가중치와 편향이 update되면서 손실값이 줄어드는 것을 볼 수 있다.
반복학습 횟수를 수정하거나, learning_rate 수치를 높여서(0.001) 속도를 높이거나, 수치를 낮춰서 안정성을 높일 수 있다.

Adam, 반복학습 횟수 변경

opt = tf.optimizers.Adam(learning_rate = 0.01) #최적화 객체

for step in range(50) : #200회 반복
    opt.minimize(loss = loss_fn, var_list=[w, b]) #손실값 최소화
    
    #step단위 -> 손실값 -> w, b 수정
    print('step : ', (step+1), '손실값 = ', loss_fn().numpy())
    #w, b변수 update
    print('가중치(w) ', w.numpy(), '편향(b) ', b.numpy())

step :  1 손실값 =  0.027950585
가중치(w)  [1.8160036] 편향(b)  [0.44134665]
    :
step :  50 손실값 =  0.0004616741
가중치(w)  [1.9758178] 편향(b)  [0.05683928]

 

손실값의 0의 수렴정도가 더 높아졌다. (= y예측치의 오차가 줄어들었다.)

손실값이 0에 수렴할수록 모델학습이 '잘 됐다'
w, b(=조절변수)의 값이 바뀜으로서 손실(오차)이 개선됨을 확인할 수 있다.

learning_rate과 반복학습 횟수는 반비례 관계에 있다.

 

 

6. 최적화된 model test
최적화된 model : 최적의 w,b(= 조절변수)가 수정된 상태

 

1) test set

X_test = [2.5] #학습되지 않은 값을 넣어 예측치를 구한다.

* 학습dataset의 구조 상, 5의 근사치가 출력되어야 잘 학습된 모델이라고 할 수 있다.

y_pred = linear_model(X_test) #최적화된 model 
print('X = 2.5 :', y_pred.numpy()) #X = 2.5 : [4.9999723] -> 어느정도 최적화된 모델이라고 판단할 수 있다.

print(X) #[1 2 3]
y_pred = linear_model(X)
print('y_pred =', y_pred.numpy()) #y_pred = [1.9999841 3.999976  5.999968 ]
print('y =', y) #y = [2 4 6]

이미 학습이 되어 있는 X([1 2 3])에 대한 y의 예측값을 model에 직접 실험
정답(real value)과 비교했을 때 아주 유사한 값을 예측했음을 알 수 있다.

2) 회귀선

import matplotlib.pyplot as plt

plt.plot(X, y, 'bo') #파란색 산점도 
plt.plot(X, y_pred, 'r-') #빨간색 실선 회귀선
plt.show()

 

 

 

 

 

regression model iris (단순선형회귀)

csv file data 이용
정규화 : X, y변수 정규화

tensorflow 가상환경에서 scikit-learn, pandas, numpy, matplotblib
(base) > conda activate tensorflow
(tensorflow) > conda install scikit-learn

import tensorflow as tf #최적화 알고리즘
import pandas as pd #csv file read
from sklearn.metrics import mean_squared_error #model 평가
from sklearn.preprocessing import minmax_scale #최소/최대값을 이용하여 모든 변수를 0~1 사이로 정규화

 

iris = pd.read_csv(r'C:\ITWILL\5_Tensorflow\data\iris.csv')
iris.info()

 0   Sepal.Length  150 non-null    float64 -> X변수 : 독립변수
 1   Sepal.Width   150 non-null    float64
 2   Petal.Length  150 non-null    float64 -> y변수 : 종속변수
 3   Petal.Width   150 non-null    float64
 4   Species       150 non-null    object 
  * float : 실수형 (32비트 or 64비트)

 
1. X, y 변수 생성

X = iris['Sepal.Length'] #독립변수(입력)
y = iris['Petal.Length'] #종속변수(출력)
print(X.mean()) #5.843333333333335 -> 정규화 이전
print(y.max()) #6.9

[추가] Tensor 상수 변환 : pandas -> tesor

X = tf.constant(X, dtype = tf.float32)
y = tf.constant(y, dtype = tf.float32)

 

 

2. X, y변수 정규화 : 딥러닝 모델에서 정규화 필수

X = minmax_scale(X)
print(X.mean()) #평균확인 : 0.42870370370370364 -> 정규화 이후

y = y / 6.9 #변수가 1개일 때는 최대값 이용해서 정규화 가능
print(y.mean()) #0.5446376811594202

3. w, b변수 정의 : 조절변수

w = tf.Variable(tf.random.normal(shape=[1])) #가중치(초기값) = 입력 수
b = tf.Variable(tf.random.normal(shape=[1])) #편향(초기값) = 출력 수

변수 타입 일치 필요 : X(float64) * w(float32) 일 때, type이 서로 다르면 연산 오류가 발생하므로 명명 필요


4. 회귀모델 함수 정의 : y의 예측치를 반환하는 역할

def linear_model(X) :
    y_pred = tf.math.multiply(X, w) + b #y_pred = X * w + b
    return y_pred

5. 손실/비용 함수(loss/cost function) : 손실값(MSE) 반환

def loss_fn() : #인수 없음
    y_pred = linear_model(X) #y예측치
    err = y - y_pred #오차(error)
    loss = tf.reduce_mean(tf.square(err)) #MSE식
    return loss

 

6. model 최적화 : 오차의 최소점을 찾는 과정
1) 최적화 객체 생성

opt = tf.optimizers.Adam(learning_rate = 0.5)
print('가중치(w) 초기값 ', w.numpy(), '편향(b) 초기값 ', b.numpy())

2) 반복학습 : 손실값 이용 -> w, b 수정

for step in range(100) : #100회 반복
    opt.minimize(loss = loss_fn, var_list=[w, b]) #손실값 최소화
    
    #step단위 -> 손실값 -> w, b 수정
    print('step : ', (step+1), '손실값 = ', loss_fn().numpy())
    #w, b변수 update
    print('가중치(w) ', w.numpy(), '편향(b) ', b.numpy())

[error] No gradients provided for any variable: ['Variable:0', 'Variable:0'].
-> X와 w의 객체 타입이 달라 에러 발생.Tensor 상수 변환 : pandas -> tesor작업 필요

step :  1 손실값 =  1.1448004
가중치(w)  [0.24944857] 편향(b)  [-0.612033]
    :
step :  100 손실값 =  0.0156148765
가중치(w)  [0.97155386] 편향(b)  [0.1308557]


7. 최적화된 model 검증

y_pred = linear_model(X) #y 예측치 반환

1) MSE

mse = mean_squared_error(y, y_pred)
print('MSE = ', mse) #MSE =  0.015614878

2) 회귀선

import matplotlib.pyplot as plt

plt.plot(X, y, 'bo') #파란색 산점도 
plt.plot(X, y_pred, 'r-') #빨간색 실선 회귀선
plt.show()

 

 

 

 

 

regression model iris2 (다중선형회귀)

다중선형회귀모델
iris dataset
X변수 : 2~4번째 칼럼
Y변수 : 1번째 칼럼 

딥러닝 최적화 알고리즘 : Adam 적용

import tensorflow as tf #딥러닝 최적화 알고리즘
from sklearn.datasets import load_iris #dataset
from sklearn.model_selection import train_test_split #split
from sklearn.metrics import mean_squared_error #model 평가
from sklearn.preprocessing import minmax_scale #X변수 정규화(0~1)

1. dataset load

X, y = load_iris(return_X_y=True)
type(X) #numpy.ndarray

X변수(입력변수) 정규화

X_nor = minmax_scale(X)
print(X_nor)

[[0.22222222 0.625      0.06779661 0.04166667]
 150행, 4개 변수 -> 2차원
가장 작은 값 0, 가장 큰 값 1로 스케일링 (딥러닝이 좋아하는 전처리)

변수 선택 (X변수 : 2~4번째 칼럼, Y변수 : 1번째 칼럼)

X_nor.shape #(150, 4)
y_data = X_nor[:,0]
x_data = X_nor[:, 1:]

y_data.shape #(150,) -> 1차원
x_data.shape #(150, 3) -> 2차원

x_data.dtype #dtype('float64')

 

2. train_test_split

X_train, X_test, y_train, y_test = train_test_split(
    x_data, y_data, test_size = 0.3, random_state=123)

X : numpy, w : tensor
- tensor 객체 변환 필요 없음
- cf) pandas -> tensor 변환 필요

 

3. w, b 조절변수 정의 : update대상

tf.random.set_seed(123)
w = tf.Variable(tf.random.normal(shape=[3,1],
                                 dtype=tf.float64)) #가중치 = 입력수
#shape : 난수 개수, dtype = 기본은 32 따로 지정해주지 않으면 error발
b = tf.Variable(tf.random.normal(shape=[1],
                                 dtype=tf.float64)) #편향 = 출력수
print(w) #dtype=float64

4. 회귀모델 정의 : y 예측치 반환

def linear_model(X) :
    #y_pred = (X*w)+b : 단순선형회귀방정식
    #y_pred = (X1*w1 + X2*w2 +X3*w3)+b : 다중선형회귀방정식
    y_pred = tf.linalg.matmul(X, w) + b #[수정] 행렬곱
    return y_pred

행렬곱 tf.linalg.matmul(X, w) 수행 조건

1. X, w : 행렬
2. 수일치 : X(열 수) = w(행 수)



5. 손실/비용 함수(loss/cost function) : 손실값(MSE) 반환

def loss_fn() : #인수 없음
    y_pred = linear_model(X_train) #y예측치 [수정] 훈련셋 x변수
    err = y_train - y_pred #오차(error) [수정] 훈련셋 y변수
    loss = tf.reduce_mean(tf.square(err)) #MSE식
    return loss

6. 최적화 객체 생성

opt = tf.optimizers.Adam(learning_rate = 0.01) #학습률 0.1 -> 0.01

learning_rate = 0.1 : 빠른 속도 최소점 수렴 (step = 100)
 -> step = 100 loss value = 0.05592662787911901
 
learning_rate = 0.01 : 안정적으로 최소점 수렴 (step=500)
 -> step = 500 loss value = 0.04842921530752257
 
* 손실값은 0에 가까울수록 좋은 모델이다. 수치의 임계값, 기준 등은 명확히 정해져있지 않다. 대신 모델의 성능 평가를 한다.

print('초기값 w = ', w.numpy(), 'b = ', b.numpy())
print('='*30)

 

7. 반복학습 과정

loss_value = [] #손실값 저장

for step in range(500) : #100 -> 500
    opt.minimize(loss = loss_fn, var_list=[w, b]) #손실값 최소화
    loss_value.append(loss_fn().numpy()) #계산된 손실값이 loss_vlaue안에 쌓임
    
    #100배수 단위 출력 (100개 문장은 너무 많아!)
    if (step+1) % 100 == 0 :
        print('step = ', (step+1), 'loss value =', loss_fn().numpy())

실행때마다 결과값이 조금씩 달라지는 이유
seed값은 같지만 3번의 w,b 조절변수는 seed값이 없는 난수이기 때문 -> 3번 과정에 seed값을 넣어서 해결



8. 최적화된 model 검증

print('='*30) #구분선 '=' 30개
print('최적화된 w =', w.numpy(), 'b = ', b.numpy())

model 평가 : test set

y_pred = linear_model(X_test)
mse = mean_squared_error(y_test, y_pred) #MSE : 0의 수렴정도로 모델을 평가하는 회귀방정식의 평가방식
print('MSE = ', mse) #0.06236167829034685

Loss value 시각화

import matplotlib.pyplot as plt

plt.plot(loss_value, 'r--')
plt.ylabel('loss value')
plt.xlabel('epochs') #1epochs : 1회 소진된 수
plt.show()

[해석] loss value가 점점 감소하고 있음을 확인할 수 있다. y축은 손실 수, x축은 step 수 (한 번 학습에 소진된 수)