ch0nny_log

[빅데이터분석] 딥러닝_7. 미니배치/수치미분/사진인식(mnist) 본문

빅데이터 분석(with 아이티윌)/deep learning

[빅데이터분석] 딥러닝_7. 미니배치/수치미분/사진인식(mnist)

chonny 2024. 10. 10. 09:44

참고 노션: 4장. 2층 신경망 구현하기(수치미분을 이용해서 학습 시키기) (notion.site)

 

4장. 2층 신경망 구현하기(수치미분을 이용해서 학습 시키기) | Notion

신경망 학습의 원리를 이해시키기 위해서 필요한 단원

gabby-nurse-0c2.notion.site

 

import  numpy  as   np

x = np.array([ 3.0, 4.0 ])

def  loss_f(x):
    return  x[0]**2 + x[1]**2

▣ 미니배치   p115 ~ 116

신경망 학습 시킬때 반드시 알아야하는 용어 3가지 ?

  1. 미니 배치  :  훈련 데이터의 일부만 골라서 학습 하는 방법
  2. 에폭 : epoch 로 훈련 데이터 전체를 다 사용해서 학습 한것을 1에폭
  3. 수치 미분 :  신경망을 학습 시키기 위해 가중치를 갱신할 때 사용하는 방법

미니배치란 ?  표본을 뽑아서 학습 시킨다

배치(batch) 란 ?  신경망을 학습 시킬때 한번에 1장씩 학습시키는게 아니라
                       한번에 여러장씩 학습 시키는 것입니다. 
                       사람은 한번에 한장씩만 학습이 가능하지만 컴퓨터를 100장씩
                       200장씩 여러장을 한번에 학습 할 수 있습니다. 
                       6만장중에 100장을 뽑을 때 랜덤으로 추출해서 100장을 뽑아냅니다.

  6만장중에서 랜덤으로 100장을 추출합니다. (복원 추출)

  100개 x 600번 -------------->  1 에폭(epoch)

 

 

import   numpy   as  np 

box = np.arange( 1, 60001 )

print( np.random.choice( box, 10 )  )

  [ 9855 27134 28352 37451 28828 45886 24738  9550  2596 23316]

이 번호에 해당하는 데이터를 신경망에 입력하는것 입니다.​


2. 숫자 1 ~ 60000까지의 숫자들 중에서 무작위로 100개를 추출하시오 !

import   numpy   as  np 

box = np.arange( 1, 60001 )

print( np.random.choice( box, 100 )  )

이렇게 600번을 수행한게 1 에폭이 됩니다.​


3. 이런 미니배치 작업을 신경망에서 수행하는 텐써 플로우 코드는 무엇인가 ?

model.fit(  x_train, y_train,  epochs=30, batch_size = 100 )

예제

1. 숫자 1 ~ 60000까지의 숫자들 중에서 무작위로 10개를 추출하시오 !

 


▣   수치미분   p121 

 

 가중치를 갱신해주기 위해서 미분이 필요합니다.

 수학 스터디 때 퍼셉트론 할때 배웠던 그 가중치 입니다. 
 퍼셉트론에서는 손으로 가중치를 계산했었습니다. 

 신경망에 들어가는 데이터는 행렬로 들어가기 때문에 가중치 또한 행렬입니다. 
 행렬로 이루어진 가중치를 한번에 갱신하려면 미분이 필요합니다. 

  가중치 = 가중치 - 기울기 

https://cafe.daum.net/oracleoracle/SpOP/102 <--- 설명 그림

설명:  x 축이 가중치(w) 이고 y 축이 오차인 오차함수가 있습니다. 
        이 오차함수에서 오차가 가장 작은 가중치(w) 를 알아내려면 
        오차가 작은 지점으로 경사하강을 해야합니다. 
        경사하강을 하려면 랜덤으로 지정된 그 가중치 지점의 오차함수의 위치에서
        기울기를 알아야합니다.  그리고 가중치에서 기울기 만큼 차감해서 경사하강을
        해야합니다. ( 가중치 = 가중치 - 기울기 )

 

 

 

