86. Tensorflow Classification 연습문제

문1) bmi.csv 데이터셋을 이용하여 다음과 같이 sigmoid classifier의 모델을 생성하시오. 
조건1> bmi.csv 데이터셋 
-> x변수 : 1,2번째 칼럼(height, weight) 
-> y변수 : 3번째 칼럼(label)
조건2> 딥러닝 최적화 알고리즘 : Adam
조건3> learning rage = 0.01    
조건4> 반복학습 : 2,000번, 200 step 단위로 loss 출력 
조건5> 최적화 모델 테스트 :  분류정확도(Accuracy report) 출력 
   
<출력결과>
step = 200 , loss = 0.532565
step = 400 , loss = 0.41763392
step = 600 , loss = 0.34404162
step = 800 , loss = 0.29450226
step = 1000 , loss = 0.25899038
step = 1200 , loss = 0.23218009
step = 1400 , loss = 0.2111086
step = 1600 , loss = 0.19401966
step = 1800 , loss = 0.17981105
step = 2000 , loss = 0.16775638
========================================
accuracy= 0.9894053767712886  

 

import tensorflow as tf 
from sklearn.metrics import accuracy_score, classification_report
from sklearn.preprocessing import minmax_scale #x변수 정규화 
import numpy as np
import pandas as pd

 csv file load

bmi = pd.read_csv('C:/ITWILL/5_Tensorflow/data/bmi.csv')
print(bmi.info())
bmi['label'].value_counts()

normal    7677
fat       7425
thin      4898

subset 생성 : label에서 normal, fat 추출 

bmi = bmi[bmi.label.isin(['normal','fat'])]
print(bmi.head())

bmi['label'].value_counts()

normal    7677 -> 0
fat       7425 -> 1
thin      4898 -> 제거 

칼럼 추출 

col = list(bmi.columns)
print(col)

x,y 변수 추출 

x_data = bmi[col[:2]] #x변수(1,2칼럼)
y_data = bmi[col[2]] #y변수(3칼럼)
y_data #dtype: object

데이터 전처리 : label 더미변수 변환(normal -> 0, fat -> 1)

map_data = {'normal': 0,'fat' : 1}
y_data= y_data.map(map_data) #dict mapping
print(y_data) #0/1

x_data 정규화 함수 

x_data = minmax_scale(x_data)

numpy 객체 변환 

x_data = np.array(x_data)
y_data = np.transpose(np.array([y_data])) #(1, 15102) -> (15102, 1)

print(x_data.shape) #(15102, 2)
print(y_data.shape) #(15102, 1)

* X,Y 데이터 전처리 완료 

 

 

1. X,Y 변수 정의   

X = tf.constant(x_data, tf.float32) 
Y = tf.constant(y_data, tf.float32)

 

2. w,b 변수 정의 : 초기값(정규분포 난수 )

w = tf.Variable(tf.random.normal([2, 1])) #[입력수,출력수]
b = tf.Variable(tf.random.normal([1])) #[출력수]

3. 회귀방정식 

def linear_model(X) : #train, test
    y_pred = tf.linalg.matmul(X, w) + b 
    return y_pred #2차원

4. sigmoid 활성함수 적용 

def sig_fn(X):
    y_pred = linear_model(X)
    sig = tf.nn.sigmoid(y_pred) 
    return sig

5. 손실 함수 정의 : 손실계산식 수정 

def loss_fn() : #인수 없음 
    sig = sig_fn(X) 
    loss = -tf.reduce_mean(Y*tf.math.log(sig)+(1-Y)*tf.math.log(1-sig))
    return loss

6. 최적화 객체 : learning_rate= 0.01

optimizer = tf.optimizers.Adam(learning_rate= 0.01)

7. 반복학습 : 반복학습 : 2,000번, 200 step 단위로 loss 출력 

for step in range(2000) :
    #model 최적화 -> w, b 업데이트 
    optimizer.minimize(loss=loss_fn, var_list=[w, b])
    
    if (step+1) % 200 == 0 :
        print('step : ', (step+1), ", loss val = ", loss_fn().numpy())
            
print('='*30)

8. model 최적화 테스트

y_pred = tf.cast(sig_fn(X) > 0.5, tf.float32)

acc = accuracy_score(Y, y_pred)
print('accuracy =', acc)

report = classification_report(Y, y_pred)
print(report)

 

 

 

 

 

