🤍

러닝스푼 수업 정리 

< 이전 글 > 

https://silvercoding.tistory.com/48

 1. pandas 불러오기 

import pandas as pd

 2. 데이터 불러오기 & 살펴보기 

fpath = './data/exam.xlsx' 
data = pd.read_excel(fpath, index_col = '번호')

index_col='번호' 로 지정하여 엑셀 파일 불러오기 

* head(), info(), describe() 를 사용하여 데이터 살펴보는 습관 갖기 

data.head()

data.info()

data.describe()

 3. 데이터 추가하기 

df[ '컬럼명' ] =  data ( df.컬럼명 = data 형태는 사용 불가능 )  

- 하나의 값 추가 : 전체 모두 동일한 값으로 추가됨 

- 그룹 추가 : 리스트, 판다스의 시리즈로 추가 

data['수학']

data.수학

데이터를 선택할 땐 위와 같은 두가지 방법으로 작성해주었다. 

- 한개 값 추가 

data['음악'] = 90             
data.head()

데이터를 추가할 땐 data.음악 의 형태로는 불가능 하다. 한개의 값을 추가하면 모든 row에 같은 값이 들어가게 된다. 

- 여러 값 추가 

data['체육'] =  [100, 80, 60]
data.head()

리스트로 여러 값을 추가해 줄 수도 있다. 이 때 주의할 점은 리스트 원소 개수와 row개수가 같아야 한다. 

data['국영수'] =  (data['국어'] + data['영어'] + data['수학'] ) / 3
data.head()

이렇게 컬럼 간의 연산을 통하여 새로운 컬럼을 만들어 줄 수도 있다. 

 4. 데이터 표 병합하기 

fpath = './data/exam.xlsx'
A = pd.read_excel(fpath, index_col = '번호')
A.head()

파일을 다시 불러와서 A 변수에 저장해 준다. 

fpath2 = './data/exam_extra.xlsx'
B = pd.read_excel(fpath2, index_col = '번호')
B.head()

추가 할 엑셀파일을 불러와 B 변수에 저장해 준다.

- merge()

병합 기준을 인자에 넣어 설정해줄 수 있다. 이 때, left_on 과 left_index 중 1개, right_on 과 right_index 중 1개를 써야 하고, 두가지를 한번에 사용할 수 없다. 

total = pd.merge(A, B, how = 'left', left_index = True, right_index = True)
total.head()

left일 경우 A를 기준으로 합병이 된다. 4번, 5번은 나오지 않고, B의 3번은 NaN으로 채워진다. 

pd.merge(A, B, how = 'right', left_index = True, right_index = True)

위와 같이 작성되었을 때 , B에 맞추어 합병된다. 따라서 3번은 없는 것을 볼 수 있다. 

pd.merge(A, B, how = 'inner', left_index = True, right_index = True)

inner를 사용하였을 경우 , A 와 B 모두 존재하는 인덱스의만 합병해준다. 

pd.merge(A, B, how = 'outer', left_index= True, right_index=True)

outer를 사용하였을 경우 모든 데이터를 합병해 준다. 

 5 . 저장하기 

total = pd.merge(A, B, how = 'left', left_index = True, right_index = True)
total

최종 모델은 left, A를 기준으로 합병한 데이터프레임으로 total 변수를 선언하고 , 저장을 해보자 ! 

total.to_excel('./data/exam_total.xlsx')

total.to_excel('./data/exam_total_withoutindex.xlsx', index = False)

index = False 인자를 사용하여 '번호' 컬럼을 제외하고 저장할 수 있다. 

러닝스푼 수업 정리 

* 판다스 기본 함수 

데이터 파일 읽기 : read_excel(), read_csv()

데이터 선택하기 : df.loc(), df.iloc()

인덱스/ 컬럼 변경하기 : columns/ index , reset_index() 

 pandas vs excel 

pandas : 가볍고 빨라서 대용량 파일 작업을 자유롭게 할 수 있다. 

excel : 모든 데이터가 눈에 보인다. (데이터가 많아 직접 보기 어려울 수 있다. ) 

 pandas 구조 

• DataFrame : 표 형태 

- index : DB의 key 개념 , 엑셀에서는 보통 첫 번째 열에 배치하는 데이터 (vlookup 등에 활용) 

- columns : 하나의 속성을 가진 데이터의 집합 -> index + column 하나로 나누어 살펴 볼 수 있음 

• Series : 하나의 속성을 가진 데이터 집합 ( DataFrame 에서 하나의 열 데이터 ) 
•  

 1. Pandas 불러오기 

- pandas 설치 

!pip install pandas

- pandas 불러오기 

import pandas as pd

 2. 데이터 불러오기 & 데이터 살펴보기 

* 파일의 경로 

- 절대경로 : "c:폴더1/폴더2/.../파일명.확장자" 

- 상대경로 : "./폴더3/.../파일명.확장자" , "../폴더4/.../파일명.확장자" (쥬피터 노트북 파일 위치를 기준으로 지정) 

- ./ : 현재 위치 ../ : 부모 폴더

* 데이터를 불러들인 뒤에는 head(), info(), descrive() 명령을 통해 데이터를 살펴보는 습관 갖기 

temp = pd.read_excel('./data/exam.xlsx')

temp

temp.head(2)

head 인자에 개수를 지정해 줄 수 있다. 

temp.tail()

- info () : 데이터프레임의 인덱스, 컬럼의 데이터 개수와 종류 확인 

temp.info()

- describe() : 수치형 데이터 (inf, float) 가 들어있는 컬럼의 기초통계량 (개수,평균,표준편차,사분위 등) 확인

temp.describe()

 2-1 인덱스 지정 

- set_index() : 인덱스 컬럼 지정하기 (컬럼 -> 인덱스) 

data = temp.set_index('번호')
data.head()

set_index를 이용하여 '번호' 컬럼을 인덱스로 지정해 주었다. 

- index_col : 엑셀 파일 읽어올 때 인덱스 지정 

temp2 = pd.read_excel('./data/exam.xlsx', index_col = 0) # index_col = '번호' (컬럼명 활용)
temp2.head()

 3. 데이터 선택하기 

- 셀 선택하기 (1개)

df.iloc[row, column] : 인덱스 번호

df.lic[row, column] : 이름 

data

data.iloc[1, 2]

55

data.loc['1번','수학']

75

print(data.loc['3번','영어'])
print(data.iloc[2, 1])

100

100