예제
1. 파이썬으로 미분을 구현하기 위해 먼저 이해야할 내용


설명:  위의 그림에 x 지점의 함수의 기울기를 구하려면 진정한 접선의 기울기를 구하면 됩니다.  그런데 수학으로는 진정한 접선의 기울기를 구할 수 있지만  컴퓨터로는 진정한 접선의 기울기를 구할 수는 없습니다. 왜냐하면 극한값을 컴퓨터 코드로 구현하기 어렵기 때문입니다. 극한이 0은 아닌데 0에 한없이 가까워지는 것을 말합니다. 
 그래서 근사로 구한 접선을 가지고 다음과 같이 식을 만들 수 있습니다.

2.  아래의 식을 파이썬 함수로 만드시오 !  
def  numerical_diff( f,  x ):
    h = 1e-50   #  0은 아닌데 0에 한없이 가까워지는 수를 표현
    return   (  f(x+h) - f(x-h) )  /  (2*h)​

3. 위의 미분함수를 이용해서 아래의 오차함수의  x 가 3인 지점의  기울기(미분계수) 를 구하시오 !
def  f(x):
    return  2*x**2 + 2 

def  numerical_diff( f,  x ):
    h = 1e-50   #  0은 아닌데 0에 한없이 가까워지는 수를 표현
    return   (  f(x+h) - f(x-h) )  /  (2*h)

print( numerical_diff(  f,  3 )  )   #  0.0​

 

설명: 12가 나와야하는데 0이 출력이 되었습니다. 왜냐하면 0.000000...01(0을 50개)  로 했더니 계산이 안되고 0이출력되었습니다. 너무 작은값이라 컴퓨터로 계산하는데 문제가 생긴것입니다.  그래서 미세한 h 로 0.0001 로 하면
좋은 결과를 얻을 수 있습니다. (p122)

4. 극한값을 표현할때 0.0001 로 해서 미분함수를 생성하고 x 가 3일 때 미분계수(기울기)를 구하시오 !
def  f(x):
    return  2*x**2 + 2 

def  numerical_diff( f,  x ):
    h = 0.0001
    return   (  f(x+h) - f(x-h) )  /  (2*h)

print( numerical_diff(  f,  3 )  )   # 1.2000000000025325e-07
                                          # 12.000000000000000025324​

설명: 12로 딱 떨어지지 않고 12에 근사한 값으로 출력되었습니다.왜 이렇게 나왔냐면 0에 가까워지는 극한값을 컴퓨터로 표현할 수 없어서 12로 딱 떨어지지 않고 12에 근사한 값으로 출력되것입니다.  이 미분함수를 이용해서 오차함수를 미분하는 신경망을 학습할때  전혀 상관없이 학습할 수 있습니다.

문제1.  아래의 오차함수가 어떻게 생겼는지 구글에서 확인하시오 !
 f(x) = 3*x^2 +  7​

 

문제2. 아래의 오차함수가 어떻게 생겼는지 구글에서 확인하시오 !
 f(x) = 3*x^3 + 2*x^2 + 5*x + 7​

 

문제3. 위의 함수를 파이썬으로 만드시오 !
def  f(x):
    return  3*x**3 + 2*x**2 + 5*x + 7​

문제4. 문제3번에서 만든 함수에 x 가 6인 지점의 기울기(미분계수) 를 구하시오 !

def  f(x):
    return  3*x**3 + 2*x**2 + 5*x + 7

def  numerical_diff( f,  x ):
    h = 0.0001
    return   (  f(x+h) - f(x-h) )  /  (2*h)

result = numerical_diff( f,  6 ) 
print( f"{ result: .10f}" )   # 353.00000002905562723754​


설명: 353 으로 딱 떨어지지 않는 이유는 진정한 접선이 아니라 근사로 구한 접선의
       미분이기 때문입니다.  

