Класификация на изображенията на TensorFlow: Всичко, което трябва да знаете за класификаторите на сгради

Класификация на изображенията задача, която дори бебето може да изпълни за секунди, но за машина това е трудна задача до последните подобрения в и Дълбоко обучение . Самоуправляващите се автомобили могат да откриват обекти и да предприемат необходимите действия в реално време и повечето от това е възможно поради Класификация на изображенията. В тази статия ще ви преведа през следните теми:

• Какво е TensorFlow?
• Какво е класификация на изображенията?
• Класификация на изображенията TensorFlow: Fashion MNIST
• CIFAR 10: CNN

Какво е TensorFlow?

TensorFlow е рамката за машинно обучение на Google с отворен код за програмиране на потока от данни за редица задачи. Възлите в графиката представляват математически операции, докато ръбовете на графиката представляват многомерните масиви от данни, съобщени между тях.

Тензорите са просто многомерни масиви, продължение на двуизмерни таблици към данни с по-високо измерение. Има много функции на Tensorflow, което го прави подходящ за дълбоко обучение и основната библиотека с отворен код ви помага да разработвате и обучавате модели на ML.

Какво е класификация на изображенията?

Целта на Класификацията на изображения е да категоризира всички пиксели в цифрово изображение в един от няколкото земно покритие класове или теми . След това тези категоризирани данни могат да бъдат използвани за създаване тематични карти на земната покривка, присъстваща в изображение.

Сега в зависимост от взаимодействието между анализатора и компютъра по време на класификацията има два вида класификация:

• Надзор и
• Без надзор

Така че, без да губим време, нека преминем към TensorFlow Image Classification. Имам 2 примера: лесно и трудно. Нека да продължим с лесния.

Класификация на изображенията TensorFlow: Fashion MNIST

Моден набор от данни MNIST

Тук ще използваме Fashion MNIST Dataset, който съдържа 70 000 сиви изображения в 10 категории. Ще използваме 60000 за обучение, а останалите 10000 за целите на тестването. Можете да получите достъп до Fashion MNIST директно от TensorFlow, просто импортирайте и заредете данните.

• Нека първо импортираме библиотеките

от __future__ import absolute_import, подразделение, print_function # TensorFlow и tf.keras импортиране tensorflow като tf от tensorflow import keras # Помощни библиотеки импортиране на numpy като np import matplotlib.pyplot като 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.имшоу(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)) за i в обхват(25): plt.подзаговор(5,5,i+един) plt.xticks([]) plt.yticks([]) plt.мрежа(Невярно) plt.имшоу(train_images[i], cmap=plt.см.двоичен) plt.xlabel(имена на класове[train_labels[i]]) plt.шоу()

• Настройте слоевете

модел = трудно.Последователно([ трудно.слоеве.Изравнете(входна_форма=(28, 28)), трудно.слоеве.Плътно(128, активиране=tf.бр.relu), трудно.слоеве.Плътно(10, активиране=tf.бр.softmax) ]))

• Съставете модела

модел.компилиране(оптимизатор=„Адам“, загуба='sparse_categorical_crossentropy', метрика=['точност']))

• Обучение на модели

модел.годни(train_images, train_labels, епохи=10)

• Оценка на точността

test_loss, test_acc = модел.оцени(test_images, test_labels) печат(„Тест на точност:“, test_acc)

• Правене на прогнози

прогнози = модел.предсказвам(test_images)

прогнози[0]

Прогнозата е масив от 10 числа. Те описват „увереността“ на модела, че изображението съответства на всеки от 10-те различни елемента на облеклото. Можем да видим кой етикет има най-висока стойност на доверие.

напр..argmax(прогнози[0]))#Model е най-уверен, че е ботуш до глезена. Да видим дали е правилно

Изход: 9

test_labels[0]

Изход: 9

• Сега е време да разгледаме пълния набор от 10 канала

