VGG16 — сверточная сеть для выделения признаков изображений

23 ноября 2018
vgg16 нейронная сеть

VGG16 — сверточная сеть для выделения признаков изображений

VGG16 — модель сверточной нейронной сети, предложенная K. Simonyan и A. Zisserman из Оксфордского университета в статье “Very Deep Convolutional Networks for Large-Scale Image Recognition”. Модель достигает точности 92.7% —…

VGG16 — модель сверточной нейронной сети, предложенная K. Simonyan и A. Zisserman из Оксфордского университета в статье “Very Deep Convolutional Networks for Large-Scale Image Recognition”. Модель достигает точности 92.7% — топ-5, при тестировании на ImageNet в задаче распознавания объектов на изображении. Этот датасет состоит из более чем 14 миллионов изображений, принадлежащих к 1000 классам.

VGG16 — одна из самых знаменитых моделей, отправленных на соревнование ILSVRC-2014. Она является улучшенной версией AlexNet, в которой заменены большие фильтры (размера 11 и 5 в первом и втором сверточном слое, соответственно) на несколько фильтров размера 3х3, следующих один за другим. Сеть VGG16 обучалась на протяжении нескольких недель при использовании видеокарт NVIDIA TITAN BLACK.

слои vgg16

Датасет

ImageNet — набор данных, состоящий из более чем 15 миллионов размеченных высококачественных изображений, разделенных на 22000 категорий. Изображения были взяты из интернета и размечены вручную людьми-разметчиками с помощью краудсорсинговой площадки Mechanical Turk от Amazon.

В 2010 году, как часть Pascal Visual Object Challenge, началось ежегодное соревнование — ImageNet Large-Scale Visual Recognition Challenge (ILSVRC). В ILSVRC используется подвыборка из ImageNet размером 1000 изображений в каждой из 1000 категорий. Таким образом, тренировочный сет состоял из примерно 1.2 миллионов изображений, проверочный — 50000 изображений, тестовый — 150000 изображений. Так как ImageNet состоит из изображений разного размера, то их необходимо было привести к единому размеру 256х256. Если изображение представляет из себя прямоугольник, то оно масштабируется и из него вырезается центральная часть размером 256х256.

Архитектура

Архитектура VGG16 представлена на рисунке ниже.

Архитектура нейросети vgg16

На вход слоя conv1 подаются RGB изображения размера 224х224. Далее изображения проходят через стек сверточных слоев, в которых используются фильтры с очень маленьким рецептивным полем размера 3х3 (который является наименьшим размером для получения представления о том,где находится право/лево, верх/низ, центр).

В одной из конфигураций используется сверточный фильтр размера 1х1, который может быть представлен как линейная трансформация входных каналов (с последующей нелинейностью). Сверточный шаг фиксируется на значении 1 пиксель. Пространственное дополнение (padding) входа сверточного слоя выбирается таким образом, чтобы пространственное разрешение сохранялось после свертки, то есть дополнение равно 1 для 3х3 сверточных слоев. Пространственный пулинг осуществляется при помощи пяти max-pooling слоев, которые следуют за одним из сверточных слоев (не все сверточные слои имеют последующие max-pooling). Операция max-pooling выполняется на окне размера 2х2 пикселей с шагом 2.

После стека сверточных слоев (который имеет разную глубину в разных архитектурах) идут три полносвязных слоя: первые два имеют по 4096 каналов, третий — 1000 каналов (так как в соревновании ILSVRC требуется классифицировать объекты по 1000 категориям; следовательно, классу соответствует один канал). Последним идет soft-max слой. Конфигурация полносвязных слоев одна и та же во всех нейросетях.

Все скрытые слои снабжены ReLU. Отметим также, что сети (за исключением одной) не содержат слоя нормализации (Local Response Normalisation), так как нормализация не улучшает результата на датасете ILSVRC, а ведет к увеличению потребления памяти и времени исполнения кода.

Конфигурация

Конфигурации сверточных сетей представлены на рисунке 2. Каждая сеть соответствует своему имени (A-E). Все конфигурации имеют общую конструкцию, представленную в архитектуре, и различаются только глубиной: от 11 слоев с весами в сети A (8 сверточных и 3 полносвязных слоя) до 19 (16 сверточных и 3 полносвязных слоя). Ширина сверточных слоев (количество каналов) относительно небольшая: от 64 в первом слое до 512 в последнем с увеличением количества каналов в 2 раза после каждого max-pooling слоя.

vgg16
Рисунок 2

Реализация

К сожалению, сеть VGG имеет два серьезных недостатка:

  1. Очень медленная скорость обучения.
  2. Сама архитектура сети весит слишком много (появляются проблемы с диском и пропускной способностью)

Из-за глубины и количества полносвязных узлов, VGG16 весит более 533 МБ. Это делает процесс развертывания VGG утомительной задачей. Хотя VGG16 и используется для решения многих проблем классификации при помощи нейронных сетей, меньшие архитектуры более предпочтительны (SqueezeNet, GoogLeNet и другие). Несмотря на недостатки, данная архитектура является отличным строительным блоком для обучения, так как её легко реализовать.

[Pytorch]

[Tensorflow]

[Keras]

Результаты

VGG16 существенно превосходит в производительности прошлые поколения моделей в соревнованиях ILSVRC-2012 and ILSVRC-2013. Достигнутый VGG16 результат сопоставим с победителем соревнования по классификации (GoogLeNet с ошибкой 6.7%) в 2014 году и значительно опережает результат Clarifai победителя ILSVRC-2013, который показал ошибку 11.2% с внешними тренировочными данными и 11.7% без них. Что касается одной сети, архитектура VGG16 достигает наилучшего результата (7.0% ошибки на тесте), опережаю одну сеть GoogLeNet на 0.9%.

Было показано, что глубина представления положительно влияет на точность классификации, и state-of-the-art результат на соревновательном датасете ImageNet может быть достигнут с помощью обычной сверточной нейронной сети с значительно большей глубиной.

FaceNet — пример простой системы распознавания лиц с открытым кодом Github

16 ноября 2018

FaceNet — пример простой системы распознавания лиц с открытым кодом Github