print(data.loc['1번', '국어'])
print(data.iloc[0, 0])

70

70

- 셀 선택하기 (복수) 

: 리스트 ( [조건1, 조건2, ... 조건n] ) 혹은 시작:종료 형태로 범위 지정 

data.loc['1번', ['국어', '영어']]

국어 70

영어 80

Name: 1번, dtype: int64

data.loc[ ['1번','2번'] , '수학']

번호

1번 75

2번 55

Name: 수학, dtype: int64

data.loc['1번', '영어': ]

영어 80

수학 75

Name: 1번, dtype: int64

- 컬럼 선택하기 (1개)

: data.컬럼명 or data.['컬럼명']

data.loc[ : , '수학']

data['수학']

data['영어']

- 컬럼 선택하기 (복수)

: 원하는 순서대로 선택 가능

data[ ['수학','영어'] ]

data[  ['수학','영어','국어']  ]

원래는 국어 영어 수학 순서였는데 위와같이 순서를 달리 하여 출력할 수 있다. 

- 특정 조건 데이터 선택하기 (한개)

pd[condition] : True인 데이터만 출력 

-> condition : True / False 로 구성된 리스트 or 시리즈 

data

cond = data['수학'] < 80
cond

이렇게 수학 컬럼에 대해 조건을 생성하면 bool타입을 반환해 준다. 

data[ cond ]

위의 조건을 데이터프레임에 적용하면 True인 row들만 나오게 된다. 

cond = [True, False, True]    # data['영어'] >  80
data[cond]

리스트에 직접 bool타입을 넣어 뽑아줄 수도 있다. 이 때 리스트의 개수와 row의 개수는 같아야 한다. 

- 특정 조건 데이터 선택하기 (여러개의 조건)

& : and , 모든 조건 만족 True

| : or , 한 개라도 만족하면 True

cond3 = (data['영어'] > 80)
cond4 = (data['수학'] > 80)

data[ cond3 | cond4]

cond3 = (data['영어'] > 80)
cond4 = (data['수학'] > 80)

cond = cond3 & cond4
data[ cond ]

cond = (data['영어'] >= 70)  & (data['수학'] >= 70)  & (data['수학'] < 90) 
data[ cond ]

cond = (data['영어'] >= 70) \
    & (data['수학'] >= 70) \
     & (data['수학'] < 90) 

data[ cond ]

줄을 바꿀 땐 \(역슬래쉬) 를 사용해 준다. 가독성이 좋아진다. 

cond_first  =  ( data['국어']  > 80)
cond_second =  ( data['영어']  > 80)

cond = cond_first   &   cond_second
data[cond]

cond_first  =  ( data['국어'] > 80 )
cond_second = ( data['영어'] > 80 )


cond = cond_first     |   cond_second

data[cond]

 index & column 

data.index

Index(['1번', '2번', '3번'], dtype='object', name='번호')

data.index = ['가반', '나반', '다반']

인덱스를 리스트로 설정해 줄 수 있다. 

data

설정한 대로 바뀐 것을 볼 수 있다. 

data.columns

Index(['국어', '영어', '수학'], dtype='object')

data.columns = ['Korean','English', 'Math']

동일하게 컬럼도 바꿔줄 수 있다. 

data

data.reset_index()

* reset_index : drop=False가 기본 값 ( 현재 인덱스를 컬럼으로 옮겨 주고 인덱스를 리셋) , 

drop = True ( 현재 인덱스에 있는 값을 컬럼으로 변경하지 않고 인덱스 초기화 ) 

(본 프로젝트 코드는 패캠 딥러닝 강의를 참고한 코드이다)

<이전 글>

https://silvercoding.tistory.com/9

이전 글에서 fashion MNIST에 대하여 알아보았다. MNIST와 동일한 형태를 가지고 있었다. 이번 글에서는 이러한 fashion MNIST 데이터셋을 전처리하는 시간을 가져보도록 한다. 

전처리 시작 

(1) data type 변경 (정수 -> 실수)

데이터의 이미지의 값은 0-255 인 uint8 타입 이었다. 그래서 데이터 타입을 실수형으로 바꾸어 주고, 범위를 0-1 로 바꾸어 준다. 

혹시 uint8 타입이 궁금하다면 이곳에서 설명을 해둔 부분을 읽어보자. 

https://silvercoding.tistory.com/3

train_images = train_images.astype(np.float64)
test_images = test_images.astype(np.float64)

이렇게 astype 을 이용하여 코드를 작성해 주면 데이터 타입을 바꿔줄 수 있다. 이제 dtype을 찍어보면 uin8이 아닌 float64로 바뀌어 있을 것이다. 

(2) normalize 

normalize작업을 하여 0~1 의 값을 가지도록 변형해주도록 하자.
식은 다음과 같다.
normalize(x) = x - 최솟값 / 최댓값 - 최솟값
normalize(x) = x / 최댓값 (최솟값이 0일 때 : 지금 데이터셋의 경우)
현재 MNIST 는 0-255 의 숫자이므로 밑의 식을 따르면 된다.

(train_images / 255.0).min(), (train_images / 255.0).max()

이렇게 하면 바로 최솟값이 0.0, 최댓값이 1.0 으로 변화하게 된다. 

*** normalize를 함수로 구현하여 일반화 시키기 

def norm(data):
  min_v = data.min()
  max_v = data.max()

  return (data - min_v) / (max_v - min_v)

이러한 normalize 함수를 생성해 놓으면 최솟값이 0이 아닌 데이터도 손쉽게 정규화 해줄 수 있다. 

여기서 데이터의 shape, dtype, 범위(최댓값, 최솟값)을 다시 확인해 본다음 시각화로 넘어가자! (포스팅은 생략)

여러장 시각화 해보기 (ex, 5장)

이 작업도 계속 반복되므로 간단하게 작성해 나가며 마치도록 한다. 

- (5, 28, 28) ---> (28, 28 * 5) shape 변경 (hstack, transpose로 가능) 

이번에도 hstack은 생략하고, transpose 방법으로만 진행한다. 

이곳에서 hstack을 사용한 적이 있다. 

https://silvercoding.tistory.com/4

train_images[:5].transpose((1, 0, 2)).reshape(28, -1).shape

(28, 140) 이 나오면 정상! 

이제 이걸 plt로 그려보면 (코드 생략)

이렇게 오류 없이 5장을 한번에 출력할 수 있게 되었다. 