문2) bmi.csv 데이터셋을 이용하여 다음과 같이 softmax classifier 모델을 생성하시오. 
조건1> bmi.csv 데이터셋 
-> x변수 : height, weight 칼럼 
-> y변수 : label(3개 범주) 칼럼
조건2> 딥러닝 최적화 알고리즘 : Adam
조건3> learning rage : 0.001 or 0.005 선택(분류정확도 높은것) 
조건4> 반복학습, step 단위로 loss : <출력결과> 참고 
조건5> 분류정확도 출력
조건6> 예측치와 정답 15개 출력   
    
<출력 결과>
step = 500 , loss = 0.44498476
step = 1000 , loss = 0.34861678
step = 1500 , loss = 0.28995454
step = 2000 , loss = 0.24887484
step = 2500 , loss = 0.2177721
step = 3000 , loss = 0.19313334
step = 3500 , loss = 0.17303815
step = 4000 , loss = 0.15629826
step = 4500 , loss = 0.1421249
step = 5000 , loss = 0.12996733
========================================
accuracy = 0.9769
========================================
y_pred :  [0 0 1 1 1 1 0 2 0 2 1 2 1 0 2]
y_true :  [0 0 1 1 1 1 0 2 0 2 1 2 1 0 2]  
========================================

 

import tensorflow as tf  ver1.x
from sklearn.preprocessing import minmax_scale #x data 정규화(0~1)
from sklearn.metrics import accuracy_score
import numpy as np
import pandas as pd
 
bmi = pd.read_csv('C:/ITWILL/5_Tensorflow/data/bmi.csv')
print(bmi.info())

칼럼 추출 

col = list(bmi.columns)
print(col)

x,y 변수 추출 

x_data = bmi[col[:2]] #x변수

x_data 정규화 

x_data = minmax_scale(x_data)

label one hot encoding 

label_map = {"thin": [1,0,0], "normal": [0,1,0], "fat": [0,0,1]}
bmi["label"] = bmi["label"].apply(lambda x : np.array(label_map[x]))

y_data = list(bmi["label"]) #중첩list : [[1,0,0], [1,0,0]]

numpy 객체 변환 

x_data = np.array(x_data)
y_data = np.array(y_data)

* X,Y 데이터 전처리 완료

 

1. X,Y변수 정의 : 공급형 변수 

X = tf.constant(x_data, tf.float32) #[?, 2]
Y = tf.constant(y_data, tf.float32) #[?, 3]

2. w,b 변수 정의 

w = tf.Variable(tf.random.normal([2, 3])) #[입력수, 출력수]
b = tf.Variable(tf.zeros([3])) #[출력수]

3. 회귀방정식 

def linear_model(X) : #train, test
    y_pred = tf.matmul(X, w) + b  #행렬곱 : [None,3]*[3,1]=[None,1]
    return y_pred

4. softmax 활성함수 적용 

def soft_fn(X):
    y_pred = linear_model(X)
    soft = tf.nn.softmax(y_pred)
    return soft

5. 손실 함수 정의 : 손실계산식 수정 

def loss_fn() : #인수 없음 
    soft = soft_fn(X) #훈련셋 -> 예측치 : 회귀방정식  
    loss = -tf.reduce_mean(Y*tf.math.log(soft)+(1-Y)*tf.math.log(1-soft))
    return loss

6. 최적화 객체 

optimizer = tf.optimizers.Adam(lr=0.005)

7. 반복학습 

for step in range(5000) : 
    #오차제곱평균 최적화 : 손실값 최소화 -> [a, b] 갱신(update)
    optimizer.minimize(loss_fn, var_list=[w, b]) #(손실값, 수정 대상)
    
    #500배수 단위 출력 
    if (step+1) % 500 == 0 :
        print("step =", (step+1), ", loss =", loss_fn().numpy())

8. 최적화된 model 검정 

soft_re = soft_fn(X).numpy()

y_pred = tf.argmax(soft_re, 1) # demension : 2d
y_true = tf.argmax(Y, 1) # demension : 2d

acc = accuracy_score(y_true, y_pred)
print("="*40)
print('accuracy =', acc) # accuracy = 0.98

y_true vs y_pred  

print("="*40) 
print('y_pred : ', y_pred.numpy()[:15])
print('y_true : ', y_true.numpy()[:15])

 

 

 

 

문3) 다음 digits 데이터셋을 이용하여 다항분류기를 작성하시오.
<조건1> digits 데이터셋의 특성을 보고 전처리/공급data 생성  
<조건2> 아래 <출력결과>를 참고하여 학습율과 반복학습 적용
<조건3> epoch에 따른 loss value 시각화 : 이미지파일 참고 (exam03_lossValue.png)