Распознавание лица — последний тренд в авторизации пользователя. Apple использует Face ID, OnePlus — технологию Face Unlock. Baidu использует распознавание лица вместо ID-карт для обеспечения доступа в офис, а при…

Распознавание лица — последний тренд в авторизации пользователя. Apple использует Face ID, OnePlus — технологию Face Unlock. Baidu использует распознавание лица вместо ID-карт для обеспечения доступа в офис, а при повторном пересечении границы в ОАЭ вам нужно только посмотреть в камеру.

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

Ссылка на Гитхаб, кому нужен только код

Немного о FaceNet

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

Триплет потерь

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

  • f(a) это энкодинг якоря
  • f(p) это энкодинг похожих лиц (positive)
  • f(n) это энкодинг непохожих лиц (negative)
  • Альфа — это константа, которая позволяет быть уверенным, что сеть не будет пытаться оптимизировать напрямую f(a) — f(p) = f(a) — f(n) = 0
  • […]+ экиввалентено max(0, sum)

Сиамские сети

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

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

В FaceNet это делается путем вычисления расстояния между двумя выходами.

Реализация

Переходим к практике.

В реализации мы будем использовать Keras и Tensorflow. Кроме того, мы используем два файла утилиты из репозитория deeplayning.ai, чтобы абстрагироваться от взаимодействий с сетью FaceNet.

  • fr_utils.py содержит функции для подачи изображений в сеть и получения кодирования изображений;
  • inception_blocks_v2.py содержит функции для подготовки и компиляции сети FaceNet.

Компиляция сети FaceNet

Первое, что нам нужно сделать, это собрать сеть FaceNet для нашей системы распознавания лиц.

import os
import glob
import numpy as np
import cv2
import tensorflow as tf
from fr_utils import *
from inception_blocks_v2 import *
from keras import backend as K
K.set_image_data_format('channels_first')
FRmodel = faceRecoModel(input_shape=(3, 96, 96))
def triplet_loss(y_true, y_pred, alpha = 0.3):
    anchor, positive, negative = y_pred[0], y_pred[1], y_pred[2]

    pos_dist = tf.reduce_sum(tf.square(tf.subtract(anchor,
               positive)), axis=-1)
    neg_dist = tf.reduce_sum(tf.square(tf.subtract(anchor, 
               negative)), axis=-1)
    basic_loss = tf.add(tf.subtract(pos_dist, neg_dist), alpha)
    loss = tf.reduce_sum(tf.maximum(basic_loss, 0.0))
   
    return loss
FRmodel.compile(optimizer = 'adam', loss = triplet_loss, metrics = ['accuracy'])
load_weights_from_FaceNet(FRmodel)

Мы начнем инициализпцию нашей сети со входа размерности (3, 96, 96). Это означает, что картинка передается в виде трех каналов RGB и размерности 96×96 пикселей.

Теперь давайте определим Triplet Loss функцию. Функция в сниппете кода выше удовлетворяет уравнению Triplet Loss, которое мы определили в предыдущей секции.

Если вы не знакомы с фреймворком TensorFlow, ознакомьтесь с документацией.

Сразу после того, как мы определили функцию потерь, мы можем скомпилировать нашу систему распознавания лиц с помощью Keras. Мы будем использовать Adam optimizer для минимизации потерь, подсчитанных с помощью функции Triplet Loss.

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

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

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

def prepare_database():
    database = {}
    for file in glob.glob("images/*"):
        identity = os.path.splitext(os.path.basename(file))[0]
        database[identity] = img_path_to_encoding(file, FRmodel)
    return database

Для каждого изображения мы преобразуем данные изображения в 128 float чисел. Этим занимается функция img_path_to_encoding. Функция принимает на вход путь до изображения и «скармливает» изображение нашей распознающей сети, после чего возвращают результаты работы сети.

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

Распознавание лиц

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

def who_is_it(image, database, model):
    encoding = img_to_encoding(image, model)
    
    min_dist = 100
    identity = None
    
    # Loop over the database dictionary's names and encodings.
    for (name, db_enc) in database.items():
        dist = np.linalg.norm(db_enc - encoding)
        print('distance for %s is %s' %(name, dist))
        if dist < min_dist:
            min_dist = dist
            identity = name
    
    if min_dist > 0.52:
        return None
    else:
        return identity

Загружаем новое изображение в функцию img_to_encoding. Функция обрабатывает изображения, используя FaceNet и возвращает закодированное изображение. Теперь мы можем сделать предположение о наиболее вероятной личности этого человека.

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

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

 if min_dist > 0.52: 
     return None 
 else:
     return identity

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

На GitHub есть демо работы полученной сети, с входом от простой вебкамеры.

Заключение

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


Интересные статьи:

Нейросеть диагностирует болезнь Альцгеймера с точностью 94%

5 октября 2018

Нейросеть диагностирует болезнь Альцгеймера с точностью 94%

Согласно данным Alzheimer’s Association, только в США болезнью Альцгеймера страдают 5,7 миллиона человек. В эту цифру входит 5,5 миллионов больных старше 65 лет, и 200 000 человек моложе 65 с…

Согласно данным Alzheimer’s Association, только в США болезнью Альцгеймера страдают 5,7 миллиона человек. В эту цифру входит 5,5 миллионов больных старше 65 лет, и 200 000 человек моложе 65 с ранними симптомами болезни. Учёные из Стэнфорда разработали алгоритм, который поможет врачам в ранней диагностике патологических изменений мозга. Модель распознаёт болезнь Альцгеймера и её биомаркеры на МРТ снимках с точностью 94%.

Метод

Команда разработала трёхмерную свёрточную нейронную сеть (3D-CNN), используя TensorFlow с расширенной cuDNN. Алгоритм обучили на данных из датасета ADNI, используя только МРТ-снимки. «Одно из достижений нашей работы — минимальная предварительная обработка МРТ, которая включает только удаление небольшого количества артефактов и обрезку изображений», — заявили исследователи в статье.

Алгоритм - нейросеть определяет болезнь Альцгеймера по МРТ снимкам
Архитектура 3D-CNN

Результаты

