DAY64. Tensorflow Classification (Sigmoid, Softmax)

index 반환 함수

argmin : 축 별 최소 값의 index 반환

argmax : 축 별 최대 값의 index 반환

unique : 중복 제거 결과 index 반환

 

 

kNN classifier

kNN 분류기 특징

- 알려지지 않은 범주를 대상으로 가장 유사한 범주로 분류

- 기존 범주가 존재해야 함

- 식료품(과일, 채소, 단백질 등)

- 학습하지 않음 : 게으른 학습

 

kNN classifier 알고리즘

* X : 기존 분류집단 Y : 새로운 분류대상

1. tensorflow Euclidean 거래 계산식

distance = tf.sqrt( tf.reduce_sum( tf.square(X-Y) ), axis=1))

 

2.오차가 최소인 index 반환 (Euclidean 거리계산식)

pred = tf.arg_min(distance, 0)

 

 

Model & Activation function

회귀분석(비율척도) : Identity function

분류분석(이항분류) : Sigmoid function

분류분석(다항분류) : Softmax function

 

Identity function : 항등함수[연산 결과를 출력으로 활성화]

Sigmoid function : 0~1 사이 확률값(Sigmoid 계열 : tanh, ReLU 등)

Softmax function : 0~1 사이 확률값, 전체합=1

 

 

 

Tensorflow 주요 Model

*w → weight / b → bias

 

1. linear regression 알고리즘 : 수치 예측

model = tf.matmul(X, w) + b #y 예측치

 

2. sigmoid classification 알고리즘 : 이항 분류

model = tf.sigmoid(tf.matmul(X, w) + b) #y 예측치

 

3. softmax classification 알고리즘 : 다항분류

model = tf.nn.softmax(tf.matmul(X, w) + b) #y 예측치

 

 

Linear Regression 알고리즘 : 수치 예측

Y = tf.placeholder(tf.float32) #y 실제값

 

1. 회귀방정식 : 기계학습 model y_pred = (X * w) + b #y 예측치

2. 손실(비용)함수 : MSE Loss = tf.reduce_mean(tf.square(Y – y_pred)) #손실값 반환

3. 경사하강법 : 비용함수 최소화 -> w(가중치), b(편향) 수정 optimizer = tf.optimizers.Adam(lr=0.01)

 

 

Sigmoid classification 알고리즘 : 이항 분류

Y = tf.placeholder(tf.float32) #y 실제값

 

1. 회귀방정식+ sigmoid 함수

y_pred = tf.matmul(X, w) + b #회귀방정식

sig = tf.nn.sigmoid(y_pred) #y 예측치

 

2. 손실(비용)함수 : Cross Entropy

loss = -tf.reduce_mean(Y*tf.math.log(sig)+(1-Y)*tf.math.log(1-sig))

 

3. 경사하강법 알고리즘 : 비용함수 최소화

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

 

 

Softmax classification 알고리즘 : 다항분류

Y = tf.placeholder('float', [None, 10]) # y 실제값

 

1. model = 회귀방정식+ softmax 함수

model = tf.matmul(X, w) + b #회귀방정식

soft = tf.nn.softmax(model) #y 예측치

 

2. 손실(비용)함수 : Cross Entropy

loss = -tf.reduce_mean(Y*tf.math.log(soft)+(1-Y)*tf.math.log(1- soft))

 

3. 경사하강법 알고리즘 : 비용함수 최소화

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

 

 

Cross Entropy

Entropy	Cross Entropy
물리학 용어	통계학 용어
확률 변수 간의 불확실성을 나타내는 수치	두 확률변수 x, y에서 x를 관찰한 후 y에 대한 불확실성을 줄인다.
이 값이 클 수록 일정한 방향성과 규칙성이 없는 무질서 (chaos)	딥러닝 분류기에서 loss 계산식 이용 (정답과 예측치 오차 계산)
식 = -sum(p * log(p))	식 = -tf.reduce_mean(Y * log(y_pred) + (1-Y) * log(1-y_pred))

 

 

Sigmoid classification

이항분류

logistic 회귀분석의 특징

목적 : 독립 변수가 [-∞,∞]의 어느 숫자이든 상관 없이 종속 변수 값이 항상 범위 [0,1] 사이에 있도록 한다.

