'Tensorflow/Linear Regression' 카테고리의 글 목록

Tensorflow/Linear Regression

Logistic Regression 2018.05.01
Elastic Net Regression 2018.04.29
LASSO and Ridge Regression 2018.04.27 1
Deming Regression 2018.04.27
Loss Function in Linear Regressions 2018.04.26
TensorFlow Way of LinearRegression 2018.04.26
Implementing_a_Decomposition_Method with the Cholesky Decomposition Method 2018.04.26
Inverse Matrix Method 2018.04.26

Logistic Regression

2018. 5. 1. 01:54

#!/usr/bin/env python3

Logistic Regression

logistic regression은 아래 1차 함수를 sigmoid와 함성합니다.

y = sigmoid(Ax + b)

birth weight data를 웹상에서 불러오겠습니다.

다음은 웹(github)에서 데이터를 불러오는 과정입니다.

현재 디렉토리에 'birth_weight.csv'가 없을 때 웹상에서 파일을 불러오는 코드는 다음과 같습니다.

import requests

import os.path

birth_weight_file = 'birth_weight.csv'

if not os.path.exists(birth_weight_file):

url='https://raw.githubusercontent.com/nfmcclure/tensorflow_cookbook/master/01_Introduction/07_Working_with_Data_Sources/birthweight_data/birthweight.dat'

load_file = requests.get(url)

data = load_file.text.split('\r\n')

header = data[0].split('\t')

raw_birth_data = [[float(args) for args in row.split('\t') if len(args) >= 1] for row in data[1:] if len(row)>=1]

length = len(raw_birth_data[0])

birth_data = np.empty([0, length])

for birth in raw_birth_data:

birth_data = np.vstack([raw_birth_data, birth])

print(header)

# ['LOW', 'AGE', 'LWT', 'RACE', 'SMOKE', 'PTL', 'HT', 'UI', 'BWT']

print(birth_data)

# [[1.000e+00 2.800e+01 1.130e+02 ... 0.000e+00 1.000e+00 7.090e+02]

# [1.000e+00 2.900e+01 1.300e+02 ... 0.000e+00 1.000e+00 1.021e+03]

# [1.000e+00 3.400e+01 1.870e+02 ... 1.000e+00 0.000e+00 1.135e+03]

# ...

# [0.000e+00 2.400e+01 2.160e+02 ... 0.000e+00 0.000e+00 4.593e+03]

# [0.000e+00 4.500e+01 1.230e+02 ... 0.000e+00 0.000e+00 4.990e+03]

# [0.000e+00 4.500e+01 1.230e+02 ... 0.000e+00 0.000e+00 4.990e+03]]

이제 이 파일을 다음 코드를 이용하여 만들어보겠습니다.

import csv

with open(birth_weight_file, 'w', newline='') as f:

writer = csv.writer(f)

writer.writerow(header)

writer.writerows(birth_data)

f.close()

이제 birth_weight_file.csv 가 현재 디렉토리에 생성되었습니다.

이 파일을 다시 불러오겠습니다.

import numpy as np

birth_data = []

with open(birth_weight_file, newline='') as csvfile:

csv_reader = csv.reader(csvfile)

birth_header = next(csv_reader)

birth_data = [[float(args) for args in row] for row in csv_reader]

birth_data = np.array(birth_data)

print(birth_data)

# [[1.000e+00 2.800e+01 1.130e+02 ... 0.000e+00 1.000e+00 7.090e+02]

# [1.000e+00 2.900e+01 1.300e+02 ... 0.000e+00 1.000e+00 1.021e+03]

# [1.000e+00 3.400e+01 1.870e+02 ... 1.000e+00 0.000e+00 1.135e+03]

# ...

# [0.000e+00 2.400e+01 2.160e+02 ... 0.000e+00 0.000e+00 4.593e+03]

# [0.000e+00 4.500e+01 1.230e+02 ... 0.000e+00 0.000e+00 4.990e+03]

# [0.000e+00 4.500e+01 1.230e+02 ... 0.000e+00 0.000e+00 4.990e+03]]

pandas로도 csv파일을 불러올 수 있습니다.

import pandas as pd

birth_data = []

birth_data_pd = pd.read_csv(birth_weight_file)

birth_data = birth_data_pd.values

print(birth_data)

# [[1.000e+00 2.800e+01 1.130e+02 ... 0.000e+00 1.000e+00 7.090e+02]

# [1.000e+00 2.900e+01 1.300e+02 ... 0.000e+00 1.000e+00 1.021e+03]

# [1.000e+00 3.400e+01 1.870e+02 ... 1.000e+00 0.000e+00 1.135e+03]

# ...

# [0.000e+00 2.400e+01 2.160e+02 ... 0.000e+00 0.000e+00 4.593e+03]

# [0.000e+00 4.500e+01 1.230e+02 ... 0.000e+00 0.000e+00 4.990e+03]

# [0.000e+00 4.500e+01 1.230e+02 ... 0.000e+00 0.000e+00 4.990e+03]]

이제 데이터를 불러오는 과정이 끝났으니 tensorflow로 Logistic Regression을 적용해보겠습니다.

Losistic Regression을 적용하기 전에 algorithm을 살펴보겠습니다.

Logistic Regression의 흐름

우선 데이터셋에서 변수를 추출하겠습니다.

birth_m_data = birth_data[:,1:8]

print(birth_m_data)

# [[ 28. 113. 1. ... 1. 0. 1.]

# [ 29. 130. 0. ... 0. 0. 1.]

# [ 34. 187. 1. ... 0. 1. 0.]

# ...

# [ 24. 216. 0. ... 0. 0. 0.]

# [ 45. 123. 0. ... 1. 0. 0.]

# [ 45. 123. 0. ... 1. 0. 0.]]

birth_target = birth_data[:, 0]

print(birth_target)

# [1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1.

# 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1.

# 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.

# 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.

# 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]

scikit-learn의 train_test_split함수를 사용해도 되지만 파이썬 코드를 사용해서 훈련데이터와 학습데이터를 8:2로 분할하겠습니다.

# Split data into train/test = 80%/20%

data_size = len(birth_m_data)

train_idx = np.random.choice(data_size, round(data_size*0.8), replace=False)

temp_test_idx = set(np.arange(data_size)) - set(train_idx)

test_idx = np.array(list(temp_test_idx))

x_train = birth_m_data[train_idx]

x_test = birth_m_data[train_idx]

y_train = birth_target[test_idx]

y_test = birth_target[test_idx]

print(x_train)

# [[ 20. 105. 1. ... 0. 0. 0.]

# [ 31. 100. 0. ... 0. 0. 1.]

# [ 32. 132. 0. ... 0. 0. 0.]