деф plot_image(i, предсказания_ масив, true_label, img): предсказания_ масив, true_label, img = предсказания_ масив[i], true_label[i], img[i] plt.мрежа(Невярно) plt.xticks([]) plt.yticks([]) plt.имшоу(img, cmap=plt.см.двоичен) предсказан_ етикет = напр..argmax(предсказания_ масив) ако предсказан_ етикет == true_label: цвят = 'зелен' друго: цвят = „мрежа“ plt.xlabel('{} {: 2.0f}% ({}) '.формат(имена на класове[предсказан_ етикет], 100*напр..макс(предсказания_ масив), имена на класове[true_label]), цвят=цвят) деф plot_value_array(i, предсказания_ масив, true_label): предсказания_ масив, true_label = предсказания_ масив[i], true_label[i] plt.мрежа(Невярно) plt.xticks([]) plt.yticks([]) този парцел = plt.лента(обхват(10), предсказания_ масив, цвят='# 777777') plt.ylim([0, един])) предсказан_ етикет = напр..argmax(предсказания_ масив) този парцел[предсказан_ етикет].set_color(„мрежа“) този парцел[true_label].set_color('зелен')

• Нека първо разгледаме 0-то и 10-то изображение

i = 0 plt.фигура(фиг=(6,3)) plt.подзаговор(един,2,един) plot_image(i, прогнози, test_labels, test_images) plt.подзаговор(един,2,2) plot_value_array(i, прогнози, test_labels) plt.шоу()

i = 10 plt.фигура(фиг=(6,3)) plt.подзаговор(един,2,един) plot_image(i, прогнози, test_labels, test_images) plt.подзаговор(един,2,2) plot_value_array(i, прогнози, test_labels) plt.шоу()

• Сега нека начертаем няколко изображения и техните прогнози. Правилните са зелени, докато неправилните са червени.

брой_редове = 5 num_cols = 3 num_images = брой_редове*num_cols plt.фигура(фиг=(2*2*num_cols, 2*брой_редове)) за i в обхват(num_images): plt.подзаговор(брой_редове, 2*num_cols, 2*i+един) plot_image(i, прогнози, test_labels, test_images) plt.подзаговор(брой_редове, 2*num_cols, 2*i+2) plot_value_array(i, прогнози, test_labels) plt.шоу()

• И накрая, ще използваме обучения модел, за да направим прогноза за едно изображение.

# Вземете изображение от тестовия набор от данни img = test_images[0] печат(img.форма)

# Добавете изображението към партида, където е единственият член. img = (напр..разширяване_dims(img,0)) печат(img.форма)

прогнози_сингъл = модел.предсказвам(img) печат(прогнози_сингъл)

plot_value_array(0, прогнози_сингъл, test_labels) plt.xticks(обхват(10), имена на класове, завъртане=Четири пет) 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-batch-py“ клас DownloadProgress(tqdm): last_block = 0 деф кука(себе си, номер_блок=един, размер_блок=един, Общият размер=Нито един): себе си.обща сума = Общият размер себе си.актуализиране((номер_блок - себе си.last_block) * размер_блок) себе си.last_block = номер_блок ' проверете дали файлът с данни (zip) вече е изтеглен ако не, изтеглете го от „https://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz“ и запазете като cifar-10-python.tar.gz ' ако не isfile(„cifar-10-python.tar.gz“): с DownloadProgress(мерна единица=„Б“, единица_скала=Вярно, миньори=един, 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“) като катран: катран.екстрактал() катран.близо()

• Импортиране на необходимите библиотеки

внос туршия внос numpy като напр. внос matplotlib.pyplot като plt

• Разбиране на данните

Оригиналната партида от данни е 10000 × 3072 тензор, изразена в numpy масив, където 10000 е броят на примерните данни. Изображението е цветно и с размер 32 × 32. Храненето може да се извърши или във формат (ширина х височина х брой_канал) или (брой_канал х ширина х височина). Нека дефинираме етикетите.