Нейронная сеть распознаёт патологические изменения, указывающие на болезнь Альцгеймера с точностью 94%. Результат превосходит предыдущие state-of-the-art методы распознавания. Алгоритм ошибается реже, чем более сложные архитектуры, потому что меньше подвержен переобучению. Кроме того, модель выявляет биомаркеры болезни — команда обнаружила, что область гиппокампа в мозге имеет решающее значение при диагностике заболевания.

болезнь Альцгеймера по МРТ снимкам
Сравнение результатов с другими методами

TensorFlow туториал. Часть 4: глубокое обучение

1 октября 2018
Глубокое обучение с Tensorflow

TensorFlow туториал. Часть 4: глубокое обучение

Теперь, когда вы изучили и подготовили свои данные, пришло время создать архитектуру нейронной сети с помощью пакета TensorFlow! Предыдущие статьи: TensorFlow туториал. Часть 1: тензоры и векторы TensorFlow туториал. Часть…

Теперь, когда вы изучили и подготовили свои данные, пришло время создать архитектуру нейронной сети с помощью пакета TensorFlow!

Предыдущие статьи:

Моделирование нейронной сети

Пришло время построить нейронную сеть, слой за слоем.

Если вы еще этого не сделали, импортируйте tensorflow в рабочую область под названием tf. Затем инициализируйте Graph с помощью функции Graph(). Используйте эту функцию для определения вычислений. Обратите внимание, что с помощью Graph вы ничего не вычисляете, поскольку она не принимает на вход никаких переменных. Graph лишь определяет операции, которые вы хотите выполнить позже.

C помощью as_default() установите контекст по умолчанию. as_default() возвращает менеджер контекста, который устанавливает заданный вами Graph графом по умолчанию. Используйте этот метод, если хотите создать несколько графов в одном процессе: с помощью этой функции создается глобальный граф по умолчанию, в который будут добавляться все операции, если вы целенаправленно не создадите еще один.

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

  • Во-первых, вы задаете плейсхолдеры для входных данных и меток, потому что пока что не задаете «настоящие» данные. Помните, что плейсхолдеры — это неинициализированные переменные, которые будут инициализированы сессией при ее запуске. Когда вы, наконец, запустите сессию, эти плейсхолдеры получат значения датасета, которые вы передадите в функцию run()!
  • Затем вы создаете сеть. Сначала нужно выполнить сглаживание входных данных с помощью функции ыхflatten(), которая создаст массив размерности [None, 784] вместо массива размерности [None, 28, 28], который является исходным массивом ваших изображений в оттенках серого.
  • После того, как вы произвели сглаживание данных, нужно создать полностью подключенный слой, который генерирует логиты размера [None, 62]. Логиты — это функции, работающие с немасштабированным выходным результатом предыдущих слоев и использующие относительную шкалу для проверки линейности единиц измерения.
  • После построения многослойного персептрона вы можете определить функцию потерь. Выбор функции потерь зависит от задачи, которую вы решаете. В нашем случае используйте эту:
sparse_softmax_cross_entropy_with_logits()
  • Эта функция вычисляет разреженную кросс-энтропию softmax между логитами и метками. Другими словами, она измеряет вероятность ошибки в дискретных задачах классификации, в которых классы являются взаимоисключающими. Это означает, что каждый элемент данных принадлежит только одному классу. В нашем случае, например, дорожный знак содержит только одну метку. Помните, хотя регрессия используется для предсказания непрерывных значений, классификация используется для предсказания дискретных значений или классов элементов данных. Вы выполняете свертку этой функции с reduce_mean(), которая вычисляет среднее значение элементов вдоль измерений тензора.
  • Также вам нужно установить оптимизатор обучения. Одни из наиболее популярных алгоритмов оптимизации — Stochastic Gradient Descent (SGD), ADAM и RMSprop. В зависимости от выбранного вами алгоритма необходимо настроить параметры, например, скорость обучения. В этом случае вы выбираете оптимизатор ADAM, для которого скорость обучения выбирается равной 0,001.
  • Наконец, вы инициализируете операции, выполняемые перед началом обучения.
# Импорт `tensorflow` 

import tensorflow as tf

# Инициализация плейсхолдеров 

x = tf.placeholder(dtype = tf.float32, shape = [None, 28, 28])

y = tf.placeholder(dtype = tf.int32, shape = [None])

# Сглаживание входных данных

images_flat = tf.contrib.layers.flatten(x)

# Полностью подключенный слой 

logits = tf.contrib.layers.fully_connected(images_flat, 62, tf.nn.relu)

# Определение функции потерь

losstf.reduce_mean(tf.nn.sparse_softmax_cross_entropy_with_logits(labels = y, logits = logits))

# Определение оптимизатора 

train_op = tf.train.AdamOptimizer(learning_rate=0.001).minimize(loss)

# Конвертация логитов в индексы меток

correct_pred = tf.argmax(logits, 1)

# Определение метрики точности

accuracy = tf.reduce_mean(tf.cast(correct_pred, tf.float32))

Вы только что успешно создали свою первую нейронную сеть с помощью TensorFlow!

Если хотите, также можно вывести значения (большинства) переменных, чтобы получить краткую сводку того, что вы только что запрограммировали:

print("images_flat: ", images_flat)

print("logits: ", logits)

print("loss: ", loss)

print("predicted_labels: ", correct_pred)

Совет. Если вы видите ошибку module ‘pandas’ has no attribute ‘computation’, обновите пакеты dask, запустив команду pip install —upgrade dask в командной строке.

Запуск нейронной сети

Теперь, когда вы собрали модель cети слой за слоем, пришло время запустить ее! Для этого сначала инициализируйте сессию с помощью Session(), которой вы передаете граф graph, определенный в предыдущем разделе. Затем вы можете запустить сессию с помощью run(), которой вы передаете инициализированные операции в форме переменной init, которую вы также определили в предыдущем разделе.

Затем можно использовать эту инициализированную сессию для запуска тренировочных циклов. В этом случае вы выбираете 201, потому что хотите зарегистрировать последнее значение loss_value. В цикле нужно запустить сессию с оптимизатором обучения и метрикой потерь (или точностью), которую вы определили в предыдущем разделе. Также нужно передать аргумент функции feed_dict, с помощью которой вы подаете данные в модель. Через каждые 10 циклов вы получаете лог, который даст вам больше информации о потерях.