- 종류끼리 시각화 하기 

def filter(label, count=5) :
  imgs = train_images[np.argwhere(train_labels == label)[:count, ..., 0]].transpose((1, 0, 2)).reshape(28, -1)
  plt.imshow(imgs, cmap='gray')
  plt.title(idx2label(label))
  plt.show()

filter 함수를 만들어서 보고싶은 의류 종류 라벨을 집어 넣으면, 그 종류끼리 시각화를 해볼 수 있다. 저번에 만들어 두었던 idx2label 을 이용하여 title도 지정해주었다. 

filter(레이블, 시각화 갯수) 이렇게 사용하면 된다. 

filter(9, 6)

9번째 라벨인 앵클부츠 6가지를 그려 보았다. 

다음시간에는 Data augmentation과 모델링을 하는 포스팅을 할 예정이다. 

(본 프로젝트 코드는 패캠 딥러닝 강의를 참고한 코드이다)

이번에는 또 유명한 데이터인 fashion MNIST를 이용하여 멀티레이블 분류를 해볼 것이다. 

여기서 멀티레이블이 무엇인지 알아보고 넘어가자. 

Multiclass vs multi-label

Binary Classification 은 클래스가 2가지인 경우이다. 사진에 나와있는 것 처럼 (스팸, 낫스팸), 저번 프로젝트에서 했었던 성별 (남, 녀), 웃음여부 (웃음, 안웃음) 이런식이다. 

MultiClass Classification 은 여러개의 클래스를 가지고 있는 경우이다. 위 사진처럼 사진에 강아지 한마리가 있고 여러 클래스들 중 한 종류를 예측해 주는 것이다. 이번에 할 fashion Mnist를 멀티레이블로 하지 않고 그대로 분류모델을 만든다면 멀티클래스 분류모델이 될 것이다. 

Multi-label Classification 은 여러개의 클래스를 가지고 있고, 라벨링도 여러개로 되어있는 경우이다. 위 사진을 보면 사진 안에 고양이와 새가 있으니 여러 클래스들 중 두가지의 라벨링이 되어있는 것이다.

본 프로젝트에서는 멀티 레이블 분류 모델을 만들 것이기 때문에 한 사진에 의류를 무작위로 붙여주는 작업을 하여 한 사진에 의류가 최대 4가지가 들어갈 수 있는 데이터로 변형을 한다. 

<multi-label 사진 출처>

https://www.kaggle.com/c/lish-moa/discussion/180500

이제 fashion MNIST를 알아보도록 하자!

이번에도 keras에서 제공해주는 datasets에서 불러와 사용한다. 수동으로 설치하려면 밑의 링크를 이용하면 된다. 

<fashion MNIST 출처 및 다운>

https://www.kaggle.com/zalando-research/fashionmnist

MNIST 데이터와 크기가 동일하게 28x28 이다. train dataset이 60,000장, test dataset이 10,000 장인 것도 동일하다. 

Labels

Each training and test example is assigned to one of the following labels:

• 0 T-shirt/top
• 1 Trouser
• 2 Pullover
• 3 Dress
• 4 Coat
• 5 Sandal
• 6 Shirt
• 7 Sneaker
• 8 Bag
• 9 Ankle boot

클래스는 총 10개로, 티셔트, 드레스, 셔츠, 샌들, 가방 등등 여러 의류 종류가 포함되어 있다.  어느 의류의 종류인지 분류해내는 모델을 생성하는 것이 목표이다.

fashion MNIST 데이터셋 알아보기 

이제 데이터셋을 알아보는 절차는 익숙해졌을 것이다. 데이터를 불러와서 데이터의 크기, 범위, 타입을 확인하고, 어떻게 생겼는지 시각화를 해본다. 

(1) 데이터 불러오기 

fashion_mnist = keras.datasets.fashion_mnist 
((train_images, train_labels), (test_images, test_labels)) = fashion_mnist.load_data()

keras의 datasets에서 fashion MNIST를 불러온다.

labels = ["T-shirt/top",  # index 0
        "Trouser",      # index 1
        "Pullover",     # index 2 
        "Dress",        # index 3 
        "Coat",         # index 4
        "Sandal",       # index 5
        "Shirt",        # index 6 
        "Sneaker",      # index 7 
        "Bag",          # index 8 
        "Ankle boot"]   # index 9

def idx2label(idx):
  return labels[idx]

레이블의 텍스트를 리스트에 저장해서 인덱스를 이용하여 텍스트를 불러올 수 있다.

idx2label 함수를 구현하여 레이블을 함수에 넣으면 레이블의 텍스트를 불러오도록 하는 코드. 시각화에서 사용할 예정이다. 

(2) 데이터의 크기 확인 

print(f"train_images: {train_images.shape}")
print(f"train_labels: {train_labels.shape}")
print(f"test_images: {test_images.shape}")
print(f"test_labels: {test_labels.shape}")

train_images: (60000, 28, 28)

train_labels: (60000,)

test_images: (10000, 28, 28)

test_labels: (10000,)

기존 MNIST와 같은 형태를 띄는 것을 알 수 있다. 

(3) 데이터의 범위 확인 

- image 에서 0이 아닌 값 출력해보기 

train_images[train_images!=0][:50]
test_images[train_images!=0][:50]

너무 많으니 50까지만 출력해본다. 0을 제외하고 255까지의 정수들로 이루어져 있으면 정상! 

- image의 최솟값, 최댓값 구해보기 

print(train_images.min(), train_images.max())
print(test_images.min(), test_images.max())

둘다 0 255 가 나오면 정상! 

***이미지의 값을 더해서 가장 큰 index, 가장 작은 index를 구해보고 시각화 해보기 

이미지의 값들을 모두 더해서 숫자가 크다면 옷의 크기가 크고 색이 밝을 것이고, 숫자가 작다면 옷의 크기가 작으면서 색이 어두울 것으로 예상할 수 있다. 정말 그런지 확인해 보자. 

print(train_images.reshape((60000, -1)).sum(axis=1).argmax())
print(train_images.reshape((60000, -1)).sum(axis=1).argmin())

axis=1 방향으로 다 더해주면 각 이미지에 대한 값들의 합이 나올 것이다. 그중에서 최댓값의 index와 최솟값의 index를 

인덱스는 55023 9230가 나왔다. 사진을 출력해보면,

예상했던 대로 합이 큰 이미지는 밝은 부분이 많고, 합이 작은 이미지는 어두운 부분이 대부분이다. 