# ...

# [ 20. 120. 1. ... 0. 0. 0.]

# [ 20. 150. 0. ... 0. 0. 0.]

# [ 16. 110. 1. ... 0. 0. 0.]]

print(x_test)

# [[ 20. 105. 1. ... 0. 0. 0.]

# [ 31. 100. 0. ... 0. 0. 1.]

# [ 32. 132. 0. ... 0. 0. 0.]

# ...

# [ 20. 120. 1. ... 0. 0. 0.]

# [ 20. 150. 0. ... 0. 0. 0.]

# [ 16. 110. 1. ... 0. 0. 0.]]

데이터셋 변수를 최솟값 0, 최댓값 1이 되도록 스케일링 해보겠습니다. 사용자 정의 함수를 이용하여 직접 코드를 짤 수도 있고,

scikit-learn의 MinMaxScaler 메소드로도 할 수 있습니다.

2가지 모두 해보겠습니다.

# user define function

def zero_to_one(m):

col_max = np.max(x_train, axis=0)

col_min = np.min(x_train, axis=0)

return (m-col_min)/(col_max-col_min)

x_train_scaled_def = np.nan_to_num(zero_to_one(x_train))

print(x_train_scaled_def)

# [[0.19354839 0.14705882 1. ... 0. 0. 0. ]

# [0.5483871 0.11764706 0. ... 0. 0. 1. ]

# [0.58064516 0.30588235 0. ... 0. 0. 0. ]

# ...

# [0.19354839 0.23529412 1. ... 0. 0. 0. ]

# [0.19354839 0.41176471 0. ... 0. 0. 0. ]

# [0.06451613 0.17647059 1. ... 0. 0. 0. ]]

x_test_scaled_def = np.nan_to_num(zero_to_one(x_test))

print(x_test_scaled_def)

# [[0.19354839 0.14705882 1. ... 0. 0. 0. ]

# [0.5483871 0.11764706 0. ... 0. 0. 1. ]

# [0.58064516 0.30588235 0. ... 0. 0. 0. ]

# ...

# [0.19354839 0.23529412 1. ... 0. 0. 0. ]

# [0.19354839 0.41176471 0. ... 0. 0. 0. ]

# [0.06451613 0.17647059 1. ... 0. 0. 0. ]]

# scikit-learn

from sklearn.preprocessing import MinMaxScaler

scaler = MinMaxScaler()

scaler.fit(x_train)

x_train_scaled = scaler.transform(x_train)

print(x_train_scaled)

# [[0.19354839 0.14705882 1. ... 0. 0. 0. ]

# [0.5483871 0.11764706 0. ... 0. 0. 1. ]

# [0.58064516 0.30588235 0. ... 0. 0. 0. ]

# ...

# [0.19354839 0.23529412 1. ... 0. 0. 0. ]

# [0.19354839 0.41176471 0. ... 0. 0. 0. ]

# [0.06451613 0.17647059 1. ... 0. 0. 0. ]]

x_test_scaled = scaler.transform(x_test)

print(x_test_scaled)

# [[0.19354839 0.14705882 1. ... 0. 0. 0. ]

# [0.5483871 0.11764706 0. ... 0. 0. 1. ]

# [0.58064516 0.30588235 0. ... 0. 0. 0. ]

# ...

# [0.19354839 0.23529412 1. ... 0. 0. 0. ]

# [0.19354839 0.41176471 0. ... 0. 0. 0. ]

# [0.06451613 0.17647059 1. ... 0. 0. 0. ]]

이제 데이터로딩과 전처리가 완료 되었으니 tensorflow로 logistic 분석을 해보겠습니다.

먼저 tensorflow로 학습 algorithm tool을 만듭니다.

import tensorflow as tf

from tensorflow.python.framework import ops

import matplotlib.pyplot as plt

ops.reset_default_graph()

# Create graph

sess = tf.Session()

# Set for reproducible results

np.random.seed(seed=99)

tf.set_random_seed(seed=99)

# Initialize placeholders

x_data = tf.placeholder(shape=[None, 7], dtype=tf.float32)

y_target = tf.placeholder(shape=[None, 1], dtype=tf.float32)

# Create variables for linear regression

A = tf.Variable(tf.random_normal(shape=[7,1]))

b = tf.Variable(tf.random_normal(shape=[1,1]))

# Declare model operations

fomula = tf.add(tf.matmul(x_data, A), b)

# Declare loss function (Cross Entropy loss)

loss = tf.reduce_mean(tf.nn.sigmoid_cross_entropy_with_logits(logits=fomula, labels=y_target))

# Declare optimizeraon

opt = tf.train.GradientDescentOptimizer(0.01)

train_step = opt.minimize(loss)

# Initialize variables

init = tf.global_variables_initializer()

sess.run(init)

# Actual Prediction

prediction = tf.round(tf.sigmoid(fomula))

predictions_correct = tf.cast(tf.equal(prediction, y_target), tf.float32) # tf.cast: 자료형태를 변환합니다. tf.cast(input tensor, dtype)

accuracy = tf.reduce_mean(predictions_correct)

이제 algorithm tool을 만들었으니 이를 바탕으로 학습을 시켜보겠습니다.

# Training loop

batch_size = 25

loss_vec = []

train_acc = []

test_acc = []

for i in range(1500):

rand_idx = np.random.choice(len(x_train_scaled), size=batch_size)

rand_x = x_train_scaled[rand_idx]

rand_y = y_train[rand_idx].reshape(-1, 1) # reshape에 주의

sess.run(train_step, feed_dict={x_data:rand_x, y_target:rand_y})

temp_loss = sess.run(loss, feed_dict={x_data:rand_x, y_target:rand_y}) # train step을 실행

loss_vec.append(temp_loss)

temp_train = sess.run(accuracy, feed_dict={x_data:x_train_scaled, y_target:y_train.reshape(-1, 1)}) # accuracy를 실행, reshape 주의

train_acc.append(temp_train)

temp_test = sess.run(accuracy, feed_dict={x_data:x_test_scaled, y_target:y_test.reshape(-1, 1)}) # accuracy를 실행, reshape 주의

test_acc.append(temp_test)

if (i+1)%300==0:

print('Loss = {}'.format(temp_loss))

# Loss: 0.8982473015785217

# Loss: 0.641773521900177

# Loss: 0.630251944065094

# Loss: 0.5026944279670715

# Loss: 0.5662710070610046

# Loss: 0.6175627708435059

# Loss: 0.5372310876846313

sess.close()

위의 결과를 바탕으로 시각화를 하는 코드는 다음과 같습니다.

_, axe = plt.subplots(1, 2)

# Plot loss over time

axe[0].plot(loss_vec, 'k-')

