CNN Класификация на изображения в TensorFlow със стъпки и примери

Какво е конволюционна невронна мрежа?

Конволюционна невронна мрежа, известен още като convnets или CNN, е добре познат метод в приложенията за компютърно зрение. Това е клас дълбоки невронни мрежи, които се използват за анализ на визуални изображения. Този тип архитектура е доминираща за разпознаване на обекти от картина или видео. Използва се в приложения като разпознаване на изображения или видео, обработка на естествен език и системи за препоръки.

Archiструктура на конволюционна невронна мрежа

Помислете за Facebook преди няколко години, след като сте качили снимка в профила си, бяхте помолени да добавите име към лицето на снимката ръчно. В наши дни Facebook използва convnet, за да маркира автоматично вашия приятел на снимката.

Конволюционната невронна мрежа за класифициране на изображения не е много трудна за разбиране. Входното изображение се обработва по време на фазата на навиване и по-късно му се приписва етикет.

Типична архитектура на convnet може да бъде обобщена на картинката по-долу. Първо, изображение се изпраща към мрежата; това се нарича входно изображение. След това входното изображение преминава през серия от стъпки; това е конволюционната част на мрежата. Накрая, невронната мрежа може да предскаже цифрата на изображението.

Изображението е съставено от масив от пиксели с височина и ширина. Сивото изображение има само един канал, докато цветното изображение има три канала (всеки за червено, зелено и синьо). Каналите са подредени един върху друг. В този урок ще използвате сиво изображение само с един канал. Всеки пиксел има стойност от 0 до 255, за да отрази интензитета на цвета. Например, пиксел, равен на 0, ще показва бял цвят, докато пиксел със стойност близка до 255 ще бъде по-тъмен.

Нека да разгледаме изображение, съхранено в Набор от данни MNISTКартината по-долу показва как да се представи изображението отляво в матричен формат. Обърнете внимание, че оригиналната матрица е стандартизирана да бъде между 0 и 1. За по-тъмните цветове стойността в матрицата е около 0.9, докато белите пиксели имат стойност 0.

Конволюционна операция

Най-критичният компонент в модела е конволюционният слой. Тази част има за цел да намали размера на изображението за по-бързо изчисляване на теглата и подобряване на обобщението.

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

Вместо това, а Keras конволюционната невронна мрежа ще използва математическа техника заtracсамо най-подходящите пиксели. Тази математическа операция се нарича конволюция. Тази техника позволява на мрежата да изучава все по-сложни характеристики на всеки слой. Конволюцията разделя матрицата на малки части, за да изучи най-съществените елементи във всяка част.

Компоненти на конволюционна невронна мрежа (ConvNet или CNN)

Конвертираната мрежа се състои от четири компонента:

1. Извивка
2. Нелинейност (ReLU)
3. Pooling или Подизвадка
4. Класификация (напълно свързан слой)

Извивка

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

Конволюцията е умножение по елементи. Концепцията е лесна за разбиране. Компютърът сканира част от изображението, обикновено с размер 3×3, и я умножава с филтър. Резултатът от умножението по елементи се нарича карта на характеристиките. Тази стъпка се повтаря, докато се сканира цялото изображение. Обърнете внимание, че след конволюцията размерът на изображението се намалява.

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

Анимацията по-долу показва същата конволюция, преминаваща през цялото изображение.

Налични са множество филтри. По-долу сме изброили някои от тях. Можете да видите, че всеки филтър има специфично предназначение. Обърнете внимание, че на картинката по-долу ядрото е синоним на филтъра.

Аритметика зад конволюцията

Конволюционната фаза ще приложи филтъра върху малък масив от пиксели в картината. Филтърът ще се движи по входното изображение с обща форма 3×3 или 5×5. Това означава, че мрежата ще плъзга тези прозорци по цялото входно изображение и ще изчислява конволюцията. Анимацията по-долу показва как работи конволюцията. Размерът на областта е 3×3, а изходната матрица е резултат от поелементната операция между матрицата на изображението и филтъра.

