Python(TensorFlow 프레임 워 크)이 손 으로 쓴 디지털 인식 시스템 을 실현 하 는 방법

핸드폰 디지털 식별 알고리즘 의 설계 와 실현
본 고 는 python 을 사용 하여 TensorFlow 를 바탕 으로 핸드폰 디지털 식별 알고리즘 을 설계 하고 GUI 인 터 페 이 스 를 프로 그래 밍 하여 핸드폰 디지털 식별 시스템 을 구축한다.이것 은 본인 의 본과 졸업 논문 과제 입 니 다.물론 이것 도 기계 학습 의 기본 적 인 문제 입 니 다.본 박문 은 논문 의 형식 으로 보 여주 지 않 고 프로 그래 밍 실전 으로 기계 학습 프로젝트 를 완성 하 는 측면 에서 묘사한다.
프로젝트 요구:본 고가 주로 해결 한 문 제 는 핸드폰 디지털 식별 이 고 최종 적 으로 식별 시스템 을 완성 해 야 한다.
식별 율 이 높 은 알고리즘 을 설계 하여 빠 른 식별 시스템 을 실현 하 다.
1.LeNet-5 모델 에 대한 소개
본 고 는 손 으로 쓴 디지털 인식 을 실현 하고 권 적 신경 망 을 사용 하 며 모델 링 사상 은 LeNet-5 에서 나온다.다음 그림 과 같다.