axe[0].set_title('Cross Entropy Loss per Generation')

axe[0].set_xlabel('Generation')

axe[0].set_ylabel('Cross Entropy Loss')

# Plot train and test accuracy

axe[1].plot(train_acc, 'k-', label='Train Set Accuracy')

axe[1].plot(test_acc, 'r--', label='Test Set Accuracy')

axe[1].set_title('Train and Test Accuracy')

axe[1].set_xlabel('Generation')

axe[1].set_ylabel('Accuracy')

axe[1].legend(loc='lower right')

plt.show()

Loss 함수와 Accuracy

참고 자료:

[1]TensorFlow Machine Learning Cookbook, Nick McClure

[2]https://github.com/nfmcclure/tensorflow_cookbook

'Tensorflow > Linear Regression' 카테고리의 다른 글

Elastic Net Regression (0)	2018.04.29
LASSO and Ridge Regression (1)	2018.04.27
Deming Regression (0)	2018.04.27
Loss Function in Linear Regressions (0)	2018.04.26
TensorFlow Way of LinearRegression (0)	2018.04.26

Elastic Net Regression

2018. 4. 29. 00:39

#!/usr/bin/env python3

Elastic Net Regression

elastic net regression을 풀기위해서는 아래 방정식을 적용합니다.

$$y = Ax + b$$

# y = Sepal Length

# x = Pedal Length, Petal Width, Sepal Width

사용자 정의 형태로 만들어 인자를 변경하며 결과를 확인해보겠습니다.

elastic net regression의 cost function은 다음과 같습니다.

$$cost = mean \left( \sum{\left (y - \overset{\wedge}{y}\right)^{2} }\right) + 1 \cdot mean \left (\sum{\left | x_{i} \right |}\right) +1 \cdot mean \left (\sum {x^{2}_{i}} \right ) $$

import matplotlib.pyplot as plt

import numpy as np

import tensorflow as tf

from sklearn import datasets

from tensorflow.python.framework import ops

def elastic_net_func(idx, batch_size):

ops.reset_default_graph()

# iris.data = [(Sepal Length, Sepal Width, Petal Length, Petal Width)]

iris = datasets.load_iris()

x_vals = iris.data[:, idx]

y_vals = iris.data[:, 0]

# Initialize placeholders

x_data = tf.placeholder(shape=[None, 1], dtype=tf.float32)

y_target = tf.placeholder(shape=[None, 1], dtype=tf.float32)

# Create variables for linear regression

A = tf.Variable(tf.random_normal(shape=[1,1]))

b = tf.Variable(tf.random_normal(shape=[1,1]))

with tf.Session() as sess:

fomula = tf.add(tf.matmul(x_data, A), b)

np.random.seed(seed=42)

tf.set_random_seed(seed=42)

l1_a_loss = tf.reduce_mean(tf.abs(A))

l2_a_loss = tf.reduce_mean(tf.square(A))

y_loss = tf.reduce_mean(tf.square(y_target - fomula))

loss = tf.add(tf.add(l1_a_loss, l2_a_loss), y_loss) # cost function

opt = tf.train.GradientDescentOptimizer(0.001)

train_step = opt.minimize(loss)

# Initialize variables

init = tf.global_variables_initializer()

init.run()

loss_vec = []

for i in range(1000):

rand_idx = np.random.choice(len(x_vals), size=batch_size)

rand_x = x_vals[rand_idx].reshape(-1, 1)

rand_y = y_vals[rand_idx].reshape(-1, 1)

my_dict = {x_data:rand_x, y_target:rand_y}

sess.run(train_step, feed_dict=my_dict)

temp_loss = sess.run(loss, feed_dict=my_dict)

loss_vec.append(temp_loss)

if (i+1)%200==0:

print('step {}: A={}, b={}, Loss={}'.format(i+1, A.eval()[0], b.eval()[0], temp_loss))

[coef] = A.eval()[0]

[intercept] = b.eval()[0]

best_params = []

for i in x_vals:

poly = i*coef + intercept

best_params.append(poly)

_, axe = plt.subplots(1, 2)

axe[0].scatter(x_vals, y_vals, edgecolors='k', label='data points')

axe[0].plot(x_vals, best_params, c='red', label='best pit line')

axe[0].set_title('index={}\nslope = {:.5f}, intercept = {:.5f}'.format(idx ,coef, intercept))

axe[0].set_xlabel('{}'.format(iris.feature_names[idx]))

axe[0].set_ylabel('{}'.format(iris.feature_names[0]))

axe[0].legend(loc=2)

axe[1].plot(loss_vec, c='k')

axe[1].set_xlabel('Generation')

axe[1].set_ylabel('Loss')

axe[1].set_title('Loss per Generation')

plt.show()

사용자 정의 함수를 이용하여 인자에 따른 시각화를 해보겠습니다.

elastic_net_func(idx=1, batch_size=50)

sepal width vs sepal length

# step 200: A=[1.70271], b=[-0.14161193], Loss=6.42409610748291

# step 400: A=[1.6244563], b=[0.16109753], Loss=6.042064189910889

# step 600: A=[1.5415831], b=[0.44974053], Loss=5.765136241912842

# step 800: A=[1.4513652], b=[0.72334766], Loss=4.744622707366943

# step 1000: A=[1.3864329], b=[0.99185705], Loss=5.004234790802002

elastic_net_func(idx=2, batch_size=50)

petal length vs sepal length

# step 200: A=[1.3025422], b=[-0.19726731], Loss=7.4931416511535645

# step 400: A=[1.2043393], b=[0.24439183], Loss=5.619389057159424

# step 600: A=[1.1216723], b=[0.6478416], Loss=4.893489837646484

# step 800: A=[1.0472624], b=[1.0189508], Loss=5.274661540985107

# step 1000: A=[0.9723399], b=[1.3565185], Loss=2.696936845779419

elastic_net_func(idx=3, batch_size=50)

petal width VS sepal length

# step 200: A=[1.3511531], b=[1.0177041], Loss=14.15509033203125

# step 400: A=[1.5765594], b=[2.0053844], Loss=8.151086807250977

# step 600: A=[1.4302077], b=[2.6739304], Loss=5.979291915893555

# step 800: A=[1.2245288], b=[3.1957018], Loss=4.475618362426758

# step 1000: A=[1.0373899], b=[3.6267276], Loss=3.252098560333252

참고 자료:

[1]TensorFlow Machine Learning Cookbook, Nick McClure

[2]https://github.com/nfmcclure/tensorflow_cookbook

'Tensorflow > Linear Regression' 카테고리의 다른 글

