1000장의 데이터

batch_size  = 10 

update : 100번

장점: 미세한 조정 가능

단점: 속도가 느리다 

업데이트 되는 양 자체도 작아서 초기 학습 값이 잘못되었을때 다시 되돌아 오지 못한다.

 

batch_size = 100

update : 10번

장점: 크게크게 업데이트

속도가 빠르다

 

단점: 정밀도 떨어진다

 

적절한 batch_size 찾는 법

model.fit(batch_size는 32로 디폴트 지정됨)

또는 전처리 단계에서 batch_size 설정 가능 -> 장점은 train batch 크게/ valid batch 작게 따로 설정가능

 

Train/valid data 개수 batch_size steps_per_epoch  validation_steps
1000 10 100  
200 10 20  
1024 10 1024//10 + 1  

 

반드시 정수로 나누어 떨어지게 값을 조정해야한다.

그렇지 못할 경우에는 몫에 + 1 로 값을 입력한다.

 

전체 복사 붙여넣게 금지

xs 와 ys 값이 랜덤으로 주어지므로 

#YOUR CODE HERE  

이하로만 손대기

 

import numpy as np
import tensorflow as tf


def solution_model():
    xs = np.array([-1.0, 0.0, 1.0, 2.0, 3.0, 4.0], dtype=float)
    ys = np.array([5.0, 6.0, 7.0, 8.0, 9.0, 10.0], dtype=float)
    # YOUR CODE HERE
    model = tf.keras.models.Sequential([
        tf.keras.layers.Dense(1, input_shape=[1]),
    ])
    model.compile(optimizer="sgd", loss="mse")
    model.fit(xs, ys, epochs=500, verbose=0)
    return model


# Note that you'll need to save your model as a .h5 like this
# This .h5 will be uploaded to the testing infrastructure
# and a score will be returned to you
if __name__ == '__main__':
    model = solution_model()
    model.save("mymodel.h5")
    print(model.predict([10.0]))

ctrl + m + a

위에 셀 추가

 

ctrl + m + b

아래에 셀 추가

 

ctrl + m + d

셀 삭제

 

ctrl + enter

해당 셀 실행

 

shift + enter

해당 셀 실행 후 다음 셀로 이동

 

Alt + enter

해당 셀 실행 후 아래쪽에 셀 추가

 

ctrl + m + m

해당 셀을 텍스트셀로 변환

 

ctrl + m + y

해당 셀을 코드셀로 변환

 

tensorflow 자격증 환경 세팅하기

 

1. 구글 드라이브 

새로만들기 - 더보기 - 연결할 앱 더보기

(필자는 코랩이 깔려있어서 목록에 보이는 상태)

 

2. "colab" 검색하여 설치 실행

1. 선형함수의 개념

Y = W * X + b

W : Weight : 기울기

b : bias : 절편

 

 

2. 오차를 구하는 방법

각각의 X 값 마다 오차값들을 그냥 더하기만 한다면?

오차가 0이 나올 수 있다. -> 오류가 있음

 

ㅇ MAE (Mean Absolute Error)

오차 절대값 평균

 

ㅇ MSE (Mean Squared Error)

오차 제곱 평균

문제 유형

1번문제 기본문제

2/3/4 는 분류문제 

sigmoid/ softmax둘 중 하나

 

checkpoint

 

callback = [checkpoint]

 

저장을 한 후 자동으로 

 

best epoch의 w 값을 실어주기

매 epoch 마다 loss가 더 낮게 나오면 checkpoint에 저장된다

가장 마지막 코드

model.load_weights(checkpoint_path)

 

2번은 3가지 문제 중에 한가지 랜덤하게 나옴 (2가지 유형)

1) 이미지 분류 2개 - mnist 손글씨분류 / fashion mnist

2) 정형데이터 - iris 꽃 분류문제

 

 

이미지 rescale

픽셀들을 하나씩 까서 보면 0~255 사이의 값을 가지고 있다.

 

1. 모든 픽셀 값이 0~1 사이의 값을 가지도록 하자 = Normalization

x_train = x_train / 255.0

x_valid = x_valid / 255.0

 

y는 class값임 분류 값이므로 255로 나누어서는 안된다.

