이미지 분류는 아기도 몇 초만에 할 수있는 작업이지만, 기계의 경우 최근 발전하기 전까지는 어려운 작업이었습니다. 과 딥 러닝 . 자율 주행 차는 실시간으로 물체를 감지하고 필요한 조치를 취할 수 있습니다. 이미지 분류. 이 기사에서는 다음 주제에 대해 설명합니다.
요리사는 오케스트레이션 도구입니다.
TensorFlow 란 무엇입니까?
TensorFlow 다양한 작업에서 데이터 흐름 프로그래밍을위한 Google의 오픈 소스 머신 러닝 프레임 워크입니다. 그래프의 노드는 수학적 연산을 나타내고 그래프 에지는 노드간에 전달되는 다차원 데이터 배열을 나타냅니다.
텐서는 2 차원 테이블을 더 높은 차원의 데이터로 확장 한 다차원 배열입니다. 딥 러닝에 적합한 Tensorflow의 많은 기능이 있으며 핵심 오픈 소스 라이브러리는 ML 모델을 개발하고 학습하는 데 도움이됩니다.
이미지 분류 란 무엇입니까?
이미지 분류의 목적은 디지털 이미지의 모든 픽셀을 여러 픽셀 중 하나로 분류하는 것입니다. 토지 피복 클래스 또는 테마 . 이 분류 된 데이터를 사용하여 주제별지도 이미지에있는 토지 피복의.
이제 분류 중 분석가와 컴퓨터 간의 상호 작용에 따라 두 가지 유형의 분류가 있습니다.
- 감독 및
- 감독되지 않음
따라서 시간을 낭비하지 않고 TensorFlow 이미지 분류로 이동하겠습니다. 두 가지 예가 있습니다 : 쉽고 어렵습니다. 쉬운 것으로 진행하겠습니다.
TensorFlow 이미지 분류 : 패션 MNIST
Fashion MNIST 데이터 세트
여기서는 10 개 범주의 70,000 회색조 이미지를 포함하는 Fashion MNIST 데이터 세트를 사용합니다. 교육용으로 60000을 사용하고 테스트 용으로 나머지 10000을 사용합니다. TensorFlow에서 직접 Fashion MNIST에 액세스하고 데이터를 가져 와서로드 할 수 있습니다.
- 먼저 라이브러리를 가져 오겠습니다.
from __future__ import absolute_import, division, print_function # TensorFlow and tf.keras import tensorflow as tf from tensorflow import keras # Helper libraries import numpy as np import matplotlib.pyplot as plt
- 데이터를로드하겠습니다.
fashion_mnist = keras.datasets.fashion_mnist (train_images, train_labels), (test_images, test_labels) = fashion_mnist.load_data ()
- 다음으로 이미지를 클래스에 매핑합니다.
class_names = [ '티셔츠 / 상판', '바지', '풀오버', '드레스', '코트', '샌들', '셔츠', '운동화', '가방', '발목 부츠']
- 데이터 탐색
train_images.모양
# 각 레이블은 0-9 사이입니다.
train_labels
test_images.모양
- 이제 데이터를 사전 처리 할 때입니다.
plt.그림() plt.imshow(train_images[0]) plt.컬러 바() plt.그리드(그릇된) plt.보여 주다()
#학습 세트의 첫 번째 이미지를 검사하면 픽셀 값이 0에서 255 사이의 범위에 있음을 알 수 있습니다.
- 이미지를 0-1에서 신경망에 공급하기 위해 크기를 조정해야합니다.
train_images = train_images / 255.0 test_images = test_images / 255.0
- 몇 가지 이미지를 표시하겠습니다.
plt.그림(무화과=(10,10)) ...에 대한 나는 에 범위(25) : plt.서브 플롯(5,5,나는+하나) plt.xticks([]) plt.이 틱스([]) plt.그리드(그릇된) plt.imshow(train_images[나는], cmap=plt.센티미터.바이너리) plt.xlabel(class_names[train_labels[나는]]) plt.보여 주다()
- 레이어 설정
모델 = 단단한.잇달아 일어나는([ 단단한.레이어.단조롭게 하다(input_shape=(28, 28)), 단단한.레이어.밀집한(128, 활성화=tf.nos.Relu), 단단한.레이어.밀집한(10, 활성화=tf.nos.소프트 맥스) ])
- 모델 컴파일
모델.엮다(최적화 프로그램='아담', 손실='sparse_categorical_crossentropy', 메트릭=['정확성'])
- 모델 훈련
모델.적당한(train_images, train_labels, 신기원=10)
- 정확도 평가
테스트 손실, test_acc = 모델.평가하다(test_images, test_labels) 인쇄('테스트 정확도 :', test_acc)
- 예측하기
예측 = 모델.예측하다(test_images)
예측[0]
예측은 10 개의 숫자로 구성된 배열입니다. 이들은 이미지가 10 개의 서로 다른 의류 품목 각각에 해당한다는 모델의 '신뢰'를 설명합니다. 신뢰도 값이 가장 높은 레이블을 확인할 수 있습니다.
예 :.argmax(예측[0])# 모델은 앵클 부츠라고 가장 자신합니다. 그것이 맞는지 보자출력 : 9
test_labels[0]
출력 : 9
Windows 10에 PHP 설치
- 이제 10 개 채널의 전체 세트를 살펴볼 시간입니다.
데프 plot_image(나는, predicts_array, true_label, img) : predicts_array, true_label, img = predicts_array[나는], true_label[나는], img[나는] plt.그리드(그릇된) plt.xticks([]) plt.이 틱스([]) plt.imshow(img, cmap=plt.센티미터.바이너리) predicted_label = 예 :.argmax(predicts_array) 만약 predicted_label == true_label: 색깔 = '초록' 그밖에: 색깔 = '그물' plt.xlabel('{} {: 2.0f}% ({}) '.체재(class_names[predicted_label], 100*예 :.최대(predicts_array), class_names[true_label]), 색깔=색깔) 데프 plot_value_array(나는, predicts_array, true_label) : predicts_array, true_label = predicts_array[나는], true_label[나는] plt.그리드(그릇된) plt.xticks([]) plt.이 틱스([]) 이 줄거리 = plt.바(범위(10), predicts_array, 색깔='# 777777') plt.일림([0, 하나]) predicted_label = 예 :.argmax(predicts_array) 이 줄거리[predicted_label].set_color('그물') 이 줄거리[true_label].set_color('초록')
- 먼저 0 번째와 10 번째 이미지를 보겠습니다
나는 = 0 plt.그림(무화과=(6,삼)) plt.서브 플롯(하나,2,하나) plot_image(나는, 예측, test_labels, test_images) plt.서브 플롯(하나,2,2) plot_value_array(나는, 예측, test_labels) plt.보여 주다()
나는 = 10 plt.그림(무화과=(6,삼)) plt.서브 플롯(하나,2,하나) plot_image(나는, 예측, test_labels, test_images) plt.서브 플롯(하나,2,2) plot_value_array(나는, 예측, test_labels) plt.보여 주다()
- 이제 여러 이미지와 그 예측을 플로팅 해 보겠습니다. 올바른 것은 녹색이고 잘못된 것은 빨간색입니다.
num_rows = 5 num_cols = 삼 num_images = num_rows*num_cols plt.그림(무화과=(2*2*num_cols, 2*num_rows)) ...에 대한 나는 에 범위(num_images) : plt.서브 플롯(num_rows, 2*num_cols, 2*나는+하나) plot_image(나는, 예측, test_labels, test_images) plt.서브 플롯(num_rows, 2*num_cols, 2*나는+2) plot_value_array(나는, 예측, test_labels) plt.보여 주다()
- 마지막으로 학습 된 모델을 사용하여 단일 이미지에 대한 예측을 수행합니다.
# 테스트 데이터 세트에서 이미지 가져 오기 img = test_images[0] 인쇄(img.모양)
# 이미지를 유일한 구성원 인 배치에 추가합니다. img = (예 :.expand_dims(img,0)) 인쇄(img.모양)
예측 _ 단일 = 모델.예측하다(img) 인쇄(예측 _ 단일)plot_value_array(0, 예측 _ 단일, test_labels) plt.xticks(범위(10), class_names, 회전=오분의 사) plt.보여 주다()
예측 _ 결과 = 예 :.argmax(예측 _ 단일[0])
출력 : 9
CIFAR-10 : CNN
CIFAR-10 데이터 세트는 비행기, 개, 고양이 및 기타 개체로 구성됩니다. 이미지를 전처리 한 다음 모든 샘플에서 컨볼 루션 신경망을 훈련시킵니다. 이미지를 정규화하고 라벨을 원-핫 인코딩해야합니다. 이 사용 사례는 TensorFlow 이미지 분류에 대한 의심을 분명히 해소 할 것입니다.
- 데이터 다운로드
...에서 urllib.request 수입 urlretrieve ...에서 os.path 수입 isfile, 그을음이다 ...에서 tqdm 수입 tqdm 수입 tarfile cifar10_dataset_folder_path = 'cifar-10-batches-py' 수업 다운로드(tqdm) : last_block = 0 데프 훅(본인, block_num=하나, block_size=하나, 총합 크기=없음) : 본인.합계 = 총합 크기 본인.최신 정보((block_num - 본인.last_block) * block_size) 본인.last_block = block_num '' ' 데이터 (zip) 파일이 이미 다운로드되었는지 확인 그렇지 않은 경우 'https://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz'에서 다운로드하고 cifar-10-python.tar.gz로 저장합니다. '' ' 만약 아니 isfile('cifar-10-python.tar.gz') : 와 다운로드(단위='비', 단위 _ 규모=진실, miniters=하나, desc='CIFAR-10 데이터 세트') 같이 pbar: urlretrieve( 'https://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz', 'cifar-10-python.tar.gz', pbar.훅) 만약 아니 그을음이다(cifar10_dataset_folder_path) : 와 tarfile.열다('cifar-10-python.tar.gz') 같이 타르: 타르.Extractall() 타르.닫기()
- 필요한 라이브러리 가져 오기
수입 간물 수입 numpy 같이 예 : 수입 matplotlib.pyplot 같이 plt
- 데이터 이해
데이터의 원래 배치는 numpy 배열로 표현 된 10000x3072 텐서이며, 여기서 10000은 샘플 데이터의 수입니다. 이미지는 색상이 있으며 크기는 32 × 32입니다. 공급은 (너비 x 높이 x num_channel) 또는 (num_channel x 너비 x 높이) 형식으로 수행 할 수 있습니다. 레이블을 정의하겠습니다.
데프 load_label_names() : 반환 ['비행기', '자동차', '새', '고양이', '사슴', '개', '개구리', '말', '배', '트럭']
- 데이터 재구성
우리는 두 단계로 데이터를 재구성 할 것입니다.
먼저 행 벡터 (3072)를 3 개로 나눕니다. 각 조각은 각 채널에 해당합니다. 결과적으로 텐서의 (3 x 1024) 차원이 생성됩니다. 그런 다음 이전 단계에서 얻은 텐서를 32로 나눕니다. 여기서 32는 이미지의 너비를 의미합니다. 결과는 (3x32x32)입니다.
둘째, 데이터를 (num_channel, width, height)에서 (width, height, num_channel)로 전치해야합니다. 이를 위해 우리는 전치 기능을 사용할 것입니다.
데프 load_cfar10_batch(cifar10_dataset_folder_path, batch_id) : 와 열다(cifar10_dataset_folder_path + '/ data_batch_' + 피(batch_id), 방법='rb') 같이 파일: # 인코딩 유형은 'latin1'입니다. 일괄 = 간물.하중(파일, 부호화='라틴 1') 풍모 = 일괄['데이터'].모양을 바꾸다((len(일괄['데이터']), 삼, 32, 32)).바꾸어 놓다(0, 2, 삼, 하나) 라벨 = 일괄['라벨'] 반환 풍모, 상표
- 데이터 탐색
데프 display_stats(cifar10_dataset_folder_path, batch_id, sample_id) : 풍모, 라벨 = load_cfar10_batch(cifar10_dataset_folder_path, batch_id) 만약 아니 (0 <= sample_id < len(풍모)) : 인쇄('{}일괄 샘플{}.{}범위를 벗어났습니다. '.체재(len(풍모), batch_id, sample_id)) 반환 없음 인쇄(' 배치 번호 통계{}: '.체재(batch_id)) 인쇄('샘플 수 :{} '.체재(len(풍모))) label_names = load_label_names() label_counts = dict(지퍼(*예 :.독특한(라벨, return_counts=진실))) ...에 대한 키, 값 에 label_counts.항목() : 인쇄('의 라벨 수 [{}] ({}) :{}'.체재(키, label_names[키].높은(), 값)) sample_image = 풍모[sample_id] 샘플 _ 라벨 = 라벨[sample_id] 인쇄(' 이미지 예{}: '.체재(sample_id)) 인쇄('이미지-최소값 :{}최대 값 :{}'.체재(sample_image.분(), sample_image.최대())) 인쇄('이미지-모양 :{}'.체재(sample_image.모양)) 인쇄('라벨-라벨 ID :{}이름:{}'.체재(샘플 _ 라벨, label_names[샘플 _ 라벨])) plt.imshow(sample_image)
%matplotlib 인라인 %구성 인라인 백엔드.figure_format = '망막' 수입 numpy 같이 예 : # 데이터 세트 탐색 batch_id = 삼 sample_id = 7000 display_stats(cifar10_dataset_folder_path, batch_id, sample_id)
- 전처리 기능 구현
최소-최대 정규화를 통해 데이터를 정규화 할 것입니다. 이것은 단순히 모든 x 값을 0과 1 사이의 범위로 만듭니다.
y = (x- 분) / (최대-최소)
데프 정규화하다(엑스) : '' ' 논의 -x : numpy 배열의 입력 이미지 데이터 [32, 32, 3] 반환 -정규화 된 x '' ' min_val = 예 :.분(엑스) max_val = 예 :.최대(엑스) 엑스 = (엑스-min_val) / (max_val-min_val) 반환 엑스
- 원-핫 인코딩
데프 one_hot_encode(엑스) : '' ' 논의 -x : 라벨 목록 반환 -핫 인코딩 매트릭스 1 개 (레이블 수, 클래스 수) '' ' 인코딩 = 예 :.0((len(엑스), 10)) ...에 대한 idx, 시간 에 세다(엑스) : 인코딩[idx] [시간] = 하나 반환 인코딩
- 데이터 전처리 및 저장
데프 _preprocess_and_save(정규화하다, one_hot_encode, 풍모, 라벨, 파일 이름) : 풍모 = 정규화하다(풍모) 라벨 = one_hot_encode(라벨) 간물.덤프((풍모, 라벨), 열다(파일 이름, 'wb')) 데프 preprocess_and_save_data(cifar10_dataset_folder_path, 정규화하다, one_hot_encode) : n_batches = 5 valid_features = [] valid_labels = [] ...에 대한 batch_i 에 범위(하나, n_batches + 하나) : 풍모, 라벨 = load_cfar10_batch(cifar10_dataset_folder_path, batch_i) # 배치의 전체 데이터 세트에서 유효성 검사 데이터로 포인트가 될 인덱스를 찾습니다 (10 %). index_of_validation = int(len(풍모) * 0.1) # 배치의 전체 데이터 세트의 90 %를 전처리합니다. #-기능 정규화 #-라벨을 one_hot_encode #- 'preprocess_batch_'+ batch_number라는 새 파일에 저장 #-각 배치에 대한 각 파일 _preprocess_and_save(정규화하다, one_hot_encode, 풍모[:-index_of_validation], 라벨[:-index_of_validation], '전처리 _ 배치 _' + 피(batch_i) + '.피') # 훈련 데이터 세트와 달리 검증 데이터 세트는 모든 배치 데이터 세트를 통해 추가됩니다. #-배치의 전체 데이터 세트의 10 %를 가져옵니다. #-목록에 추가 #-유효한 _ 기능 #-유효한 _ 라벨 valid_features.넓히다(풍모[-index_of_validation:]) valid_labels.넓히다(라벨[-index_of_validation:]) # 모든 누적 유효성 검사 데이터 세트를 전처리합니다. _preprocess_and_save(정규화하다, one_hot_encode, 예 :.정렬(valid_features), 예 :.정렬(valid_labels), 'preprocess_validation.p') # 테스트 데이터 셋로드 와 열다(cifar10_dataset_folder_path + '/ 테스트 _ 배치', 방법='rb') 같이 파일: 일괄 = 간물.하중(파일, 부호화='라틴 1') # 테스트 데이터 전처리 test_features = 일괄['데이터'].모양을 바꾸다((len(일괄['데이터']), 삼, 32, 32)).바꾸어 놓다(0, 2, 삼, 하나) test_labels = 일괄['라벨'] # 모든 테스트 데이터 전처리 및 저장 _preprocess_and_save(정규화하다, one_hot_encode, 예 :.정렬(test_features), 예 :.정렬(test_labels), 'preprocess_training.p')
preprocess_and_save_data(cifar10_dataset_folder_path, 정규화하다, one_hot_encode)
- 검문소
수입 간물 valid_features, valid_labels = 간물.하중(열다('preprocess_validation.p', 방법='rb'))
- 네트워크 구축
전체 모델은 총 14 개의 레이어로 구성됩니다.
수입 텐서 플로우 같이 tf 데프 conv_net(엑스, keep_prob) : conv1_filter = tf.변하기 쉬운(tf.truncated_normal(모양=[삼, 삼, 삼, 64], 평균=0, stddev=0.08)) conv2_filter = tf.변하기 쉬운(tf.truncated_normal(모양=[삼, 삼, 64, 128], 평균=0, stddev=0.08)) conv3_filter = tf.변하기 쉬운(tf.truncated_normal(모양=[5, 5, 128, 256], 평균=0, stddev=0.08)) conv4_filter = tf.변하기 쉬운(tf.truncated_normal(모양=[5, 5, 256, 512], 평균=0, stddev=0.08)) # 1, 2 conv1 = tf.nos.conv2d(엑스, conv1_filter, 보폭=[하나,하나,하나,하나], 심='같은') conv1 = tf.nos.Relu(conv1) conv1_pool = tf.nos.max_pool(conv1, ksize=[하나,2,2,하나], 보폭=[하나,2,2,하나], 심='같은') conv1_bn = tf.레이어.배치 _ 정규화(conv1_pool) # 3. 4 conv2 = tf.nos.conv2d(conv1_bn, conv2_filter, 보폭=[하나,하나,하나,하나], 심='같은') conv2 = tf.nos.Relu(conv2) conv2_pool = tf.nos.max_pool(conv2, ksize=[하나,2,2,하나], 보폭=[하나,2,2,하나], 심='같은') conv2_bn = tf.레이어.배치 _ 정규화(conv2_pool) # 5, 6 conv3 = tf.nos.conv2d(conv2_bn, conv3_filter, 보폭=[하나,하나,하나,하나], 심='같은') conv3 = tf.nos.Relu(conv3) conv3_pool = tf.nos.max_pool(conv3, ksize=[하나,2,2,하나], 보폭=[하나,2,2,하나], 심='같은') conv3_bn = tf.레이어.배치 _ 정규화(conv3_pool) 7, 8 위 conv4 = tf.nos.conv2d(conv3_bn, conv4_filter, 보폭=[하나,하나,하나,하나], 심='같은') conv4 = tf.nos.Relu(conv4) conv4_pool = tf.nos.max_pool(conv4, ksize=[하나,2,2,하나], 보폭=[하나,2,2,하나], 심='같은') conv4_bn = tf.레이어.배치 _ 정규화(conv4_pool) # 9 플랫 = tf.기여하다.레이어.단조롭게 하다(conv4_bn) # 10 full1 = tf.기여하다.레이어.완전히 연결됨(입력=플랫, num_outputs=128, activation_fn=tf.nos.Relu) full1 = tf.nos.탈락(full1, keep_prob) full1 = tf.레이어.배치 _ 정규화(full1) # 열한 full2 = tf.기여하다.레이어.완전히 연결됨(입력=full1, num_outputs=256, activation_fn=tf.nos.Relu) full2 = tf.nos.탈락(full2, keep_prob) full2 = tf.레이어.배치 _ 정규화(full2) # 12 full3 = tf.기여하다.레이어.완전히 연결됨(입력=full2, num_outputs=512, activation_fn=tf.nos.Relu) full3 = tf.nos.탈락(full3, keep_prob) full3 = tf.레이어.배치 _ 정규화(full3) # 13 full4 = tf.기여하다.레이어.완전히 연결됨(입력=full3, num_outputs=1024, activation_fn=tf.nos.Relu) full4 = tf.nos.탈락(full4, keep_prob) full4 = tf.레이어.배치 _ 정규화(full4) # 14 밖 = tf.기여하다.레이어.완전히 연결됨(입력=full3, num_outputs=10, activation_fn=없음) 반환 밖
- 하이퍼 파라미터
신기원 = 10 배치 _ 크기 = 128 keep_probability = 0.7 학습률 = 0.001
로짓 = conv_net(엑스, keep_prob) 모델 = tf.정체(로짓, 이름='로짓') # 로짓 Tensor의 이름을 지정합니다. 학습 후 디스크에서로드 할 수 있습니다. # 손실 및 최적화 도구 비용 = tf.감소 _ 평균(tf.nos.softmax_cross_entropy_with_logits(로짓=로짓, 라벨=와이)) 최적화 프로그램 = tf.기차.AdamOptimizer(학습률=학습률).최소화(비용) # 정확도 correct_pred = tf.같은(tf.argmax(로짓, 하나), tf.argmax(와이, 하나)) 정확성 = tf.감소 _ 평균(tf.캐스트(correct_pred, tf.float32), 이름='정확성')
- 신경망 훈련
# 단일 최적화
데프 train_neural_network(세션, 최적화 프로그램, keep_probability, feature_batch, label_batch) : 세션.운영(최적화 프로그램, feed_dict={ 엑스: feature_batch, 와이: label_batch, keep_prob: keep_probability })
# 통계 표시 def print_stats(세션, feature_batch, label_batch, 비용, 정확성) : 손실 = sess.운영(비용, feed_dict={ 엑스: feature_batch, 와이: label_batch, keep_prob: 하나. }) valid_acc = sess.운영(정확성, feed_dict={ 엑스: valid_features, 와이: valid_labels, keep_prob: 하나. }) 인쇄('손실:{:> 10.4f}검증 정확도 :{: .6f}'.체재(손실, valid_acc))
- 모델 완전 훈련 및 저장
데프 batch_features_labels(풍모, 라벨, 배치 _ 크기) : '' ' 기능 및 레이블을 배치로 분할 '' ' ...에 대한 스타트 에 범위(0, len(풍모), 배치 _ 크기) : 종료 = 분(스타트 + 배치 _ 크기, len(풍모)) 수율 풍모[스타트:종료], 라벨[스타트:종료] 데프 load_preprocess_training_batch(batch_id, 배치 _ 크기) : '' ' 전처리 된 학습 데이터를로드하고 일괄 또는 그 이하로 반환 '' ' 파일 이름 = '전처리 _ 배치 _' + 피(batch_id) + '.피' 풍모, 라벨 = 간물.하중(열다(파일 이름, 방법='rb')) # 훈련 데이터를 크기 이하의 배치로 반환 반환 batch_features_labels(풍모, 라벨, 배치 _ 크기)
# 모델 및 경로 저장
save_model_path = './image_classification' 인쇄('훈련...') 와 tf.세션() 같이 sess: # 변수 초기화 sess.운영(tf.global_variables_initializer()) # 훈련주기 ...에 대한 시대 에 범위(신기원) : # 모든 배치에 대해 반복 n_batches = 5 ...에 대한 batch_i 에 범위(하나, n_batches + 하나) : ...에 대한 배치 _ 기능, 배치 _ 라벨 에 load_preprocess_training_batch(batch_i, 배치 _ 크기) : train_neural_network(sess, 최적화 프로그램, keep_probability, 배치 _ 기능, 배치 _ 라벨) 인쇄('시대{:> 2}, CIFAR-10 배치{}: '.체재(시대 + 하나, batch_i), 종료='') print_stats(sess, 배치 _ 기능, 배치 _ 라벨, 비용, 정확성) # 모델 저장 절약기 = tf.기차.절약기() save_path = 절약기.저장(sess, save_model_path)
이제 Tensorflow 이미지 분류의 중요한 부분이 완료되었습니다. 이제 모델을 테스트 할 시간입니다.
- 모델 테스트
수입 간물 수입 numpy 같이 예 : 수입 matplotlib.pyplot 같이 plt ...에서 sklearn. 전처리 수입 LabelBinarizer 데프 batch_features_labels(풍모, 라벨, 배치 _ 크기) : '' ' 기능 및 레이블을 배치로 분할 '' ' ...에 대한 스타트 에 범위(0, len(풍모), 배치 _ 크기) : 종료 = 분(스타트 + 배치 _ 크기, len(풍모)) 수율 풍모[스타트:종료], 라벨[스타트:종료] 데프 display_image_predictions(풍모, 라벨, 예측, top_n_predictions) : n_classes = 10 label_names = load_label_names() label_binarizer = LabelBinarizer() label_binarizer.적당한(범위(n_classes)) label_ids = label_binarizer.역변환(예 :.정렬(라벨)) 무화과, 근심 = plt.서브 플롯(nrows=top_n_predictions, ncols=2, 무화과=(스물, 10)) 무화과.타이트 레이아웃() 무화과.suptitle('Softmax 예측', 글꼴 크기=스물, 와이=1.1) n_ 예측 = 삼 여유 = 0.05 ind = 예 :.Arange(n_ 예측) 폭 = (하나. - 2. * 여유) / n_ 예측 ...에 대한 image_i, (특색, label_id, pred_indicies, pred_values) 에 세다(지퍼(풍모, label_ids, 예측.지수, 예측.가치)) : 만약 (image_i < top_n_predictions) : pred_names = [label_names[pred_i] ...에 대한 pred_i 에 pred_indicies] 올바른 _ 이름 = label_names[label_id] 근심[image_i] [0].imshow((특색*255).astype(예 :.int32, 부=그릇된)) 근심[image_i] [0].set_title(올바른 _ 이름) 근심[image_i] [0].set_axis_off() 근심[image_i] [하나].바(ind + 여유, pred_values[:삼], 폭) 근심[image_i] [하나].set_yticks(ind + 여유) 근심[image_i] [하나].set_yticklabels(pred_names[::-하나]) 근심[image_i] [하나].set_xticks([0, 0.5, 1.0])
%matplotlib 인라인 %구성 인라인 백엔드.figure_format = '망막' 수입 텐서 플로우 같이 tf 수입 간물 수입 무작위 save_model_path = './image_classification' 배치 _ 크기 = 64 n_samples = 10 top_n_predictions = 5 데프 test_model() : test_features, test_labels = 간물.하중(열다('preprocess_training.p', 방법='rb')) loaded_graph = tf.그래프() 와 tf.세션(그래프=loaded_graph) 같이 sess: # 모델로드 짐을 싣는 사람 = tf.기차.import_meta_graph(save_model_path + '.meta') 짐을 싣는 사람.복원(sess, save_model_path) #로드 된 모델에서 Tensor 가져 오기 loaded_x = loaded_graph.get_tensor_by_name('input_x : 0') loaded_y = loaded_graph.get_tensor_by_name('출력 _y : 0') loaded_keep_prob = loaded_graph.get_tensor_by_name('keep_prob : 0') loaded_logits = loaded_graph.get_tensor_by_name('logits : 0') loaded_acc = loaded_graph.get_tensor_by_name('정확도 : 0') # 메모리 제한에 대해 일괄 적으로 정확도 얻기 test_batch_acc_total = 0 test_batch_count = 0 ...에 대한 train_feature_batch, train_label_batch 에 batch_features_labels(test_features, test_labels, 배치 _ 크기) : test_batch_acc_total + = sess.운영( loaded_acc, feed_dict={loaded_x: train_feature_batch, loaded_y: train_label_batch, loaded_keep_prob: 1.0}) test_batch_count + = 하나 인쇄('테스트 정확도 :{} '.체재(test_batch_acc_total/test_batch_count)) # 무작위 샘플 인쇄 random_test_features, random_test_labels = 튜플(지퍼(*무작위.견본(명부(지퍼(test_features, test_labels)), n_samples))) random_test_predictions = sess.운영( tf.nos.top_k(tf.nos.소프트 맥스(loaded_logits), top_n_predictions), feed_dict={loaded_x: random_test_features, loaded_y: random_test_labels, loaded_keep_prob: 1.0}) display_image_predictions(random_test_features, random_test_labels, random_test_predictions, top_n_predictions) test_model()
산출: 테스트 정확도 : 0.5882762738853503
java double을 int로 변환하는 방법
이제 더 많은 에포크를 위해 신경망을 훈련 시키거나 활성화 함수를 변경하면 정확도가 더 높은 다른 결과를 얻을 수 있습니다.
이것으로이 TensorFlow 이미지 분류 기사를 마칩니다. 이제 동일한 이미지를 사용하여 모든 종류의 이미지를 분류 할 수 있으며 이미지 분류에 대한 초보자가 아닙니다.
에두 레카 with Python Certification Training은 업계 요구 사항 및 요구 사항에 따라 업계 전문가가 큐레이팅합니다. SoftMax 기능, Autoencoder 신경망, RBM (Restricted Boltzmann Machine), Keras 및 TFLearn과 같은 개념을 마스터하게됩니다. 이 과정은 실시간 사례 연구를 통해 업계 전문가가 특별히 선별했습니다.