Как было показано в разделе об основах TensorFlow, нет необходимости закрывать сессию вручную; это уже сделано для вас. Хотите опробовать другую конфигурацию? Вам, вероятно, понадобится сделать это с помощью sess.close(), если вы определили свою сессию как sess, как в блоке ниже:

tf.set_random_seed(1234)

sess = tf.Session()

sess.run(tf.global_variables_initializer())

for i in range(201):

print('EPOCH', i)

_, accuracy_val = sess.run([train_op, accuracy], feed_dict={x: images28, y: labels})

if i % 10 == 0:

print("Loss: ", loss)

print('DONE WITH EPOCH')

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

tf.set_random_seed(1234)

with tf.Session() as sess:

sess.run(tf.global_variables_initializer())

for i in range(201):

_, loss_value = sess.run([train_op, loss], feed_dict={x: images28, y: labels})

if i % 10 == 0:

print("Loss: ", loss)

Обратите внимание, что используется функция global_variables_initializer(), потому что функция initialize_all_variables() устарела.

Вы успешно обучили свою модель! Это было не слишком сложно, не так ли?

Оценка вашей нейронной сети

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

Давайте воспользуемся matplotlib и выведем дорожные знаки для визуального сравнения:

# Импорт `matplotlib`

import matplotlib.pyplot as plt

import random

# Выбор 10 случайных изображений

sample_indexes = random.sample(range(len(images28)), 10)

sample_images = [images28[i] for i in sample_indexes]

sample_labels = [labels[i] for i in sample_indexes]

# Запуск операции "correct_pred"

predicted = sess.run([correct_pred], feed_dict={x: sample_images})[0]

# Вывод истинных и предсказанных меток

print(sample_labels) print(predicted)

# Вывод предсказанных и истинных изображений

fig = plt.figure(figsize=(10, 10))

for i in range(len(sample_images)):

truth = sample_labels[i]

prediction = predicted[i]

plt.subplot(5, 2,1+i)

plt.axis('off') color='green' if truth == prediction else 'red'

plt.text(40, 10, "Truth: {0}\nPrediction: {1}".format(truth, prediction), fontsize=12, color=color)

plt.imshow(sample_images[i], cmap="gray")

plt.show()

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

Обратите внимание, что используется функция load_data(), которая была определена в начале этого руководства.

# Импорт`skimage`

from skimage import transform

# Загрузка данных проверки

test_images, test_labels = load_data(test_data_directory)

# Преобразование изображений в 28 х 28 пикселей

test_images28 = [transform.resize(image, (28, 28)) for image in test_images]

# Конвертация в оттенки серого

from skimage.color import rgb2gray

test_images28 = rgb2gray(np.array(test_images28))

# Вывод предсказаний и полного набора данных проверки

predicted = sess.run([correct_pred], feed_dict={x: test_images28})[0]

# Вычисление совпадений 

match_count = sum([int(y == y_) for y, y_ in zip(test_labels, predicted)])

# Вычисление точности

accuracy = match_count / len(test_labels)

# Вывод точности

print("Accuracy: {:.3f}".format(accuracy))

Не забудьте закрыть сессию помощью sess.close(), если вы не использовали команду with tf.Session() as sess:, чтобы начать сеанс TensorFlow.

Что делать дальше с моделью?

Если вы хотите продолжить работу с этим датасетом и моделью, которую вы построили в этом туториале, попробуйте выполнить следующее:

  • Примените регуляризованный LDA к данным перед добавлением в ​модель. Это предложение исходит от одной из оригинальных работ, написанных исследователями, которые собрали и проанализировали этот датасет.
  • Следите за погрешностью обучения и тестирования во время обучения нейронной сети. Остановите обучение, когда обе ошибки уменьшатся, а затем внезапно увеличатся — это признак того, что нейронная сеть начала переобучаться.
  • Пробуйте разные оптимизаторы.

Если знаете английский язык, обязательно ознакомьтесь с книгой Machine Learning With TensorFlow, написанной Nishant Shukla.


Интересные статьи:

TensorFlow туториал. Часть 3: работа с данными

26 сентября 2018
tensorflow анализ и работа с данными

TensorFlow туториал. Часть 3: работа с данными

Пора переходить к работе с реальными данными! Мы будем работать с дорожными знаками Бельгии. Дорожный трафик — понятная тема, но не помешает уточнить, какие данные включены в датасет, перед тем…

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


Перед прочтением статьи рекомендуем изучить:


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

  • Текст на дорожных знаках в Бельгии обычно приведен на голландском и французском языках. Это полезно знать, но для датасета, с которым вы будете работать, это не слишком важно!
  • В Бельгии шесть категорий дорожных знаков: предупреждающие знаки, знаки приоритета, запрещающие знаки, предписывающие знаки, знаки, связанные с парковкой и стоянкой у дорог, и, наконец, обозначения.
  • 1 января 2017 года с бельгийских дорог было снято более 30 000 дорожных знаков. Это были запрещающие знаки, ограничивающие максимальную скорость вождения.
  • Снятие знаков связано с длительной дискуссией в Бельгии (и во всем Европейском Союзе) о чрезмерном количестве дорожных знаков.

Загрузка датасета

Теперь, когда вы знакомы со спецификой бельгийского трафика, пришло время скачать датасет. Вы должны скачать два zip-файла в разделе «BelgiumTS for Classification (cropped images)» с названиями «BelgiumTSC_Training» и «BelgiumTSC_Testing».

Совет. Если вы скачали файлы или сделаете это после прочтения туториала, взгляните на структуру папок, которые вы загрузили! Вы увидите, что папки тестирования и обучения содержат 61 подпапку, соответствующую 61 типам дорожных знаков, которые вы будете использовать для классификации в этом туториале. Кроме того, вы обнаружите, что файлы имеют расширение .ppm или Portable Pixmap Format. Вы скачали изображения дорожных знаков!