Logistic Regression (0)	2018.05.01
LASSO and Ridge Regression (1)	2018.04.27
Deming Regression (0)	2018.04.27
Loss Function in Linear Regressions (0)	2018.04.26
TensorFlow Way of LinearRegression (0)	2018.04.26

LASSO and Ridge Regression

2018. 4. 27. 14:28

#!/usr/bin/env python3

LASSO and Ridge Regression

이전 포스팅 보기

[1]Ridge, [2]Lasso

LASSO Ridge는 모두 출력 값에 미치는 regularization을 적용합니다.

tensorflow에서는 기울기A값에 의존하는 항을 cost function에 추가하면 이런 효과를 얻을 수 있습니다.

LASSO의 경우 기울기A가 특정 값 이상이 되면 cost를 크게 증가시키는 항을 추가해야합니다.

tensorflow의 논리 연산을 사용할 수도 있지만, 이렇게 하면 경사도를 계산할 수 없습니다. 대신에 step function을 연속 함수로 근사한 continuous heavyside step 함수를 조절해서 사용하여 문제를 해결 할 수 있습니다.

step function은 step이 중요합니다. step이 너무 높으면 수렴하지 않는 경우가 발생할 수 있습니다.

iris데이터셋으로 LASSO를 적용해보겠습니다.

먼저 data를 로딩하고 placeholder를 생성하겠습니다.

import tensorflow as tf

from tensorflow.python.framework import ops

import numpy as np

from sklearn.datasets import load_iris

ops.reset_default_graph()

iris = load_iris()

# iris.keys(): dict_keys(['data', 'target', 'target_names', 'DESCR', 'feature_names'])

# iris.feature_names: ['sepal length (cm)', 'sepal width (cm)', 'petal length (cm)', 'petal width (cm)']

regression_type = 'LASSO' # LASSO, Ridge

x_vals = iris.data[:, 3] # petal width

y_vals = iris.data[:, 0] # sepal length

x_data = tf.placeholder(shape=[None, 1], dtype=tf.float32)

y_target = tf.placeholder(shape=[None, 1], dtype=tf.float32)

A = tf.Variable(tf.random_normal(shape=[1, 1]))

b = tf.Variable(tf.random_normal(shape=[1, 1]))

연속함수로 근사한 LASSO의 cost function인 heavyside step function은 다음과 같이 쓸 수 있습니다.$$y = \frac {1}{e^{ \left( x-\theta \right) \cdot (-\delta) }+1}$$

Ridge의 cost function은 다음과 같습니다.

$$mean\left(\sum { \left( y-\overset { \wedge }{ y } \right) ^{ 2 } }\right) + mean \left(\theta \sum {A^{ 2 } } \right)$$

여기서 $\theta$는 critical value^임계값을 말하며 $\delta$는 step의 sensitivity^민감도를 나타냅니다.

activate function인 continuous heavyside step함수는 다음 코드로 시각화 할 수 있습니다.

deltas = [0.1, 1, 5, 50]

_, axes = plt.subplots(2, 2)

for ax, delta in zip(axes.ravel(), deltas):

line = np.linspace(-5, 5)

theta = 0.9

step = 1

y = 1/(np.exp((line-theta)*(-delta)) + 1) * step

ax.plot(line, y)

ax.set_title('$\delta$={}'.format(delta))

plt.show()

$\delta$값에 따른 heavyside step function

따라서 LASSO와 Ridge의 cost function을 고려한 연산과정은 다음과 같습니다

with tf.Session() as sess:

fomula = tf.add(tf.matmul(x_data, A), b)

if regression_type == 'LASSO':

lasso_params = tf.constant(0.9, dtype=tf.float32) # limit slope

heavyside_step = tf.truediv(1., tf.add(tf.exp(tf.multiply(tf.subtract(A, lasso_params), -50)), 1))

regularization = tf.multiply(99., heavyside_step)

loss = tf.add(tf.reduce_mean(tf.square(y_target-fomula)), regularization)

elif regression_type == 'Ridge':

ridge_params = tf.constant(1., dtype=tf.float32)

ridge_loss = tf.reduce_mean(tf.square(A))

loss = tf.expand_dims(tf.add(tf.reduce_mean(tf.square(y_target-fomula)),

tf.multiply(ridge_params, ridge_loss)), 0)

opt = tf.train.GradientDescentOptimizer(learning_rate=0.001)

train_step = opt.minimize(loss)

init = tf.global_variables_initializer()

init.run()

loss_vec = []

for i in range(1500):

rnd_idx = np.random.choice(len(x_vals), size = batch_size)

rnd_x = x_vals[rnd_idx].reshape(-1, 1)

rnd_y = y_vals[rnd_idx].reshape(-1, 1)

my_dict = {x_data:rnd_x, y_target:rnd_y}

sess.run(train_step, feed_dict=my_dict)

temp_loss = sess.run(loss, feed_dict=my_dict)

loss_vec.append(temp_loss[0])

if (i+1)%300 == 0:

print('step={}: A={}, b={}, Loss={}'.format(i+1, A.eval(), b.eval(), temp_loss))

# step=300: A=[[0.7634046]], b=[[2.8413053]], Loss=[[5.382721]]

# step=600: A=[[0.75245243]], b=[[3.7877374]], Loss=[[1.4977918]]

# step=900: A=[[0.7403701]], b=[[4.3101645]], Loss=[[0.6288415]]

# step=1200: A=[[0.72969586]], b=[[4.60605]], Loss=[[0.40883213]]

# step=1500: A=[[0.72272784]], b=[[4.7734385]], Loss=[[0.3297159]]

slope = A.eval()[0]

cept = b.eval()[0]

더 자세히 알아보기 위해 시각화 하면

best_fit = []

for i in x_vals.ravel():

poly = i*slope + cept

best_fit.append(poly)

_, ax = plt.subplots(1, 2)

ax[0].scatter(x_vals, y_vals, edgecolors='k', label='Data Points')

ax[0].plot(x_vals, best_fit, c='red', label='Best fit line', linewidth=3)

ax[0].legend(loc=2)

ax[0].set_title('Petal Width vs Sepal Length')

ax[0].set_xlabel('Petal Width')

ax[0].set_ylabel('Sepal Length')

ax[1].plot(loss_vec, c='k')

ax[1].set_title(regression_type + ' Loss per Generation')

ax[1].set_xlabel('Generation')

ax[1].set_ylabel('Loss')

plt.show()

LASSO Regression과 Loss함수

위의 코드를 사용자 정의 함수로 만들어 LASSO, Ridge를 살펴보겠습니다

위의 결과는 아래 코드로 확인할 수 있습니다.

my_regression_type(regression_type='LASSO', batch_size=50)

# step=300: A=[[0.764575]], b=[[2.5382898]], Loss=[[5.8621655]]