(4) 데이터 타입 확인 

print(train_images.dtype)
print(train_labels.dtype)
print(test_images.dtype)
print(test_labels.dtype)

모두 uint8 이 나오면 정상! 

이를 통해 알 수 있는 것은 전처리 할 때 0-1 사이의 float 형태로 바꿔 주어야 된다라는 것.  

(5) 데이터 한장씩 시각화 해보기 

def show(idx):
  plt.imshow(train_images[idx], cmap='gray')
  plt.title(idx2label(train_labels[idx]))
  plt.show()

시각화 하는 함수를 구현해주어 편리하게 사진을 확인할 수 있다. 

show(777)

train image의 777번째 사진은 sandal 

show(77)

train image의 77번째 사진은 shirt 임을 알 수 있다. 

다음 포스트에서는 fashion MNIST 전처리와 여러장 시각화하는 방법에 대하여 작성할 예정이다. 

(본 프로젝트 코드는 패캠 딥러닝 강의를 참고한 코드이다)


<이전 포스팅>
https://silvercoding.tistory.com/7

저번 포스팅까지 celeba 데이터셋에 대한 전처리를 모두 마쳤다. 이제 모델링 하는일만 남았다.
그런데 바로 이전 프로젝트였던 mnist 모델은 어느 숫자인지 맞추는 1개의 아웃풋이 나오는 분류기였다.

이번에는 성별과, 웃음 여부 두가지를 맞추어야 한다. 그래서 첫번째로 이를 따로따로 각각 모델을 만들어 보고,  두번째로는 weights는 공유하면서 아웃풋만 다르게 해주는 모델을 만들어 볼 것이다.





각각 모델링 하기
(1) simple model 구현

from keras.models import Model 
from keras.layers import Conv2D, MaxPool2D, Input, Dense, Flatten 
def simple_model(): 
	inputs = Input((72, 59, 3)) 
    x = Conv2D(32, 3, activation='relu')(inputs) 
    x = MaxPool2D(2)(x) 
    x = Conv2D(64, 3, activation='relu')(x) 
    x = MaxPool2D(2)(x) 
    x = Conv2D(64, 3, activation='relu')(x) 
    x = MaxPool2D(2)(x) 
    x = Flatten()(x) 
    x = Dense(64, activation='relu')(x) 
    
    outputs = Dense(2, activation='softmax')(x) 
    model = Model(inputs, outputs) 
    
    return model

두개를 똑같은 모델로 구현할 것이기 때문에 효율적으로 사용하기 위해 함수를 구현해 놓는다.








(2) 모델 생성 및 요약정보 출력
- 모델 생성

gender_model = simple_model() 
smile_model = simple_model()

각각에 대하여 모델을 생성한다.


- 모델 요약 정보 출력

gender_model.summary() 
smile_model.summary()

이렇게 생긴 모델이 2개가 나오게 된다.








(3) loss, optimizer, metrics 설정

gender_model.compile(loss = 'categorical_crossentropy', optimizer = 'adam', metrics = ['accuracy']) 
smile_model.compile(loss = 'categorical_crossentropy', optimizer = 'adam', metrics = ['accuracy'])

이것 또한 동일하게 작성해준다. compile 함수를 이용하여 손실함수는 categorical crossentropy, optimizer는 adam, 평가지표는 정확도로 설정을 해주었다.

-- 두 model 의 weight 확인 해보기

gender_model.get_weights()[0][0][0][0] 
smile_model.get_weights()[0][0][0][0]

두 모델의 weight들을 얻어와보면 다른 것을 알 수 있다. 구조만 같은 모델이고, 서로 독립적으로 학습이 진행된다는 의미이다.







(4) 학습 시키기

gender_hist = gender_model.fit(train_images, train_male_labels, validation_data=(test_images, test_male_labels), epochs=15, verbose=1) 
smile_hist = smile_model.fit(train_images, train_smile_labels, validation_data=(test_images, test_smile_labels), epochs=15, verbose=1)

학습도 역시 각각 따로 시킨다. 라벨 빼고는 이미지 데이터를 비롯해 모두 동일하다.
이 시점에서 weight를 또 불러와 보면 아까와 달라져 있을 것이다. 당연히 두 모델의 weight도 여전히 다를 것이다.


참고로 verbose에 관련된 설명은 여기에 있다
https://silvercoding.tistory.com/5

(5) 학습 결과 확인
- 학습 결과 시각화

plt.plot(gender_hist.history['accuracy'], label = 'gender_accuracy') 
plt.plot(gender_hist.history['loss'], label = 'gender_loss') 
plt.plot(gender_hist.history['val_accuracy'], label = 'gender_val_accuracy') 
plt.plot(gender_hist.history['val_loss'], label = 'gender_val_loss') 

plt.plot(smile_hist.history['accuracy'], label = 'smile_accuracy') 
plt.plot(smile_hist.history['loss'], label = 'smile_loss') 
plt.plot(smile_hist.history['val_accuracy'], label = 'smile_val_accuracy') 
plt.plot(smile_hist.history['val_loss'], label = 'smile_val_loss') 

plt.legend(loc='uppder left') 
plt.show()

히스토리에 저장된 accuracy와 loss를 꺼내서 그래프를 그려보면

나름 괜찮은 모양을 띈다!


--- test image 한장으로 결과 확인해보기

gender_res = gender_model.predict(test_images[77:78]) 
smile_res = smile_model.predict(test_images[77:78]) 

77번째 사진으로 결과를 확인 해보자.

우선 77번째 사진은 위와 같다. 여자 웃음O 일 것으로 추정된다.
결과도 각각 해주어야 한다.

- gender

plt.bar(range(2), gender_res[0], color='red') 
plt.bar(np.array(range(2)) + 0.3, test_male_labels[77]) 
plt.xticks(range(2), ['female', 'male']) 
plt.show()

print(gender_res)

red가 예측, blue가 정답이다. 잘 맞추었다!

- smile

(코드 생략) gender_res ---> smile_res, test_male_labels ---> test_smile_labels 로 바꿔주면 된다.
아주 조금은 unsmiling으로 예측하고 거의 잘 맞춘 것으로 보인다!








(6) 모델 평가
모델 평가도 두개를 따로 해주어야 한다.

gender_model.evaluate(test_images, test_male_labels, verbose=2) 
smile_model.evaluate(test_images, test_smile_labels, verbose=2)