Давайте начнем с импорта данных в рабочую область. Начнем со строк кода, которые отображаются под пользовательской функцией load_data():

  • Сначала установите ROOT_PATH. Этот путь к каталогу, в котором находятся данные для обучения и тестирования.
  • Затем добавьте пути к вашему ROOT_PATH с помощью функции join(). Сохраните эту пути в train_data_directory и test_data_directory.
  • Вы увидите, что после этого можно вызвать функцию load_data() и передать в нее train_data_directory.
  • Теперь сама функция load_data() запускается путем сбора всех подкаталогов, присутствующих в train_data_directory; она делает это с помощью спискового включения, что является естественным способом составления списков — то есть, если вы найдете что-то в train_data_directory, вы проверяете, папка ли это и, если так и есть, добавляете ее в свой список. Помните, что каждый подкаталог представляет собой метку.
  • Затем вам нужно перебрать подкаталоги. Сначала вы инициализируете два списка, labels и images. Затем вы собираете пути подкаталогов и имена файлов изображений, которые хранятся в этих подкаталогах. После этого можно собрать данные в двух списках с помощью функции append().
def load_data(data_directory):

directories = [d for d in os.listdir(data_directory)

if os.path.isdir(os.path.join(data_directory, d))]

labels = []

images = [] for d in directories:

label_directory = os.path.join(data_directory, d)

file_names = [os.path.join(label_directory, f)

for f in os.listdir(label_directory)

if f.endswith(".ppm")]

for f in file_names:

images.append(skimage.data.imread(f))

labels.append(int(d))

return images, labels

ROOT_PATH = "/your/root/path"

train_data_directory = os.path.join(ROOT_PATH, "TrafficSigns/Training")

test_data_directory = os.path.join(ROOT_PATH, "TrafficSigns/Testing")

images, labels = load_data(train_data_directory)

Обратите внимание, что в приведенном выше блоке данные для обучения и тестирования находятся в папках с названиями «training» и «testing», которые являются подкаталогами другого каталога «TrafficSigns». На компьютере это может выглядеть примерно так: «/Users /Name /Downloads /TrafficSigns», а затем две подпапки под названием «training» и «testing».

Исследование данных

Когда данные загружены, пришло время для их исследования! Для начала можно провести элементарный анализ с помощью атрибутов ndim и size массива images:

Обратите внимание, что переменные images и labels являются списками, поэтому вам, возможно, придется воспользоваться np.array() для преобразования переменных в массив в рабочей области. Но здесь это уже сделано для вас!

# Вывести размерность 'images'
print(images.ndim)

# Вывести количество элементов в 'images'
print(images.size)

# Вывести первое значение 'images'
images[0]

Обратите внимание, что значение images[0], которое вы вывели, на самом деле представляют собой одно изображение, представленное массивами в массиве! Это может показаться нелогичным, но вы привыкните к этому, когда будете работать с изображениями в проектах машинного или глубокого обучения.

Далее, обратимся к labels, но на этот раз никаких сюрпризов не будет:

# Вывести размерность 'labels'
print(labels.ndim)

# Вывести число элементов в 'labels'
print(labels.size)

# Вывести длину массива 'labels'
print(len(set(labels)))

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

Совет. Попробуйте добавить в свои массивы следующие атрибуты, чтобы получить дополнительную информацию о распределении памяти: длину одного элемента массива в байтах и ​​общее количество байтов, занимаемых элементами массива: flags, itemsize и nbytes.

Затем можно изучить распределение дорожных знаков по типам:

# Импортировать модуль 'pyplot'
import matplotlib.pyplot as plt

# Построить гистограмму с 64 точками - значениями 'labels'
plt.hist(labels, 62)

# Вывести график
plt.show()

Отлично! Давайте посмотрим на полученную гистограмму:

изучение данных в tensorflow

Хорошо видно, что не все типы дорожных знаков одинаково представлены в датасете. Это то, с чем вы столкнетесь позже, когда будете работать с данными, прежде чем приступать к моделированию нейронной сети. На первый взгляд видно: количество знаков типов 22, 32, 38 и 61 определенно преобладает над остальными. Запомните это, в следующем разделе вам пригодится эта информация.

Визуализация данных

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

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

  • Во-первых, убедитесь, что вы импортируете модуль pyplot пакета matplotlib под общепринятым названием plt.
  • Затем создайте список из 4 случайных чисел. Они будут использоваться для выбора дорожных знаков из массива images, загруженного в прошлом разделе. В нижеследующем примере это будут числа 300, 2250, 3650 и 4000.
  • Затем для каждого элемента этого списка, от 0 до 4, вы создаете графики без осей (чтобы они не мешали сосредоточиться на изображениях). На этих графиках вы увидите конкретные изображения из массива images, которые соответствует номеру индекса i. На первом шаге цикла вы получите i = 300, во втором — 2250 и так далее. Наконец, нужно расположить графики так, чтобы между ними было достаточно пространства.
  • Последнее — выведите ваши графики с помощью функции show()!

Код:

# Импорт модуля 'pyplot' 'matplotlib`

import matplotlib.pyplot as plt

# Задание (случайных) номеров изображений, которые вы хотите вывести

traffic_signs = [300, 2250, 3650, 4000]

# Заполнение графиков изображениями

for i in range(len(traffic_signs)):

plt.subplot(1, 4, i+1)

plt.axis('off')

plt.imshow(images[traffic_signs[i]])

plt.subplots_adjust(wspace=0.5)

plt.show()

Как можно догадаться, знаки каждого из 62 типов отличаются друг от друга.

Но что еще можно заметить? Взглянем на изображения ниже:

работа с данными

Эти четыре изображения имеют разный размер!

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

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

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

# Импорт 'matplotlib'

import matplotlib.pyplot as plt

# Задание (случайных) номеров изображений, которые вы хотите вывести

traffic_signs = [300, 2250, 3650, 4000]

# Заполнение графиков изображениями и вывод размеров

for i in range(len(traffic_signs)):

plt.subplot(1, 4, i+1)

plt.axis('off')

plt.imshow(images[traffic_signs[i]])

plt.subplots_adjust(wspace=0.5)

plt.show()