Забелязвате, че ширината и височината на изхода може да се различават от ширината и височината на входа. Това се случва поради граничния ефект.

Граничен ефект

Изображението има карта на характеристиките 5×5 и филтър 3×3. Има само един прозорец в центъра, където филтърът може да екранира мрежа 3×3. Изходната карта на характеристиките се свива с две плочки по всяка ос, оставяйки измерение 3×3.

За да получите същото изходно измерение като входното измерение, трябва да добавите допълване (padding). Допълването се състои в добавяне на правилния брой редове и колони от всяка страна на матрицата. Това ще позволи на конволюцията да центрира всяка входна плочка. На изображението по-долу входната и изходната матрица имат едно и също измерение, 5×5.

Когато дефинирате мрежата, извитите функции се контролират от три параметъра:

Дълбочина: Той определя броя на филтрите, които да се приложат по време на конволюцията. В предишния пример видяхте дълбочина от 1, което означава, че се използва само един филтър. В повечето случаи има повече от един филтър. Анимацията по-долу показва операциите, извършени в ситуация с три филтъра.

крачка: Той определя броя на „пикселовите скокове“ между два слоя. Ако стъпката е равна на 1, прозорецът ще се движи с разстояние от един пиксел. Ако стъпката е равна на две, прозорецът ще скочи с 2 пиксела. Ако увеличите стъпката, ще имате по-малки карти на характеристиките. Двете диаграми по-долу сравняват стъпка от 1 със стъпка от 2.

Примерна стъпка 1

крачка 2

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

Нелинейност (ReLU)

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

Pooling OperaАЦИ

Тази стъпка е лесна за разбиране. Целта на обединяването е да се намали размерността на входното изображение. Стъпките се извършват, за да се намали изчислителната сложност на операцията. Чрез намаляване на размерността, мрежата има по-малко тегла за изчисляване, което предотвратява пренареждането.

На този етап трябва да дефинирате размера и стъпката. Стандартен начин за обединяване на входното изображение е да се използва максималната стойност на картата на характеристиките. Вижте картинката по-долу. Обединяването ще прегледа четири подматрици на картата на характеристиките 4×4 и ще върне максималната стойност. Обединяването взема максималната стойност на масив 2×2 и след това премества този прозорец с два пиксела. Например, първата подматрица е [3,1,3,2], така че обединяването ще върне максималната стойност, която е 3.

Има друга операция за обединяване, като средната стойност.

Тази операция агресивно намалява размера на картата с характеристики.

Напълно свързани слоеве

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

Обзор:

Конволюционната невронна мрежа на TensorFlow компилира различни слоеве, преди да направи прогноза. Невронната мрежа има:

• Конволюционен слой
• Функция за активиране на ReLU
• Pooling слой
• Плътно свързан слой

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

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

Обучете CNN с TensorFlow

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

Подготовката на данните е същата като в предишния урок. Можете да стартирате кодовете и да преминете директно към архитектурата на CNN.

Ще следвате стъпките по-долу за класифициране на изображения с помощта на CNN:

1. Стъпка 1: Качете набор от данни
2. Стъпка 2: Входен слой
3. Стъпка 3: Конволюционен слой
4. Стъпка 4: Pooling слой
5. Стъпка 5: Втори конволюционен слой и Pooling Слой
6. Стъпка 6: Плътен слой
7. Стъпка 7: Logit слой

Бележка към версията: Списъците по-долу са насочени към TensorFlow 1.x. В TensorFlow 2 пространството от имена tf.layers и tf.estimator.inputs.numpy_input_fn вече не съществуват; еквивалентите са tf.keras.layers.Conv2D, Max.Pooling2D, Dense и Dropout, асемблирани в tf.keras.Model и обучени с model.fit(). Прочетете стъпките за механиката на всеки слой, след което ги картографирайте върху Keras API.

Стъпка 1: Качете набор от данни