деф 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“) Характеристика = партида['данни'].преоформяне((пост(партида['данни']), 3, 32, 32)).транспониране(0, 2, 3, един) етикети = партида['етикети'] връщане Характеристика, етикет

• Проучване на данните

деф display_stats(cifar10_dataset_folder_path, batch_id, sample_id): Характеристика, етикети = load_cfar10_batch(cifar10_dataset_folder_path, batch_id) ако не (0 <= sample_id < пост(Характеристика)): печат('{}проби в партида{}.{}е извън обхвата. '.формат(пост(Характеристика), batch_id, sample_id)) връщане Нито един печат(' Статистика на партида #{}: '.формат(batch_id)) печат('# от пробите:{} '.формат(пост(Характеристика))) имена на етикети = load_label_names() етикет_брои = дикт(цип(*напр..единствен по рода си(етикети, return_counts=Вярно))) за ключ, стойност в етикет_брои.елементи(): печат(„Брой етикети на [{}] ({}):{}'.формат(ключ, имена на етикети[ключ].горен(), стойност)) образец_изображение = Характеристика[sample_id] sample_label = етикети[sample_id] печат(' Пример за изображение{}: '.формат(sample_id)) печат(„Изображение - Минимална стойност:{}Максимална стойност:{}'.формат(образец_изображение.мин(), образец_изображение.макс())) печат(„Изображение - форма:{}'.формат(образец_изображение.форма)) печат(„Етикет - Идент. № на етикета:{}Име:{}'.формат(sample_label, имена на етикети[sample_label])) plt.имшоу(образец_изображение)

%matplotlib в редица %конфиг InlineBackend.формат_фигура = 'ретина' внос numpy като напр. # Разгледайте набора от данни batch_id = 3 sample_id = 7000 display_stats(cifar10_dataset_folder_path, batch_id, sample_id)

• Внедряване на функции за предварителна обработка

Ще нормализираме данните чрез Min-Max нормализация. Това просто прави всички x стойности да варират между 0 и 1.
y = (x-min) / (max-min)

деф нормализират(х): ' аргумент - x: въвеждане на данни за изображението в масив numpy [32, 32, 3] връщане - нормализиран х ' min_val = напр..мин(х) max_val = напр..макс(х) х = (х-min_val) / (max_val-min_val) връщане х

• Едно горещо кодиране