선형 회귀분석과 차이점 : 종속변수 범주형(binary) -> [0, 1] encoding

ANN, 딥 러닝의 중요 컴포넌트

 

활용분야

1. 메시지 분류 → Spam(1)/ham(0)

2. 이미지를 보고 종양(tumor) 진단 → 악성(1)/양성(0)

3. 이전의 시장 동향으로 학습 → 주식 매매(1)/비매매(0)

 

Sigmoid(Logistic) 활성함수 예

 

Sigmoid classification 알고리즘

Y = tf.placeholder(tf.float32) #y 실제값

 

(1) model : 회귀방정식

model = tf.matmul(X, w) + b #-inf ~ + inf # sigmoid(model)

sig = tf.nn.sigmoid(model) # 0~1 확률값

 

(2) loss function : Entropy 이용 = -sum(Y * log(model))

loss = -tf.reduce_mean(Y * tf.log(sig) + (1 - Y) * tf.log(1 - sig))

 

(3) 경사하강법 알고리즘 : 비용함수 최소화

optimizer = tf.optimizers.Adam (0.1)

 

 

Softmax Classification

다항 분류(multi-classification)

주어진 데이터 집합을 이미 정의된 몇 개의 클래스로 구분하는 문제

입력 데이터와 각 데이터의 클래스 라벨이 함께 제공 -> {xi, y(xi)}

y변수의 label에 따라서 활성함수 적용(이항분류, 다항분류)

 

Softmax 활성함수 예

Y1 : 0.09003057  (9%)

Y2 : 0.24472847 (24%)

Y3: 0.66524096 (67% -> 가능성이 가장 높다)

 

다항분류 예

털과 날개가 있는지 없는지에 따라, 포유류, 조류, 기타로 분류하는 신경망 모델

import tensorflow as tf
import numpy as np

#[털, 날개]
x_data = np.array(
[[0, 0], [1, 0], [1, 1], [0, 0], [0, 1], [1, 1]])

#[기타, 포유류, 조류]
y_data = np.array([
[1, 0, 0], # 기타
[0, 1, 0], # 포유류
[0, 0, 1], # 조류
[1, 0, 0],
[1, 0, 0],
[0, 0, 1] ])

* one hot encoding : 전체 벡터 데이터 중 하나만 1이고, 나머지는 0인 인코딩 방식 ≒ dummy는 n-1개로 변수 사이즈가 설정

 

softmax classification 알고리즘

Y = tf.placeholder('float', [None, 10]) # y 실제값

(1) 회귀방정식 : 예측치
model = tf.matmul(X, w) + b # 회귀모델

softmax(예측치)
soft = tf.nn.softmax(model) # 0~1 확률값(전체 합=1)

(2) loss function : Entropy 이용 : -sum(Y * log(model)) 
loss = -tf.reduce_mean(Y * tf.log(soft) + (1 - Y) * tf.log(1 - soft))

(3) 경사하강법 알고리즘 : 비용함수 최소화
optimizer = tf.optimizers.Adam (0.1)

 

 

Tensorflow 다항분류 model

x_data = np.array( [[0, 0], [1, 0], [1, 1], [0, 0], [0, 1], [1, 1]])
y_data = np.array([ [1, 0, 0], [0, 1, 0], [0, 0, 1], [1, 0, 0], [1, 0, 0], [0, 0, 1]])

X = tf.placeholder(tf.float32, [None, 2])
Y = tf.placeholder(tf.float32, [None, 3])

w = tf.Variable(tf.random_normal([2, 3])) # (2, 3)
b = tf.Variable(tf.zeros([3])) # (3)