# step=600: A=[[0.7535565]], b=[[3.618642]], Loss=[[1.8615394]]

# step=900: A=[[0.7427662]], b=[[4.2173624]], Loss=[[0.7045775]]

# step=1200: A=[[0.7338138]], b=[[4.5521526]], Loss=[[0.44136143]]

# step=1500: A=[[0.72335386]], b=[[4.739038]], Loss=[[0.23825285]]

LASSO Linear Regression과 Loss

my_regression_type(regression_type='Ridge', batch_size=50)

# step=300: A=[[1.9796406]], b=[[1.416961]], Loss=[8.540436]

# step=600: A=[[1.7114378]], b=[[2.419876]], Loss=[5.517313]

# step=900: A=[[1.4033114]], b=[[3.132286]], Loss=[3.4445624]

# step=1200: A=[[1.1520133]], b=[[3.6732914]], Loss=[2.298217]

# step=1500: A=[[0.95343864]], b=[[4.086554]], Loss=[1.4839184]

Ridge Linear Regression과 Loss

참고 자료:

[1]TensorFlow Machine Learning Cookbook, Nick McClure

[2]https://github.com/nfmcclure/tensorflow_cookbook

'Tensorflow > Linear Regression' 카테고리의 다른 글

Logistic Regression (0)	2018.05.01
Elastic Net Regression (0)	2018.04.29
Deming Regression (0)	2018.04.27
Loss Function in Linear Regressions (0)	2018.04.26
TensorFlow Way of LinearRegression (0)	2018.04.26

Deming Regression

2018. 4. 27. 11:48

#!/usr/bin/env python3

Deming Regression

Deming regression은 total regression^전회귀로도 불립니다.

Deming regression는 y값과 x값의 오차를 최소화 합니다.

Deming regression을 구현하기 위해서는 Loss Cost Function을 수정해야합니다.

일반적인 선형 회귀의 비용함수는 수직거리를 최소화 하기 때문입니다.

직선의 기울기와 y절편을 이용하여 점까지 수식 거리를 구하고

tensorflow가 그 값을 최소화 하게 합니다.

직선까지의 수직 거리를 최소화(좌) 직선까지의 전체거리를 최소화(우)

출처: https://github.com/nfmcclure/tensorflow_cookbook/

데이터를 로딩하고 placeholder를 다음과 같이 생성해보겠습니다.

import tensorflow as tf

from tensorflow.python.framework import ops

import numpy as np

from sklearn.datasets import load_iris

ops.reset_default_graph()

iris = load_iris()

print(iris.keys())

# dict_keys(['data', 'target', 'target_names', 'DESCR', 'feature_names'])

print(iris.feature_names)

# ['sepal length (cm)', 'sepal width (cm)', 'petal length (cm)', 'petal width (cm)']

# load the data

x_val = iris.data[:,3] # petal width

y_val = iris.data[:,0] # sepal length

# initialize placeholders

x_data = tf.placeholder(shape=[None, 1], dtype=tf.float32)

y_target = tf.placeholder(shape=[None, 1], dtype=tf.float32)

# create variables for linear regression

A = tf.Variable(tf.random_normal(shape=[1, 1]))

b = tf.Variable(tf.random_uniform(shape=[1, 1]))

직선 $y = mx +b$와 점 $(x_{0}, y_{0})$가 주어졌을 때 둘 사이의 수직 거리는 다음과 같이 쓸 수 있습니다.

$$d=\frac{\left |y_{0}-(mx_{0}+b) \right|}{\sqrt{m^{2}+1}}$$

따라서 이 식을 이용하여 loss function을 재구성하여 linear regression을 구현해보겠습니다.

with tf.Session() as sess:

fomula = tf.add(tf.matmul(x_data, A) ,b)

demm_numer = tf.abs(tf.subtract(fomula, y_target)) # numerator

demm_denom = tf.sqrt(tf.add(tf.square(A), 1)) # denominator

loss = tf.reduce_mean(tf.truediv(demm_numer, demm_denom)) # 점과 직선사이의 거리

opt = tf.train.GradientDescentOptimizer(learning_rate=0.15)

train_step = opt.minimize(loss)

init = tf.global_variables_initializer()

init.run()

loss_vec = []

batch_size = 125

for i in range(1000):

rand_idx = np.random.choice(len(x_val), size=batch_size)

rand_x = x_val[rand_idx].reshape(-1, 1)

rand_y = y_val[rand_idx].reshape(-1, 1)

my_dict = {x_data:rand_x, y_target:rand_y}

sess.run(train_step, feed_dict=my_dict)

temp_loss = sess.run(loss, feed_dict=my_dict)

loss_vec.append(temp_loss)

if (i+1)%100==0:

print('step {}: A={}, b={}, Loss={}'.format(i+1, A.eval(), b.eval(), temp_loss))

# step 100: A=[[2.8481812]], b=[[2.1150784]], Loss=0.39886653423309326

# step 200: A=[[2.4716957]], b=[[2.581221]], Loss=0.4149680733680725

# step 300: A=[[2.0858126]], b=[[3.1767926]], Loss=0.37009572982788086

# step 400: A=[[1.5102198]], b=[[3.989578]], Loss=0.30516621470451355

# step 500: A=[[1.0213077]], b=[[4.55735]], Loss=0.25061553716659546

# step 600: A=[[1.0353084]], b=[[4.609328]], Loss=0.2725234925746918

# step 700: A=[[1.0107175]], b=[[4.6160936]], Loss=0.3082656264305115

# step 800: A=[[1.0400845]], b=[[4.612001]], Loss=0.27881959080696106

# step 900: A=[[1.0318567]], b=[[4.6159105]], Loss=0.27347463369369507

# step 1000: A=[[0.9662517]], b=[[4.5973287]], Loss=0.2258552461862564

[slope] = A.eval()

[cept] = b.eval()

위의 결과를 시각화하는 코드는 다음와 같습니다.

import matplotlib.pyplot as plt

best_fit = []

for i in x_val.ravel():

poly = i*slope[0] + cept[0]

best_fit.append(poly)

_, axes = plt.subplots(1, 2)

axes[0].scatter(x_val, y_val, edgecolors='k', label='Data Points')

axes[0].plot(x_val, best_fit, c='red', label='Best fit line')

axes[0].set_title('Petal Width vs Sepal Length', size=12)

axes[0].set_xlabel('Petal Width')

axes[0].set_ylabel('Sepal Length')

axes[0].legend(loc=2)

axes[1].plot(loss_vec, c='k')

axes[1].set_title('Demming Loss per Generation', size=12)

axes[1].set_xlabel('Iteration')

axes[1].set_ylabel('Demming Loss')