деф one_hot_encode(х): ' аргумент - x: списък с етикети връщане - една матрица за горещо кодиране (брой етикети, брой клас) ' кодиран = напр..нули((пост(х), 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 валидни_характеристики = [] валидни_ етикети = [] за партида_i в обхват(един, n_batches + един): Характеристика, етикети = load_cfar10_batch(cifar10_dataset_folder_path, партида_i) # намери индекс, който да е точката като данни за валидиране в целия набор от данни на партидата (10%) index_of_validation = инт(пост(Характеристика) * 0,1) # предварителна обработка на 90% от целия набор от данни на партидата # - нормализиране на характеристиките # - one_hot_encode етикетите # - запишете в нов файл с име „preprocess_batch_“ + batch_number # - всеки файл за всяка партида _preprocess_and_save(нормализират, one_hot_encode, Характеристика[:-index_of_validation], етикети[:-index_of_validation], 'preprocess_batch_' + стр(партида_i) + „.p“) # за разлика от набора от данни за обучение, наборът за валидиране ще бъде добавен през целия пакет от данни # - вземете 10% от общия набор от данни на партидата # - добавете ги в списък с # - валидни_характеристики # - валидни_ етикети валидни_характеристики.разшири(Характеристика[-index_of_validation:]) валидни_ етикети.разшири(етикети[-index_of_validation:]) # предварителна обработка на всички подредени валидиращи данни _preprocess_and_save(нормализират, one_hot_encode, напр..масив(валидни_характеристики), напр..масив(валидни_ етикети), 'preprocess_validation.p') # заредете тестовия набор от данни с отворен(cifar10_dataset_folder_path + '/ test_batch', режим='rb') като файл: партида = туршия.натоварване(файл, кодиране=„латински1“) # предварителна обработка на данните за тестване test_features = партида['данни'].преоформяне((пост(партида['данни']), 3, 32, 32)).транспониране(0, 2, 3, един) 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)

• Чекпойнт

внос туршия валидни_характеристики, валидни_ етикети = туршия.натоварване(отворен('preprocess_validation.p', режим='rb'))

• Изграждане на мрежата

Целият модел се състои от общо 14 слоя.

как да използвам python в anaconda

внос тензор поток като tf деф conv_net(х, keep_prob): conv1_filter = tf.Променлива(tf.пресечен_нормален(форма=[3, 3, 3, 64], означава=0, stddev=0,08)) conv2_filter = tf.Променлива(tf.пресечен_нормален(форма=[3, 3, 64, 128], означава=0, stddev=0,08)) conv3_filter = tf.Променлива(tf.пресечен_нормален(форма=[5, 5, 128, 256], означава=0, stddev=0,08)) conv4_filter = tf.Променлива(tf.пресечен_нормален(форма=[5, 5, 256, 512], означава=0, stddev=0,08)) # 12 conv1 = tf.бр.conv2d(х, conv1_filter, крачки=[един,един,един,един], подплата='ЕДИН И СЪЩ') conv1 = tf.бр.relu(conv1) conv1_pool = tf.бр.max_pool(conv1, ksize=[един,2,2,един], крачки=[един,2,2,един], подплата='ЕДИН И СЪЩ') conv1_bn = tf.слоеве.batch_normalization(conv1_pool) # 3. 4 conv2 = tf.бр.conv2d(conv1_bn, conv2_filter, крачки=[един,един,един,един], подплата='ЕДИН И СЪЩ') conv2 = tf.бр.relu(conv2) conv2_pool = tf.бр.max_pool(conv2, ksize=[един,2,2,един], крачки=[един,2,2,един], подплата='ЕДИН И СЪЩ') conv2_bn = tf.слоеве.batch_normalization(conv2_pool) # 5, 6 conv3 = tf.бр.conv2d(conv2_bn, conv3_filter, крачки=[един,един,един,един], подплата='ЕДИН И СЪЩ') conv3 = tf.бр.relu(conv3) conv3_pool = tf.бр.max_pool(conv3, ksize=[един,2,2,един], крачки=[един,2,2,един], подплата='ЕДИН И СЪЩ') conv3_bn = tf.слоеве.batch_normalization(conv3_pool) # 7, 8 conv4 = tf.бр.conv2d(conv3_bn, conv4_filter, крачки=[един,един,един,един], подплата='ЕДИН И СЪЩ') conv4 = tf.бр.relu(conv4) conv4_pool = tf.бр.max_pool(conv4, ksize=[един,2,2,един], крачки=[един,2,2,един], подплата='ЕДИН И СЪЩ') conv4_bn = tf.слоеве.batch_normalization(conv4_pool) # 9 апартамент = tf.принос.слоеве.изравнявам(conv4_bn) # 10 пълен1 = tf.принос.слоеве.напълно_свързан(входове=апартамент, брой_изходи=128, activation_fn=tf.бр.relu) пълен1 = tf.бр.отпадат(пълен1, keep_prob) пълен1 = tf.слоеве.batch_normalization(пълен1) # единадесет пълен2 = tf.принос.слоеве.напълно_свързан(входове=пълен1, брой_изходи=256, activation_fn=tf.бр.relu) пълен2 = tf.бр.отпадат(пълен2, keep_prob) пълен2 = tf.слоеве.batch_normalization(пълен2) # 12 пълен3 = tf.принос.слоеве.напълно_свързан(входове=пълен2, брой_изходи=512, activation_fn=tf.бр.relu) пълен3 = tf.бр.отпадат(пълен3, keep_prob) пълен3 = tf.слоеве.batch_normalization(пълен3) # 13 пълен4 = tf.принос.слоеве.напълно_свързан(входове=пълен3, брой_изходи=1024, activation_fn=tf.бр.relu) пълен4 = tf.бр.отпадат(пълен4, keep_prob) пълен4 = tf.слоеве.batch_normalization(пълен4) # 14 навън = tf.принос.слоеве.напълно_свързан(входове=пълен3, брой_изходи=10, activation_fn=Нито един) връщане навън

• Хиперпараметри

епохи = 10 batch_size = 128 keep_probability = 0.7 скорост на обучение = 0,001

логити = conv_net(х, keep_prob) модел = tf.самоличност(логити, име='logits') # Name logits Tensor, за да може да се зареди от диска след обучение # Загуба и оптимизатор цена = tf.намали_означава(tf.бр.softmax_cross_entropy_with_logits(логити=логити, етикети=Y.)) оптимизатор = tf.влак.AdamOptimizer(скорост на обучение=скорост на обучение).минимизиране(цена) # Точност правилно_пред = tf.равен(tf.argmax(логити, един), tf.argmax(Y., един)) точност = tf.намали_означава(tf.гласове(правилно_пред, tf.float32), име='точност')

• Тренирайте невронната мрежа

# Единична оптимизация 
деф train_neural_network(сесия, оптимизатор, keep_probability, feature_batch, label_batch): сесия.бягай(оптимизатор, feed_dict={ х: feature_batch, Y.: label_batch, keep_prob: keep_probability })

# Показване на статистика деф print_stats(сесия, feature_batch, label_batch, цена, точност): загуба = сес.бягай(цена, feed_dict={ х: feature_batch, Y.: label_batch, keep_prob: един. }) валиден_acc = сес.бягай(точност, feed_dict={ х: валидни_характеристики, Y.: валидни_ етикети, keep_prob: един. }) печат(„Загуба:{:> 10.4f}Точност на валидиране:{: .6f}'.формат(загуба, валиден_acc))

• Напълно обучение и запазване на модела

деф batch_features_labels(Характеристика, етикети, batch_size): ' Разделете функции и етикети на партиди ' за старт в обхват(0, пост(Характеристика), batch_size): край = мин(старт + batch_size, пост(Характеристика)) добив Характеристика[старт:край], етикети[старт:край] деф load_preprocess_training_batch(batch_id, batch_size): ' Заредете предварително обработените данни за обучение и ги върнете на партиди или по-малко ' име на файл = 'preprocess_batch_' + стр(batch_id) + „.p“ Характеристика, етикети = туршия.натоварване(отворен(име на файл, режим='rb')) # Върнете данните за обучение на партиди с размер или по-малък връщане batch_features_labels(Характеристика, етикети, batch_size)

# Запазване на модел и път 
save_model_path = './image_classification' печат(„Обучение ...“) с tf.Сесия() като сес: # Инициализиране на променливите сес.бягай(tf.global_variables_initializer()) # Обучителен цикъл за епоха в обхват(епохи): # Повтаряйте всички партиди n_batches = 5 за партида_i в обхват(един, n_batches + един): за batch_features, batch_labels в load_preprocess_training_batch(партида_i, batch_size): train_neural_network(сес, оптимизатор, keep_probability, batch_features, batch_labels) печат(- Епоха{:> 2}, Партида CIFAR-10{}: '.формат(епоха + един, партида_i), край=') print_stats(сес, batch_features, batch_labels, цена, точност) # Запазване на модел спестител = tf.влак.Спестяване() save_path = спестител.запази(сес, save_model_path)

Сега, важната част от класификацията на изображения на Tensorflow е изпълнена. Сега е време да тествате модела.

• Тестване на модела

внос туршия внос numpy като напр. внос matplotlib.pyplot като plt от sklearn.преработка внос LabelBinarizer деф batch_features_labels(Характеристика, етикети, batch_size): ' Разделете функции и етикети на партиди ' за старт в обхват(0, пост(Характеристика), batch_size): край = мин(старт + batch_size, пост(Характеристика)) добив Характеристика[старт:край], етикети[старт:край] деф display_image_predictions(Характеристика, етикети, прогнози, top_n_predictions): n_classes = 10 имена на етикети = load_label_names() label_binarizer = LabelBinarizer() label_binarizer.годни(обхват(n_classes)) label_ids = label_binarizer.inverse_transform(напр..масив(етикети)) фиг, оси = plt.подзаговори(nrows=top_n_predictions, ncols=2, фиг=(двайсет, 10)) фиг.тясно_разпределение() фиг.презаглавие(„Прогнози на Softmax“, размер на шрифта=двайсет, Y.=1.1) n_прогнози = 3 марж = 0,05 инд = напр..подредете(n_прогнози) ширина = (един. - 2. * марж) / n_прогнози за image_i, (особеност, label_id, pred_indicies, pred_values) в изброявам(цип(Характеристика, label_ids, прогнози.индекси, прогнози.стойности)): ако (image_i < top_n_predictions): pred_names = [имена на етикети[pred_i] за pred_i в pred_indicies] правилно_име = имена на етикети[label_id] оси[image_i] [0].имшоу((особеност*255).астип(напр..int32, копие=Невярно)) оси[image_i] [0].set_title(правилно_име) оси[image_i] [0].set_axis_off() оси[image_i] [един].бах(инд + марж, pred_values[:3], ширина) оси[image_i] [един].set_yticks(инд + марж) оси[image_i] [един].set_yticklabels(pred_names[::-един])) оси[image_i] [един].set_xticks([0, 0,5, 1.0]))

