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

Для чего нужны эти 15 строк кода? Мультиклассовая классификация.
У нас есть 3 известных класса цветов, которые мы пытаемся отсортировать.
Что такое глубокое обучение? Это разновидность машинного обучения, основанная на структурах мозга. (Пример: Нейронные сети)
Почему вы выбрали Keras? (Кроме того, что такое Keras…)
Keras - это высокоуровневый API Nueral Networks, написанный на Python на TensorFlow. Керас выполняет глубокое обучение так же, как Google Home автоматизирует ваш дом. Вы можете выключить свет, закрыть дверь, установить будильник и т. Д. Или сказать: «Окей, Google, иди спать!» (TensorFlow делает все вручную, Keras - это Google Home)

Полезное примечание. Каждому разделу кода соответствует номер 1–4. Я буду использовать нотацию (1), чтобы связать разделы с кодом.

Coderview (Обзор кода)

Прежде чем смотреть на код, давайте разберемся, что пытается сделать каждая часть:

  1. Импортируйте набор данных. Это лайнер 1 для извлечения данных диафрагмы.
  2. Подготовьте входные данные, удалив последний столбец в наборе данных.
  3. Подготовьте вывод. (Это выглядит немного странно, поэтому я подробно расскажу об этом ниже)
  4. Создайте, скомпилируйте и запустите модель.
Results:
Epoch 1/150
150/150 [==============================] — 0s 2ms/step — loss: 4.1396 — acc: 0.3333
Epoch 2/150
150/150 [==============================] — 0s 89us/step — loss: 3.6754 — acc: 0.3333
Epoch 3/150
150/150 [==============================] — 0s 94us/step — loss: 3.2460 — acc: 0.3333
…
Epoch 148/150
150/150 [==============================] - 0s 95us/step - loss: 0.1776 - acc: 0.9733
Epoch 149/150
150/150 [==============================] - 0s 86us/step - loss: 0.1772 - acc: 0.9667
Epoch 150/150
150/150 [==============================] - 0s 94us/step - loss: 0.1759 - acc: 0.9733
150/150 [==============================] - 0s 2ms/step
[0.17427776996046304, 0.9800000011920929]

После запуска: мы получили точность 98% при сравнении результатов модели с нашими выходными данными. Имеется функция потерь 17,4% (насколько хорошо алгоритм моделирует набор данных, где чем меньше, тем лучше).

Вот и все! Теперь давайте углубимся в детали.

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

Первоначально набор данных выглядит так (1):

iris.iloc[[0,50,100]]
0     1     2     3           4         
 ----- ----- ----- ----- ----- ----------------- 
    0   5.1   3.5   1.4   0.2   Iris-setosa      
   50   7.0   3.2   4.7   1.4   Iris-versicolor  
  100   6.3   3.3   6.0   2.5   Iris-virginica

Удаляем метки, чтобы сделать входы (2):

input_x = iris.drop(4,axis=1)
0     1     2     3   
 ----- ----- ----- ----- ----- 
    0   5.1   3.5   1.4   0.2  
   50   7.0   3.2   4.7   1.4  
  100   6.3   3.3   6.0   2.5

Выходы (3)

Нам нужно сделать 3 разных класса (Iris-setosa, Iris-versicolor, Iris-virginica) категориями без предвзятости, которые сможет понять Керас.

Что это значит? Многие люди первым делом захотят превратить их в числа: Iris-setosa = 1, Iris-versicolor = 2, Iris-virginica = 3

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

Iris-setosa   Iris-versicolor   Iris-virginica  
------------- ----------------- ---------------- 
            1                 0                0  
            0                 1                0  
            0                 0                1

Таким образом, ни один класс не имеет большего веса, чем два других.

Как я подошел к этому в Python, было следующее:

  1. Дайте мне key_value, который выглядит так:
    {‘Iris-setosa’: 0, ‘Iris-versicolor’: 1, ‘Iris-virginica’: 2}
    - Дайте мне все уникальные классы iris[4].unique()
    - Превратите эту последовательность в list()
    - цикл по списку и назначьте элементы как ключи, а их индексы как значения {v: k for k, v in enumerate(alist)}
  2. Замените имена выходных данных («Ирис-…») на индексы из key_value и сохраните их в output_class_int.
  3. Наконец, замените эти 0s, 1s, 2s двоичными массивами, указанными выше.
    [ 0 = [1,0,0], 1 = [0,1,0], 2 = [0,0,1] ] и сохраните их в output_y.
key_value = {v: k for k, v in enumerate(list(iris[4].unique()))}
output_class_int = iris.replace({4:key_value})[4]
output_y = keras.utils.to_categorical(output_class_int,len(key_value))

Я знаю, что это было много. Давайте присоединимся к input_x и out_y, чтобы вы могли увидеть, как это выглядит:

         0     1     2     3    4   5   6  
 ----- ----- ----- ----- ----- --- --- --- 
    0   5.1   3.5   1.4   0.2   1   0   0  
   50   7.0   3.2   4.7   1.4   0   1   0  
  100   6.3   3.3   6.0   2.5   0   0   1