plt.show()

Demming Regression과 Loss Function

참고 자료:

[1]TensorFlow Machine Learning Cookbook, Nick McClure

[2]https://github.com/nfmcclure/tensorflow_cookbook

'Tensorflow > Linear Regression' 카테고리의 다른 글

Elastic Net Regression (0)	2018.04.29
LASSO and Ridge Regression (1)	2018.04.27
Loss Function in Linear Regressions (0)	2018.04.26
TensorFlow Way of LinearRegression (0)	2018.04.26
Implementing_a_Decomposition_Method with the Cholesky Decomposition Method (0)	2018.04.26

Loss Function in Linear Regressions

2018. 4. 26. 17:17

#!/usr/bin/env python3

Loss Function in Linear Regressions

이 그림은 Learning rate에 따른 L1과 L2 손실함수를 보여줍니다.

learning rate가 낮으면 정확도는 높아지지만 그만큼 많은 시간과 비용이 들어가며

learning rate가 높으면 발산 or 수렴할 수 있습니다. 따라서 적절한 learning rate를 선정하는 것이 중요합니다.

Linear Regression: L1 vs L2

출처: https://github.com/nfmcclure/tensorflow_cookbook

L1 Loss for Linear Least Squares 공식은 다음과 같습니다.

$$S =\sum_{i=1}^{N }{ \left| y_{i}-\overset {\wedge }{y}_{i} \right |} $$

여기서 $N$은 data points의 수이고, $y_{i}$는 $y$의 실제 값이며, $\overset{\wedge}{y_{i}}$는 $i$번째 $y$의 예측 값입니다.

iris데이터셋에 L1 Loss function을 사용하여 결과를 확인해보면 다음과 같습니다.

from sklearn.datasets import load_iris

import tensorflow as tf

import numpy as np

from tensorflow.python.framework import ops

ops.reset_default_graph()

iris = load_iris()

print(iris.keys())

# dict_keys(['data', 'target', 'target_names', 'DESCR', 'feature_names'])

print(iris.feature_names)

# ['sepal length (cm)', 'sepal width (cm)', 'petal length (cm)', 'petal width (cm)']

x_vals = iris.data[:, 3] # petal width

y_vals = iris.data[:, 0] # sepal length

batch_size = 25

lrn_rate = 0.1 # divergenc at 0.4

iterations = 100

x_data = tf.placeholder(shape=[None, 1], dtype=tf.float32)

y_target = tf.placeholder(shape=[None, 1], dtype=tf.float32)

A = tf.Variable(tf.random_normal(shape=[1, 1]))

b = tf.Variable(tf.random_normal(shape=[1, 1]))

with tf.Session() as sess:

model_output = tf.add(tf.matmul(x_data, A), b)

loss_l1 = tf.reduce_mean(tf.abs(y_target - model_output))

my_opt_l1 = tf.train.GradientDescentOptimizer(learning_rate=lrn_rate)

train_step_l1 = my_opt_l1.minimize(loss_l1)

init = tf.global_variables_initializer()

init.run()

loss_vec_l1 = []

for i in range(iterations):

rnd_idx = np.random.choice(len(x_vals), size=batch_size)

rnd_x = x_vals[rnd_idx].reshape(-1, 1)

rnd_y = y_vals[rnd_idx].reshape(-1, 1)

feed = {x_data:rnd_x, y_target:rnd_y}

sess.run(train_step_l1, feed_dict=feed)

temp_loss_l1 = sess.run(loss_l1, feed_dict=feed)

loss_vec_l1.append(temp_loss_l1)

if (i+1)%10 == 0:

print('Step {}: A={}, b={}'.format(i+1, A.eval(), b.eval()))

# Step 10: A=[[-0.4101382]], b=[[-0.2588229]]

# Step 20: A=[[0.7642619]], b=[[0.74117714]]

# Step 30: A=[[1.9774618]], b=[[1.7411773]]

# Step 40: A=[[2.3398612]], b=[[2.3091774]]

# Step 50: A=[[2.252261]], b=[[2.6771777]]

이번에는 L2 Loss function에 대해 알아보겠습니다.

L2 Loss for Linear Least Squares는 다음과 같으며

$$S = \sum_{i=1}^{N}{\left(y_{i}-\overset{\wedge}{y_{i}} \right)^{2}}$$

위와 마찬가지로 $N$은 data points의 수이고, $y_{i}$는 $y$의 실제 값이며, $\overset{\wedge}{y_{i}}$는 $i$번째 $y$의 예측 값입니다.

다음 코드는 iris데이터에 L2 Loss function을 사용한 예입니다.

ops.reset_default_graph()

iris = load_iris()

print(iris.keys())

# dict_keys(['data', 'target', 'target_names', 'DESCR', 'feature_names'])

print(iris.feature_names)

# ['sepal length (cm)', 'sepal width (cm)', 'petal length (cm)', 'petal width (cm)']

x_vals = iris.data[:, 3] # petal width

y_vals = iris.data[:, 0] # sepal length

x_data = tf.placeholder(shape=[None, 1], dtype=tf.float32)

y_target = tf.placeholder(shape=[None, 1], dtype=tf.float32)

A = tf.Variable(tf.random_normal(shape=[1, 1]))

b = tf.Variable(tf.random_normal(shape=[1, 1]))

with tf.Session() as sess:

fomula = tf.add(tf.matmul(x_data, A), b)

loss_l2 = tf.reduce_mean(tf.square(y_target - fomula))

opt = tf.train.GradientDescentOptimizer(lrn_rate)

train_step_l2 = opt.minimize(loss_l2)

init = tf.global_variables_initializer()

init.run()

loss_vec_l2 = []

for i in range(iterations):

rand_idx = np.random.choice(len(x_vals), size=batch_size)

rand_x = x_vals[rand_idx].reshape(-1, 1)

rand_y = y_vals[rand_idx].reshape(-1, 1)

my_dict = {x_data:rand_x, y_target:rand_y}

sess.run(train_step_l2, feed_dict=my_dict)

temp_loss_l2 = sess.run(loss_l2, feed_dict=my_dict)

loss_vec_l2.append(temp_loss_l2)

if (i+1)%20 == 0:

print('step {}: A={}, b={}'.format(i+1, A.eval()[0], b.eval()[0]))

# step 20: A=[1.876194], b=[3.1437955]

# step 40: A=[1.3978924], b=[4.1212244]

# step 60: A=[1.1288545], b=[4.4799623]

# step 80: A=[0.9617775], b=[4.64575]

# step 100: A=[0.88910973], b=[4.7133427]

L1 Loss function과 L2 Loss function을 시각화하는 코드는 다음과 같습니다.