이것 은 핸드폰 디지털 인식 에 응 용 된 원시 적 인 네트워크 로 나 는 이것 도 가장 간단 한 깊이 있 는 네트워크 라 고 생각한다.
LeNet-5 는 입력 을 포함 하지 않 고 모두 7 층 으로 낮은 층 은 볼 륨 층 과 최대 풀 화 층 이 교체 되 어 구성 되 고 더 높 은 층 은 전체 연결 과 고 스 연결 이다.
LeNet-5 의 입력 은 BP 신경 망 과 다르다.여기 서 그림 이 흑백 이 라 고 가정 하면 LeNet-5 의 입력 은 32*32 의 2 차원 행렬 이다.동시에 입력 과 다음 층 은 모두 연 결 된 것 이 아니 라 희소 한 연결 을 한다.이 층 의 모든 신경원 의 입력 은 전 층 신경원 의 국부 구역 에서 나온다(5×5)볼 륨 은 원본 이미지 볼 륨 의 결과 에 해당 하 는 한도 값 을 추가 하고 얻 은 결 과 는 활성화 함수 처 리 를 거 쳐 출력 은 볼 륨 층(C 층)을 형성한다.볼 륨 층 의 모든 특징 맵 은 각자 가중치 와 한도 값 을 공유 하여 훈련 비용 을 크게 줄 일 수 있다.강 샘플링 층(S 층)은 데이터 양 을 줄 이 고 유용 한 정 보 를 저장 하기 위해 아 샘플링 을 한다.
첫 번 째 볼 륨 층(C1 층)은 6 개의 특징 맵 으로 구성 되 어 있 으 며,각 특징 맵 은 28 개 입 니 다.×28 의 신경원 진열,그 중 각 신경원 은 5 에서×5 구역 은 볼 륨 필 터 를 통 해 부분 적 특징 을 추출 합 니 다.일반적인 상황 에서 필터 의 수량 이 많 을 수록 더 많은 특징 맵 을 얻어 원시 이미지 의 특징 을 나타 낸다.이층 훈련 파라미터 총 6×(5×5+1)=156 개,픽 셀 마다 상층 5×5=25 개의 픽 셀 점 과 1 개의 한도 값 연결 계산 소득,총 28×28×156=122304 개의 연결.
S2 층 은 상기 6 가지 특징 에 대응 하 는 샘플링 층(pooling 층)입 니 다.pooling 층 의 실현 방법 은 두 가지 가 있 는데 그것 이 바로 max-poling 과 mean-poling 이 고 LeNet-5 는 mean-poling,즉 n 을 취한 다.×영역 내 픽 셀 의 평균 값C1 통과 2×2.창 영역 픽 셀 의 평균 값 을 구하 고 이 층 의 한도 값 을 더 한 다음 활성화 함수 의 처 리 를 통 해 S2 층 을 얻 을 수 있 습 니 다.pooling 의 실현 은 이미지 정 보 를 저장 하 는 토대 에서 가중치 파 라 메 터 를 줄 이 고 계산 원 가 를 낮 추 며 의합 도 제어 할 수 있 습 니 다.이 층 의 학습 매개 변 수 는 모두 1*6+6=12 개 이 고 S2 의 모든 픽 셀 은 C1 층 의 2 와 같 습 니 다.×2 개의 픽 셀 과 1 개의 한도 값 이 연결 되 어 있 으 며,모두 6 이다.×(2×2+1)×14×14=5880 개의 연결.
S2 층 과 C3 층 의 연결 은 비교적 복잡 하 다.C3 볼 륨 층 은 16 개 크기 에서 10 입 니 다.×10 의 특징 맵 으로 구성 되 어 있 으 며,그 중의 모든 특징 맵 과 S2 층 의 몇 가지 특징 맵 의 부분 적 인 느낌 야(크기 는 5 이다.×5)연결 되 어 있다.그 중에서 앞의 6 개의 특징 맵 은 S2 층 연속 3 개의 특징 맵 과 연결 되 고 뒤의 6 개의 맵 은 S2 층 의 연속 적 인 4 개의 특징 맵 과 연결 되 며 그 다음 의 3 개의 특징 맵 은 S2 층 의 불 연속 적 인 4 개의 특징 맵 과 연결 되 며 마지막 맵 은 S2 층 의 모든 특징 맵 과 연결된다.여기 볼 륨 핵 크기 는 5 입 니 다.×5,그래서 학습 매개 변 수 는 모두 6×(3×5×5+1)+9×(4×5×5+1)+1×(6×5×5+1)=1516 개의 인자.그림 크기 는 28 입 니 다.×28.그래서 모두 151600 개의 연결 이 있다.
S4 층 은 C3 층 에 대한 샘플링 으로 S2 와 같은 이치 로 학습 매개 변 수 는 16 이다.×1+16=32 개,동시에 총 16 개×(2×2+1)×5×5=2000 개 연결.
C5 층 은 120 개 크기 에서 1 입 니 다.×1 의 특징 맵 으로 구 성 된 볼 륨 층 이 고 S4 층 과 C5 층 이 모두 연결 되 어 있 기 때문에 학습 매개 변수 총 개 수 는 120 이다.×(16×25+1)=4 천 812 개.
F6 는 C5 와 모두 연 결 된 84 개의 신경 원 이기 때문에 모두 84 이다.×(120+1)=10164 개의 학습 매개 변수.
권 적 신경 망 은 희소 한 연결 과 공유 가중치 와 한도 값 을 통 해 계 산 된 비용 을 크게 줄 이 는 동시에 pooling 의 실현 은 어느 정도 의합 문제 의 발생 을 감소 시 켜 이미지 의 처리 와 식별 에 매우 적합 하 다.
2.손 으로 쓴 디지털 인식 알고리즘 모델 의 구축
2.1 각 층 의 디자인
제1 절의 기초 지식 을 가지 고 이 를 바탕 으로 보완 하고 개선 했다.
입력 계층 설계
입력 28×28 의 행렬 은 벡터 가 아니다.
함수 선택 활성화
Sigmoid 함 수 는 매 끄 러 움,노 스틱 성과 그 도체 가 자신 이 표시 할 수 있 는 장점 을 가지 지만 그 연산 은 지수 연산 과 관련 되 고 역방향 전파 로 오차 경도 를 구 할 때 구 도 는 곱 하기 연산 과 관련 되 며 계 산 량 이 상대 적 으로 크다.또한 본 고 에서 구축 한 2 층 권 적 층 과 샘플링 층 에 대해 sgmoid 함수 자체 의 특성 으로 인해 역방향 으로 전 파 될 때 경사도 가 사라 지 는 상황 이 나타 나 네트워크 의 훈련 을 완성 하기 어렵다.따라서 본 고가 디자인 한 네트워크 는 ReLU 함 수 를 활성화 함수 로 사용한다.
ReLU 의 표현 식:
볼 륨 디자인
본 고 는 볼 륨 신경 망 을 디자인 할 때 분 산 된 볼 륨 을 사용 하고 볼 륨 의 길 이 는 1 이다.즉,수평 과 수직 방향 이 매번 연산 이 끝나 면 픽 셀 을 이동 하 는 것 이다.볼 륨 핵 크기 5×5。
하강 샘플링 층
본 논문 의 샘플링 층 을 낮 추 는 pooling 방식 은 max-poling 이 고 크기 는 2 이다.×2。
출력 층 설계
출력 층 은 10 개의 신경 망 노드 로 설정 되 어 있다.숫자 0~9 의 목표 벡터 는 다음 표 와 같다.

2.2 네트워크 모델 의 전체적인 구조

사실은 본 고 네트워크 의 구축 은 TensorFlow 의 손 으로 쓴 디지털 인식 공식 튜 토리 얼 을 참고 하여 독자 들 이 관심 이 있 으 면 상세 하 게 읽 을 수 있다.
2.3 프로 그래 밍 실현 알고리즘
본 고 는 Python 을 사용 하여 TensorFlow 의 api 를 호출 하여 손 으로 쓴 숫자 인식 알고리즘 을 완성 합 니 다.
주:본 프로그램의 운영 환경 은 Win 10,python 3.5.2 입 니 다.물론 리 눅 스에 서도 실행 할 수 있 습 니 다.TensorFlow 는 py2 와 py3 를 잘 호 환 하기 때문에 리 눅 스에 서 python 2.7 에서 실행 할 수 있 습 니 다.

