🤍

본 프로젝트는 패캠 강의를 참고 합니다.

<이전 글>

https://silvercoding.tistory.com/11

처음 사용하는 DJANGO인데다 강의 내용대로 하면 안되는 부분도 있어서 진행속도 마치 거북이!

----이전 글에서 했던 것 점검

• 가상환경 생성 및 적용
• django 설치
• project 생성 (community) ---> 이번 글의 터미널 에서 입력할 때 파일 끝이 community로 되어있어야 한다. (cd community로 들어갈 수 있음)
• app 생성 (board, user)
• app 등록 ☆☆☆ (app등록이 되어있어야 migration 가능/ settings.py 에서 등록 가능) 

이번 작업은 위의 상태에서 시작한다. 잘 안되는 게 있으면 침착하게 점검 해보기.

MTV 구조에서 Model 만들기 

1. 모델 작성

user 폴더 -----> model.py

class User(models.Model):
    Username = models.CharField(max_length=64,
    verbose_name="사용자명")

    password = models.CharField(max_length=64,
    verbose_name="비밀번호")

    registered_dttm = models.DateTimeField(auto_now_add=True,
    verbose_name="등록시간")

    class Meta:
        db_table = 'test_user'

클래스 안의 Meta클래스를 작성하여 테이블 이름을 지정해 준다. 

2. 모델 등록 

터미널

python manage.py makemigrations user 

바로 했더니 app이 없다고 에러(;;)가 나길래 이전 글에서 앱 등록을 해주었던 settings.py를 실행 시키고, models.py도 실행시킨 후 다시 작성해주었더니

 Create model User 완료

터미널

python manage.py migrate

이렇게 나오면 성공

이제 sqlite에 들어가서 등록한 table을 확인해 본다.

sqlite 삽질

sqlite3 db.sqlite3

강의에선 이렇게 작성하였고, 나는 실행할 수 없는 명령어! 오류가 났다. 구글링 해보니 환경변수 path 설정 관련 문제인 것 같은데 시간이 없어서 기각! 다른 방법을 찾아봤다. 퍽하면 이 에러가 나니 한번쯤 조치를 취해주어야겠다. 

python manage.py dbshell

이러한 방법도 있었다. 오 그랬더니 

CommandError: You appear not to have the 'sqlite3' program installed or on your path.

이러한 에러가 났다. 그래도 이건 구글링 해보니 간단하게 해결할 수 있어보여서 이 방법으로 채택!

----> 에러 해결 방법
https://www.sqlite.org/download.html 에서
sqlite-tools-win32-x86-3350500.zip 설치 

압축 풀고 sqlite3.exe를 db.sqlite3가 있는 폴더 안에 넣어준다. 

두근두근 다시 입력해줬더니 

python manage.py dbshell

드디어 sqlite에 들어가진다. 

간단한 sqlite 사용 

1. table 확인

.table

test_user도 들어가 있는 것을 볼 수 있다.

2. schema 확인

.schema test_user

모델 작성에서 생성했던 field들이 잘 나오면 성공 

3. model field내용 변경 후 확인해보기

class User(models.Model):
    Username = models.CharField(max_length=32,
    verbose_name="사용자명")

    password = models.CharField(max_length=64,
    verbose_name="비밀번호")

    registered_dttm = models.DateTimeField(auto_now_add=True,
    verbose_name="등록시간")

    class Meta:
        db_table = 'test_user'

Username의 max_length를 32로 바꾸고 적용해보자. 

우선 sqlite에서 빠져나오려면 

.q

를 작성해주면 된다. 

이제 앞의 내용과 똑같이 해주면 된다. 

model 바꾸고 실행을 안시키고 다음을 작성하면

python manage.py makemigrations user

No changes detected in app 'user'  이런게 뜬다. 실행을 시키고 다시 작성해주면 정상적으로 Alter field Username on user 라는 메시가 뜬다. (실행을 안시켜도 되는 방법을 알려주신다면 감사합니다) 

python manage.py migrate

그다음 똑같이 migrate 를 작성해주고 sqlite에 다시 들어가서 확인 해보면 

위와 같이 Username varchar(32)로 변경된 것을 볼 수 있다. 

이렇게 makemigrations 와 migrate를 이용하여 지속적으로 db에 적용이 가능하다. 

프레임 워크 

- 자주 사용되는 코드를 체계화 하여 쉽게 사용할 수 있도록 도와주는 코드 집합 

- 라이브러리와 혼동될 수 있지만 좀 더 규모가 크고 프로젝트의 기반이 됨 

- 건축에 비유하면 구조를 만드는 골조가 프레임 워크라면 그 외 자재들이 라이브러리가 됨 

웹개발에 필요한 기본적인 구조와 코드(클래스, 함수 등) 가 만들어져 있음 

Django 문서 

https://docs.djangoproject.com/ko/3.2/intro/

본 프로젝트는 패캠 강의를 참고 합니다.

가상환경 설정 (visual studio code)

강의 내용대로 따라하다가 안돼서 삽질하다가 구글링 해서 가상환경 생성을 해주었다. 

우선 폴더를 열어준다. 

그다음 보기에서 터미널 클릭 

python -m venv testvenv

터미널에 위의 코드를 쳐주면 다음과 같이 testvenv 폴더가 생성된다. 

window에서는 F1 또는 Ctrl+Shift+P를 누르고, Python Select Interpreter 를 입력 후 해당하는 가상환경을 선택해 준다. 

testvenv 선택!

그다음 우측 상단 + 버튼을 누르면 testvenv 가상환경 설정이 된다. 

DJANGO 설치 후 app 만들기 

1. django 설치 

pip install django

터미널에 입력하기

2. project 생성 

django-admin startproject community

community 자리에 원하는 폴더 이름을 작성한다. 그럼 community 폴더가 하나 만들어져 있을 것이다. 

3. app 생성 

community 안에 앱을 만드는 방법

cd community

community 폴더 안으로 들어간다. 

django-admin startapp board
django-admin startapp user

마찬가지로 django-admin명령어를 사용한다. board, user자리에 원하는 이름 쓰기. 

이를 실행하면 community 폴더 안에 board, user 폴더가 생긴다. 

*** mtv 구조 (Model, template, view) 를 사용하기 위해 templates 폴더를 생성해준다. 

3. app 등록 

마지막으로 app을 등록해 주어야 한다. 

community 폴더 안에 있는 settings.py 를 들어가서 

INSTALLED_APPS = [
   
     ...,
   
    'board',
    'user'
]

INSTALLED_APPS 리스트 안에 app 폴더 이름을 작성해 주면 된다. 

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

<이전 글>

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')