Deep learning помогает извлечь информацию из изображений

Анализ признаков, извлеченных нейросетью

Мы продолжаем рассматривать, как использовать предварительно обученные нейронные сети для решения новых задач, а не тех, на которых они обучались. Популярный подход – замена классификатора предварительно обученной сети на новый и дообучение сети на новом наборе данных. Такой подход работает хорошо, но требует больших вычислительных ресурсов для дообучения.

Альтернативный вариант, который мы рассмотрим в этой статье – извлечение признаков из изображений с помощью предварительно обученной глубокой нейронной сети (по-английски такие признаки называются deep features) и последующий анализ уже этих признаков, а не исходных изображений. Как правило, объем признаков значительно меньше, чем изображений, из которых они извлечены, поэтому сеть обучается гораздо быстрее. Часто при таком подходе удается обучить нейронную сеть за разумное время даже без GPU.

Как и зачем анализировать признаки, извлеченные глубокой нейронной сетью

В качестве примера мы по-прежнему будем рассматривать задачу классификации изображений котов и собак на картинках из соревнования Kagge с использованием глубокой нейронной сети VGG16. Эта сеть имеет следующую архитектуру:

.

Мы удаляем у предварительно обученной сети классификатор, но новый не добавляем. Вместо этого мы подам на сеть без классификатора наш набор изображений котов и собак и сохраняем векторы, которые выдает сеть:

.

На следующем этапе мы анализируем уже не исходные изображения, а векторы признаков, извлеченные из этих изображений.

Обратите внимание

Векторы признаков из картинок с котами будут больше похожи друг на друга, чем на векторы из картинок с собаками. Поэтому можно применить какой-нибудь алгоритм классификации к векторам признаков.

Одним из таких алгоритмов классификации может быть небольшая полносвязная сеть, которую можно быстро обучить даже на CPU.

.

Анализ признаков из изображений в Keras

Давайте рассмотрим, как анализировать признаки, извлеченные нейросетью, в Keras. Полный ноутбук с кодом доступен в репозитории примеров курса.

Подготовка набора данных

Перед тем, как анализировать признаки, необходимо подготовить набор изображений котов и собак для работы с Keras. Как это сделать, описано в статье по подготовке набора изображений. В результате должна получится следующая структура каталогов:

cats_vs_dogs/
|—-train/
| |—-cats/
| |—-dogs/
|
|—-validation/
| |—-cats/
| |—-dogs/
|
|—-test/ |—-cats/ |—-dogs/

Набор данных разделен на три части: данные для обучения (каталог train), данные для проверки (каталог validation) и данные для тестирования (каталог test). В каждом каталоге два подкаталога: cats и dogs с фотографиями котов и собак соответственно.

Генераторы для чтения изображений

В Keras для загрузки изображений с диска используются генераторы. Если мы собираемся не обучать сеть на изображениях, а извлекать признаки из изображений, то генераторы нужно настраивать специальным образом. Сначала зададим константы для удобства:

# Каталог с данными для обучения
train_dir = 'train'
# Каталог с данными для проверки
val_dir = 'val'
# Каталог с данными для тестирования
test_dir = 'test'
# Размеры изображения
img_width, img_height = 150, 150
# Размерность тензора на основе изображения для входных данных в нейронную сеть
# backend Tensorflow, channels_last
input_shape = (img_width, img_height, 3)
# Размер мини-выборки
batch_size = 10
# Количество изображений для обучения
nb_train_samples = 17500
# Количество изображений для проверки
nb_validation_samples = 3750
# Количество изображений для тестирования
nb_test_samples = 3750

Мы используем 70% набора изображений котов и собак для обучения (17,5 тыс. из 25 тыс.) и по 15% для проверки и тестирования (3750 изображений).

Задаем ImageDataGenerator, в котором каждый пиксель изображения будет делиться на 255, чтобы данные на входе в сеть были в диапазоне от 0 до 1:

datagen = ImageDataGenerator(rescale=1. / 255)

Описываем генератор данных для обучения:

train_generator = datagen.flow_from_directory( train_dir, target_size=(img_width, img_height), batch_size=batch_size, class_mode=None, shuffle=False)

Основное отличие от того, что мы делали раньше, в двух последних параметрах генератора — class_mode и shuffle. Параметр class_mode=None говорит о том, что генератор не возвращает правильные ответы, а только исходные изображения. Правильные ответы нам на этом этапе не нужны, т.к.

мы не планируем дообучать предварительно обученную сеть. С помощью shuffle=False мы говорим генератору, что не нужно перемешивать изображения. Тогда генератор будет выдавать изображения в том порядке, в котором они записаны на диск: сначала все изображения котов, а потом собак.

В этом случае мы легко сможем сгенирировать метки для векторов, извлеченных из изображений.

Похожим образом задаем генераторы для проверки и тестирования. Они отличатся только каталогом, из которого берут данные:

val_generator = datagen.flow_from_directory( val_dir, target_size=(img_width, img_height), batch_size=batch_size, class_mode=None, shuffle=False) test_generator = datagen.flow_from_directory( test_dir, target_size=(img_width, img_height), batch_size=batch_size, class_mode=None, shuffle=False)

Извлекаем признаки из изображений

Признаки из изображений мы будем извлекать с помощью сети VGG16, а затем сохраним их в файлы для дальнейшего анализа.

Загружаем сеть VGG16 с весами, обученными на наборе данных ImageNet, без части, которая занимается классификацией:

vgg16_net = VGG16(weights='imagenet', include_top=False, input_shape=(img_width, img_height, 3))

В этот раз мы не будем добавлять новый классификатор и дообучать сеть, а применим VGG16 в готовом виде без классификатора для извлечения векторов признаков из изображений, которые выдают подготовленные нами ранее генераторы:

features_train = vgg16_net.predict_generator( train_generator, nb_train_samples // batch_size)

Важно

Переменная features_train – это numpy массив размерности (17500, 4, 4, 512). Первая размерность 17500 соответствует количеству изображений в наборе данных для обучения. (4, 4, 512) — это размерность вектора признаков, который выдает сверточная часть сети VGG16: 512 карт признаков размером 4х4. Можно посмотреть фрагмент вектора признаков:

print(features_train[0])
array([[[0.48350716, 0. , 0. , …, 0. , 0.8291736 , 0. ], [0.0348561 , 0. , 0.22486642, …, 0. , 1.038972 , 0. ], [0.31540298, 0. , 0. , …, 0. , 0.49017912, 0. ], [0.23459446, 0. , 0. , …, 0. , 0.28118512, 0. ]], … [[0.44808802, 0. , 0. , …, 0. , 0.3077254 , 0. ], [0.43148196, 0. , 1.0594087 , …, 0. , 0.5165488 , 0. ], [0.2360073 , 0. , 1.3714772 , …, 0. , 0.8434944 , 0. ], [0. , 0. , 1.3223135 , …, 0.30869496, 0.5962191 , 0. ]]], dtype=float32)

Вектор признаков — это просто набор чисел, которые, по мнению VGG16 или другой предварительно обученной нейросети, лучше всего описывают характеристики изображения.

Сгенерированные векторы признаков записываем в массив с помощью средств numpy:

np.save(open('features_train.npy', 'wb'), features_train)

Аналогичным образом генерируем и сохраняем векторы признаков для наборов данных проверки и тестирования:

# Генерируем и сохраняем векторы изображений проверочного набора данных
features_val = vgg16_net.predict_generator( val_generator, nb_validation_samples // batch_size)
np.save(openopen('features_val.npy', 'wb'), features_val) # Генерируем и сохраняем векторы изображений набора данных для тестирования
features_test = vgg16_net.predict_generator( test_generator, nb_test_samples // batch_size)
np.save(open('features_test.npy', 'wb'), features_test)

Мы извлекли векторы признаков из всех изображений трех наборов данных и сохранили их в отдельные файлы. Теперь можно переходить к анализу векторов признаков.

Нейронная сеть для классификации векторов признаков

Теперь давайте попытаемся решить задачу классификации: на основе вектора признаков определить, кот или собака на исходном изображении. Для этого нам нужно загрузить векторы признаков, сохраненные ранее в файлы:

features_train = np.load(open('features_train.npy', 'rb'))
features_val = np.load(open('features_val.npy', 'rb'))
features_test = np.load(open('features_test.npy', 'rb'))

Мы используем обучение с учителем, поэтому для каждого вектора признаков нам нужно знать, кто на исходной картинке: кот или собака. При создании векторов признаков мы использовали генераторы, которые сначала выдают фотографии всех котов, а затем всех собак. Поэтому мы можем сгенерировать метки классов очень просто:

labels_trainlabels_t = np.array( [0] * (nb_train_samples // 2) + [1] * (nb_train_samples // 2))
labels_vallabels_v = np.array( [0] * (nb_validation_samples // 2) + [1] * (nb_validation_samples // 2))
labels_test = np.array( [0] * (nb_test_samples // 2) + [1] * (nb_test_samples // 2))

Для первой половины данных записывается метка 0, что соответствует коту, а для второй половины – метка 1 (собака).

Классифицировать векторы признаков будем с помощью простой полносвязной нейронной сети:

model = Sequential()
model.add(Flatten(input_shape=features_train.shape[1:]))
model.add(Dense(512, activation='relu'))
model.add(Dropout(0.5))
model.add(Dense(1, activation='sigmoid'))

Полносвязной сети для работы нужен плоский вектор, а наши векторы признаков, полученные от сети VGG16, имеют размерность (4, 4, 512).

Поэтому первым в сети идет слой Flatten, который преобразуют векторы признаков в плоские. Затем идет полносвязный слой Dense с 512 нейронами, а за ним слой Dropout для регуляризации.

Выходной слой Dense содержит один нейрон (у нас бинарная классификация, кот или собака) и функцией активации sigmoid.

Совет

Компилируем модель и обучаем на векторах признаков, которые мы загрузили из файлов, и метках классов для них:

model.compile(optimizer='Adam', loss='binary_crossentropy', metrics=['accuracy']) model.fit(features_train, labels_train, epochs=15, batch_size=64, validation_data=(features_val, labels_val), verbose=2)

Читайте также:  Памяти м.а. кумахова

Фрагмент диагностического вывода при обучения нейронной сети в течение 15 эпох:

Train on 17500 samples, validate on 3750 samples
Epoch 1/15 — 5s — loss: 0.3228 — acc: 0.8636 — val_loss: 0.2185 — val_acc: 0.9109
Epoch 2/15 — 4s — loss: 0.2234 — acc: 0.9053 — val_loss: 0.2346 — val_acc: 0.9019
Epoch 3/15 — 4s — loss: 0.1967 — acc: 0.9171 — val_loss: 0.2090 — val_acc: 0.9157

Epoch 13/15 — 4s — loss: 0.0943 — acc: 0.9618 — val_loss: 0.2332 — val_acc: 0.9197
Epoch 14/15 — 4s — loss: 0.0774 — acc: 0.9676 — val_loss: 0.2623 — val_acc: 0.9173
Epoch 15/15 — 4s — loss: 0.0823 — acc: 0.9669 — val_loss: 0.2431 — val_acc: 0.9205

Аккуратность на проверочной выборке получилась 92%. Это меньше, чем при дообучении сети VGG16 на новом наборе данных. Однако время обучения, 4-5 секунд на одну эпоху на GPU, также значительно меньше. Такую сеть действительно можно обучить на CPU за разумное время.

Проверим качество работы сети на данных для тестирования:

scoresscores == modelmodel..evaluateevaluate(features_test, labels_test, verbose=1)
print(«Аккуратность на тестовых данных: %.2f%%» % (scores[1]*100))
3750/3750 [==============================] — 0s 78us/step
Аккуратность на тестовых данных: 91.25%

Ожидаемо, точность работы на тестовых данных меньше, чем на обучающем и проверочном наборах.

Не забудьте сохранить нейронную сеть после окончания обучения!

Итоги

Мы научились применять предварительно обученные нейронные сети для решения своих задач с помощью извлечения признаков из изображений и последующего их анализа.

Преимущество такого подхода в том, что предварительно обученная нейронная сеть, которая требует больших вычислительных ресурсов, используется только один раз для каждого изображения при извлечении вектора признаков.

Размерность полученных векторов значительно меньше, чем размерность исходного изображения, поэтому для их анализа требуется меньше вычислительных ресурсов. Нейронные сети, которые работают с векторами признаков, можно обучить за разумное время на CPU.

К недостаткам подхода можно отнести менее высокую аккуратность, по сравнению с дообучением предварительно обученной сети. Также нет возможности использовать расширение данных, что негативно сказывается на качестве обучения.

Полезные ссылки

Источник: https://www.asozykin.ru/deep_learning/2018/06/26/Deep-Features-Analysis.html

Заметки о статьях по DeepLearning и ImageNet

Краткая заметка о содержании классических статей по сверточным нейронным сетям и ImageNet.

ImageNet classification with deep convolutional neural networks

Krizhevsky, Alex, Ilya Sutskever, and Geoffrey E. Hinton. “Imagenet classification with deep convolutional neural networks.” Advances in neural information processing systems. 2012. [pdf] (AlexNet, Deep Learning Breakthrough)

Одна из классических статей, с которых начался современный виток диплернинга (сеть AlexNet).

Про ImageNet

Появление датасета ImageNet позволило решать задачу классификации изображений на качественно новом уровне. ImageNet содержит более миллионов размеченных изображений, разбитых на категорий.

Начиная с года проводится соревнование ImageNet Large Scale Visual Recognition Challenge (ILSVRC) по распознаванию и детекции на ImageNet. Датасет соревнования представлен классов и разделен на части: train , validation , test . Качество классификации оценивается по метрикам: ошибка на топ и ошибка на топ .

Архитектура сети

Авторы использовали сверточную сеть из слоев: сверточных, полносвязных. Последний слой — softmax на классов.

Оригинальная схема из статьи.
(Да, она неправильно обрезана в статье.)

А еще в схеме есть забавная неточность.

Для тренировки сети все изображения масштабировали в x. Препроцессинг — вычитание среднего (mean).

Обратите внимание

Функцией активации вместо общепринятых тогда сигмоида и tanh выбрали ReLU, что в несколько раз увеличило скорость обучения.

Хотя ReLU не требует нормализации данных, после экспериментов, авторы решили использовать локальную нормализацию (local normalization). Хитрая формула нормализации приведена в статье.

Борьба с оверфитом

Использовали основных подхода: аугментации и дропаут.

Аугментации. Аугментированные изображения генерировали на лету с помощью Python и не хранили на диске. Пока сеть перемножала тензоры на GPU, через CPU обсчитывали новое аугментированное изображение.

Использовали вида аугментаций:

  • извлечение случайных фрагментов изображений x из изображения x и горизонтальное отображение этих фрагментов.
  • изменение RGB компонет. Из imageNet с помощью PCA получили главные компоненты, которые хитрым способом сложили с оригинальными изображениями. Это уменьшило ошибку на тесте более чем на .

Второй подход: дропаут с коэффициентом в первых двух полносвязных слоях. На каждой итерации случайным образом половина нейронов не учавствовала в обучении, что улучшило обобщаущую способность сети.

Детали обучения

Модель обучали стохастическим градиентным спуском с импульсом (momentum) и затуханием (weight decay). Веса иницилизировали Гауссовым распределением с центром в и среднеквадратическим отклонением .

Обучали на двух GPU GTX (по Gb памяти) в течении 6 дней.

Полученные результаты:

  • ошибка на топ :
  • ошибка на топ :

Very deep convolutional networks for large-scale image recognition

Simonyan, Karen, and Andrew Zisserman. “Very deep convolutional networks for large-scale image recognition.” arXiv preprint arXiv:1409.1556 (2014). [pdf] (VGGNet,Neural Networks become very deep!)

Вторая классическая статья по сверточным сетям. Этой статье мы обязаны архитектурами VGG- и VGG-.

Архитектура

Сеть организована по тем же принципам что в вышеприведенной статье. Для обучения использованы x RGB изображения, препроцессинг — вычитаение среднего (mean).

Ключевая особенность полученных сетей — использование маленьких сверток x, что ползволило увеличить глубину до — слоев.

Ранее использовались свертки x и x. Согласно статье использование двух сверточных слоев x заменяет один слой x, а использование слоев x заменяет один слой x. Замена одной большой свертки на несколько маленьких позволяет увеличить число нелинейных преобразований и значительно уменьшить количество параметров сети.

После сверточных слоев идут два полносвязных слоя на нейронов и последний softmax слой на . В качестве функции активации примененили ReLU.

От использования локальной нормализации из вышеприведенной статьи отказались, т.к. на тестах она не дала никаких преимуществ, зато увеличила потребление памяти.

Сеть обучали на оптимизацию множественной логистической регрессии, используя градиентный спуск с импульсом (momentum), регуляризацию и дропаут на первых двух полносвязных слоях.

Веса инициализировали используя предварительное обучение на сети с меньшим количеством слоев и случайно инициализированными параметрами.

Реализация

Сеть собрали на Caffe, модифицировав для возможности обучения на нескольких GPU. Тренировка занимала — недели на х NVIDIA Titan Black.

Лучшие результаты на сети:

  • ошибка на топ :
  • ошибка на топ :

Усреднение softmax классов нескольких сетей улучшило результаты:

  • ошибка на топ :
  • ошибка на топ :

Затем эту сеть применили к задаче локализации (определение баундинг-боксов объектов). Обучали аналогично задаче классификации, только логистическую регрессию заменили на Евклидово расстояние. Полученные результаты превзошли state of the art на момент написания статьи.

Сеть обученную на ImageNet применили к другим датасетам. Для этого выкинули последний полносвязный слой.

Важно

Предпоследний слой, содержащий 4096 нейронов использовали в качестве извлекаемых из изображения признаков. К полученным признаками применили SVM классификатор с регуляризацией.

Веса предобученных слоев не меняли. На новых данных были получены результаты аналогичные либо превосходящие state of the art.

Going Deeper with Convolutions

Источник: http://re9ulus.github.io/2017/03/03/imagenet-paper-digest/

Извлечь функции с помощью предварительно обученного (Tensorflow) CNN

Глубокое обучение успешно применяется в нескольких больших наборах данных для классификации нескольких классов (кошек, собак, автомобилей, самолетов и т.д.), причем выступления превосходят более простые дескрипторы, такие как Сумки функций над SIFT, цветные гистограммы и т.д..

Тем не менее, для обучения такой сети требуется много данных для каждого класса и много времени на обучение. Однако очень часто не хватает данных или просто хочет получить представление о том, насколько хорошо может сверточную нейронную сеть, прежде чем тратить время на разработку и обучение такого устройства и сбор данных обучения.

В этом конкретном случае было бы идеально, если бы сеть была настроена и обучена с использованием некоторого набора данных тестов, используемых в современных публикациях, и просто применить его к некоторому набору данных, который может иметься как средство выделения.

Это приводит к набору функций для каждого изображения, которое можно было бы использовать для классического метода классификации, такого как SVM, логистическая регрессия, нейронные сети и т.д.

В частности, когда у кого-то недостаточно данных для обучения CNN, я могу ожидать, что это превысит конвейер, где CNN был обучен нескольким образцам.

Читайте также:  Американские ученые работают над созданием истребителей с искусственным интеллектом

Я смотрел обучающие программы tenorflow, но у них всегда есть четкий этап обучения/тестирования. Я не смог найти файл рассола (или аналогичный) с предварительно сконфигурированным экстрактором функций CNN.

Мои вопросы: существуют ли такие предварительно подготовленные сети и где я могу их найти. Альтернативно: этот подход имеет смысл? Где я могу найти вес CNN +?

Совет

ИЗМЕНИТЬ W.r.t. @john comment Я попытался использовать 'DecodeJpeg:0' и 'DecodeJpeg/contents:0' и проверил выходы, которые отличаются (: S)

import cv2, requests, numpy
import tensorflow.python.platform
import tensorflow as tf
response = requests.get('https://i.stack.imgur.com/LIW6C.jpg?s=328&g=1')
data = numpy.asarray(bytearray(response.content), dtype=np.*****)
image = cv2.imdecode(data,-1)
compression_worked, jpeg_data = cv2.imencode('.jpeg', image)
if not compression_worked: raise Exception(«Failure when compressing image to jpeg format in opencv library»)
jpeg_data = jpeg_data.tostring()
with open('./deep_learning_models/inception-v3/classify_image_graph_def.pb', 'rb') as graph_file: graph_def = tf.GraphDef() graph_def.ParseFromString(graph_file.read()) tf.import_graph_def(graph_def, name='')
with tf.Session() as sess: softmax_tensor = sess.graph.get_tensor_by_name('pool_3:0') arr0 = numpy.squeeze(sess.run( softmax_tensor, {'DecodeJpeg:0': image} )) arr1 = numpy.squeeze(sess.run( softmax_tensor, {'DecodeJpeg/contents:0': jpeg_data} )) print(numpy.abs(arr0 — arr1).max())

Таким образом, максимальная абсолютная разница 1.27649, и вообще все элементы различаются (тем более, что среднее значение самих arr0 и arr1 лежит между 0 — 0,5).

Я также ожидал бы, что для 'DecodeJpeg:0' нужна строка jpeg, а не массив numpy, почему другое имя содержит «Jpeg». @john: Не могли бы вы указать, как  что вы о своем комментарии?

Итак, я думаю, я не уверен, что это такое, поскольку я ожидал бы, что обученная нейронная сеть будет детерминированной (но хаотичной).

Источник: https://qa-help.ru/questions/izvlech-funkczii-s-pomoshhyu-predvaritelno-obuchennogo-tensorflow-cnn

Deep learning вместе с Caffe и Digits часть 1

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

Однако одним из важнейших факторов всех алгоритмов является точность обнаружения и классификации данных. Многие алгоритмы обнаружения являются неустойчивыми к различным признакам или свойствам изображения, на котором будет происходить поиск объекта.

Многие объекты, которые приходится распознавать, могут быть повернутые, искажены или же деформированы.

Применения нейронных сетей, для распознавая объекта, позволяет решить эту проблему. Однако не все сети подходят. К примеру одна из наиболее распространенных моделей нейронной сети является многослойный персептрон. Использования такой модели может привести к сильному увеличению времени и вычислительной сложности процесса обучения.

Для устранения данных недостатков применяется свёрточная нейронная сеть.

Свёрточная нейронная сеть (Convolutional neural network или CNN) — это специальная архитектура искусственных нейронных сетей. Данная сеть была предложена Яном Лекуном.

Но что же такое глубинное обучения (Deep learning) и как оно помогает нам для решения задач распознавания и классификации. Глубинное обучения это некий набор алгоритмов машинного обучения, которые пытаются моделировать абстракции в данных.

Различные архитектуры глубинного обучения использовались в различных областях и применяются все чаще и чаще, по сравнению с обычными методами.

В большинстве задач компьютерного зрения, в которых были применено глубинное обучение, показало лучший на данный момент результат.

Обратите внимание

Данная свёрточная сеть (CNN), о которой пойдет дальше речь, нацелена на эффективное распознавания изображения и входит в состав глубокого обучения.   

На рисунке ниже изображена типовая архитектура свёрточной нейронной сети.

Рисунок 1 — Архитектура свёрточной нейронной сети

Работа CNN в основном обеспечивается несколькими элементами, такими как фильтры и карта признаков. Сама идея работы заключается в построение чередующихся слоев, таких как convolution и subsampling

К преимуществам работы с такой сетью можно отнести то, что данный метод имеет устойчивость к повороту и сдвигу распознаваемого изображения а также имеет удобное распараллеливание вычислений. 
Для работы с CNN разрабртано несколько фреймворков.

Одним из таких является  Caffe. Данный фреймворк в свой работе может использовать GPU, что значительно ускоряет процесс вычислений.   Давайте попытаемся его поставить.

Данный фреймворк мы будем использовать в дальнейшем в связке с Digits, о котором мы в дальнейшем поговорим. 

Для начала нам необходимо создать папку куда мы будем все устанавливать и перейдем в эту папку:

Источник: https://sidstudio.com.ua/sidstudio-blog/deep-learning-vmeste-s-caffe-i-digits-chast-1

machine-learning example tutorial — Извлечь функции с помощью предварительно обученного (Tensorflow) CNN

Глубокое обучение было успешно применено в нескольких больших наборах данных для классификации нескольких классов (кошек, собак, автомобилей, самолетов и т. Д.), При этом выступления превосходили более простые дескрипторы, такие как Сумки функций по SIFT, цветные гистограммы и т. Д.

Тем не менее, для обучения такой сети требуется много данных для каждого класса и много времени на обучение. Однако очень часто не хватает данных или просто хочет получить представление о том, насколько хорошо может сверточную нейронную сеть, прежде чем тратить время на разработку и обучение такого устройства и сбор данных обучения.

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

Важно

Это приводит к набору признаков для каждого изображения, которое можно использовать для классического метода классификации, такого как SVM, логистическая регрессия, нейронные сети и т. Д.

В частности, когда у кого-то недостаточно данных для обучения CNN, я могу ожидать, что это превысит конвейер, где CNN был обучен нескольким образцам.

Я смотрел на обучающие программы tensorflow, но у них всегда есть четкий этап обучения / тестирования. Я не мог найти файл рассола (или аналогичный) с предварительно сконфигурированным экстрактором функций CNN.

Мои вопросы: существуют ли такие предварительно подготовленные сети и где я могу их найти. Альтернативно: этот подход имеет смысл? Где я могу найти вес CNN +?

EDIT Комментарий Wrt @ john Я попытался использовать 'DecodeJpeg:0' и 'DecodeJpeg/contents:0' и проверил выходы, которые отличаются (: S)

import cv2, requests, numpy
import tensorflow.python.platform
import tensorflow as tf response = requests.get('https://i.stack.imgur.com/LIW6C.jpg?s=328&g=1')
data = numpy.asarray(bytearray(response.content), dtype=np.uint8)
image = cv2.imdecode(data,-1) compression_worked, jpeg_data = cv2.imencode('.jpeg', image)
if not compression_worked: raise Exception(«Failure when compressing image to jpeg format in opencv library»)
jpeg_data = jpeg_data.tostring() with open('./deep_learning_models/inception-v3/classify_image_graph_def.pb', 'rb') as graph_file: graph_def = tf.GraphDef() graph_def.ParseFromString(graph_file.read()) tf.import_graph_def(graph_def, name='') with tf.Session() as sess: softmax_tensor = sess.graph.get_tensor_by_name('pool_3:0') arr0 = numpy.squeeze(sess.run( softmax_tensor, {'DecodeJpeg:0': image} )) arr1 = numpy.squeeze(sess.run( softmax_tensor, {'DecodeJpeg/contents:0': jpeg_data} )) print(numpy.abs(arr0 — arr1).max())

Таким образом, максимальная абсолютная разница составляет 1.27649 , и вообще все элементы различаются (тем более, что среднее значение самих arr0 и arr1 лежит между 0 — 0,5).

Я также ожидал бы, что 'DecodeJpeg:0' нуждается в jpeg-строке, а не в массиве numpy, почему еще это имя содержит «Jpeg». @john: Не могли бы вы сказать, насколько вы уверены в своем комментарии?

Поэтому я думаю, что я не уверен, что это такое, поскольку я ожидал бы, что обученная нейронная сеть будет детерминированной (но хаотичной).

Источник: http://code.i-harness.com/ru/q/20978c6

Deep learning: анализ текста и изображений при помощи Рекурсивных Нейронных сетей

Продолжая тему Deep Learning, получившую в последнее время большое внимание научного сообщества и индустрии, хочется рассказать про довольно необычную сферу применения нейронных сетей.

Это сфера разбора (parsing) изображений рекурсивными нейронными сетями. В этом посте я кратко опишу суть и приведу ссылки для более детального ознакомления с материалом.

Помимо этого будет ссылка на задачу из Stanford'а для желающих попробовать свои силы и получить практический результат в области deep learning для NLP.

Этот пост базируется на докладе Richard Socher, видео на английском доступно здесь.

Как оказывается, рекурсивной (или некоторой регулярной) структурой может обладать не только язык, но и изображения. Но в начале о рекурсивных свойствах предложений.

Совет

Принцип композиционности (principle of compositionality) делает предположение, что любое предложение на естественном языке можно представить в виде иерархической структуры из связных составляющих.

Смысл предложения можно представить в виде смыслов слов, в него входящих, и списка правил соединения слов в группы. Например, в предложении:

Это страна моего рождения.

Cлова «моего» и «рождения» образуют единую группу, «страна» и «моего рождения» над-группу, а всё предложение замыкает его смысл в виде иерархического представления указанных групп. Таким образом, получаются не только смыслы отдельных слов предложения, но и древесные структуры, в которые данные слова увязываются.

Читайте также:  Роботы будут учиться разговаривать, основываясь на видео из интернета

Как можно разобрать изображения по аналогии с текстовыми рекурсивными представлениями? Можно утверждать, что существует схожий принцип композиционности для изображений. Рассмотрим изображение:

Если рассмотреть некоторые сегменты изображения: здание, конусообразная крыша, оконный ряд, окна по отдельности. В указанном порядке они описывают «вложенную» рекурсивную структуру, которой можно описать здание целиком. Есть ещё параллельные зданию объекты — люди, деревья и трава.

Таким образом, изображение, например, дома можно представить виде древесной структуры, где узлы на нижних уровнях являются составляющими узлов-предков. В точности, как и в древесных структурах предложений на естественном языке.

Алгоритм на основе рекурсивных нейронных сетей авторов Socher и др. достигает 78,1% качества.

Область применения таких алгоритмов — распознавание сцен (область анализа изображений или image analysis). Исходные коды и датасеты можно посмотреть здесь.

Задачка. Для более детального ознакомления с deep learning в применении к задачам NLP на сайте Stanford'a предлагается к решению задачка: реализовать простой оконный распознаватель именных сущностей (Named Entity Recognition или NER). Описание задачки здесь. Стартовый исходный код на Java и тренировочный сет здесь. Тренировочный сет аннотирован персонами, например:

Franz PERSON

Fischler PERSON У исходного кода есть два режима: собственно, исполнение и отправка решения на сервер. Понятно, что из этих двух режимов нас интересует первый.

Обратите внимание

Довольно много материалов по теме Deep Learning можно найти на сайте Richard Socher, включая применение данного направления к распознаванию тональности (sentiment analysis).

Источник: http://dmitrykan.blogspot.com/2013/10/deep-learning.html

Простой классификатор изображений на Python с помощью библиотеки TensorFlow: пошаговое руководство

Это руководство поможет вам создать классификатор изображений, используя несколько строк кода и TensorFlow — библиотеку машинного обучения от Google.

Чтобы извлечь максимальную пользу из руководства, вам понадобится:

  • компьютер с 64-битной операционной системой Linux или macOS (пользователям Windows рекомендуем использовать виртуальную машину);
  • базовое знание Unix-команд и интерфейса командной строки;
  • базовое понимание устройства контейнеров Docker (поможет наше руководство) и виртуальных машин;
  • библиотека TensorFlow версии 1.2.0, установленная в контейнере Docker (смотрите ниже);
  • последняя версия библиотеки numpy (pip install numpy);
  • знание Python;
  • базовые навыки работы с Git (снова поможет наше руководство).

Постановка задачи

Что должен выполнить алгоритм:

  • проанализировать изображение и определить, есть ли на нём цветок;
  • если есть — определить, к какой из предложенных категорий он относится;
  • вывести процент уверенности в своём ответе.

Категории цветов, включенные во входной набор данных: ромашки, одуванчики, розы, подсолнухи и тюльпаны.

Мы будем использовать Inception v3 — готовую модель машинного обучения для тренировки на нашем собственном наборе данных. Эта нейронная сеть используется в «Кампании по широкомасштабному распознаванию образов ImageNet» (ILSVRC — ImageNet Large Scale Visual Recognition Challenge) и ранее на ней проводилось обучение описываемого алгоритма на определение категорий объектов на изображениях.

Настройка инструментов

Воспользуемся пакетом контейнеров Docker, предоставляемым TensorFlow.

Одним из преимуществ контейнера является то, что все зависимости, необходимые для запуска TensorFlow, уже присутствуют в контейнере, поэтому нет необходимости устанавливать что-либо самостоятельно (тем не менее, необходимо убедиться, что в контейнере установлена последняя версия библиотеки TensorFlow. Для этого в консоли Docker необходимо ввести pip install —upgrade tensorflow). Следуйте этим указаниям для установки панели инструментов Docker на ПК.

Docker-контейнер работает по принципу небольшого компьютера, отделённого от вашего основного компьютера. Он имеет свою собственную файловую систему, а также ему будет назначен собственный IP-адрес после успешного завершения установки. Чтобы проверить, правильно ли установлен Docker, запустите Docker Daemon, введя следующую команду в основном терминале:

sudo service docker start

Запуск образа Docker TensorFlow

Установите образ Docker TensorFlow:

sudo docker run -it gcr.io/tensorflow/tensorflow:latest-devel

После того, как вы введёте данную команду, появится новый пользователь с рут-правами и длинным номером (root@xxx), как это показано на скриншоте ниже. Обратите внимание, что в Docker будет находиться папка tensorflow.

Чтобы убедиться в корректной работе TensorFlow, вы можете набрать следующий код на Python, состоящий из трёх строк, для отображения приветствия TensorFlow в терминале Docker:

Подготовка входных данных для обучения

Чтобы модель Inception v3 могла определять цветы на изображениях, необходимо подготовить входные данные, на которых алгоритм будет обучаться. Для этого сначала следует создать каталог на вашем основном компьютере / виртуальной машине с названием tf_files, путь может выглядеть примерно так: ~/Documents/tutorial_ML/tf_files.

Если вы всё ещё находитесь в терминале Docker, можете нажать Ctrl+D, чтобы выйти из Docker и вернуться в терминал вашего основного компьютера / виртуальной машины, либо создать новое окно терминала. Для загрузки набора изображений с цветами сначала перейдите в каталог tf_files, а затем введите следующую команду в основном терминале:

curl -O http://download.tensorflow.org/example_images/flower_photos.tgz

Разархивируйте полученный файл, введя эту команду:

tar xzf flower_photos.tgz

В каталоге flower_photos вы увидите поддиректории с именами: daisy (ромашки), dandelion (одуванчики), roses (розы), sunflowers (подсолнухи) и tulips (тюльпаны).

Привязка набора данных к образу Docker TensorFlow

Так как образ Docker TensorFlow не содержит входного набора данных с изображениями, нужно связать эти файлы, набрав команду в терминале вашего основного компьютера / виртуальной машины, которая активирует терминал Docker:

sudo docker run -it -v $HOME/tf_files:/tf_files gcr.io/tensorflow/tensorflow:latest-devel

Здесь $HOME соответствует директории ~/Documents/tutorial_ML/. Чтобы узнать, корректно ли связаны изображения, вы можете набрать следующую команду в терминале:

ls /tf_files

Вывод команды должен содержать папку с названием flower_photos.

Получение примера исходного кода

Перейдите в каталог tensorflow, который расположен в файловой системе Docker, и введите git pull, чтобы получить последнюю версию кода из git-репозитория TensorFlow. Полученный исходный код будет располагаться по следующему пути: /tensorflow/tensorflow/examples/image_retraining/.

Для обучения введите следующую команду и нажмите ENTER:

# python tensorflow/examples/image_retraining/retrain.py
—bottleneck_dir=/tf_files/bottlenecks
—how_many_training_steps 500
—model_dir=/tf_files/inception
—output_graph=/tf_files/retrained_graph.pb
—output_labels=/tf_files/retrained_labels.txt
—image_dir /tf_files/flower_photos

Пока модель Inception обрабатывается (а это займёт продолжительное время), вы увидите, что сначала создаются критические параметры (bottlenecks), как это показано на скриншоте ниже.

Критические параметры — это последний слой перед основным слоем начальной модели, который будет классифицировать изображения.

В них заключается содержательное, но при этом компактное резюме изображения, которое помогает классификатору сделать наиболее точный выбор:

После того, как обучение критических параметров завершится, алгоритм перейдёт на финальный этап обучения. Во время обучения в терминале Docker будут отображены следующие параметры: точность обучения (train accuracy) и точность проверки (validation accuracy). Вы увидите аналогичную скриншоту ниже картину. В конце будет отображено значение точности от 85% до 99%:

Тестирование классификатора изображений

В каталоге /tensorflow/.git, который находится в корневой директории Docker, создайте файл label_image.py. Введите следующие строки кода и сохраните его:

# -*- coding: utf-8 -*-
import tensorflow as tf
import sys
from numpy import argsort image_path = sys.argv[1] # считывает файл image_data
image_data = tf.gfile.FastGFile(image_path, 'rb').read() # загружает выбранный файл и удаляет символ разрыва строки
label_lines = [line.rstrip() for line in tf.gfile.GFile(«/tf_files/retrained_labels.txt»)] # отделяет граф от файла
with tf.gfile.FastGFile(«/tf_files/retrained_graph.pb», 'rb') as f: graph_def = tf.GraphDef() graph_def.ParseFromString(f.read()) _ = tf.import_graph_def(graph_def, name='') # загружает image_data как входные данные и отображает первые предположения with tf.Session() as sess: softmax_tensor = sess.graph.get_tensor_by_name('final_result:0') predictions = sess.run(softmax_tensor, {'DecodeJpeg/contents:0': image_data}) # сортирует категории после первых предположений в порядке роста уверенности
top_k = predictions[0].argsort()[-len(predictions[0]):][::-1] for node_id in top_k: human_string = label_lines[node_id] score = predictions[0][node_id] print('%s (score = %.5f)' % (human_string, score))

Если вы вышли из Docker, введите следующую команду, чтобы перезапустить контейнер:

docker run -it -v $HOME/tf_files:/tf_files gcr.io/tensorflow/tensorflow:latest-devel

Выполните следующую команду в терминале Docker, чтобы протестировать, например, изображение, на котором присутствует ромашка:

# python /tensorflow/.git/label_image.py /tf_files/flower_photos/daisy/21652746_cc379e0eea_m.jpg

Как видно на скриншоте ниже, при тестировании выбранного изображения было получено число 0,98929. Это указывает на то, что классификатор на 98% уверен, что изображение содержит цветок ромашки.

Важно

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

Это говорит о том, что алгоритм определил, что наличие какого-либо цветка маловероятно на тестируемом изображении:

Предлагаем поэкспериментировать, подготовив другой набор входных данных, чтобы создать свой собственный классификатор изображений. Удачи в обучении!

Перевод статьи «Machine Learning using TensorFlow in 10 Lines of Code»

Источник: https://tproger.ru/translations/image-classifier-tensorflow/

Ссылка на основную публикацию