#!/usr/bin/env python2
# -*- coding: utf-8 -*-
"""
Created on Fri Feb 17 19:50:49 2017

@author: Yonghao Huang
"""

#import modules
import numpy as np
import matplotlib.pyplot as plt
#from sklearn.metrics import confusion_matrix
import tensorflow as tf
import time
from datetime import timedelta
import math
from tensorflow.examples.tutorials.mnist import input_data


def new_weights(shape):
  return tf.Variable(tf.truncated_normal(shape,stddev=0.05))
def new_biases(length):
  return tf.Variable(tf.constant(0.1,shape=length))
def conv2d(x,W):
  return tf.nn.conv2d(x,W,strides=[1,1,1,1],padding='SAME')
def max_pool_2x2(inputx):
  return tf.nn.max_pool(inputx,ksize=[1,2,2,1],strides=[1,2,2,1],padding='SAME')

#import data
data = input_data.read_data_sets("./data", one_hot=True) # one_hot means [0 0 1 0 0 0 0 0 0 0] stands for 2

print("Size of:")
print("--Training-set:\t\t{}".format(len(data.train.labels)))
print("--Testing-set:\t\t{}".format(len(data.test.labels)))
print("--Validation-set:\t\t{}".format(len(data.validation.labels)))
data.test.cls = np.argmax(data.test.labels,axis=1)  # show the real test labels: [7 2 1 ..., 4 5 6], 10000values

x = tf.placeholder("float",shape=[None,784],name='x')
x_image = tf.reshape(x,[-1,28,28,1])

y_true = tf.placeholder("float",shape=[None,10],name='y_true')
y_true_cls = tf.argmax(y_true,dimension=1)
# Conv 1
layer_conv1 = {"weights":new_weights([5,5,1,32]),
        "biases":new_biases([32])}
h_conv1 = tf.nn.relu(conv2d(x_image,layer_conv1["weights"])+layer_conv1["biases"])
h_pool1 = max_pool_2x2(h_conv1)
# Conv 2
layer_conv2 = {"weights":new_weights([5,5,32,64]),
        "biases":new_biases([64])}
h_conv2 = tf.nn.relu(conv2d(h_pool1,layer_conv2["weights"])+layer_conv2["biases"])
h_pool2 = max_pool_2x2(h_conv2)
# Full-connected layer 1
fc1_layer = {"weights":new_weights([7*7*64,1024]),
      "biases":new_biases([1024])}
h_pool2_flat = tf.reshape(h_pool2,[-1,7*7*64])
h_fc1 = tf.nn.relu(tf.matmul(h_pool2_flat,fc1_layer["weights"])+fc1_layer["biases"])
# Droupout Layer
keep_prob = tf.placeholder("float")
h_fc1_drop = tf.nn.dropout(h_fc1,keep_prob)
# Full-connected layer 2
fc2_layer = {"weights":new_weights([1024,10]),
       "biases":new_weights([10])}