print("shape: {0}, min: {1}, max: {2}".format(images[traffic_signs[i]].shape, images[traffic_signs[i]].min(), images[traffic_signs[i]].max()))

Обратите внимание на то, как вы используется метод format() в строке «shape: {0}, min: {1}, max: {2}», чтобы заполнить аргументы {0}, {1} и {2}.

визуализация данных tensorflow

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

# Импорт модуля 'pyplot' 'matplotlib'

import matplotlib.pyplot as plt

# Задание типов

unique_labels = set(labels)

# Инициализация графика

plt.figure(figsize=(15, 15))

# Задание счетчика

i = 1

# Для каждого типа:

for label in unique_labels:

# Выбирается первое изображение каждого типа:

image = images[labels.index(label)]

# Задание 64 графиков

plt.subplot(8, 8, i)

# Выключение осей

plt.axis('off')

# Добавление заголовка каждому графику

plt.title("Label {0} ({1})".format(label, labels.count(label)))

# Увеличить значение счетчика на 1

i += 1

# Вывод первого изображения

plt.imshow(image)

# Вывод всего графика

plt.show()

Обратите внимание, что даже если вы определяете 64 графика, не на всех из них будут изображения (так как есть всего 62 типа знаков!). Обратите также внимание на то, что опять же, вы не выводите оси, чтобы не отвлекаться на них.

анализ данных в Tensorflow

Как было видно из гистограммы, количество фотографий знаков с типами 22, 32, 38 и 61 значительно больше остальных. Эта видно из из графика выше: есть 375 снимков с меткой 22, 316 снимков с меткой 32, 285 снимков с меткой 38 и, наконец, 282 снимка с меткой 61.

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

Давайте рассмотрим более подробно: видно, что метки 22 и 32 являются запретительными знаками, но метки 38 и 61 являются указательными знаками и знаками приоритета, соответственно. Это означает, что между этими четырьмя знаками нет непосредственной связи, за исключением того факта, что половина знаков, наиболее широко представленных в датасетах, являются запрещающими.

Извлечение признаков

Теперь, когда вы тщательно изучили свои данные, пришло время засучить рукава! Давайте кратко отметим, что вы обнаружили, чтобы убедиться, что вы не забыли какие-либо моменты:

  • Изображения имеют разный размер;
  • Есть 62 метки (помним, что нумерация меток начинаются с 0 и заканчиваются на 61);
  • Распределение типов знаков трафика довольно неравномерно; между знаками, которые в большом количестве присутствовали в наборе данных, нет никакой связи.

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

Масштабирование изображений

Чтобы сделать размеры изображений одинаковыми, можно воспользоваться функцией skimage или библиотекой Scikit-Image, которая представляет собой набор алгоритмов для обработки изображений.

Во втором случае случае будет полезен модуль transform, так как в нем есть функция resize(); она снова использует списковое включение, чтобы сделать разрешение снимков равным 28×28 пикселей. Повторюсь: вы увидите, что фактически составляете список — для каждого изображения в массиве image вы выполните операцию преобразования, которую позаимствуете из библиотеки skimage. Наконец, вы сохраняете результат в переменной images28:

# Импорт модуля 'transform' из 'skimage'

import transform

# Масштабирование изображений в 'image'

array images28 = [transform.resize(image, (28, 28)) for image in images]

Выглядит очень просто, не так ли?

Обратите внимание, что изображения теперь четырехмерны: если вы конвертируете images28 в массив и привязываете атрибут shape, видно, что размеры imeges28 равны (4575, 28, 28, 3). Изображения 784-мерные (потому что ваши изображения имеют размер 28 на 28 пикселей).

Вы можете проверить результат операции масштабирования путем повторного использования кода, который вы использовали выше, для построения 4 случайных изображений с помощью переменной traffic_signs; просто не забудьте изменить images на images28.

Результат:

результат визуализации данных tensorflow

Обратите внимание, что, поскольку вы изменили масштаб, значения min и max также изменились; сейчас они все лежат в одном диапазоне, что действительно здорово, потому что теперь вам не нужно производить нормировку данных!

Преобразование изображений в оттенки серого

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

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

Как и при масштабировании, вы можете использовать библиотеку Scikit-Image; в этом случае вам понадобится модуль color с функцией rgb2gray().

Это будет просто!

Однако не забудьте преобразовать переменную images28 в массив, так как функция rgb2gray() в качестве аргумента принимает именно массивы.

# Импорт `rgb2gray` из`skimage.color`

from skimage.color import rgb2gray

# Конвертация `images28` в массив

images28 = np.array(images28)

# Конвертация `images28` в оттенки серого

images28 = rgb2gray(images28)

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

import matplotlib.pyplot as plt

traffic_signs = [300, 2250, 3650, 4000]

for i in range(len(traffic_signs)):

plt.subplot(1, 4, i+1)

plt.axis('off')

plt.imshow(images28[traffic_signs[i]], cmap="gray") plt.subplots_adjust(wspace=0.5)

# Вывод графика

plt.show()

Обратите внимание, что вам обязательно нужно указать цветовую карту или cmap и выставить значение ‘gray’ для вывода изображений в оттенках серого. Это связано с тем, что imshow() по умолчанию использует тепловую цветовую карту.


Совет. Поскольку этот блок используется в туториале несколько раз, будет полезно подумать, как можно сделать его функцией 🙂

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

В следующей частиглубокое обучение c TensorFlow.


Интересные статьи:

TensorFlow туториал. Часть 2: установка и начальная настройка

24 сентября 2018
установка Tensorflow

TensorFlow туториал. Часть 2: установка и начальная настройка

Теперь, когда вы получше узнали TensorFlow, пора приступить к работе с ним и установить библиотеку. Важно знать, что TensorFlow предоставляет API для Python, C ++, Haskell, Java, Go, Rust. Также…

Теперь, когда вы получше узнали TensorFlow, пора приступить к работе с ним и установить библиотеку. Важно знать, что TensorFlow предоставляет API для Python, C ++, Haskell, Java, Go, Rust. Также существует сторонний пакет для R.

Читайте также Часть 1: тензоры и векторы