각각 정확도 94%, 89% 로 모델 평가까지 마친다.






그런데 아주 번거롭다. 두개라서 할만했지 만약 더 많은 속성을 분류하고자 했다면 정말 힘들었을 것이다. 모델 생성, 학습, 결과 확인, 평가까지 모두 따로따로 해주어야 한다. 그래서 멀티 아웃풋 모델링으로 학습을 해보려고 한다.



멀티 아웃풋 모델링
우선 아이디어는 output 이전까지는 다 같으니 똑같이 작성하고, output만 다르게 작성해준다는 것이다.

- 방법 1

from keras.models import Model 
from keras.layers import Conv2D, MaxPool2D, Input, Dense, Flatten, Concatenate 
def multi_model(): 
	inputs = Input((72, 59, 3)) 
    l1 = Conv2D(32, 3, activation='relu')(inputs) 
    l2 = MaxPool2D(2)(l1) 
    l3 = Conv2D(64, 3, activation='relu')(l2) 
    l4 = MaxPool2D(2)(l3) 
    l5 = Conv2D(64, 3, activation='relu')(l4) 
    l6 = MaxPool2D(2)(l5) 
    l7 = Flatten()(l6) 
    latent_vector = Dense(64, activation='relu')(l7) 
    
    gender_outputs = Dense(2, activation='softmax')(latent_vector) 
    smile_outputs = Dense(2, activation='softmax')(latent_vector) 
    
    outputs = Concatenate(axis=1)([gender_outputs, smile_outputs]) 
    model = Model(inputs, outputs) 
    
    return model

(1) 모델 생성 및 요약정보 출력

# 모델 생성
model = multi_model() 
# 모델 요약정보 
model.summary()

(None, 4)로 최종 아웃풋이 1개


(2) loss, optimizer, metrics 설정

model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy'])

전과 같이 해준다.

(3) 모델 학습

hist1 = model.fit(train_images, train_labels2, validation_data=(test_images, test_labels2), epochs=15, verbose=1)

(4) 결과 그래프

그래프가 굉장히 이상하다. loss가 accuracy 보다 높다. 오!



(5) 예측 확인 (테스트 데이터셋 사진 한장 확인해보기)

res = model.predict(test_images[77:78]) print(res2.shape)

res의 shape 은 (1, 4) 가 나온다.

77번째 사진은

이분이시고, 잘 예측하는지 시각화하여 확인을 해보자.

plt.bar(range(4), res[0]) 
plt.bar(np.array(range(4)) + 0.3, test_labels2[77]) 
plt.show()

77번째 이미지는 예상과 다르게 잘 맞춘 것 같다. 결과 그래프는 아주 이상했는데 꽤 맞추긴 하나보다.

(6) 모델 평가

model.evaluate(test_images, test_labels2, verbose=2)

엄청난 loss와 정확도 60%로 방법 1의 모델 평가까지 마쳤다. 한번에 합쳐서 모델링을 하려면 다른 조치가 더 필요해 보인다.






-방법 2

from keras.models import Model 
from keras.layers import Conv2D, MaxPool2D, Input, Dense, Flatten, Concatenate 
def multi_model(): 
	inputs = Input((72, 59, 3)) 
    l1 = Conv2D(32, 3, activation='relu')(inputs) 
    l2 = MaxPool2D(2)(l1) 
    l3 = Conv2D(64, 3, activation='relu')(l2) 
    l4 = MaxPool2D(2)(l3) 
    l5 = Conv2D(64, 3, activation='relu')(l4) 
    l6 = MaxPool2D(2)(l5) 
    l7 = Flatten()(l6) 
    latent_vector = Dense(64, activation='relu')(l7) 
    
    gender_outputs = Dense(2, activation='softmax')(latent_vector) 
    smile_outputs = Dense(2, activation='softmax')(latent_vector) 
    
    model = Model(inputs, [gender_outputs, smile_outputs]) 
    
    return model

여기서는 gender_outpus와 smile_outputs를 concatenate해주지 않고, model에 리스트로 묶어 바로 넣어준다. 파라미터의 개수는 절반으로 줄여주면서 처음에 했던 각각 모델링과 같은 형태의 결과가 나오게 해준다.


(1) 모델 생성 및 요약정보 출력

# 모델 생성 
model2 = multi_model() 
# 모델 요약정보 
model2.summary()

(None, 2) (None, 2) 로 최종 아웃풋이 2개


(2) loss, optimizer, metrics 설정

model2.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy'])

똑같이 설정!



(3) 모델 학습

hist2 = model2.fit(train_images, [train_male_labels, train_smile_labels], validation_data=(test_images, [test_male_labels, test_smile_labels]), epochs=15, verbose=1)

(4) 결과 그래프

각각 모델링 했을 때와 비슷한 형태로 나옴을 알 수 있다.


(5) 예측 확인 (테스트 데이터셋 사진 한장 확인해보기)
아까와 같은 77번째 이미지를 예측해본다.

res2 = model2.predict(test_images[77:78]) print(res[0].shape, res[1].shape)

여기서는 아웃풋이 2개이기 때문에 각각 출력해주면 (1, 2) (1, 2) 이러한 형태가 나오게 된다.
res2를 출력해보면,
[array([[9.999993e-01, 6.897806e-07]], dtype=float32),
array([[0.01424873, 0.9857512 ]], dtype=float32)] 이러한 형태가 나오게 되는 것이다.

코드는 위에서 살짝 바꿔주면 되니 생략하고, 각각 그래프를 그려보면

성별은 여자, 100%는 아니지만 웃는 사람으로 잘 판별 하는 것을 볼 수 있다.



(6) 모델 평가

model2.evaluate(test_images, [test_male_labels, test_smile_labels], verbose=2)

너무 길어서 짤렸다. 결과는 두 성별, 웃음 모델 모두 정확도 91% 정도로 나왔다. 제일 높게 나왔다!


(7) 모델 분리 해보기

gender_model2 = Model(inputs = model2.input, outputs = model2.get_layer('dense_5').output) 
gender_model2.summary()

smile_model2 = Model(inputs = model2.input, outputs = model2.get_layer('dense_6').output) 
smile_model2.summary()

model2에서 input과 gender_outputs, smile_oupts에 해당했던 layer를 get_layer를 통해 얻어와서 모델을 생성해주면 된다.
summary를 해보면 가장 처음에 했던 각각 모델링에서의 형태와 같게 나온다.


- weights 확인 해보기