문제5. 아래의 함수를 파이썬으로 생성하고 x가 2인 지점에서의 미분계수(기울기)
         를 구하시오 !
def  f(x):
    return   6*x**4 + 3*x**2 + 7

def  numerical_diff( f,  x ):
    h = 0.0001
    return   (  f(x+h) - f(x-h) )  /  (2*h)

result = numerical_diff( f,  2 ) 
print( f"{ result: .10f}" )   # 204.0000004802​

정리:  미분을 왜 알아야하는가?  신경망 학습시 가중치를 갱신하기 위해서 입니다.

       가중치 = 가중치 - 기울기 (오차함수를 미분한 기울기)
                              
 위의 식이 기울기가 0에 가까워질 때 까지 반복 계산이 되면서 가중치가 만들어 집니다.
  
 그런데 이 기울기가 하나의 가중치에만 있는게 아니라 여러개의 가중치에 기울기를  알아내야해서 미분을 할 때 "편미분"을 알아야합니다. 

 


▣ 편미분   p125


  신경망이 학습되는 원리를 이해한다고 생각하면서 '편미분' 을 이해하면 됩니다.

  편미분의 '편' 이 무슨 뜻이냐면 편애하다 할 때의 '편' 입니다.
  한쪽 편으로 미분한다는 것입니다. 

 구글에서  z = x^2 + y^2  이라고 검색해보세요 ~


                                                              아래의 신경망도 가중치 행렬이 2개가 필요합니다. 그럼 2개의 기울기 행렬을 알아내야 합니다.  그래서 편미분이 필요합니다.  편미분을 하게 되면 w1 과 w2 에 대해서 각각 기울기를 구할 수 있게 됩니다. 


편미분이란 ?  변수가 2개이상인 함수를 미분할 때 미분 대상 변수외에 나머지 변수를
                  상수처럼 고정 시켜서 미분하는것을 편미분이라고 합니다. 

 f = x0**2 + x1**2

답:

def  loss_f(x):
    return  x[0]**2 + x[1]**2​


예제2.  f = x0**2 + x1**2 함수에서 좌표 (3,4) 지점의 기울기는 ? 

import  numpy  as   np

x = np.array([ 3.0, 4.0 ])

def  loss_f(x):
    return  x[0]**2 + x[1]**2​

예제3. f = x0**2 + x1**2 함수에서 좌표 (7,4) 지점의 기울기는 ? 

예제4.  위의 함수를 파이썬으로 생성하고 편미분하는 함수를 생성해서  예제3번의 기울기를 구하시오 !
def  numerical_gradient( f, x ):     # 오차함수와 가중치를 받을 입력 매개변수 2개를 생성
    h = 0.0001                        # 0에 가까워지는 극한값을 코드로 간단하게 구현
    grad = np.zeros_like(x)       # x 와 형상이 같은 배열을 생성하는데 원소는 다 0입니다.
                                          # 기울기를 담는 변수입니다.
   
    for i in range(x.size):        # x.size = x의 원소의 갯수
        tmp_val = x[i]            # x[i] 값을 tmp_val에 담습니다.
        x[i] = tmp_val + h       # tmp_val + h 가 x[i]으로 들어가서 x 변수중 i 번째 요소만 변경
        fxh1 = f(x)                 # x[i] 만 바뀐채로 f(x) 대입
       
        x[i] = tmp_val -h        # tmp_val + h 가 x[i]으로 들어가서 x 변수중 i 번째 요소만 변경
        fxh2 = f(x)                # x[i] 만 바뀐채로 f(x) 대입
       
        grad[i] = (fxh1 - fxh2) / (2*h)   # grad[i] 에 (fxh1 - fxh2) / (2*h)  를 담습니다.
        x[i] = tmp_val              # tmp_val 에 있었던 값을 다시 x[i]에 넣어서 처음으로 되돌린다.

    return grad           

x = np.array([ 7.0, 4.0 ])