После прочтения этого туториала вы сможете скачать версию TensorFlow, которая позволит вам написать код для проекта по глубокому обучению на Python. На странице установки TensorFlow представлены некоторые из наиболее распространенных способов установки (и советы по ним) с использованием virtualenv, pip, Docker, а также несколько других способов инсталляции.

Примечание. Если вы работаете на Windows, можно установить TensorFlow с помощью Conda. Однако, поскольку существует сообщество для помощи при инсталляции TensorFlow, лучше изучить официальные инструкции по установке.

Проверим, что TensorFlow установлен корректно. Для этого его нужно импортировать в рабочую область под названием tf:

import tensorflow as tf

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

Начало работы с TensorFlow

Обычно TensorFlow-программы запускаются блоками. На первый взгляд это противоречит принципам программирования на Python. Однако, если вы хотите, можно также использовать интерактивные сессии TensorFlow, в которых работа с библиотекой идет более тесно. Это особенно удобно, если вы уже работали с IPython.

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

Во-первых, импортируйте библиотеку tensorflow под названием tf, как было показано в предыдущем разделе. Затем инициализируйте две переменные-константы. Подайте массив из четырех чисел в функцию constant().

Обратите внимание, что можно также подать целое число, но чаще всего вы будете работать с массивами. Как вы увидели во введении, тензоры — это и есть массивы! Так что убедитесь, что передаете массив. Затем можно использовать multiply() для перемножения двух переменных. Сохраните результат в переменной result. Окончательно, выведите результат с помощью функции print().

# Import `tensorflow`
import tensorflow as tf

# Initialize two constants
x1 = tf.constant([1,2,3,4])
x2 = tf.constant([5,6,7,8])

# Multiply
result = tf.multiply(x1, x2)

# Print the result
print(result)

Обратите внимание, что для запуска интерактивной сессии можно использовать нижеследующий код. Запустите result и автоматически закройте сессию после вывода output:

# Import `tensorflow`
import tensorflow as tf

# Initialize two constants
x1 = tf.constant([1,2,3,4])
x2 = tf.constant([5,6,7,8])

# Multiply
result = tf.multiply(x1, x2)

# Initialize Session and run `result`
with tf.Session() as sess:
output = sess.run(result)
print(output)

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

Например, если добавить

config= tf.ConfigProto (log_device_placement = True)

к сессии, вы убедитесь, что зарегистрировали устройство GPU или CPU, назначенное для этой операции. Затем вы получите информацию о том, какие устройства используются в сессии для каждой операции. Если вы используете мягкие ограничения для размещения устройств, можно использовать следующую конфигурацию сессии:

congif= tf.ConfigProto (allow_soft_placement = True)

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

В следующей частиработа с данными в TensorFlow.

TensorFlow туториал. Часть 1: тензоры и векторы

20 сентября 2018
Tensorflow tutorial

TensorFlow туториал. Часть 1: тензоры и векторы

TensorFlow — это ML-framework от Google, который предназначен для проектирования, создания и изучения моделей глубокого обучения. Глубокое обучение — это область машинного обучения, алгоритмы в которой были вдохновлены структурой и…

TensorFlow — это ML-framework от Google, который предназначен для проектирования, создания и изучения моделей глубокого обучения. Глубокое обучение — это область машинного обучения, алгоритмы в которой были вдохновлены структурой и работой мозга. Вы можете использовать TensorFlow, чтобы производить численные вычисления. Само по себе это не кажется специфичным, однако эти вычисления производятся с помощью data-flow графов. В этих графах, вершины представляют собой математические операции, в то время как ребра представляют собой данные, которые обычно представляются в виде многомерных массивов или тензоров, которые сообщаются между этими ребрами.

Поняли? Название TensorFlow происходит из вычислений, которые нейросеть производит с многомерными данными и тензорами! Буквально — поток тензоров. На данный момент это все, что нужно знать о тензорах, но мы вернемся к ним чуть позже.

TensorFlow tutorial познакомит вас с глубоким обучением в интерактивной форме:

  • Сначала вы узнаете больше о тензорах
  • Затем, туторил плавно расскажет о там, как установить TensorFlow
  • Далее вы узнаете об основах Tesorflow: как произвести свои первые простейшие вычисления
  • Следующий этап — настоящая задача на реальных данных: данные по Бельгийскому дорожным знаком и обработка с помощью статистики
  • Научитесь размечать данные таким образом, чтобы “скормить” эти данные нейросети.
  • И, наконец, разработаете свою модель нейронной сети — слой за слоем.
  • Как только архитектура будет готова, вы сможете тренировать сеть интерактивно, а также производить оценку эффективности, использую тестовую выборку.
  • Последнее, вы получите указания, как можно улучшить свою модель и как можно дальше работать с TensorFlow.

Полная версия статьи на английском языке здесь.

Введение в тензоры

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

Плоские векторы

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

Пример скаляра — “5 метров” или “60 м/с”, тогда как вектор — “5 метров на север” или “60 м/с на восток”.

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

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

tensorflow туториал - тензоры и векторы

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

Так что же с плоскими векторами?

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

Чтобы понять, что это значит, рассмотрим пример: пусть есть вектор 2 X 1. Это означает, что вектор принадлежит множеству действительных чисел, которые объединены в пары. Или, иначе говоря, элемент двумерного пространства. В таких случаях, вы можете задавать вектор на координатной плоскости, как стрелки или лучи.

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

Замечание: если вы рассматриваете вектор размера 3 X 1, то вы работаете трехмерном пространстве. Здесь вы можете представить вектор, как стрелку в трехмерном пространстве, которое обычно задается тремя осями х, у и z.

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

Единичные векторы — векторы длины 1. Двумерные или трехмерные вектора хорошо раскладываются в сумму ортогональных единичных векторов, таких как оси координат.

Тензоры

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

И так же как вы представляли скаляр одним числом, а трехмерный вектор как тройку чисел, тензор представляется в виде массива 3R чисел в трехмерном пространстве.

R в этой записи отвечает за ранг тензора: в трехмерном пространстве тензор ранга 2 может быть представлен девятью числами. В N-мерном скаляр требует только одного числа, векторы требуют N чисел, а тензоры требуют N^R чисел. Этим объясняется, почему скаляры часто называют тензорами размера 0: у них нет направления, и они могут быть представлены только одним числом.

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