smile_model2.get_weights()[0][0][0][0] 
gender_model2.get_weights()[0][0][0][0]

각각모델링에서 weights를 확인해 보았을 때는 서로 달랐다. 하지만 model2에서 weights를 공유하고 분리를 해준 위의 모델은 weights가 같은 것을 알 수 있다.



(8) 모델 저장 및 불러오기

# 모델 저장
model2.save("./multimodel.h5")

# 모델 불러오기 
model3 = tf.keras.models.load_model('./multimodel.h5')

이름 설정하고 h5로 저장하고 불러오기!


--- 코랩을 사용했다면 컴퓨터에 모델 저장하는 코드

from google.colab import files 
files.download('./multimodel.h5')

결론적으로
파라미터 개수 => 각각 모델링 (총 약 40만개) > 멀티 아웃풋 모델링 (약 20만개)
절반이 줄어들기 때문에 같은 형태의 모델의 아웃풋만 달리 해줄 때는 멀티 아웃풋 모델링이 더 효율적이라고 생각한다.


방법1 vs 방법2
방법 1 은 아웃풋이 1개 (None, 4) , 방법2는 아웃풋이 2개 (None, 2) (None, 2) (각각 모델링과 같음)
방법1은 이미지 한장은 잘 분류한 것 같은데, loss나 accuracy가 이상해서 조치를 더 취해주거나, 조금 더 알아볼 필요가 있을 것 같다.

(본 프로젝트 코드는 패캠 딥러닝 강의를 참고한 코드이다)

<이전 포스팅>
https://silvercoding.tistory.com/6

전처리를 하기 위해선 데이터를 잘 파악해야 한다. 또한 실수를 하지 않기 위해서 데이터의 범위, 크기, 데이터 타입을 수시로 확인해 주며 전처리를 진행하도록 한다. (포스팅에서는 생략)

이전 포스팅에 따르면, 범위는 0.0-1.0, 이미지 크기는 (2000, 72, 59, 3) (200, 72. 59. 3), 라벨 크기는 (2000, 2) (200, 2), 데이터 타입은 이미지 float64, 라벨은 int8 이었다.


이전에도 말했듯이 이번 프로젝트에서는 normalize를 할 필요가 없다. 따라서 이번에는 라벨만 전처리 시켜주면 된다.

전처리 시작
(1) 라벨 크기 변경
(배치, 2) --> (배치, 2) (배치, 2)
(배치, (성별, 웃음)) --> (배치, 남자, 여자) (배치, 웃음, 안웃음)

# (배치, 2) ---> (배치, 1) (배치, 2) 
train_male_labels, train_smile_labels = np.split(train_labels, 2, axis=1) 
test_male_labels, test_smile_labels = np.split(test_labels, 2, axis=1) 
# 잘 나눠졌는지 확인 
print(train_male_labels.shape, train_smile_labels.shape) 
print(train_male_labels[777], train_smile_labels[777], train_labels[777]) 

shape은 각각 (2000, 1) 이 나오면 된다. test의 shape을 출력해보면 (200, 1) 이 나올 것이다.
[0] [0] [0 0] 나눠진 라벨들과 나눠지기 전 라벨을 비교한 코드이다. 전에 777번째 사진 안웃는 여자였기 때문에 잘 출력된 것을 알 수 있다.

from tensorflow.keras.utils import to_categorical train_male_labels = to_categorical(train_male_labels) train_smile_labels = to_categorical(train_smile_labels) test_male_labels = to_categorical(test_male_labels) test_smile_labels = to_categorical(test_smile_labels)

그다음으로는 원핫인코딩으로 나누어 준다.
(2000, 2) (2000, 2)
(200, 2) (200, 2)


모델링 단계 때 성별과 웃음 여부를 각각 모델링하기도 하고, 멀티 아웃풋 모델링도 할 예정이다.
그래서 (2000, 2) (2000, 2) ---> (2000, 4) 로 합친 라벨도 필요하다. 만들어 놓자.

train_labels2 = np.concatenate([train_male_labels, train_smile_labels], axis = 1) test_labels2 = np.concatenate([test_male_labels, test_smile_labels], axis = 1) print(train_labels2.shape, test_labels2.shape)

(2000, 4) (200, 4) 이렇게 합친 라벨도 생성한다! 예를들어 남자고 웃고있지 않다면 [0 1 1 0] 이런식으로 나오게 될 것이다.

이번엔 이렇게 해서 전처리를 끝낸다.
---> 결론적으로 전처리 결과 : (배치, 2) --> (배치, 2) (배치, 2) / (배치, 4) 이렇게 두 종류의 라벨을 획득했다!



여러 장 시각화 하기
(1) 이미지 shape 변경
이 내용은 저번 프로젝트와 동일하다. 그래서 hstack 은 생략하고, transpose 함수를 사용하여 이미지의 shape을 변경해 줄 것이다.

train_images[:5].transpose((1, 0, 2, 3)).reshape((72, -1, 3)).shape

shape을 (5, 72, 59, 3) ---> (72, 5*59, 3) 으로 변경해 주어야 한다. 따라서 transpose로 위치를 변경해주고, reshape으로 shape을 맞춰주면 된다.


이를 plt로 시각화 해보면

이렇게 연속으로 5장을 시각화 할 수 있다.




이번에는 정말 간단하게 전처리와 시각화를 구현해 보았다. 다음은 여러 방법으로 모델링하는 방법을 포스팅 할 예정이다.

(본 프로젝트 코드는 패캠 딥러닝 강의를 참고한 코드이다)

<celeb_a 데이터셋 출처>
https://www.tensorflow.org/datasets/catalog/celeb_a

caleba 데이터셋은 40개의 속성, 10,177개의 신원, 20만개 이상의 유명인 이미지가 포함된 대규모 얼굴 속성 데이터셋이다.
활용 - 얼굴 속성인식, 얼굴 감지, 얼굴 위치파악

celeba의 속성들은 다음과 같이 dictionary로 구성되어 있다.