import matplotlib.pyplot as plt

plt.plot(loss_vec_l1, c='k', label='L1 Loss')

plt.plot(loss_vec_l2, c='red', ls='--', label='L2 Loss')

plt.title('L1 and L2 Loss per Generation, learning rate={}'.format(lrn_rate))

plt.xlabel('Generation')

plt.ylabel('Loss')

plt.legend(loc=1)

plt.show()

learning rate=0.1일 때 수렴(좌) , learning rate=0.4일 때 발산(우)

참고 자료:

[1]TensorFlow Machine Learning Cookbook, Nick McClure

[2]https://github.com/nfmcclure/tensorflow_cookbook

'Tensorflow > Linear Regression' 카테고리의 다른 글

LASSO and Ridge Regression (1)	2018.04.27
Deming Regression (0)	2018.04.27
TensorFlow Way of LinearRegression (0)	2018.04.26
Implementing_a_Decomposition_Method with the Cholesky Decomposition Method (0)	2018.04.26
Inverse Matrix Method (0)	2018.04.26

TensorFlow Way of LinearRegression

2018. 4. 26. 16:43

#!/usr/bin/env python3

TensorFlow Way of LinearRegression

이번 예제에서는 tensorflow를 통해 일괄적으로 데이터에 대한 루프를 돌면서 기울기와 y절편을 갱신할 것입니다.

Petal width꽃잎 폭을 x로 Sepal length길이를 y로하는 데이터를 대상으로 최적 직선을 찾아보겠습니다. L2 비용 함수를 사용하겠습니다.

iris데이터셋으로 Linear Regression을 해결하기 위해서는 역시 아래 방정식을 풀어야 합니다.

$$y = Ax+b$$

linear regression computational graph를 사용하기 위해서서는 input으로 $x$ 를 넣었을 때,

$Ax+b$가 만들어져야 하고 $A$, $b$는 손실값이 최소가 되어야 합니다.

import numpy as np

import tensorflow as tf

from sklearn.datasets import load_iris

from tensorflow.python.framework import ops

iris = load_iris()

print(iris.keys())

# dict_keys(['data', 'target', 'target_names', 'DESCR', 'feature_names'])

print(iris.feature_names)

# ['sepal length (cm)', 'sepal width (cm)', 'petal length (cm)', 'petal width (cm)']

x_vals = np.array([x[3] for x in iris.data])

y_vals = iris.data[:,0]

batch_size = 25

x_data = tf.placeholder(shape=[None, 1], dtype=tf.float32)

y_target = tf.placeholder(shape=[None, 1], dtype=tf.float32)

A = tf.Variable(tf.random_normal(shape=[1, 1]))

b = tf.Variable(tf.random_normal(shape=[1, 1]))

데이터가 준비되었으니 tensorflow 방식으로 algorithm을 구현하면 다음과 같습니다.

with tf.Session() as sess:

model_output = tf.add(tf.matmul(x_data, A), b) # linear regression fomula

loss = tf.reduce_mean(tf.square(y_target - model_output)) # L2 loss

my_opt = tf.train.GradientDescentOptimizer(learning_rate=0.05)

train_step = my_opt.minimize(loss) # loss가 최소인 방향으로 다음 단계 이동

init = tf.global_variables_initializer()

init.run()

loss_vec = []

for i in range(100):

rand_idx = np.random.choice(len(x_vals), size=batch_size)

rand_x = x_vals[rand_idx].reshape(-1, 1)

rand_y = y_vals[rand_idx].reshape(-1, 1)

fedict={x_data: rand_x, y_target:rand_y}

sess.run(train_step, feed_dict=fedict) # step 반복

temp_loss = sess.run(loss, feed_dict=fedict)

loss_vec.append(temp_loss)

if (i+1)%20==0:

print('Step {}\nA={}, b={} Loss={:.5f}'.format(i+1, A.eval(), b.eval(), temp_loss))

# Step 20

# A=[[2.4062862]], b=[[2.4534268]] Loss=1.78677

# Step 40

# A=[[1.9556967]], b=[[3.2615643]] Loss=0.92836

# Step 60

# A=[[1.5368886]], b=[[3.698664]] Loss=0.53148

# Step 80

# A=[[1.4006948]], b=[[4.085002]] Loss=0.46051

# Step 100

# A=[[1.1938996]], b=[[4.331669]] Loss=0.31104

[slope] = A.eval()

print('slope: {}'.format(slope))

# slope: [1.1938996]

[cept] = b.eval()

print('intercept: {}'.format(cept))

# intercept: [4.331669]

위의 결과를 시각화하는 코드는 다음과 같습니다.

import matplotlib.pyplot as plt

best_params = []

for i in x_vals.ravel():

poly = i*slope+cept

best_params.append(poly)

plt.scatter(x_vals, y_vals, label='Data Points', edgecolors='k')

plt.plot(x_vals, best_params, 'red')

plt.xlabel('Petal Width', size=15)

plt.ylabel('Sepal Length', size=15)

plt.title('Petal Width vs Sepal Length')

plt.show()

plt.plot(loss_vec, c='k')

plt.xlabel('Generation')

plt.ylabel('L2 Loss')

plt.title('L2 Loss per Generation')

plt.show()

참고 자료:

[1]TensorFlow Machine Learning Cookbook, Nick McClure

[2]https://github.com/nfmcclure/tensorflow_cookbook

'Tensorflow > Linear Regression' 카테고리의 다른 글

LASSO and Ridge Regression (1)	2018.04.27
Deming Regression (0)	2018.04.27
Loss Function in Linear Regressions (0)	2018.04.26
Implementing_a_Decomposition_Method with the Cholesky Decomposition Method (0)	2018.04.26
Inverse Matrix Method (0)	2018.04.26

Implementing_a_Decomposition_Method with the Cholesky Decomposition Method

2018. 4. 26. 12:02

#!/usr/bin/env python3

Using the Cholesky Decomposition Method

Linear Regression은 $A \cdot x=y$을 사용합니다.

Cholesky decomposition은 matrix $A$를 lower triangular matrix $L$과 $L^{T}$로 분해합니다.

차원을 같게 하기 위해 matrix $A$ 앞에 $A^{T}$를 곱하여 square matrix로 만듭니다.

따라서 아래와 같은 식이 성립합니다.

$A^{T} \cdot A=L^{T} \cdot L$

Linear Regression을 적용하면 아래와 같이 사용할 수 있습니다.

$A\cdot X=Y$

$(A^{T} \cdot A) \cdot X = A^{T} \cdot Y$

$(L^{T} \cdot L) \cdot X = A^{T} \cdot Y$

$L^{T} \cdot Z = A^{T} \cdot Y$, $L \cdot X = Z$