이미지 데이터인 x 에 대해서만 255로 나누어 rescale을 해준다.

Normalization을 해야하는 이유?

- 데이터 분산 값을 줄여줌으로서 원하는 목표 loss 까지 수렴이 더 빨리 된다. 

 

2. OneHot Encoding

 

빨강 1

노랑 2 

파랑 3

>>>>>>>>>>>>>

빨강 (1, 0, 0)

노랑 (0, 1, 0)

파랑 (0, 0, 1)

 

y.head() / y_train[0] 등과 같이 y값을 살짝 찍어보면, onehot 인코딩 여부를 확인 할 수 있다.

 

onehot 인코딩 된 Y 값 onehot 인코딩 안 된 Y값
[0,0,0,1,0] 3
[0,1,0,0,0] 1
[0,0,0,0,1] 4
[1,0,0,0,0] 5

Onehot 인코딩 하는 방법

print(tf.one_hot(y_train[0], 10))

print(tf.one_hot(y_train[0], 10))

 

3. 선형 / 비선형 번갈아가면서 사용하기

Dense 선형

Relu 비선형

 

tf.keras.layers.Dense(512)

tf.keras.layers.Relu(512)

 

tf.keras.layers.Dense(512, activation = 'relu') 와 같이 표현 가능

def relu(x):
    return np.maximum(x, 0)
    
x = np.linspace(-10, 10)
y = relu(x)

plt.figure(figsize=(10, 7))
plt.plot(x, y)
plt.title('ReLU activation function')
plt.show()

 

4. 마지막 Dense

분류해야할 클래스의 갯수와 맞춰서 써주기

tf.keras.layers.Dense(1, activation = 'sigmoid')

tf.keras.layers.Dense(10, activation= 'softmax')

 

 

5. 컴파일 주의사항

softmax => loss = 'sparse_categorical_crossentropy')

sigmoid => loss = 'binary_crossentropy'

 

***********************************************************************

이진분류 : 둘 중 하나 (ex) 개 / 고양이, 나비 / 벌 )

방법1)

Dense(1, activation = 'sigmoid')

loss = 'binary_crossentropy'

sigmoid 함수는 x에 어떤 값을 넣든지 y는 0과 1 사이의 값이 나온다.

이 함수가 이진 분류에서 사용된다면, y값이 0.5 를 기준으로 개/고양이 분류를 한다.

def sigmoid(z):
    return  1/(1+np.exp(-z))

plt.figure(figsize=(10, 7))

x = np.arange(-10, 10)
y = sigmoid(x)

plt.plot(x, y)
plt.show()

 

방법2)

Dense(2, activation = 'softmax')

loss = 'categorical_crossentropy' (y값이 onehot 인코딩 되어있을 때)

또는

loss = 'sparse_categorical_crossentropy' (y값이 onehot 인코딩 안되어 있을 때)

각각의 뉴런이 될 확률을 구해서 가장 큰 값을 가진 뉴런으로 분류

A가 될 확률 : 0.7 

B가 될 확률 : 0.2

C가 될 확률 : 0.1

 

--> A로 분류

import numpy as np

a = np.random.uniform(low=0.0, high=10.0, size=3)

def softmax(a) :
    exp_a = np.exp(a)
    sum_exp_a = np.sum(exp_a)
    y = exp_a / sum_exp_a
    return y

y = softmax(a)
print('Class 별 확률 값 출력')
print('===' * 10)
for i in range(3):
    print('Class {} 의 확률: {:.3f}'.format(i, y[i]))
print('===' * 10)
print('Class 별 확률 값의 합: {:.1f}'.format(y.sum()))

Flatten이란?

  • 고차원을 1D로 변환하여 Dense Layer에 전달해 주기 위하여 사용합니다.
  • 28 X 28 의 2D로 되어 있는 이미지를 784로 1D로 펼쳐 주는 작업입니다.

이미지는 2차원 데이터(2D)

2D데이터는 Dense Layer에 못들어간다. 

2차원 데이터를 1차원으로 변환해주어야 함

 

5. Model 만들기

model 정의 할 때 input_shape 잡는 법

input 으로 들어가는 x_train의 shape를 확인하면 된다. 해당 결과를 그대로 사용하면 된다 (28,28)