Можно достаточно легко различать векторы, скаляры и тензоры: скаляры представляются одним числом, векторы — последовательностью чисел, тензоры — массивом чисел.

Что делает тензоры такими особенными, так это комбинация компонентов и базисных векторов: все операция производится над тензорами сохраняют отношения между базисными векторами и компонентами такими же.

В следующей частиустановка TensorFlow и первые шаги.


Интересные статьи:

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

7 августа 2018
введение в машинное обучение примеры и модели для новичков

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

Перевод статьи разработчика алгоритмов машинного обучения, бизнес-консультанта и популярного автора Ганта Лаборде «Machine Learning: from Zero to Hero».  Начнешь c “Зачем?”, придешь к “Я готов!” Если вы мало знаете об…

Перевод статьи разработчика алгоритмов машинного обучения, бизнес-консультанта и популярного автора Ганта Лаборде «Machine Learning: from Zero to Hero». 

Начнешь c “Зачем?”, придешь к “Я готов!”

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

Почему машинное обучение сейчас в тренде

Искусственный интеллект (далее ИИ) всегда имел применение, начиная от перемещения ракетки в пинг понге и заканчивая выполнением комбо в Street Fighter.

ИИ опирается на представление программиста о том, как программа должна себя вести. Но как часто становится понятно, не все программисты талантливы в программировании искусственного интеллекта. Стоит только погуглить “эпичные фейлы в играх” и наткнуться на глюки в физике, даже у опытных разработчков.

Несмотря на это, компьютер поддается обучению для игры в видеоигры, понимания языка и распознавания людей и предметов. Этот навык исходит из старой концепции, которая только недавно получила необходимые вычислительные мощности для существования вне теории. Я имею в виду машинное обучение (ML, Machine learning).

Не продумывайте сложные алгоритмы самостоятельно — обучите компьютер создавать собственные сложные алгоритмы. Как это будет работать? Алгоритм не столько написан, сколько выведен. Посмотри это короткое видео, с помощью анимации оно должно дать понимание общего принципа создания ИИ.

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

Впечатлены? Как это возможно? К счастью, Элон Маск представил некоммерческую компанию, которая предоставляет возможность подключения ИИ к любым играм и задачам с помощью дюжины строк кода. Посмотрите, как это работает.

Зачем следует использовать машинное обучение?

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

Во-вторых, если не влияете на мир, мир повлияет на вас. Компании инвестируют в ML, и эти инвестиции уже меняют мир. Лидеры мысли предупреждают, что нельзя позволить алгоритмам машинного обучения быть в тени. Представьте себе, если бы монополия из нескольких корпораций контролировала Интернет. Если мы не “возьмемся за оружие”, наука не будет нашей.

Christian Heilmann высказал правильную мысль в беседе о машинном обучении:

“Можно надеяться, что остальные будут использовать эту мощь только в мирных целях. Я, например, не рассчитываю на эту милость. Предпочитаю играть и быть частью этой революции. И вы присоединяйтесь”.

Хорошо, теперь я заинтересован…

Концепт полезный и веселый. Но что за дичь там в действительности творится? Как это работает? Если хочешь сразу погрузиться, советую пропустить раздел и перейти к следующему “С чего мне начать?”. Если вы уже мотивированы делать модели ML, эти видео не понадобятся.

Если ты все еще пытаешься понять, как такое вообще возможно, следующее видео проведет тебя через логику работы алгоритмов, используя классическую задачу ML — проблему распознавания рукописного текста.

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

введение в машинное обучение

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

Классический пример машинного обучения в действии — датасет прямиком из 1936-го года, называемый ирисами Фишера. На презентации эксперта JavaFX, посвященной машинному обучению, я узнал, как использовать этот инструмент, чтобы визуализировать прикрепление и обратное распространение весов к нейронам в нейронной сети. Понаблюдайте за тем, как тренируется нейронная сеть.

обучение нейронной сети
Обучение нейронной сети Ирисы

Готовы стать Эйнштейном новой эры? Прорывы происходят каждый день, поэтому начинайте сейчас.

С чего мне начать?

Доступных ресурсов много. Я рекомендую два подхода.

Основы

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

Если хочешь получить силу в этой сфере и вести серьезные обсуждения о ML, то этот путь для тебя. Советую пройти курс по искусственным нейронным сетям. Этот подход позволит вам изучать ML на вашем телефоне, убивая время, например, в очереди. Одновременной проходите курс о машинном обучении.

машинное обучение введение для новичков

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

Гонщик

Если вы не заинтересованы в написании алгоритмов, но хотите использовать их для создания сайтов и приложений, то используйте TensorFlow и погрузитесь в crash course.

TensorFlow — это библиотека с открытым исходным кодом для машинного обучения. Ее можно использовать любым способом, даже с JavaScript. А вот crash source.

Услуги ML

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

Предупреждаю, что нет гарантии, что ваши данные будут в безопасности или вообще останутся вашими, но предложения услуг по ML очень привлекательны, если вы заинтересованы в результате и имеете возможность загрузить данные на Amazon/Microsoft/Google.

Давайте быть созидателями

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

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

Надеюсь, эта статья вдохновила вас и ваше окружение изучать ML!

Google выпустили дополнения к Tensorflow Object Detection API

20 июля 2018
tensprflow detection api

Google выпустили дополнения к Tensorflow Object Detection API

Обновления включают новые модели класса SSD, которые оптимизированы для ускоренного обучения на облачных TPU, и готовые веса для них. Теперь обучение модели RetinaNet на основе ResNet-50 на датасете COCO для…

Обновления включают новые модели класса SSD, которые оптимизированы для ускоренного обучения на облачных TPU, и готовые веса для них. Теперь обучение модели RetinaNet на основе ResNet-50 на датасете COCO для достижения 35% mAP занимает 3,5 часа. Также поддерживается ускоренный вывод через квантование и упрощённый экспорт модели на мобильный с TensorFlow Lite.

Подробнее на ai.google.com