Cholesky decomposition을 Linear Regression에 적용하기 위해서는 다음과 같은 step이 필요합니다.

1. $A^{T} \cdot A = L^{T} \cdot L$에서 $L$을 구합니다.

2. $L^{T} \cdot Z = A^{T} \cdot Y$에서 $Z$를 구합니다.

3. $L \cdot X = Z$에서 $X$를 구합니다.

$X$는 우리가 구하고자 하는 slope와 intercept가 있는 matrix입니다.

이 과정을 간단한 데이터를 만들어 구현해 보겠습니다.

import tensorflow as tf

import numpy as np

x_vals = np.linspace(0, 10, 100).reshape(-1, 1)

print(x_vals[:6])

# [[0. ]

# [0.1010101 ]

# [0.2020202 ]

# [0.3030303 ]

# [0.4040404 ]

# [0.50505051]]

y_vals = x_vals + np.random.normal(0, 1, size=100).reshape(-1, 1)

print(y_vals[:6])

# [[-1.34770577]

# [-0.4146378 ]

# [-0.14096172]

# [ 0.23305495]

# [ 1.66821972]

# [-0.35141322]]

ones = np.ones(100).reshape(-1, 1)

print(ones[:6])

# [[1.]

# [1.]

# [1.]]

A = np.c_[x_vals, ones]

print(A[:6])

# [[0. 1. ]

# [0.1010101 1. ]

# [0.2020202 1. ]

# [0.3030303 1. ]

# [0.4040404 1. ]

# [0.50505051 1. ]]

A_tsr = tf.constant(A, dtype=tf.float32)

y_tsr = tf.convert_to_tensor(y_vals, dtype=tf.float32)

with tf.Session() as sess:

tA_A = tf.matmul(tf.transpose(A_tsr), A_tsr)

L = tf.cholesky(tA_A)

# solve $L\cdot Z=A^{T} \cdot Y$, for $Z$

tA_y = tf.matmul(tf.transpose(A_tsr), y_tsr)

sol1 = tf.matrix_solve(L, tA_y)

# solve $L^{T} \cdot X= Z$, $Z$=sol1, for $X$

sol2 = tf.matrix_solve(tf.transpose(L), sol1)

solution = sol2.eval()

slope = solution[0][0]

print('slope: {:3f}'.format(slope))

# slope: 0.988516

cept = solution[1][0]

print('intercept: {:.3f}'.format(cept))

# intercept: 0.163

시각화는 다음코드로 구현할 수 있습니다.

import matplotlib.pyplot as plt

reg_params = []

for i in x_vals.ravel():

poly = i*slope + cept

reg_params.append(poly)

plt.scatter(x_vals, y_vals, label='data')

plt.plot(x_vals, reg_params, c='red', label='best fit line')

plt.xlabel('feature 0', size=15)

plt.ylabel('feature 1', size=15)

plt.legend(loc='upper center', bbox_to_anchor=[0.1, 1.1], fancybox=True)

plt.show()

Cholesky 분해로 분석한 LinearRegression

참고 자료:

[1]TensorFlow Machine Learning Cookbook, Nick McClure

[2]https://github.com/nfmcclure/tensorflow_cookbook

'Tensorflow > Linear Regression' 카테고리의 다른 글

LASSO and Ridge Regression (1)	2018.04.27
Deming Regression (0)	2018.04.27
Loss Function in Linear Regressions (0)	2018.04.26
TensorFlow Way of LinearRegression (0)	2018.04.26
Inverse Matrix Method (0)	2018.04.26

Inverse Matrix Method

2018. 4. 26. 10:14

#!/usr/bin/env python3

Inverse Matrix Method

일반적인 linear regression의 식은 다음과 같이 쓸 수있습니다.

$ y = ax + b $, 그러나 이 식을 행렬로 확장하면 $AX = Y$로 쓸 수 있습니다.

$$X=A^{-1}(A^{-T}A^{T})Y$$

$$X=(A^{T}A)^{-1}A^{T}Y$$

$$A = \left[ {\begin{array}{cc} x_{ 11 } & x_{ 12 } & x_{ 13 } & \cdots & 1 \\ x_{ 21 } & x_{ 22 } & x_{ 23 } & \cdots & 1 \\ \vdots&\vdots &\vdots &\ddots & \vdots \\x_{ 31 } & x_{ 32 } & x_{ 33 } & \cdots & 1 \end{array} } \right]$$

$$ point_{i}=(y_{i}, x_{i1}, x_{i2}, \cdots, x_{iF})$$

간단한 데이터를 만들어 이를 구현해보겠습니다.

import tensorflow as tf

import numpy as np

x_vals = np.linspace(0, 10, 100).reshape(-1, 1)

y_vals = x_vals + np.random.normal(0, 1, size=100).reshape(-1, 1)

ones = np.ones(100).reshape(-1, 1)

A = np.c_[x_vals, ones]

A_tsr = tf.constant(A, dtype=tf.float32)

y_tsr = tf.convert_to_tensor(y_vals, dtype=tf.float32)

init = tf.global_variables_initializer()

with tf.Session() as sess:

init.run()

tA_A = tf.matmul(tf.transpose(A_tsr), A_tsr)

tA_A_inv = tf.matrix_inverse(tA_A)

prod = tf.matmul(tA_A_inv, tf.transpose(A_tsr))

sol = tf.matmul(prod, y_tsr)

solution = sol.eval()

slope = solution[0][0]

cept = solution[1][0]

print('slope :{:.3f}'.format(slope))

# slope :1.000

print('intercept :{:.3f}'.format(cept))

# intercept :0.012

이 결과를 시각화하는 코드는 다음과 같습니다.

import matplotlib.pyplot as plt

reg_params = []

for i in x_vals.ravel():

poly = slope*i + cept

reg_params.append(poly)

plt.scatter(x_vals, y_vals, c='orange')

plt.plot(x_vals, reg_params, c='blue', lw=2)

plt.show()

inverse matrix를 이용한 Linear Regression

이런 방법은 데이터셋이 커지게 되면 느려진다는 단점이 있습니다.

참고 자료:

[1]TensorFlow Machine Learning Cookbook, Nick McClure

[2]https://github.com/nfmcclure/tensorflow_cookbook

'Tensorflow > Linear Regression' 카테고리의 다른 글

LASSO and Ridge Regression (1)	2018.04.27
Deming Regression (0)	2018.04.27
Loss Function in Linear Regressions (0)	2018.04.26
TensorFlow Way of LinearRegression (0)	2018.04.26
Implementing_a_Decomposition_Method with the Cholesky Decomposition Method (0)	2018.04.26

PREV 1 NEXT

게으른 우루루