tensorflow 2.0 학습 (4 개)

mnist의 연구는 연구의 정확성을 살펴보고, 테스트 세트에 합류, 다음 코드

# 인코딩 :. UTF 8- 

오기 TF AS tensorflow
 임포트 AS PLT의 matplotlib.pyplot 

#의 로드 MNIST 훈련 데이터베이스를 다운로드 60000 10000 시험 각 사이즈 (28, 28) 
경로 R & LT = ' G : \ 2,019 \ 파이썬 \ MNIST .npz ' 
(x_train, y_train) (x_test, android.permission.FACTOR.) = tf.keras.datasets.mnist.load_data (경로) 

# 1 입력 층 (256), 제 2 출력 (128), 제 10 층 출력 
# , II 세 파라미터 B, W 
W1 = tf.Variable (tf.random.truncated_normal ([784, 256], STDDEV = 0.1))     # 통상 하나의 
B1 = tf.Variable (tf.zeros ([256 ] )) 
의 W2 = tf.Variable (tf.random.truncated_normal ([256, 128], STDDEV = 0.1 )) 
B2Tf.Variable = (tf.zeros ([128 ])) 
W3 = tf.Variable (tf.random.truncated_normal ([128, 10], STDDEV = 0.1 )) 
B3 = tf.Variable (tf.zeros ([10 ] )) 

# 두 데이터 전처리 방법 
# (a) 훈련 데이터 전처리 
X = tf.convert_to_tensor을 (x_train, DTYPE = tf.float32) / 255     # 0 :. 1; 훈련 -1 :. 1 (적합하지 정확한 높지) 
X = tf.reshape (X, [-1, 28 * 28 ]) 
Y = tf.convert_to_tensor (y_train, DTYPE = tf.int32) 
Y = tf.one_hot (Y, 깊이 = 10 )
 # 60,000 트레이닝 데이터 세트는 데이터 (100) (600 개)의 그룹으로 분할되고 
train_db = tf.data.Dataset.from_tensor_slices ((X, Y)) 
train_db = train_db.shuffle (60000)      # 가능한 샘플 공간으로 컸다 
train_db = train_db.batch (100)           # 128 


# (b) 미리 정의 된 테스트 기능 이후 
DEF 전처리 (X, Y) : 
    X = tf.cast (X, DTYPE = tf.float32) / 255      # 다음 0-1로 정규화 float32에 제 타입 
    X = tf.reshape (X는, [-1, 28 * 28])               # 1 대체품 -1 784 일차원으로, X의 수를 알지 못하는 데이터 
    Y = tf.cast (Y, DTYPE = tf.int32)               #는 32 개의 정수로 변환 
    Y = tf.one_hot (Y, 깊이 = 10)                  # 필요한 트레이닝 데이터 하나 핫 부호화 
    복귀 X, Y의 

# 1 것 전처리 테스트 데이터 세트 10,000 
TEST_DB = tf.data.Dataset.from_tensor_slices ((x_test, android.permission.FACTOR.)) 
TEST_DB을Test_db.shuffle = (10000 ) 
TEST_DB = test_db.batch (100)         # 128 
TEST_DB = test_db.map (전처리) 

LR = 0.001       # 학습 속도 
손실 = []      #의 각 에포크의 기억 손실 값이 쉽게 배우고 관찰 
도 Acc = ]         #의 정확성 