def loss_func(x):
    return x[0]**2 + x[1]**2

print( numerical_gradient( loss_func, x ) )        #  [14.  8.]​

위의 편미분하는 파이썬 함수는 굳이 이해하지 않아도 되고 편미분이 왜 필요한지만 정확히
이해하고 있으면 됩니다. 




 


▣ 신경망에서의 기울기

 

신경망을 학습 시키려면 오차함수에서 경사하강을 해야하는데 경사 하강을 하려면 '기울기' 가 필요합니다.  이 기울기의 갯수는 가중치의 갯수 만큼 필요합니다. 

 그러면 일반적인 신경망에서 가중치의 갯수가 몇개나 될까요 ?

 28x28의 필기체 데이터 6만장을 학습 시키는 2층 신경망 : 배치 사이즈 100개

                                784                                         10                         10
                             입력층  --------------------------->  은닉층  ------------->출력층
                             (100,784)  ◎ ( 784, 10)  = ( 100, 10 )  ◎   ( 10 ,  10  )  = ( 100 ,  10 )     



 28x28의 필기체 데이터 6만장을 학습 시키는 3층 신경망 :  배치 사이즈 100개

   784개                           50개                     100개                          10개 
   입력층 ---------------->  은닉1층 -------------> 은닉2층 ----------------> 출력층 
 (100, 784 ) ◎ (784 ,50 ) = (100,50)  ◎ ( 50, 100)=(100,100)  ◎ ( 100, 10) = (100, 10)
                       w1                            w2                              w3
                        ↓                             ↓                              ↓
                   기울기 행렬                기울기 행렬                     기울기 행렬
              (784, 50)                     (50, 100)                       (100, 10)

 가중치 = 가중치 - 기울기 

 

 


▣    mnist 필기체 데이터를 텐썬 플로우로 2층 신경망 클래스 구현하기

         784                                10                      10
      입력층  ------------------>  은닉층  -------------> 출력층
       (100,784)  ◎ ( 784, 10)  = ( 100, 10 )  ◎   ( 10 ,  10  )  = ( 100 ,  10 )     

# 2층 신경망

#1. mnist 필기체 데이터 불러오기

from  tensorflow.keras.datasets.mnist   import   load_data
(x_train, y_train), ( x_test, y_test ) = load_data('mnist.npz')

print(x_train.shape)  # (60000, 28, 28)

# 차원 축소하기
x_train = x_train.reshape((x_train.shape[0], -1))
x_test =  x_test.reshape((x_test.shape[0], -1) )  # 차원 축소 코드
print(x_train.shape)  # (60000, 784)

# 설명: 필기체 사진을 신경망에 넣으려면 다음과 같이 차원을 축소해야합니다.

# ( 60000, 28, 28 )  --------->  차원 축소 코드 ---------> ( 60000, 784 ) 
# -1 이라고 쓰면 28x28 을 알아서 계산해서 784로 해주는것입니다.

#2. 신경망 구성에 필요한 모듈 불러오기
import  tensorflow  as   tf
import  numpy  as  np
from  tensorflow.keras.models  import  Sequential   # 신경망 모델 구성
from  tensorflow.keras.layers  import  Dense  # 완전 연결계층 
from  tensorflow.keras.optimizers  import   SGD  # 경사감소법 
from  tensorflow.keras.losses   import   mse    #  오차함수 

#3. 모델 생성하기
model = Sequential()

#4. 층 구성하기 (2층 신경망)
model.add( Dense(  10,  input_shape=( 784,  ),  activation='sigmoid')  )  # 은닉층
model.add( Dense( 10, activation='softmax')   )  # 출력층 

#5. 모델 학습 방법 지정하기
model.compile( optimizer=SGD(),  # 경사하강법
                    loss= 'sparse_categorical_crossentropy',          # 오차함수
                     metrics=['acc']  )  # 정확도를 높이는 방법으로 학습 시키겠다.