%matplotlib в редица %конфиг InlineBackend.формат_фигура = 'ретина' внос тензор поток като tf внос туршия внос случайни save_model_path = './image_classification' batch_size = 64 n_samples = 10 top_n_predictions = 5 деф тест_модел(): test_features, test_labels = туршия.натоварване(отворен('preprocess_training.p', режим='rb')) loaded_graph = tf.Графика() с tf.Сесия(графика=loaded_graph) като сес: # Заредете модел товарач = tf.влак.import_meta_graph(save_model_path + „.meta“) товарач.Възстанови(сес, save_model_path) # Вземете тензори от зареден модел load_x = loaded_graph.get_tensor_by_name(„input_x: 0“) натоварен_y = loaded_graph.get_tensor_by_name('output_y: 0') loaded_keep_prob = loaded_graph.get_tensor_by_name('keep_prob: 0') load_logits = loaded_graph.get_tensor_by_name('logits: 0') load_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, batch_size): test_batch_acc_total + = сес.бягай( load_acc, feed_dict={load_x: train_feature_batch, натоварен_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 = сес.бягай( tf.бр.top_k(tf.бр.softmax(load_logits), top_n_predictions), feed_dict={load_x: random_test_features, натоварен_y: random_test_labels, loaded_keep_prob: 1.0}) display_image_predictions(random_test_features, random_test_labels, random_test_predictions, top_n_predictions) тест_модел()

Изход: Точност на тестване: 0,5882762738853503

Сега, ако тренирате невронната си мрежа за повече епохи или промените функцията за активиране, може да получите различен резултат, който може да има по-добра точност.

И така, с това стигнахме до края на тази статия за класификация на изображенията на TensorFlow. Сигурен съм, че вече можете да използвате същото, за да класифицирате всякакъв вид изображения и не сте начинаещ в класификацията на изображенията.

Edureka’s с Python Certification Training се подготвя от професионалисти в бранша според изискванията и изискванията на бранша. Ще овладеете понятията като функцията SoftMax, автокодиращи невронни мрежи, ограничена машина на Boltzmann (RBM), Keras и TFLearn. Курсът е специално подготвен от експерти в бранша с казуси в реално време.