<출력결과>
step = 200 , loss = 0.06003735238669643
step = 400 , loss = 0.02922042555340125
step = 600 , loss = 0.01916724251850193
step = 800 , loss = 0.01418028865527556
step = 1000 , loss = 0.011102086315873883
step = 1200 , loss = 0.008942419709185086
step = 1400 , loss = 0.007311927138572721
step = 1600 , loss = 0.006023632246639046
step = 1800 , loss = 0.004981346240771604
step = 2000 , loss = 0.004163072611802871
========================================
accuracy = 0.9648148148148148

 

import tensorflow as tf #ver 2.0
from sklearn.preprocessing import OneHotEncoder #y data -> one hot
from sklearn.metrics import accuracy_score
from sklearn.model_selection import train_test_split
from sklearn.datasets import load_digits

digits 데이터셋 : 숫자 필기체 이미지 -> 숫자 예측(0~9)

• 타겟 변수 : y
 - 0 ~ 9 : 10진수 정수 
• 특징 변수(64픽셀) : X 
 - 0부터 9까지의 숫자를 손으로 쓴 이미지 데이터
 - 각 이미지는 0부터 15까지의 16개 명암을 가지는 8x8=64픽셀 해상도의 흑백 이미지

digits = load_digits() #dataset load

X = digits.data  #X변수 
y = digits.target #y변수 
print(X.shape) #(1797, 64) : 64=8x8
print(y.shape) #(1797,)

1. digits dataset split

x_train, x_test, y_train, y_test = train_test_split(
    X, y, test_size=0.3, random_state=123)

2. 전처리 : X변수 정규화, Y변수 one-hot encoding  

print(X.max()) #16.0
x_train_nor, x_test_nor = x_train / 16.0, x_test / 16.0

reshape

y_train = y_train.reshape([-1, 1])
y_test = y_test.reshape([-1, 1])

one-hot encoding

obj = OneHotEncoder()
y_train = obj.fit_transform(y_train).toarray()
y_train.shape #(1257, 10)

y_test = obj.fit_transform(y_test).toarray()
y_test.shape #(540, 10)

print(y_train.dtype) #float64

3. 공급 data : 

x_train = x_train_nor
x_test = x_test_nor
x_train.shape #(1257, 64)
x_test.shape #(540, 64)

4. w, b 변수 정의 

w = tf.Variable(tf.random.normal([64, 10], dtype=tf.float64)) #[입력수, 출력수]
b = tf.Variable(tf.random.normal([10], dtype=tf.float64)) #[출력수]
#type 일치

5. 회귀방정식 

def linear_model(X) : #train, test
    y_pred = tf.matmul(X, w) + b  #행렬곱 : [None,10]*[10,1]=[None,1]
    return y_pred

6. softmax 활성함수 적용 

def soft_fn(X):
    y_pred = linear_model(X)
    soft = tf.nn.softmax(y_pred)
    return soft

7. 손실 함수 정의 : 손실계산식 수정 

def loss_fn() : #인수 없음 
    soft = soft_fn(x_train) #훈련셋 -> 예측치 : 회귀방정식  
    loss = -tf.reduce_mean(y_train*tf.math.log(soft)+(1-y_train)*tf.math.log(1-soft))
    return loss

8. 최적화 객체 

optimizer = tf.optimizers.Adam(lr=0.01)

9. 반복학습 

loss_val = []
for step in range(2000) : 
    #오차제곱평균 최적화 : 손실값 최소화 -> [a, b] 갱신(update)
    optimizer.minimize(loss_fn, var_list=[w, b]) #(손실값, 수정 대상)
    
    #100배수 단위 출력 
    if (step+1) % 200 == 0 :
        print("step =", (step+1), ", loss =", loss_fn().numpy())
    loss_val.append(loss_fn().numpy())

    
10. 적적화된 model 검증 

soft_re = soft_fn(x_test).numpy()

y_pred = tf.argmax(soft_re, 1) #demension : 2d
y_true = tf.argmax(y_test, 1) #demension : 2d

acc = accuracy_score(y_true, y_pred)
print('accuracy =', acc) #accuracy = 0.98

step = 200 , loss = 0.06003735238669643
step = 400 , loss = 0.02922042555340125
step = 600 , loss = 0.01916724251850193
step = 800 , loss = 0.01418028865527556
step = 1000 , loss = 0.011102086315873883
step = 1200 , loss = 0.008942419709185086
step = 1400 , loss = 0.007311927138572721
step = 1600 , loss = 0.006023632246639046
step = 1800 , loss = 0.004981346240771604
step = 2000 , loss = 0.004163072611802871
========================================
accuracy = 0.9648148148148148


11. loss value vs epochs 시각화 

import matplotlib.pyplot as plt
plt.plot(loss_val, 'r--')
plt.show()