#6. 학습 시키기
model.fit( x_train, y_train, batch_size=100,  epochs=200 )

#7. 테스트 데이터 예측하기
test_loss, test_acc = model.evaluate( x_test, y_test )
print( test_acc )  # 0.8883000016212463

문제1. 위의 코드를 수정해서 다음과 같이 3층 신경망을 만드시오 !

   784개                           50개                     100개                          10개 
   입력층 ---------------->  은닉1층 -------------> 은닉2층 ----------------> 출력층 
 (100, 784 ) ◎ (784 ,50 ) = (100,50)  ◎ ( 50, 100)=(100,100)  ◎ ( 100, 10) = (100, 10)
                       w1                            w2                              w3
                        ↓                             ↓                              ↓
                   기울기 행렬                기울기 행렬                     기울기 행렬
              (784, 50)                     (50, 100)                       (100, 10)

# 3층 신경망

#1. mnist 필기체 데이터 불러오기

from  tensorflow.keras.datasets.mnist   import   load_data
(x_train, y_train), ( x_test, y_test ) = load_data('mnist.npz')

print(x_train.shape)  # (60000, 28, 28)

# 차원 축소하기
x_train = x_train.reshape((x_train.shape[0], -1))
x_test =  x_test.reshape((x_test.shape[0], -1) )  # 차원 축소 코드
print(x_train.shape)  # (60000, 784)

# 설명: 필기체 사진을 신경망에 넣으려면 다음과 같이 차원을 축소해야합니다.

# ( 60000, 28, 28 )  --------->  차원 축소 코드 ---------> ( 60000, 784 ) 
# -1 이라고 쓰면 28x28 을 알아서 계산해서 784로 해주는것입니다.

#2. 신경망 구성에 필요한 모듈 불러오기
import  tensorflow  as   tf
import  numpy  as  np
from  tensorflow.keras.models  import  Sequential   # 신경망 모델 구성
from  tensorflow.keras.layers  import  Dense  # 완전 연결계층 
from  tensorflow.keras.optimizers  import   SGD  # 경사감소법 
from  tensorflow.keras.losses   import   mse    #  오차함수 

#3. 모델 생성하기
model = Sequential()

#4. 층 구성하기 (3층 신경망)
model.add( Dense(  50,  input_shape=( 784,  ),  activation='sigmoid')  )  # 은닉1층
model.add( Dense(  100,  activation='sigmoid')  )  # 은닉2층
model.add( Dense( 10, activation='softmax')   )  # 출력층 

#5. 모델 학습 방법 지정하기
model.compile( optimizer=SGD(),  # 경사하강법
                    loss= 'sparse_categorical_crossentropy',          # 오차함수
                     metrics=['acc']  )  # 정확도를 높이는 방법으로 학습 시키겠다.

#6. 학습 시키기
model.fit( x_train, y_train, batch_size=100,  epochs=200 )

#7. 테스트 데이터 예측하기
test_loss, test_acc = model.evaluate( x_test, y_test )
print( test_acc )  # 0.9577000141143799

 


▣ 필기체 데이터 말고 다른 데이터로 신경망 학습 시키기 

컬러 사진으로 학습을 시켜야하는데 컬러 사진을 학습 시키려면 7장 cnn 을배워야합니다. 그래서 흑백 사진으로 학습 시키겠습니다.

 흑백 사진 데이터셋 2가지 ?

1. 필기체 mnist  데이터 
 2. 패션 mnist 데이터

* Fashion-MNIST 데이터셋 소개

https://cafe.daum.net/oracleoracle/SpOP/112

* 텐써플로우를 이용하여 패션 mnist 학습 시키기

https://cafe.daum.net/oracleoracle/SpOP/113

# 1. mnist 데이터를 불러옵니다.
import  tensorflow  as  tf
from tensorflow.keras.datasets.fashion_mnist import load_data

(x_train, y_train), (x_test, y_test) = load_data() 

# 2.1  28x28 의 shape 를 1 x 784 로 변경합니다.