Наборът от данни MNIST е достъпен чрез scikit-learn. Моля, изтеглете го и го запазете в „Изтегляния“. Можете да го качите с fetch_mldata('MNIST original').

Бележка към версията: mldata.org е затворен и fetch_mldata() е премахнат в scikit-learn 0.22. При всяка текуща инсталация, заредете същите цифри с fetch_openml вместо това, използвайки fetch_openml('mnist_784', version=1). Останалата част от конвейера е непроменена.

Създайте набор от влак/тест

Трябва да разделите набора от данни с train_test_split.

Мащабирайте функциите

Накрая, можете да мащабирате характеристиките с MinMaxScaler, както е показано в класификацията на изображението по-долу, използвайки примера на TensorFlow CNN.

import numpy as np
import tensorflow as tf
from sklearn.datasets import fetch_mldata

#Change USERNAME by the username of your machine
## Windows USER
mnist = fetch_mldata('C:\\Users\\USERNAME\\Downloads\\MNIST original')
## Mac User
mnist = fetch_mldata('/Users/USERNAME/Downloads/MNIST original')

print(mnist.data.shape)
print(mnist.target.shape)
from sklearn.model_selection import train_test_split

X_train, X_test, y_train, y_test = train_test_split(mnist.data, mnist.target, test_size=0.2, random_state=42)
y_train  = y_train.astype(int)
y_test  = y_test.astype(int)
batch_size =len(X_train)

print(X_train.shape, y_train.shape,y_test.shape )
## resclae
from sklearn.preprocessing import MinMaxScaler
scaler = MinMaxScaler()
# Train
X_train_scaled = scaler.fit_transform(X_train.astype(np.float64))
# test
X_test_scaled = scaler.fit_transform(X_test.astype(np.float64))
feature_columns = [tf.feature_column.numeric_column('x', shape=X_train_scaled.shape[1:])]
X_train_scaled.shape[1:]

Дефинирайте CNN

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

1. Конволюционен слой: Приложете n броя филтри към картата на характеристиките. След конволюцията е необходимо да използвате ReLU активираща функция, за да добавите нелинейност към мрежата.
2. Pooling слой: Следващата стъпка след конволюцията е намаляване на семплирането на картата на характеристиките. Целта е да се намали размерността на картата на характеристиките, за да се предотврати пренареждане и да се подобри скоростта на изчисление. Максималното обединяване е конвенционалната техника, която разделя картите на характеристиките на подрегиони (обикновено с размер 2×2) и запазва само максималните стойности.
3. Напълно свързани слоеве: Всички неврони от предишните слоеве са свързани със следващите слоеве. CNN ще класифицира етикета според характеристиките от конволюционните слоеве и намален със слоя за обединяване.

CNN архитектура