# Predicted class
y_pred = tf.nn.softmax(tf.matmul(h_fc1_drop,fc2_layer["weights"])+fc2_layer["biases"]) # The output is like [0 0 1 0 0 0 0 0 0 0]
y_pred_cls = tf.argmax(y_pred,dimension=1) # Show the real predict number like '2'
# cost function to be optimized
cross_entropy = -tf.reduce_mean(y_true*tf.log(y_pred))
optimizer = tf.train.AdamOptimizer(learning_rate=1e-4).minimize(cross_entropy)
# Performance Measures
correct_prediction = tf.equal(y_pred_cls,y_true_cls)
accuracy = tf.reduce_mean(tf.cast(correct_prediction,"float"))
with tf.Session() as sess:
  init = tf.global_variables_initializer()
  sess.run(init)
  train_batch_size = 50
  def optimize(num_iterations):
    total_iterations=0
    start_time = time.time()
    for i in range(total_iterations,total_iterations+num_iterations):
      x_batch,y_true_batch = data.train.next_batch(train_batch_size)
      feed_dict_train_op = {x:x_batch,y_true:y_true_batch,keep_prob:0.5}
      feed_dict_train = {x:x_batch,y_true:y_true_batch,keep_prob:1.0}
      sess.run(optimizer,feed_dict=feed_dict_train_op)
      # Print status every 100 iterations.
      if i%100==0:
        # Calculate the accuracy on the training-set.
        acc = sess.run(accuracy,feed_dict=feed_dict_train)
        # Message for printing.
        msg = "Optimization Iteration:{0:>6}, Training Accuracy: {1:>6.1%}"
        # Print it.
        print(msg.format(i+1,acc))
    # Update the total number of iterations performed
    total_iterations += num_iterations
    # Ending time
    end_time = time.time()
    # Difference between start and end_times.
    time_dif = end_time-start_time
    # Print the time-usage
    print("Time usage:"+str(timedelta(seconds=int(round(time_dif)))))
  test_batch_size = 256
  def print_test_accuracy():
    # Number of images in the test-set.
    num_test = len(data.test.images)
    cls_pred = np.zeros(shape=num_test,dtype=np.int)
    i = 0
    while i < num_test:
      # The ending index for the next batch is denoted j.
      j = min(i+test_batch_size,num_test)
      # Get the images from the test-set between index i and j
      images = data.test.images[i:j, :]
      # Get the associated labels
      labels = data.test.labels[i:j, :]
      # Create a feed-dict with these images and labels.
      feed_dict={x:images,y_true:labels,keep_prob:1.0}
      # Calculate the predicted class using Tensorflow.
      cls_pred[i:j] = sess.run(y_pred_cls,feed_dict=feed_dict)
      # Set the start-index for the next batch to the
      # end-index of the current batch
      i = j
    cls_true = data.test.cls
    correct = (cls_true==cls_pred)
    correct_sum = correct.sum()
    acc = float(correct_sum) / num_test
    # Print the accuracy
    msg = "Accuracy on Test-Set: {0:.1%} ({1}/{2})"
    print(msg.format(acc,correct_sum,num_test))
  # Performance after 10000 optimization iterations
  optimize(num_iterations=10000)
  print_test_accuracy()
  savew_hl1 = layer_conv1["weights"].eval()
  saveb_hl1 = layer_conv1["biases"].eval()
  savew_hl2 = layer_conv2["weights"].eval()
  saveb_hl2 = layer_conv2["biases"].eval()
  savew_fc1 = fc1_layer["weights"].eval()
  saveb_fc1 = fc1_layer["biases"].eval()
  savew_op = fc2_layer["weights"].eval()
  saveb_op = fc2_layer["biases"].eval()

  np.save("savew_hl1.npy", savew_hl1)
  np.save("saveb_hl1.npy", saveb_hl1)
  np.save("savew_hl2.npy", savew_hl2)
  np.save("saveb_hl2.npy", saveb_hl2)
  np.save("savew_hl3.npy", savew_fc1)
  np.save("saveb_hl3.npy", saveb_fc1)
  np.save("savew_op.npy", savew_op)
  np.save("saveb_op.npy", saveb_op)

실행 결과:테스트 집중 정확도 가 99.2%로 나 타 났 다.
나 는 일부 잘못된 그림 을 식별 할 수 있 는 보조 함수 도 썼 다.

헷 갈 리 는 행렬 도 볼 수 있 고,

2.3 핸드폰 인식 시스템 실현
마지막 으로 훈련 된 매개 변 수 를 저장 하고 GUI 인터페이스 에 봉 하여 손 글씨 인식 시스템 을 형성한다.

시스템 에 이미지 전처리 작업 도 추가 되 었 는데 예 를 들 어 그 레이스 케 일 화,이미지 정보의 획일 화 등 이 실제 응용 에 더욱 가깝다.
시스템 은 빠 른 식별 을 할 수 있 는데 다음 과 같다.

3 총화
본 고가 실현 한 시스템 은 사실 권 적 신경 네트워크 를 바탕 으로 하 는 핸드폰 디지털 식별 시스템 이다.이 시스템 은 손 으로 쓴 디지털 인식 을 신속하게 실현 하여 식별 율 이 높다.단점:하나의 숫자 만 정확하게 식별 할 수 있 고 이미지 의 예비 처리 가 부족 하 며 이미지 분할 을 하지 않 으 면 독자 도 스스로 추가 하여 보완 할 수 있다.
수확
저 는 예전 에 대학 에 다 닐 때 고수,선형 대수 와 확률 론 을 열심히 공 부 했 지만 기계 공 부 를 열심히 하지 않 았 습 니 다.저 는 2017 년 에 야 기계 학습 과 관련 된 지식 을 체계적으로 공 부 했 고 대학 졸업 논문 도 관련 과 제 를 선 택 했 습 니 다.비록 기초 에 비해 열심히 공부 한 후에 실제 적 인 만족 감 을 느 꼈 습 니 다.또한 저 에 게 더욱 깊이 있 는 이론 학습 과 실천 연 구 를 하고 모든 독자 와 격려 하도록 격려 했 습 니 다.
이상 이 바로 본 고의 모든 내용 입 니 다.여러분 의 학습 에 도움 이 되 고 저 희 를 많이 응원 해 주 셨 으 면 좋 겠 습 니 다.