x_train = x_train.reshape(60000,28*28)
x_test  = x_test.reshape(10000, 28*28)

# 최대 최소 정규화 진행(학습 잘되게 하려고)

x_train = x_train/255.0
x_test = x_test/255.0

# 2.2 정답 데이터를 준비합니다. (p98 원핫인코딩을 해야합니다.)
 
# 3 ------>  [ 0, 0, 0, 1, 0, 0, 0, 0, 0, 0 ] 
# 신경망 학습할때 정답을 위와 같이 제공해줘야합니다.

from  tensorflow.keras.utils import  to_categorical

y_train = to_categorical(y_train)
y_test = to_categorical(y_test)
print ( y_train.shape)  # (60000, 10)

# 3. 모델을 구성합니다.

from  tensorflow.keras.models  import  Sequential
from  tensorflow.keras.layers    import  Dense

model = Sequential()
model.add(Dense(128, activation='relu', input_shape=(784, ) ) ) # 은닉1층
model.add(Dense(128, activation='relu' ) ) # 은닉2층
model.add(Dense( 10, activation='softmax') )  # 출력층

# 4. 모델을 설정합니다. (경사하강법과 오차함수를 정의해줍니다. 4장에서 배웁니다)

model.compile(optimizer='adam',  # 경사하강법 
                     loss='categorical_crossentropy',  #오차함수
                     metrics=['acc'] )  # 학습과정에서 정확도를 보려고 지정

# 5. 모델을 훈련 시킵니다.

model.fit( x_train, y_train, epochs=30, batch_size=100)

# model.fit( 훈련데이터, 정답, 에폭수, 배치사이즈) 
# 에폭수 :  학습횟수 (책을 몇번 볼건지)
# 배치사이즈:  한번에 학습할 양 ( 사람은 책을 한번에 한페이지 밖에 못보지만 컴퓨터는 한번에
# 여러 페이지를 볼 수 있다)


# 6. 모델을 평가합니다. (시험을 봅니다.)

model.eval‎uate(x_test, y_test) 

#7. 모델 저장 
model.save('c:\\data\\fashion_model.h5')


 10개중에 1개는 잘못 맞추는 모델입니다. 

 

 

2. 만들어진 모델이 잘 불러와지는지 확인합니다.

# 모델 불러오는 코드

# 1. 모델을 불러옵니다.

from tensorflow.keras.models import load_model

new_model = load_model('c:\\data\\fashion_model.h5')

# 2.모델을 평가합니다. (오차, 정확도가 출력됩니다.)

new_model.eval‎uate(x_test, y_test)

#3. dress.jpg 를 c 드라이브 밑에 data 폴더 밑에 가져다 둡니다. 

6. 텐써 플로우를 이용하여 dress.jpg 를 흑백처리하고 28x28 로 resize 합니다.

import tensorflow as  tf
import cv2                         # 이미지를 전문으로 전처리하는 모듈

img_path = 'c:\\data\\dress.jpg'

img = cv2.imread(img_path)   #  이미지를 읽어서 숫자로 변환
img = cv2.bitwise_not(img)     #  색 반전시키는 코드, 흰색을 검정색으로
print(img.shape)  # (683, 427, 3) 

import tensorflow.compat.v1 as tf   # 텐써 플로우 1.x 버젼에서 사용하던 API 호환모드
tf.disable_v2_behavior()                # 텐써 플로우 2.X 기능을 비활성화 하겠다.

resized_images=tf.image.resize_images(img, (28, 28))  #  28X28 로 리사이즈
a = tf.image.rgb_to_grayscale(resized_images)  # 흑백처리 
print(a.shape)  # ( 28, 28, 1 )

7. 전처리한 데이터를 신경망에 넣고 예측합니다.


[쉬움주의] 텐써플로우를 이용하여 패션 mnist 학습 시키기

1. 패션 mnist 데이터를 학습 시켜 모델을 준비합니다.