• Конволюционен слой: Прилага 14 филтъра 5×5 (напр.trac(образувайки 5×5-пикселови подрегиони), с функция за активиране на ReLU
• Pooling Слой: Извършва максимално обединяване с филтър 2×2 и стъпка 2 (което указва, че обединените региони не се припокриват)
• Конволюционен слой: Прилага 36 5×5 филтъра с функция за активиране ReLU
• Pooling Слой #2: Отново, извършва максимално обединяване с филтър 2×2 и стъпка от 2
• 1,764 неврона, със степен на регулиране на отпадането от 0.4 (вероятност от 0.4, че всеки даден елемент ще бъде изпуснат по време на обучение)
• Плътен слой (Logits Layer): 10 неврона, по един за всеки цифрен целеви клас (0–9).

Има три важни модула, които да използвате за създаване на CNN:

• conv2d(). Конструира двуизмерен конволюционен слой с броя на филтрите, размера на ядрото на филтъра, подложката и функцията за активиране като аргументи.
• max_pooling2d(). Конструира двуизмерен обединяващ слой с помощта на алгоритъма за максимално обединяване.
• dense(). Изгражда плътен слой със скритите слоеве и единици

Ще дефинирате функция за изграждане на CNN. Нека видим подробно как да конструираме всеки градивен блок, преди да приключим.ping всичко заедно във функцията.

Стъпка 2: Входен слой

def cnn_model_fn(features, labels, mode):
    input_layer = tf.reshape(tensor = features["x"],shape =[-1, 28, 28, 1])

Трябва да дефинирате тензор с формата на данните. За целта можете да използвате модула tf.reshape. В този модул трябва да декларирате тензора за преоформяне и формата на тензора. Първият аргумент е характеристиките на данните, които са дефинирани в аргумента на функцията.

Картината има височина, ширина и канал. Наборът от данни MNIST е монохромна картина с размер 28×28. Задаваме размера на партидата на -1 в аргумента shape, така че тя да приеме формата на характеристиките [„x“]. Предимството е размерът на партидата да се превърне в хиперпараметър за настройване. Ако размерът на партидата е зададен на 7, тогава тензорът ще подаде 5,488 стойности (28*28*7).

Стъпка 3: Конволюционен слой

# first Convolutional Layer
  conv1 = tf.layers.conv2d(
      inputs=input_layer,
      filters=14,
      kernel_size=[5, 5],
      padding="same",
      activation=tf.nn.relu)

Първият конволюционен слой има 14 филтъра с размер на ядрото 5×5 с еднакво допълване. Едно и също допълване означава, че както изходният тензор, така и входният тензор трябва да имат еднаква височина и ширина. TensorFlow ще добави нули към редовете и колоните, за да осигури еднакъв размер.

Използвате функцията за активиране на ReLU. Размерът на изхода ще бъде [28, 28, 14].

Стъпка 4: Pooling слой

Следващата стъпка след конволюцията е изчислението за обединяване. Изчислението за обединяване ще намали размерността на данните. Можете да използвате модула max_pooling2d с размер 2×2 и стъпка 2. Използвате предишния слой като вход. Размерът на изхода ще бъде [batch_size, 14, 14, 14].

# first Pooling Layer 
pool1 = tf.layers.max_pooling2d(inputs=conv1, pool_size=[2, 2], strides=2)

Стъпка 5: Втори конволюционен слой и Pooling Слой

Вторият конволюционен слой прилага 36 филтъра, давайки изходен размер [batch_size, 14, 14, 36]. Слоят за обединяване използва същия прозорец 2×2 и стъпка от 2, както преди, така че разделя наполовина всяка пространствена ос и изходната форма става [batch_size, 7, 7, 36].

conv2 = tf.layers.conv2d(
      inputs=pool1,
      filters=36,
      kernel_size=[5, 5],
      padding="same",
      activation=tf.nn.relu)
pool2 = tf.layers.max_pooling2d(inputs=conv2, pool_size=[2, 2], strides=2)

Стъпка 6: Плътен слой

След това трябва да дефинирате напълно свързания слой. Картата на характеристиките трябва да бъде изравнена, преди да бъде свързана с плътния слой. Можете да използвате модула за преобразуване с размер 7*7*36.

Плътният слой ще свърже 1,764 неврона. Добавяте ReLU активираща функция. Освен това добавяте член за регуляризация на отпадането с честота 0.3, което означава, че 30 процента от активациите ще бъдат зададени на 0. Обърнете внимание, че отпадането се извършва само по време на фазата на обучение. Функцията cnn_model_fn има аргумент mode, за да декларира дали моделът трябва да бъде обучен или оценен, както е показано в примера по-долу за класификация на CNN изображения в TensorFlow.

pool2_flat = tf.reshape(pool2, [-1, 7 * 7 * 36])

dense = tf.layers.dense(inputs=pool2_flat, units=7 * 7 * 36, activation=tf.nn.relu)
dropout = tf.layers.dropout(
      inputs=dense, rate=0.3, training=mode == tf.estimator.ModeKeys.TRAIN)

Стъпка 7: Logit слой

Накрая, в примера за класификация на изображения в TensorFlow, можете да дефинирате последния слой с прогнозата на модела. Изходната форма е равна на размера на партидата и 10, общия брой целеви класове.

# Logits Layer
logits = tf.layers.dense(inputs=dropout, units=10)

Можете да създадете речник, съдържащ класовете и вероятността за всеки клас. Функцията tf.argmax() връща индекса на най-високата стойност в слоя с логитове. Функцията softmax връща вероятността за всеки клас.

predictions = {				
	# Generate predictions				
    "classes": tf.argmax(input=logits, axis=1),				
    "probabilities": tf.nn.softmax(logits, name="softmax_tensor")  }			

Искате да върнете речника за прогнозиране само когато режимът е зададен на prediction. Добавяте този код, за да покажете прогнозите.

if mode == tf.estimator.ModeKeys.PREDICT:
    return tf.estimator.EstimatorSpec(mode=mode, predictions=predictions)

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

# Calculate Loss (for both TRAIN and EVAL modes)
loss = tf.losses.sparse_softmax_cross_entropy(labels=labels, logits=logits)

Последната стъпка от примера с TensorFlow CNN е оптимизирането на модела, т.е. намирането на най-добрите стойности на теглата. За целта се използва оптимизатор с градиентен спускащ механизъм с коефициент на обучение 0.001. Целта е да се минимизират загубите.

optimizer = tf.train.GradientDescentOptimizer(learning_rate=0.001)
train_op = optimizer.minimize(
        loss=loss,
        global_step=tf.train.get_global_step())

Готово е с CNN. Искате обаче да покажете показателите за производителност по време на режим на оценка. Показателят за производителност за многокласов модел е точността. TensorFlow е оборудван с модул за точност, който приема два аргумента - етикетите и прогнозираните стойности.

eval_metric_ops = {
      "accuracy": tf.metrics.accuracy(labels=labels, predictions=predictions["classes"])}
return tf.estimator.EstimatorSpec(mode=mode, loss=loss, eval_metric_ops=eval_metric_ops)

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

def cnn_model_fn(features, labels, mode):
  """Model function for CNN."""
  # Input Layer
  input_layer = tf.reshape(features["x"], [-1, 28, 28, 1])

  # Convolutional Layer
  conv1 = tf.layers.conv2d(
      inputs=input_layer,
      filters=32,
      kernel_size=[5, 5],
      padding="same",
      activation=tf.nn.relu)

  # Pooling Layer
  pool1 = tf.layers.max_pooling2d(inputs=conv1, pool_size=[2, 2], strides=2)

  # Convolutional Layer #2 and Pooling Layer
  conv2 = tf.layers.conv2d(
      inputs=pool1,
      filters=36,
      kernel_size=[5, 5],
      padding="same",
      activation=tf.nn.relu)
  pool2 = tf.layers.max_pooling2d(inputs=conv2, pool_size=[2, 2], strides=2)

  # Dense Layer
  pool2_flat = tf.reshape(pool2, [-1, 7 * 7 * 36])
  dense = tf.layers.dense(inputs=pool2_flat, units=7 * 7 * 36, activation=tf.nn.relu)
  dropout = tf.layers.dropout(
      inputs=dense, rate=0.4, training=mode == tf.estimator.ModeKeys.TRAIN)

  # Logits Layer
  logits = tf.layers.dense(inputs=dropout, units=10)

  predictions = {
      # Generate predictions (for PREDICT and EVAL mode)
      "classes": tf.argmax(input=logits, axis=1),
      "probabilities": tf.nn.softmax(logits, name="softmax_tensor")
  }

  if mode == tf.estimator.ModeKeys.PREDICT:
    return tf.estimator.EstimatorSpec(mode=mode, predictions=predictions)

  # Calculate Loss
  loss = tf.losses.sparse_softmax_cross_entropy(labels=labels, logits=logits)

  # Configure the Training Op (for TRAIN mode)
  if mode == tf.estimator.ModeKeys.TRAIN:
    optimizer = tf.train.GradientDescentOptimizer(learning_rate=0.001)
    train_op = optimizer.minimize(
        loss=loss,
        global_step=tf.train.get_global_step())
    return tf.estimator.EstimatorSpec(mode=mode, loss=loss, train_op=train_op)

  # Add evaluation metrics Evaluation mode
  eval_metric_ops = {
      "accuracy": tf.metrics.accuracy(
          labels=labels, predictions=predictions["classes"])}
  return tf.estimator.EstimatorSpec(
      mode=mode, loss=loss, eval_metric_ops=eval_metric_ops)

Забележка относно асемблираната функция: Обвитата версия по-горе задава първия конволюционен слой на 32 филтъра и отпадане на 0.4, докато подробните фрагменти използват 14 филтъра и 0.3. И двете се изпълняват, но избират една двойка стойности и я поддържат последователна, така че отпечатаните форми да съответстват на таблицата със слоеве.

Стъпките по-долу са същите като предишните уроци.

Първо, дефинирате оценител с модела на CNN за класификация на изображения.

# Create the Estimator
mnist_classifier = tf.estimator.Estimator(
    model_fn=cnn_model_fn, model_dir="train/mnist_convnet_model")

Обучението на CNN отнема много време, следователно създавате logging hook, за да съхранявате стойностите на softmax слоевете на всеки 50 итерации.

# Set up logging for predictions
tensors_to_log = {"probabilities": "softmax_tensor"}
logging_hook = tf.train.LoggingTensorHook(tensors=tensors_to_log, every_n_iter=50)

Готови сте да оцените модела. Задавате размер на партидата от 100 и разбърквате данните. Обърнете внимание, че сме задали стъпки за обучение от 16 000, което може да отнеме много време за обучение. Бъдете търпеливи.

# Train the model
train_input_fn = tf.estimator.inputs.numpy_input_fn(
    x={"x": X_train_scaled},
    y=y_train,
    batch_size=100,
    num_epochs=None,
    shuffle=True)
mnist_classifier.train(
    input_fn=train_input_fn,
    steps=16000,
    hooks=[logging_hook])

След като моделът е обучен, можете да го оцените и да отпечатате резултатите.

# Evaluate the model and print results
eval_input_fn = tf.estimator.inputs.numpy_input_fn(
    x={"x": X_test_scaled},
    y=y_test,
    num_epochs=1,
    shuffle=False)
eval_results = mnist_classifier.evaluate(input_fn=eval_input_fn)
print(eval_results)

Оценката отпечатва възстановената контролна точка, стъпката, на която е спряла, и окончателния речник на показателите.

INFO:tensorflow:Calling model_fn.
INFO:tensorflow:Done calling model_fn.
INFO:tensorflow:Starting evaluation at 2018-08-05-12:52:41
INFO:tensorflow:Graph was finalized.
INFO:tensorflow:Restoring parameters from train/mnist_convnet_model/model.ckpt-15652
INFO:tensorflow:Running local_init_op.
INFO:tensorflow:Done running local_init_op.
INFO:tensorflow:Finished evaluation at 2018-08-05-12:52:56
INFO:tensorflow:Saving dict for global step 15652: accuracy = 0.9589286, global_step = 15652, loss = 0.13894269
{'accuracy': 0.9689286, 'loss': 0.13894269, 'global_step': 15652}

С текущата архитектура, речникът за оценка отчита точност от 0.9689286, приблизително 97%. Можете да промените архитектурата, размера на партидата и броя на итерациите, за да подобрите точността. CNN се е представил много по-добре от... изкуствена невронна мрежа или логистична регресия: в урока по изкуствени невронни мрежи имахте точност от 96%, което е по-ниско от CNN. Производителността на CNN е впечатляваща с по-голям набор от изображения, както по отношение на скоростта на изчисление, така и на точността.

Въпроси и Отговори