FeaturesDict({
    'attributes': FeaturesDict({
        '5_o_Clock_Shadow': tf.bool,
        'Arched_Eyebrows': tf.bool,
        'Attractive': tf.bool,
        'Bags_Under_Eyes': tf.bool,
        'Bald': tf.bool,
        'Bangs': tf.bool,
        'Big_Lips': tf.bool,
        'Big_Nose': tf.bool,
        'Black_Hair': tf.bool,
        'Blond_Hair': tf.bool,
        'Blurry': tf.bool,
        'Brown_Hair': tf.bool,
        'Bushy_Eyebrows': tf.bool,
        'Chubby': tf.bool,
        'Double_Chin': tf.bool,
        'Eyeglasses': tf.bool,
        'Goatee': tf.bool,
        'Gray_Hair': tf.bool,
        'Heavy_Makeup': tf.bool,
        'High_Cheekbones': tf.bool,
        'Male': tf.bool,
        'Mouth_Slightly_Open': tf.bool,
        'Mustache': tf.bool,
        'Narrow_Eyes': tf.bool,
        'No_Beard': tf.bool,
        'Oval_Face': tf.bool,
        'Pale_Skin': tf.bool,
        'Pointy_Nose': tf.bool,
        'Receding_Hairline': tf.bool,
        'Rosy_Cheeks': tf.bool,
        'Sideburns': tf.bool,
        'Smiling': tf.bool,
        'Straight_Hair': tf.bool,
        'Wavy_Hair': tf.bool,
        'Wearing_Earrings': tf.bool,
        'Wearing_Hat': tf.bool,
        'Wearing_Lipstick': tf.bool,
        'Wearing_Necklace': tf.bool,
        'Wearing_Necktie': tf.bool,
        'Young': tf.bool,
    }),
    'image': Image(shape=(218, 178, 3), dtype=tf.uint8),
    'landmarks': FeaturesDict({
        'lefteye_x': tf.int64,
        'lefteye_y': tf.int64,
        'leftmouth_x': tf.int64,
        'leftmouth_y': tf.int64,
        'nose_x': tf.int64,
        'nose_y': tf.int64,
        'righteye_x': tf.int64,
        'righteye_y': tf.int64,
        'rightmouth_x': tf.int64,
        'rightmouth_y': tf.int64,
    }),
})

성별, 웃음 여부, 젊음, 안경 착용, 모자 착용, 웨이브 머리, 갈색머리 여부 등등 많은 속성들이 존재한다. 이 중에서 본 프로젝트에서는 성별(Male)과 웃음 여부(Smiling)를 분류해 내는 모델을 만들 것이다.

속성을 꺼낼때는 ['attributes']['Male'] 이런식으로 꺼내주면 된다.




전체 데이터 셋 다운로드

import tensorflow_datasets as tfds 
# tfds.list_builders() -> 데이터셋 목록 전체보기 
celeb_a = tfds.load('celeb_a') # celeb_a 데이터셋 불러오기

본 프로젝트에서는 축소된 celeba 데이터셋을 사용할 것이다. 축소하는 코드는 생략하지만, 과정을 적어보면
1. celeb_a['validation']과 celeb_a['test'] 를 각각 train, test 로 할당해준다.
2. Male, Smiling 속성만 불러와 train_images, train_labels, test_images, test_labels를 생성한다.
---> 여기서 test_images와 test_labels 만 이용하여 데이터 축소
3. test_images와 test_labels에서 웃는남자, 안웃는남자, 웃는여자, 안웃는여자를 분리해내어 각각 550개씩 잘라 고르게 축소하여 합해진다 ---> 그럼 총 2200개가 된다!
4. 2200개 짜리 데이터를 섞어주고, 2000개까지 train, 나머지 200개는 test로 할당한다.
5. 이를 다시 train_images, train_labels, test_images, test_labels 로 나누어주면 끝! 축소하는 게 번거로우므로 npz파일로 저장해놓자.





celeba_small 데이터 살펴보기
(1) 데이터 불러오고 train, test 데이터 나누기

celeba_small = np.load('./celeba_small.npz') 

# 데이터 불러오기 
train_images = celeba_small['train_images'] 
train_labels = celeba_small['train_labels'] 
test_images = celeba_small['test_images'] 
test_labels = celeba_small['test_labels']

(2) 사진 한장 꺼내서 시각화 해보기

plt.imshow(train_images[777]) 
plt.colorbar() 
plt.show() 
print(train_labels[777])

777번째 사진을 꺼내보았다.

결과는 이러하다. 웃는 것 같기도 한데 웃지않는 여자라고 라벨링이 되어있다!





(3) 데이터의 범위, 크기, 데이터 타입 알아보기
- 범위

# 0이 아닌 숫자 50개만 출력해보기 
train_images[train_images != 0][:50] 
test_images[test_images != 0][:50] 
# 데이터의 최솟값 / 최댓값 
print(train_images.min(), train_images.max()) 
print(train_labels.min(), train_labels.max()) 
print(test_images.min(), test_images.max()) 
print(test_labels.min(), test_labels.max())

50개 출력한 데이터들은 모두 0과 1사이의 값들이어야 하고, 이미지의 범위는 0.0-1.0, 라벨의 범위는 0-1 으로 나오면 정상!

- 크기

print(train_images.shape, test_images.shape) 
print(train_labels.shape, test_labels.shape) 

(2000, 72, 59, 3) (200, 72, 59, 3)
(2000, 2) (200, 2)
이와 같이 나오면 정상! 사진의 크기를 데이터 축소할 때 줄여서 원본보다는 작다. 저번 프로젝트 mnist 와 달리 채널 3이 추가되어 색이 있다는 것을 알 수 있다!

- 데이터 타입

print(train_images.dtype, test_images.dtype) 
print(train_labels.dtype, test_labels.dtype) 

float64 float64
int8 int8
위와 같이 나오면 정상! 이걸 통해 안 사실은 dtype이 float64이고, 범위가 0.0 - 1.0 이므로 normalize를 안해줘도 된다는 것이다.

범위, 크기, 데이터 타입은 수시로 확인하는 습관을 갖자!

다음에는 전처리와 시각화에 대한 포스팅을 할 예정이다.

(이번 프로젝트 코드는 패캠 딥러닝 강의를 참고한 코드이다)


<이전 포스팅>
https://silvercoding.tistory.com/4

Noise 추가하기

https://www.tensorflow.org/tutorials/images/data_augmentation

우선 Data augmentation 은 무작위 변환을 적용하여 훈련 세트의 다양성을 증가시키는 기술이다.

이 사진과 같이 사람 눈에는 회전을 하든 확대를 하든 같은 꽃이라는 걸 판별할 수 있지만, 컴퓨터 입장에서는 서로 다른 사진으로 입력된다는 것이다. 따라서 이러한 무작위 변형을 시켜 훈련세트의 다양화를 하고자 한다.