Если вы сравните приведенное выше с «Первоначально набор данных выглядит так: (1):»
Вы увидите, что строка 0 - это Iris-setosa, строка 50 - Iris-versicolor, а строка 100 - Iris-virginica.

Модель

Создать (4a)

model = keras.models.Sequential()
model.add(Dense(8, input_dim=4, activation=’relu’))
model.add(Dense(3, activation=’softmax’))

Для нашей модели мы используем модель Keras Sequential. Вы можете думать о последовательной модели как о слоеном пироге (в последнее время я много смотрел Great British Baking Show), где каждый «слой» является частью нейронной сети.

Первый слой: model.add(Dense(8,input_dim=4,activation='relu'))

Добавьте этот первый слой. Давайте используем 8 узлов для этого слоя. У нас есть 4 входных атрибутов (см. input_x). Давайте использовать выпрямленную линейную единицу (relu) для нашей функции активации.

Второй слой: model.add(Dense(3,activation='softmax’))

Добавьте последний слой. Для каждого вывода будут атрибуты 3. (Это из-за функции to_categorical, которую мы использовали выше в разделе вывода). Давайте использовать softmax в качестве нашей функции активации.

Скомпилировать (4b)

model.compile(loss=’categorical_crossentropy’, optimizer=’adam’, metrics=[‘accuracy’])

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

loss=’categorical_crossentropy’
Мы устанавливаем функцию потерь на category_crossentropy (AKA. Loss от 0 до 1 для каждого класса)

optimizer='adam'
Мы настраиваем оптимизатор на Адама (оценка адаптивного момента), чтобы обновлять веса сети на основе данных обучения.

metrics=['accuracy']
Мы повышаем точность наших выходных показателей. (Вот почему мы видим 0.980000000 в нашем выводе)

Подгонка и оценка (4c)

model.fit(input_x, output_y, epochs=150, batch_size=15, verbose=1)
score = model.evaluate(input_x, output_y, batch_size=15)
score

Подгонка и оценка - это то место, где все взаимосвязано.
Вернемся к аналогии с Великой британской выставкой выпечки:
- Каждому дается рецепт (input_x)
- У каждого есть своя техника и исполнение (модель )
- Что создает выпечку (результат модели).
- Это оценивается (оценивает) комиссией
- У кого есть предвзятые ожидания (output_y)

Примечание. Эта часть модели впервые появляется при моделировании. Обратите внимание, что input_x и output_y даже не упоминаются в разделах создания или компиляции. Об этом важно помнить концептуально с Keras.

Каковы все эти другие компоненты в разделах настройки и оценки?

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

Допустим, у вас 105 человек (dataset_size = 105). Вы запускаете тест и хотите тестировать 10 за раз (batch_size = 10). Вам нужно будет запустить этот тест 11 раз, при этом на последней итерации будет всего 5 человек. Вы решили, что хотите, чтобы все прошли тест 3 раза (эпоха = 3). Чтобы все 105 человек прошли тест 3 раза группами по 10, нам нужно будет запустить тест 33 раз (11 запусков на эпоху с 3 эпохами ).

Возвращаясь к нашему упражнению, у нас есть dataset_size, равный 150 (это количество строк в csv). Мы проводим это через 150 эпох с batch_size 15.

Следующие шаги

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

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

Спасибо за прочтение! Если у вас есть вопросы / комментарии, пожалуйста, оставьте их ниже. Если у вас есть более острые вопросы, не стесняйтесь обращаться ко мне в LinkedIn.

С уважением,
AndrewDoesData
DAG Solutions

Приложение

  • Объяснение ввода Keras при переполнении стека: для меня лучшим ответом был лучший обзор того, как думать об интерпретации Кераса нейронных сетей.
  • Руководство по последовательной модели Кераса: у Кераса есть замечательная документация для использования. Помните, что эта документация предполагает, что вы понимаете концепции глубокого обучения. (чего не делает большинство из нас) Во многих моих исследованиях я искал в Google все термины в этой документации.
  • Функции активации: Relu vs softmax vs все остальное? Если вы новичок в глубоком обучении, это отличная шпаргалка по активациям.
  • Оптимизация Адама для глубокого обучения: вот отличное пошаговое руководство по Адаму и тому, почему он использует классический стохастический градиентный спуск.
  • Функции потери в ML Cheatsheet: Как и в случае с активацией и оптимизацией, вот хорошее прочтение о функциях потери и почему они необходимы для ML.
  • Multi-Classificartion-Tutorial-Keras-Deep-Learning: Это было основой моего кода. Я отошел от этого подхода двумя способами: 1) output_y построен более питоническим способом по сравнению с использованием кодировщика numpy. 2) Я использовал собственный оценщик Keras вместо numpy.
  • Построение модели глубокого обучения с помощью Keras: это еще один пост, который я использовал для создания подходящих функций.