x_train[0].shape
model = Sequential([
    # Flatten으로 shape 펼치기
    Flatten(input_shape=(28, 28)),
    # Dense Layer
    Dense(1024, activation='relu'),
    Dense(512, activation='relu'),
    Dense(256, activation='relu'),
    Dense(128, activation='relu'),
    Dense(64, activation='relu'),
    # Classification을 위한 Softmax 
    Dense(10, activation='softmax'),
])

Dense 노드를 2의 제곱수로 잡는 이유? : GPU의 병렬처리를 할때 2의 제곱수가 좀 더 학습이 빠름

Dense 노드수가 줄어들게 쌓는 이유? : 논문 등에서 자주 사용되는 경향임. 가이드라인과 같은 역할. 상관없음.

 

 

6. Compile

metrics 에 accuracy 담기

model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['acc'])

loss = 'categorical_crossentropy'(잘못된 loss 함수)를 사용한다면, accuracy가 안올라감, 학습이 안되는 것

 

7. ModelCheckpoint: 체크포인트 생성

val_loss 기준으로 epoch 마다 최적의 모델을 저장하기 위하여, ModelCheckpoint를 만듭니다.

  • checkpoint_path는 모델이 저장될 파일 명을 설정합니다.
  • ModelCheckpoint을 선언하고, 적절한 옵션 값을 지정합니다.
checkpoint_path = "my_checkpoint.ckpt"
checkpoint = ModelCheckpoint(filepath=checkpoint_path, 
                             save_weights_only=True, 
                             save_best_only=True, 
                             monitor='val_loss', 
                             verbose=1)

 

8. 학습

  1. validation_data를 반드시 지정합니다.
  2. epochs을 적절하게 지정합니다. : 
  3. callbacks에 바로 위에서 만든 checkpoint를 지정합니다.

epoch은 감소하다가 다시 늘어나는 지점까지 충분히 주어야한다.

 

history = model.fit(x_train, y_train,
                    validation_data=(x_valid, y_valid),
                    epochs=20,
                    callbacks=[checkpoint],
                   )

 

1. Dense Layer (Fully Connected Layer)

: 완전히 연결된 레이어

각각의 노드들이 완전히 연결되어있는 레이어 = Dense Layer = Fully Connected Layer = FC

 

ㅇ 그림에서 보이는 하나의 동그라미는 = 노드 = 뉴런 이라고 한다.

ㅇ 그림에서 각각의 layer 마다 노드의 개수가 다르다. hidden layer1의 Dense는 4 

ㅇ input layer로 데이터가 들어와서 output layer로 데이터가 나간다.

ㅇ input layer에서는 input_shape를 명시해 주어야한다.

ㅇ 분류문제의 경우) output layer에서는 분류 class의 개수와 output layer의 노드의 개수가 일치해야한다.

    ex) 빨강/노랑/파랑 분류 문제시 output layer의 노드수는 3개

 

 

2. 위 그림의 모델을 코드화 해본다면 다음과 같다

import numpy as np
import tensorflow as tf
from tensorflow.keras.layers import Dense
from tensorflow.keras.models import Sequential

xs = np.array([-1.0, 0.0, 1.0, 2.0, 3.0, 4.0], dtype=float)
ys = np.array([5.0, 6.0, 7.0, 8.0, 9.0, 10.0], dtype=float)

model = Sequential([
    Dense(3, input_shape=[1]),
    Dense(4),
    Dense(4),
    Dense(1),
])

 

3. 컴파일하기 (optimizer와 loss 반드시 지정)

optimizer : 알고리즘, 어떤 알고리즘을 사용하여서 오차를 줄여나갈 것인가?

               ex) sgd : Stochastic Gradient Descent

loss : 오차값

               ex) mse : mean squered error

model.compile(optimizer='sgd', loss='mse')

 

4. 학습하기

순서대로 input 데이터 / output 데이터 / 학습시킬 횟수 / 진행상황 안보여줌

model.fit(xs, ys, epochs=1200, verbose=0)

 

5. 예측하기

# output
# 16.000046
model.predict([10.0])

결과적으로 y=x+6 일차함수를 예측하는 모델이므로 10을 넣었을때 y값이 16으로 잘 나오는 것을 확인할 수 있다.

+ Recent posts