이 글에서는 MNIST에 이러한 Noise를 입힌 데이터를 사용할 것이다.

(1) (28, 28) 크기의 랜덤 노이즈 생성하기
- np.random.random

print(np.random.random((2, 2))) 

np.random.random() 함수를 사용하면 0-1사이의 실수가 나오게 된다. 괄호 안에 사이즈를 입력해주면

이렇게 (2, 2) 형태로 랜덤값이 나오는 것을 알 수 있다.

np.random.random((28,28)).shape

따라서 이렇게 해주면 (28, 28) 사이즈의 랜덤 노이즈가 생성된다.
이를 plt.imshow()에 넣어 확인해보면 위에서 보았던 노이즈 그림을 볼 수 있을 것이다.

그런데 위에서 보았던 그림보다는 진하다. 노이즈를 주기엔 너무 세다.

- np.random.normal

print(np.random.normal(0.0, 0.1, (28, 28))) 

그래서 np.random.normal로 평균과 표준편차를 지정해준다. 평균 0, 표준편차 0.1 로 지정해준다.
이를 그래프로 그려주면

적당한 노이즈가 생성되었다!




(2) 이미지 한장에 적용해보기
777번째 이미지에 노이즈를 씌워보자.

noisy_image = train_images[777] + np.random.normal(0.5, 0.1, (28, 28))

차이를 더 선명히 보기 위해 평균을 0.5로 준다.

그래프를 그려보니 노이즈가 생겼지만 1이 넘는 값이 생겨버린다.

noisy_image[noisy_image > 1.0] = 1.0 

그래서 1.0이 넘는 값은 1.0으로 대체한다는 코드를 작성해주면

0과 1사이의 값으로 이루어진 노이즈 이미지가 완성된다.




(3) 모든 이미지에 노이즈 적용하기

train_noisy_images = train_images + np.random.normal(0.5, 0.1, train_images.shape) 
train_noisy_images[train_noisy_images > 1.0] = 1.0 

test_noisy_images = test_images + np.random.normal(0.5, 0.1, test_images.shape) 
test_noisy_images[test_noisy_images > 1.0] = 1.0

최종적으로 train이미지와 test이미지 모두 노이즈를 적용시키는 코드이다.
저번시간에 여러장의 이미지를 한번에 시각화하는 방법을 사용하여 첫 5개의 이미지를 출력해보면 다음과 같이 정상적으로 나오는 것을 볼 수 있다.

드디어
모델링 하기

(1) 모델링 준비 - 라벨 원핫인코딩 작업 (배치사이즈,) -> (배치사이즈, 클래스 개수)
(60000,) (10000,) 의 형태였던 라벨을 (60000, 10) (10000, 10) 의 형태로 one-hot encoding 해줄 것이다.

from keras.utils import to_categorical 
train_labels = to_categorical( train_labels, 10) 
test_labels = to_categorical( test_labels, 10) 

keras.utils의 to_categorical을 import 하여 사용한다. to_categorical(원핫인코딩할 라벨, 클래스 개수) 이렇게 사용하면 된다.




(2) simpleRNN classification 모델 생성

from keras.layers import simpleRNN 
from keras.layers import Dense, Input 
from keras.models import Model 

inputs = Input(shape=(28, 28)) 
x1 = simpleRNN(64, activation="tanh")(inputs) 
x2 = Dense(10, activation="softmax")(x1) 

model = Model(inputs, x2)

keras.layers의 simpleRNN으로 모델 생성을 한다. activation 함수는 각각 tanh, softmax로 구성이 되어있다.

model.summary()

summary함수를 이용하여 요약정보를 얻어올 수 있다. 파라미터의 개수와 아웃풋 shape을 알 수 있다.




(3) loss, optimizer, metrics 설정

model.compile(loss='categorical_crossentropy', optimizer='adam', metrics = ["accuracy"])

compile 함수를 이용하여 손실함수는 categorical crossentropy, optimizer 는 adam, 지표는 정확도로 설정해 준다.




(4) 학습시키기

hist = model.fit(train_noisy_images, train_labels, validation_data=(test_noisy_images, test_labels), epochs=5, verbose=2)

다른 건 다 예상 가능하지만 verbose는 무엇인지 잘 모르겠어서 찾아보았다.

verbose: 'auto', 0, 1, or 2. Verbosity mode. 0 = silent, 1 = progress bar, 2 = one line per epoch. 'auto' defaults to 1 for most cases, but 2 when used with ParameterServerStrategy. Note that the progress bar is not particularly useful when logged to a file, so verbose=2 is recommended

<출처>
https://keras.io/api/models/model_training_apis/

** 비교해보기
- verbose = 1

- verbose = 2

(5) 학습 결과 확인

plt.plot(hist.history['accuracy'], label='accuracy') plt.plot(hist.history['loss'], label='loss') plt.plot(hist.history['val_accuracy'], label='val_accuracy') plt.plot(hist.history['val_loss'], label='val_loss') plt.legend(loc='upper left') plt.show()

학습한 결과를 그래프로 그려보았을 때 정확도는 매우 높고 오류는 매우 낮은 걸 볼 수 있다. 간단한 RNN모델로 구현을 하여도 성능이 괜찮다!


--- 완성된 모델에 test 이미지 한장으로 결과 확인해보기

res = model.predict( test_noisy_images[777:778] ) 

777번째 이미지를 확인해보자.

plt.bar(range(10), res[0], color='red') plt.bar(np.array(range(10)) + 0.35, test_labels[777]) plt.show()

red가 예측한 확률, blue가 정답이다. 보면 1로 잘 예측했지만, 7과 8로 예측한 것이 미세하게 보인다. 성능은 나쁘지 않아보인다.




(6) 테스트 데이터셋으로 평가하기

loss, acc = model.evaluate(test_noisy_images, test_labels, verbose=2) print(loss, acc)

evaluate에 테스트 데이터셋을 넣어주면 된다.

정확도 95%로 모델 평가까지 마쳤다.




(7) 모델 저장하고 불러오기

# 모델 저장 
model.save("./mnist_rnn.h5")

# 모델 불러오기 
new_model = tf.keras.models.load_model('./mnist_rnn.h5')

h5로 저장해주면 된다.


** 혹시 코랩으로 했다면, 코랩에 저장된 모델을 컴퓨터에 저장하는 코드

from google.colab import files 
files.download('./mnist_rnn.h5')