# 1. mnist 데이터를 불러옵니다.
import  tensorflow  as  tf
from tensorflow.keras.datasets.fashion_mnist import load_data

(x_train, y_train), (x_test, y_test) = load_data() 

# 2.1  28x28 의 shape 를 1 x 784 로 변경합니다.

x_train = x_train.reshape(60000,28*28)
x_test  = x_test.reshape(10000, 28*28)

x_train = x_train/255.0
x_test = x_test/255.0

# 2.2 정답 데이터를 준비합니다. (p98 원핫인코딩을 해야합니다.)
 
from  tensorflow.keras.utils import  to_categorical

y_train = to_categorical(y_train)
y_test = to_categorical(y_test)
print ( y_train.shape)  # (60000, 10)

# 3. 모델을 구성합니다.

#그림: https://cafe.daum.net/oracleoracle/Shyl/183

from  tensorflow.keras.models  import  Sequential
from  tensorflow.keras.layers    import  Dense

model = Sequential()
model.add(Dense(128, activation='relu', input_shape=(784, ) ) ) # 은닉1층
model.add(Dense(128, activation='relu' ) ) # 은닉1층
model.add(Dense( 10, activation='softmax') ) 

# 4. 모델을 설정합니다. (경사하강법과 오차함수를 정의해줍니다. 4장에서 배웁니다)

model.compile(optimizer='adam',  # 경사하강법 
                     loss='categorical_crossentropy',  #오차함수
                     metrics=['acc'] )  # 학습과정에서 정확도를 보려고 지정

# 5. 모델을 훈련 시킵니다.

model.fit( x_train, y_train, epochs=30, batch_size=100)

#model.fit( 훈련데이터, 정답, 에폭수, 배치사이즈) 
# 에폭수 :  학습횟수 (책을 몇번 볼건지)
# 배치사이즈:  한번에 학습할 양 ( 사람은 책을 한번에 한페이지 밖에 못보지만 컴퓨터는 한번에
#                  여러 페이지를 볼 수 있다)


# 6. 모델을 평가합니다. (시험을 봅니다.)

model.eval‎uate(x_test, y_test) 

model.save('fashion_model.h5')

2. 만들어진 모델이 잘 불러와지는지 확인합니다.

# 모델 불러오는 코드

# 1. 모델을 불러옵니다.

from tensorflow.keras.models import load_model

new_model = load_model('fashion_model.h5')

# 2.모델을 평가합니다. (오차, 정확도가 출력됩니다.)

new_model.eval‎uate(x_test, y_test)
3. 테스트할 이미지를 올리기 위해 코렙과 구글 드라이브를 연동합니다.

from google.colab import drive
drive.mount('/content/drive')
4. /content/drive/MyDrive/ 밑에 yys19 폴더를 만듭니다.

 

5. /content/drive/MyDrive/yys19 밑에 아래의 dress.jpb 이미지를 올립니다.

dress.jpg
55.42KB
 

6. 텐써 플로우를 이용하여 dress.jpg 를 흑백처리하고 28x28 로 resize 합니다.

import tensorflow as  tf
import cv2

img_path = 'dress.jpg'

img = cv2.imread(img_path)
img = cv2.bitwise_not(img)
print(img.shape)

import tensorflow.compat.v1 as tf
tf.disable_v2_behavior()

resized_images=tf.image.resize_images(img, (28, 28))
a = tf.image.rgb_to_grayscale(resized_images)
print(a.shape)
 

7. 전처리한 데이터를 신경망에 넣고 예측합니다.

import numpy as np

x =tf.reshape(a, [ 28,28])     # 텐써 플로우 배열로 a 이미지를 변환
x2 =tf.reshape(x, [1, 784])    # 신경망에 넣기 좋도록 1x784로 변환
print(x2.shape)

from tensorflow.keras.models import load_model

new_model = load_model('c:\\data\\fashion_model.h5')

results = new_model.predict(x2,steps=1)
np.argmax(results)