에 대한 에포크  범위 (30) :      # 20이다 
    # 일회용 처리 (100) (X, Y) 데이터 세트 
    에 대한 공정과, (X, Y) 에서 다음 열거 (train_db)     #의 이송 양호한 데이터 분할 단계 : 0 -> 599 
        : 테이프 AS tf.GradientTape ()와
             #의 확산 전진 1, 둘, 셋
            X @ + = W1 H1은 tf.broadcast_to들 (B1, [x.shape [0, 256])   #가 B1 +에 직접 기록 할 수 
            H1 =의 tf.nn.relu (의 H1) 
            H2 의 + H1의 = @ W2 B2 
            H2 = TF한다. nn.relu (H2) 
            OUT = W3 + H2 @ B3 

            # 계산 된 MSE의 
            손실 tf.square = (Y - OUT) 
            손실 = tf.reduce_mean 손익
         # 계산 그래디언트 파라미터 tape.gradient 자동 유도 함수 손실 타겟 데이터 객체는 참값에 가까운 그것을 만들 
        래드 = tape.gradient (손실 [W1, B1, B2의 W2, W3, B3])
         #의 갱신 W, B의 
        w1.assign_sub을 (LR * 래드 [0] )   #주어진 값에 의해 원위치이 파라미터를 달성하기 위해 자기 - 갱신 
        b1.assign_sub (LR * 래드 [. 1 ]) 
        w2.assign_sub (LR * 래드 [2 ]) 
        b2.assign_sub (LR * 래드 [. 3 ]) 
        w3.assign_sub (LR * 래드 [4. ]) 
        b3.assign_sub (LR * 래드 [5. ])
         # 관찰 학습 
        IF STEP 100 % == 0 :
             전단 ( ' 교육 ' , 에포크, ' ' , ' 첫번째 ' , STEP , ' 단계 ' , ' 손실 : ' , 부동 소수점 (손실))
            losses.append (플로트 (손실))           # 각 경우에 저장 한 후, 최종 관찰 100step 손실 

        IF STEP 500 % == 0 : 
            합계 total_correct = 0의 0으로의
             대한 X, Y TEST_DB : 
                의 H1 = X @ W1 + B1 
                H1의 = tf.nn.relu (의 H1) 
                H2 = @ W2 + H1 중 B2 
                H2 = tf.nn.relu (H2) 
                OUT = W3 + H2 @ B3 

                Pred를 가산 = tf.argmax (OUT, 축 =. 1)   # 가장 가능성 카테고리를 선택
                tf.argmax = Y (Y = 축. 1)   #는 역 비슷 하나 핫 부호화 
                올바른 tf.equal = (Pred를 가산하여, Y)   # 예측 값과 실제 값과 동일 비교 
                합계 + = x.shape [0]
                 # 통계 정확한 수 
                total_correct + = tf.reduce_sum (tf.cast (올바른 DTYPE = tf.int32)). NumPy와 ()
             전단 ( ' 교육 ' , 에포크, ' ' , ' 첫번째 ' 단계, ' 단계 , ' , ' ACC는 평가 : ' , total_correct / 총)
            acc.append (total_correct/ 전체) 

#에 plt.subplot (121) 
X1 = [I (100) * 대한 I 범위 (렌 (손실))] 
plt.plot (X1, 손실, 마커 = ' S ' , 라벨 = ' 교육 ' ) 
plt.xlabel ( " 단계 " ) 
plt.ylabel ( ' MSE ' ) 
plt.legend () 
#에 plt.savefig ( 'exam_mnist_forward.png') 
#의 plt.show () 

#에 plt.subplot (122) 
plt.figure () 
X2 = I 에 대한범위 (렌 (ACC))] 
plt.plot (X2, ACC, ' R ' , 마커 = ' D ' , 라벨 = ' 검사 ' ) 
plt.xlabel를 ( " 단계 " ) 
plt.ylabel ( ' 정확도 ' ) 
PLT. 전설 () 
#의 plt.savefig ( 'test_mnist_forward.png') 
plt.show ()

무엇 정확도 오류를 다음과

이 책과 비슷한 찾았지만, 다음 사항에 유의하십시오

(1) 사전 처리 된 데이터를, 큰 데이터 공간으로 구분 값을 선택하는 단계;

대신에 (-1 : 1)의 데이터 처리 선택기 0-1과 (2)에, 후자는 바람직 학습 효율 아니므!

(3) 코드는 최적화 될 수있다!

전반적으로, 코드는 간단한 사용하고 더 이해하기 쉽습니다!

다음 업데이트 완전히 연결 네트워크, 자동차의 연료 소비에 대한 예측.

추천

출처www.cnblogs.com/heze/p/12081024.html