model = tf.matmul(X, w) + b
# (None, 3)
[[ 0.74250543 -1.18412077 -0.74753278]
[ 0.10888183 -0.62678969 -0.88903713]
[ 0.486274 -1.19238925 -1.20663118]
...

softmax = tf.nn.softmax(model)
# (None, 3)
[[ 0.72939312 0.10622789 0.164379 ]
[ 0.54117554 0.25932243 0.19950208]
[ 0.72960341 0.13616098 0.13423553]
...

* 행의 합 = 1

 

 

 

 

 

index 리턴 

1. argmin/argmax
- 최소/최대 값의 index 반환 
tf.arg_min -> tf.arg_min

2. unique
- 중복제거 

import tensorflow as tf #ver2.3

1. argmin/argmax

a = tf.constant([5,2,1,4,3], dtype=tf.int32)
b = tf.constant([4,5,1,3,2])
c = tf.constant([[5,4,2], [3,2,4]]) #2차원 
print(c)
'''
[[5 4 2]
 [3 2 4]]
'''

dimension : reduce 차원(vector = 0) 

min_index = tf.argmin(a, 0) #1차원 대상 
max_index = tf.argmax(b, 0) #1차원 대상 
print(tf.argsort(a, 0)) #[2 1 4 3 0]

max_index2 = tf.argmax(c, 1) #2차원 대상
min_index2 = tf.argmin(c, 1) #2차원 대상

print(min_index.numpy()) #2
print(max_index.numpy()) #1
print(max_index2.numpy()) #[0 2] - [1행, 2행]
print(min_index2.numpy()) #[2 1] - [1행, 2행]

 

2. unique

c = tf.constant(['a','b','a','c','b', 'c'])

cstr, cidx = tf.unique(c)
print(cstr.numpy()) #['a' 'b' 'c']
print(cidx.numpy()) #[0 1 0 2 1 2]

 

 

 

 

 

KNN(K-Nearest Neighbor) 알고리즘

- 학습과정 없음 
- Euclidean 거리계산식

import numpy as np
import tensorflow as tf

x : 분류집단 

p1 = [1.2, 1.1] 
p2 = [1.0, 1.0]
p3 = [1.8, 0.8]
p4 = [2, 0.9]

x_data = np.array([p1, p2, p3, p4]) #알려진 범주 
label = ['A','A','B','B'] #분류범주(Y변수)
y_data = [1.6, 0.85] #y : 분류대상

x,y 변수 선언 : tensor 생성 

X = tf.constant(x_data, tf.float32) #알려진 집단 
Y = tf.constant(y_data, tf.float32) #알려지지 않은 집단(분류대상)

Euclidean 거리계산식 

distance = tf.math.sqrt(tf.math.reduce_sum(tf.math.square(X-Y),axis=1))
'''
브로드캐스팅 연산 : sqrt( sum( (x-y)^2 ) )
distance : 거리계산 결과 4개 원소를 갖는 vector 
'''
print(distance) #[0.47169903 0.61846584 0.20615523 0.40311286]

가장 가까운 거리 index 반환 

idx = tf.argmin(distance, 0) #input, dimension

print('분류 index :', idx.numpy())   
print('분류결과  : ', label[idx]) #분류결과  :  B

 

 

 

 

 

CrossEntropy

- 두 확률변수 x, y에서 x를 관찰한 후 y에 대한 불확실성 측정
- 딥러닝 분류기 : 정답(Y) VS 예측치(y_pred)
-> 정답(Y)를 관찰한 후 예측치의 손실(loss) 계산
* Cross의미 : Y = 1, Y = 0일 때 서로 교차하여 손실(loss) 계산 
- loss : -(Y * log*(y_pred) + (1-Y) * log(1-y_pred))

왼쪽 식 : Y * log*(y_pred) -> Y = 1일 때 손실값
오른쪽 식 : (1-Y) * log(1-y_pred)) -> Y = 0일 때 손실값

import tensorflow as tf

model_pred = [0.02, 0.98] #model 예측치

Y = 1 #정답
for y_pred in model_pred :
    loss_val = -(Y * tf.math.log(y_pred)) #-넣음으로써 +로 출력되게끔 (log함수 트성)
    print(loss_val.numpy())
'''
3.912023    -> 1 vs 0.02 : 손실값 커짐
0.020202687 -> 1 vs 0.98 : 손실값 작음
'''

Y = 0 #정답
for y_pred in model_pred :
    loss_val = -((1-Y) * tf.math.log(1-y_pred)) #-넣음으로써 +로 출력되게끔 (log함수 트성)
    print(loss_val.numpy())
'''
0.020202687 -> 0 vs 0.02  : 손실값 작음
3.912023    -> 0 vs 0.98 : 손실값 커짐
'''

 

Cross Entropy(Y=1 and Y=0)에 의한 손실 계산 수

Y = 1 #정답 (Y=1 and Y=0)
for y_pred in model_pred :
    loss_val = -tf.reduce_mean(Y * tf.math.log(y_pred) +(1-Y) * tf.math.log(1-y_pred))
    print(loss_val.numpy())
'''
Y = 0일 때
0.020202687
3.912023

Y = 1일 때
3.912023
0.020202687
'''

 

 

 

 

 

 

sigmoid classifier

- 이항분류기

활성함수 : Sigmoid함수 - 이항분류
손실함수 : Cross Entropy 함수 - 손실값 반환

import tensorflow as tf
from sklearn.metrics import accuracy_score #평가도구

1. x, y 공급 data 

#x변수 : [hours, video]
x_data = [[1, 2], [2, 3], [3, 1], [4, 3], [5, 3], [6, 2]] #[6,2]

#y변수 : binary data (fail or pass)
y_data = [[0], [0], [0], [1], [1], [1]] #이항분류

2. X, y변수 정의 : type일치 - float32

X = tf.constant(value=x_data, dtype=tf.float32) #[관측치, 입력수]
y = tf.constant(value=y_data, dtype=tf.float32) #[관측치, 출력수]

3. w, b변수 정의 : 초기값(난수) -> update대상

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

4. sigmoid(회귀모델) 함수 : y 예측치 반환 

def sig_fun(X) : 
    model = tf.linalg.matmul(X, w) + b  #회귀방정식
    y_pred = tf.nn.sigmoid(model)  #sigmoid(model)
    return y_pred #0~1 확률값

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

def loss_fn() : # 인수 없음 
    y_pred = sig_fun(X) # y 예측치    
    #Cross Entropy 
    loss = -tf.reduce_mean(y*tf.math.log(y_pred) + (1-y)*tf.math.log(1-y_pred))    
    return loss

6. 최적화 객체 생성 

opt = tf.optimizers.Adam(learning_rate=0.5) #학습률

7. 반복학습   

for step in range(100) : 
    opt.minimize(loss=loss_fn, var_list=[w, b])
    
    #10배수 단위 출력 
    if (step+1) % 10 == 0 :
        print('step =', (step+1), ', loss value=',loss_fn().numpy())

        
8. 최적화된 model 검증 

y_pred = sig_fun(X) 
print(y_pred.numpy()) #확률값 예측치

cut-off=0.5 : T/F -> 1.0/0.0

y_pred = tf.cast(sig_fun(X).numpy() > 0.5, dtype=tf.float32)
y_pred #class 예측치

  
model 평가 

acc = accuracy_score(y, y_pred)
print('accuracy =',acc) #accuracy = 1.0

 

 

 

 

 

sigmoid classifier iris

dataset : iris 
활성함수 : Sigmoid함수 - 이항분류 
손실함수 : Cross Entropy함수 -> 손실값 

import tensorflow as tf 
from sklearn.metrics import accuracy_score, confusion_matrix #model 평가 
from sklearn.datasets import load_iris #datase 
from sklearn.preprocessing import minmax_scale #X변수 정규화

1. [수정] x, y 공급 data 

X, y = load_iris(return_X_y=True)

x변수 : 100개 관측치 

x_data = X[:100]
x_data.shape #(100, 4)

x변수 정규화(0~1)

x_data = minmax_scale(x_data)

y변수 : 100개 관측치 

y_data = y[:100]

y변수 : 1d -> 2d

y_data = y_data.reshape(100, 1) 
y_data.shape #(100, 1)

2.  X, y변수 정의 : type 일치 - float32

X = tf.constant(value=x_data, dtype=tf.float32) #[관측치,입력수]
y = tf.constant(value=y_data, dtype=tf.float32) #[관측치,출력수]

3. w, b변수 정의 : 초기값(난수) -> update

w = tf.Variable(tf.random.normal(shape=[4, 1])) #[수정] : [입력수,출력수]
b = tf.Variable(tf.random.normal(shape=[1])) #[출력수]

4. sigmoid(회귀모델) 함수 : y 예측치 반환 

def sig_fun(X) : 
    model = tf.linalg.matmul(X, w) + b  #회귀방정식
    y_pred = tf.nn.sigmoid(model)  #sigmoid(model)
    return y_pred #0~1 확률값

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

def loss_fn() : # 인수 없음 
    y_pred = sig_fun(X) #y 예측치    
    # Cross Entropy 
    loss = -tf.reduce_mean(y*tf.math.log(y_pred) + (1-y)*tf.math.log(1-y_pred))    
    return loss

 

6. 최적화 객체 생성 

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

 

7. 반복학습   

for step in range(500) : 
    opt.minimize(loss=loss_fn, var_list=[w, b])
    
    #10배수 단위 출력 
    if (step+1) % 10 == 0 :
        print('step =', (step+1), ', loss value=',loss_fn().numpy())

        

8. 최적화된 model 검증 

y_pred = sig_fun(X) 
print(y_pred.numpy()) #확률값 예측치

cut-off=0.5 : T/F -> 1.0/0.0

y_pred = tf.cast(sig_fun(X).numpy() > 0.5, dtype=tf.float32)
y_pred #class 예측치

model 평가 

acc = accuracy_score(y, y_pred)
print('accuracy =',acc) #accuracy = 1.0

혼동행렬

con = confusion_matrix(y, y_pred)
print(con)

 

 

 

 

 

softmax classifier

- 다항분류기
활성함수 : softmax함수
손실함수 : cross entropy함수
y_data : one hot encodig

import tensorflow as tf
from sklearn.metrics import accuracy_score #model평가
import numpy as np

1. x, y 공급 data 
[털, 날개]

x_data = np.array(
    [[0, 0], [1, 0], [1, 1], [0, 0], [0, 1], [1, 1]]) #[6, 2] -> 관측치 6개, 입력변수 2개

 

[기타, 포유류, 조류] : [6, 3] 

y_data = np.array([ #one hot encoding
    [1, 0, 0],  #기타[0] -> 털과 날개가 모두 없음
    [0, 1, 0],  #포유류[1] -> 털은 있는데 날개가 없음
    [0, 0, 1],  #조류[2] -> 털과 날개가 모두 존재
    [1, 0, 0],
    [1, 0, 0],
    [0, 0, 1]
]) #y개수가 3개

* one hot encoding VS dummy
공통점 : encoding(2진수로 변환)
차이점 : one-hot은 변수size = class수, dummy는 변수size = class-1

x_data.shape #(6, 2) - (관측치, 입력수)
y_data.shape #(6, 3) - (관측치, 출력수)

2. X, y변수 정의 : type float32로 일치시키기

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

3. w, b변수 정의 : 초기값(난수) -> update

w = tf.Variable(tf.random.normal([2, 3])) #[입력수, 출력수] -> 총 6개의 w가 생성됨
b = tf.Variable(tf.random.normal([3])) #[출력수]

4. softmax(회귀모델) 함수 : y 예측치 반환 

def soft_fn(X) : 
    model = tf.linalg.matmul(X, w) + b  #회귀방정식
    y_pred = tf.nn.softmax(model)  #softmax(model)
    return y_pred #0~1 확률값

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

def loss_fn() : # 인수 없음 
    y_pred = soft_fn(X) #y 예측치    
    # Cross Entropy 
    loss = -tf.reduce_mean(y*tf.math.log(y_pred) + (1-y)*tf.math.log(1-y_pred))    
    return loss

 

6. 최적화 객체 생성 

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

7. 반복학습   

for step in range(100) : 
    opt.minimize(loss=loss_fn, var_list=[w, b])
    
    #10배수 단위 출력 
    if (step+1) % 10 == 0 :
        print('step =', (step+1), ', loss value=',loss_fn().numpy())

step = 10 , loss value= 0.2945415
step = 100 , loss value= 0.014622948   
      

        
8. 최적화된 model 검증

y_pred = soft_fn(X).numpy()
print(y_pred)

[[9.88110900e-01 9.25376546e-03 2.63541052e-03] -> 1번 관측치 예측치 (97%, 0.15%, 0.4%)
 [3.77652748e-03 9.63190913e-01 3.30325998e-02]
 [1.07707642e-02 1.05104195e-02 9.78718817e-01]
 [9.88110900e-01 9.25376546e-03 2.63541052e-03]
 [9.73005116e-01 3.48643771e-05 2.69599613e-02]
 [1.07707642e-02 1.05104195e-02 9.78718817e-01]] -> 6번 관측치 예측치

print(y_pred.shape) #(6, 3)
y_pred.sum(axis=1) #행 단위 합계. 'axis=0' : 열 단위
#[1., 1., 1., 1., 1., 1.]

y : one-hot-encoding(2진수) vs y_pred : prob
* y, y_pred -> 10진수로 변환 (=class 변환)

y_pred = tf.argmax(y_pred, axis=1) #가장 높은 확률을 색인으로 반환
y_true = tf.argmax(y, axis=1)

acc = accuracy_score(y_true, y_pred)
print('accuracy = ', acc) #accuracy =  1.0 -> 100% 일치

print(y_pred) #[0 1 2 0 0 2]
print(y_true) #[0 1 2 0 0 2]

 

 

 

 

 

softmax classifier iris

- 다항분류기
dataset : iris
활성함수 : softmax함수
손실함수 : cross entropy함수
y_data : one hot encodig

import tensorflow as tf
from sklearn.datasets import load_iris #datset load
from sklearn.preprocessing import minmax_scale #x변수 정규화
from sklearn.preprocessing import OneHotEncoder #y변수 2진수 인코딩
from sklearn.metrics import accuracy_score #model평가

1. x, y 공급 data

X, y = load_iris(return_X_y=True)
y #0~2의 3가지 클래스(꽃의 종)로 이루어져 있음

x_data = X
y_data = y

x_data.shape #(150, 4) - (관측치, 입력수)
y_data.shape #(150,) - (관측치, 출력수)

변수 전처리

x_data = minmax_scale(x_data) #x변수 정규화

1d, 10진수 -> 2d, 2진수

obj = OneHotEncoder()
y_data = obj.fit_transform(y_data.reshape(150, 1)).toarray() #인코딩, 2차원으로 변경, array로 변경
print(y_data)

[[1. 0. 0.]
 [1. 0. 0.]
 [1. 0. 0.]...
-> class별로 1(=꽃의 종)의 값이 다르게 나타나는 것을 볼 수 있음

 

2. X, y변수 정의 : type float32로 일치시키기

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

3. w, b변수 정의 : 초기값(난수) -> update

x_data.shape #(150, 4) : 입력수 4개
y_data.shape #(150, 3) : 출력수 3개

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

4. softmax(회귀모델) 함수 : y 예측치 반환 

def soft_fn(X) : 
    model = tf.linalg.matmul(X, w) + b  #회귀방정식
    y_pred = tf.nn.softmax(model)  #softmax(model)
    return y_pred #0~1 확률값

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

def loss_fn() : # 인수 없음 
    y_pred = soft_fn(X) #y 예측치    
    # Cross Entropy 
    loss = -tf.reduce_mean(y*tf.math.log(y_pred) + (1-y)*tf.math.log(1-y_pred))    
    return loss

6. 최적화 객체 생성 

opt = tf.optimizers.Adam(learning_rate=0.1) #learning_rate : 학습률

 

7. 반복학습   

for step in range(100) : 
    opt.minimize(loss=loss_fn, var_list=[w, b])
    
    #10배수 단위 출력 
    if (step+1) % 10 == 0 :
        print('step =', (step+1), ', loss value=',loss_fn().numpy())

step = 10 , loss value= 0.2945415
step = 100 , loss value= 0.014622948   
          
         

8. 최적화된 model 검증

y_pred = soft_fn(X).numpy()

print(y_pred) : 예측한 확률값

y : one-hot-encoding(2진수) vs y_pred : prob
* y, y_pred -> 10진수로 변환 (=class 변환)

y_pred = tf.argmax(y_pred, axis=1) #가장 높은 확률을 색인으로 반환
y_true = tf.argmax(y, axis=1)

acc = accuracy_score(y_true, y_pred)
print('accuracy = ', acc) #accuracy =  0.96 -> data의 복잡도가 높아지면서 예측도가 떨어졌지만, 상당히 높은 수준의 예측률

print(y_pred) 
print(y_true)