머신러닝 기초 4 - 다중 선형회귀

다중선형회귀 (Multiple Linear Regression)

- 입력 데이터가 여러 개인 선형 회귀

 : 예측 분야에서 많이 사용 (온도, 습도 등을 통한 날씨 예측 등..)

- 가중치와 편향이 배열의 형태로 구성

- 선형회귀와 비교 했을때 가설의 변화만 있고 비용함수의 변화는 없음

 

 

 

다중선형회귀 파이썬 예제

import tensorflow as tf

x_data = tf.constant([
    [73,80,75],
    [93,88,93],
    [89,91,90],
    [96,98,100],
    [73,66,70]], dtype=tf.float32)             # x데이터 정의 (5*3 실수행렬)

y_data = tf.constant([
    [152],[185],[180],[196],[142]], dtype=tf.float32)   # y데이터 정의 (5*1 실수행렬)

W = tf.Variable(tf.random.normal([3,1]), name='Weight')  # 가중치 정의 (3*1 형태의 난수행렬)
B = tf.Variable(tf.random.normal([1]), name='Bias')      # 편향 정의 (1*1 형태의 난수행렬)

@tf.function
def Hypothesis(X):
    return tf.matmul(X,W) + B            # 가설정의 (데이터*가중치) + 편향

@tf.function
def loss(H,Y):
    return tf.reduce_mean(tf.square(H-Y))  # 손실함수 정의 (MSE - 평균제곱오차)

@tf.function
def train(X, Y, learning_rate=1e-5):        # 훈련함수 정의 (X데이터, Y데이터, 학습률 = 1e-5)
    with tf.GradientTape() as tape:         # 기울기 연산을 위한 손실 값 기록
        _loss = loss(Hypothesis(X), Y)      
    _w, _b = tape.gradient(_loss, [W,B])    # 손실 값을 통한 가중치 및 편향 출력
    W.assign_sub(learning_rate * _w)        # 가중치 - (학습률 * 조정된 가중치)  => 오차 반영
    B.assign_sub(learning_rate * _b)        # 편향 - (학습률 * 조정된 편향) => 오차 반영
    
for step in range(10001):                    # 모델 훈련 (훈련을 반복)
    _c = loss(Hypothesis(x_data), y_data)
    train(x_data, y_data, learning_rate=1e-5)
    if step % 20 == 0:
        print(f"{step} : {_c.numpy()}")

#test data                   # 테스트
test_data = tf.constant([
    [73,80,75],\
    [93,88,93],\
    [89,91,90],\
    [96,98,100],\
    [73,66,70],\
    [100,70,101],\
    [60,70,110],\
    [90,100,80]], dtype=tf.float32)     # 테스트 데이터 정의(8*3 실수행렬)

for data in test_data:                  # 훈련을 제외한 과정 과정
    y = Hypothesis([data])
    print("X =", data.numpy(), "then Y =",y.numpy())

0~9780번째 생략

- 횟수 : 손실률

  X = 원본 데이터  then Y = 훈련 후 수정된 가중치와 편향을 적용한 결과 값

 

 

 

파일로 부터 데이터 읽기 예제

data01.txt (파이썬 소스 파일과 같이 놓을 것)

import os
os.environ['TF_CPP_MIN_LOG_LEVEL'] = '3'
import tensorflow as tf
import numpy as np

# 파일로 부터 데이터 읽기
xy = np.loadtxt('data01.txt', delimiter=',', dtype=np.float32)  
x_data = xy[:, 0:-1]              # 원본 행렬에서 오른쪽 끝 열을 제외한 행렬 
y_data = xy[:, [-1]]              # 원본 행렬에서 오른쪽 끝 열만 추출한 벡터

print(x_data.shape, '\n', x_data)
print(y_data.shape, '\n', y_data)

- 텍스트 파일에 배열을 만들어 놓고 이를 응용하여 데이터로 입력할 수 있음을 보여주는 예제이다.

 

 

 

 

로지스틱 분류 (논리합 분류)

- 이진분류기

 : 어떤 데이터가 어떤 그룹에 속하는지 분류하는 것

- 활성함수

 : 시그모이드 함수 사용

 

 

 

 

로지스틱 분류 파이썬 예제

import tensorflow as tf

x_data = tf.constant([[1,2],[2,3],[3,1],[4,3],[5,3],[6,2]], dtype=tf.float32)   # 데이터정의 (6*2 실수행렬)
y_data = tf.constant([[0],[0],[0],[1],[1],[1]], dtype=tf.float32)               # 데이터정의 (6*1 실수행렬)

W = tf.Variable(tf.random.normal([2,1]), name='Weight')     # 가중치 정의 (2*1 난수행렬)
B = tf.Variable(tf.random.normal([1]), name='Bias')         # 편향 정의 (1*1 난수)

@tf.function
def Hypothesis(X):                          # 가설정의
    return tf.sigmoid(tf.matmul(X,W) + B)   # 활성화함수로 시그모이드 함수 사용 [시그모이드((데이터값*가중치)+편향)]

@tf.function
def loss(H,Y):                                                             # 비용함수(손실함수) 정의
    cost = -tf.reduce_mean(Y*tf.math.log(H) + (1-Y) * tf.math.log(1-H))    # 비용 값 = 각 데이터의 1-로그값의 MSE (평균제곱오차)
    return cost

@tf.function
def train(X, Y, learning_rate=0.1):            # cost를 최소화 시키도록 학습하는 함수 정의
    with tf.GradientTape() as tape:
        _loss = loss(Hypothesis(X), Y)         # 손실 값 정의
    _w, _b = tape.gradient(_loss, [W,B])       # 손실 값을 반영한 가중치와 편향의 조정 값 정의 
    W.assign_sub(learning_rate * _w)           # 가중치 조정
    B.assign_sub(learning_rate * _b)           # 편향 조정

@tf.function 
def test(H,Y):                                                                    # 테스트 함수
    predicted = tf.cast(H>0.5, dtype=tf.float32)                                  # 가설의 출력 값이 0.5이상이면 실수형태로 1을 반환 그렇지 않으면 0을 반환
                                                                                  # 예측 값 정의
    accuracy = tf.reduce_mean(tf.cast(tf.equal(predicted, Y), dtype=tf.float32))  # 예측 값과 Y데이터가 같으면 True출력 후 cast함수를 통해 실수형태로 1반환
                                                                                  # 정확도 정의
    return predicted, accuracy                                                    # 예측 값과 정확도 반환

for step in range(10001):                        # 충분한 훈련 반복
    _c = loss(Hypothesis(x_data), y_data)        # 가설을 적용한 x_data와 y_data를 입력 값으로 손실함수를 호출 
    train(x_data, y_data, learning_rate=0.1)     # x_data와 y_data를 입력 값으로 하고 학습률을 0.1로 적용하여 모델 훈련
    if step % 500 == 0:                          # 500회 마다 손실률 출력
        print(f"{step} : {_c.numpy()}")

print("\nAccuracy...")
_h=Hypothesis(x_data)                         # 훈련된 x_data를 가설노드에 넣고 출력 값을 _h에 대입
_p, _a = test(_h, y_data)                     # 훈련된 x_data와 y_data를 테스트하여 _p와 _a에 대입
print("Hypothesis =\n", _h.numpy())           # 가설 값 출력
print("Predicted =\n", _p.numpy())            # 예측 값 출력
print("Accuracy =\n", _a.numpy())             # 정확도 출력

0~1500번의 횟수 중략

- 모든 데이터 값은 벡터의 형태로 출력 됨