Tensorflow - самая известная библиотека, используемая в производстве для моделей глубокого обучения. У него очень большое и замечательное сообщество, и он дает большую гибкость в работе. Однако Tensorflow не так удобен для пользователя и требует более крутого обучения. Чтобы решить эту проблему, высокоуровневый API Keras Tensorflow предоставляет строительные блоки для более простого создания и обучения моделей глубокого обучения. Кроме того, модели Keras создаются путем соединения настраиваемых строительных блоков вместе с некоторыми ограничениями. Это делает его более модульным и компонуемым. Вы можете изучить их на официальном сайте.

Классификация

Чтобы выполнить простую классификацию с использованием высокоуровневого API Keras, необходимо выполнить следующие действия:

  1. Импорт необходимых модулей.
  2. Подготовка данных в подходящем формате для Apis.
  3. Построение модели нейронной сети с использованием API tf.keras (Tensorflow-Keras) и ее компиляция.
  4. Обучение модели на подготовленных данных при попытке разрешить как недостаточный, так и избыточный сценарий.
  5. Оцениваем модель.
  6. Сохранение и восстановление моделей для использования в производстве.

Импорт необходимых модулей.

Во-первых, необходимо импортировать numpy и pandas, поскольку они потребуются для обработки и подготовки данных. Tensorflow API и высокоуровневый Keras API необходимо импортировать для низкоуровневых операций и построения моделей. Matplotlib необходимо импортировать для графического анализа производительности, точности и т. Д.

# TensorFlow and tf.keras
import tensorflow as tf
from tensorflow import keras
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
%matplotlib inline
''' 
%matplotlib inline means with this backend, the output of plotting commands is displayed inline within frontends like the Jupyter notebook, directly below the code cell that produced it. The resulting plots will then also be stored in the notebook document.
'''

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

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

Набор данных о моде MNIST содержит 70 000 изображений в оттенках серого в 10 категориях. На изображениях показаны отдельные предметы одежды в низком разрешении (28 на 28 пикселей). Ссылка: https://github.com/zalandoresearch/fashion-mnist

Мы будем использовать 60 000 изображений для обучения сети и 10 000 изображений, чтобы оценить, насколько точно сеть научилась классифицировать изображения.

API Tensorflow для загрузки этих данных показывал ошибку gzip. Используемый здесь подход заключается в том, чтобы загрузить исходный набор данных с https://github.com/zalandoresearch/fashion-mnist и следовать https://pjreddie.com/projects/mnist-in-csv/. для преобразования набора данных в формат CSV.

class_names = ['T-shirt/top', 'Trouser', 'Pullover', 'Dress', 'Coat', 
               'Sandal', 'Shirt', 'Sneaker', 'Bag', 'Ankle boot']
import pandas as pd
train_df = pd.read_csv('data/fashion-mnist_train.csv',sep=',')
test_df = pd.read_csv('data/fashion-mnist_test.csv', sep = ',')
train_df.head()
''' 
we need to convert the dataframes into numpy arrays of float32 type which is the acceptable form for tensorflow and keras. 
'''
train_data = np.array(train_df, dtype = 'float32')
test_data = np.array(test_df, dtype = 'float32')
'''
We scale the pixel values to a range of 0 to 1 before feeding to the neural network model. (presently they are from 0-255)
'''
x_train = train_data[:,1:]/255
y_train = train_data[:,0]
x_test= test_data[:,1:]/255
y_test=test_data[:,0]

Построение модели нейронной сети

Базовым строительным блоком нейронной сети является слой. Слои извлекают представления из введенных в них данных. Например:

model = keras.Sequential([
    keras.layers.Flatten(input_shape=(784,)),
    keras.layers.Dense(128, activation=tf.nn.relu),
    keras.layers.Dense(10, activation=tf.nn.softmax)
])

Сеть состоит из последовательности двух слоев tf.keras.layers.Dense. Это плотно связанные или полностью связанные нейронные слои.

Первый плотный слой имеет 128 узлов (или нейронов).

Второй (и последний) слой - это слой softmax с 10 узлами - он возвращает массив из 10 оценок вероятности, сумма которых равна 1. Каждый узел содержит оценку, которая указывает вероятность того, что текущее изображение принадлежит одному из 10 классов.

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

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

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

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

'''
When doing multi-class classification, categorical cross entropy loss and sparse categorical cross entropy is used a lot. To compare them both read https://jovianlin.io/cat-crossentropy-vs-sparse-cat-crossentropy/
'''
model.compile(optimizer=tf.train.AdamOptimizer(), 
              loss='sparse_categorical_crossentropy',
              metrics=['accuracy'])

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

Обучение модели нейронной сети требует следующих шагов:

  1. Загрузите данные обучения в модель - в этом примере массивы train_images и train_labels.
  2. Модель учится связывать изображения и ярлыки.
  3. Мы просим модель делать прогнозы относительно набора тестов. В этом примере массив test_images. Мы проверяем, соответствуют ли прогнозы меткам из массива test_labels.
model.fit(x_train, y_train, epochs=10)
test_loss, test_acc = model.evaluate(x_test, y_test)
print('Test accuracy:', test_acc)
print('Test loss:', test_loss)
10000/10000 [==============================] - 1s 52us/step
Test accuracy: 0.8963
Test loss: 0.3374745888918638

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

Добавить регуляризацию веса

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

Регуляризация L1, где добавленные затраты пропорциональны абсолютному значению весовых коэффициентов (то есть тому, что называется «нормой L1» весов).

L2-регуляризация, где добавленные затраты пропорциональны квадрату значения весовых коэффициентов (то есть тому, что называется «L2-нормой» весов). Регуляризация L2 также называется уменьшением веса в контексте нейронных сетей. Пусть вас не смущает другое название: спад веса математически точно такой же, как регуляризация L2.

Единственное, что требуется изменить, - это архитектура модели:

l2_model = keras.models.Sequential([
    keras.layers.Dense(16, kernel_regularizer=keras.regularizers.l2(0.001),
                       activation=tf.nn.relu, input_shape=(NUM_WORDS,)),
    keras.layers.Dense(16, kernel_regularizer=keras.regularizers.l2(0.001),
                       activation=tf.nn.relu),
    keras.layers.Dense(1, activation=tf.nn.sigmoid)
])

Добавить отсев

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

Выпадение, применяемое к слою, состоит из случайного «отбрасывания» (т.е. обнуления) ряда выходных характеристик слоя во время обучения. Допустим, данный слой обычно возвращал бы вектор [0,2, 0,5, 1,3, 0,8, 1,1] для данной входной выборки во время обучения; после применения исключения этот вектор будет иметь несколько случайных нулевых записей, например [0, 0,5, 1,3, 0, 1,1].

«Коэффициент отсева» - это доля обнуляемых функций; обычно устанавливается от 0,2 до 0,5. Во время тестирования никакие единицы не выпадают, а вместо этого выходные значения уровня уменьшаются с коэффициентом, равным частоте выпадения, чтобы сбалансировать тот факт, что больше единиц активно, чем во время обучения.

Здесь также требуется единственное изменение в архитектуре модели.

dpt_model = keras.models.Sequential([
    keras.layers.Dense(16, activation=tf.nn.relu, input_shape=(NUM_WORDS,)),
    keras.layers.Dropout(0.5),
    keras.layers.Dense(16, activation=tf.nn.relu),
    keras.layers.Dropout(0.5),
    keras.layers.Dense(1, activation=tf.nn.sigmoid)
])

Оценка модели

Существует множество показателей для оценки классификаций, регрессий, кластеризации и т. Д. Здесь мы будем использовать точность для измерения классификации. (Точность, Напоминание, F-мера и Точность - это в основном используемые метрики для измерения производительности классификатора).

test_loss, test_acc = model.evaluate(x_test, y_test)
print('Test accuracy:', test_acc)
print('Test loss:', test_loss)
10000/10000 [==============================] - 1s 52us/step
Test accuracy: 0.8963
Test loss: 0.3374745888918638

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

history = model.fit(train_data, train_labels,
                    epochs=50,
                    batch_size=512,
                    validation_split=0.2)
acc = history.history['acc']
val_acc = history.history['val_acc']
loss = history.history['loss']
val_loss = history.history['val_loss']
epochs = range(1, len(acc) + 1)
plt.plot(epochs, acc, 'bo', label='Training Acc')
plt.plot(epochs, val_acc, 'b', label='Validation Acc')
plt.title('Training and validation Acc')
plt.xlabel('Epochs')
plt.ylabel('Acc')
plt.legend()
plt.show()

Сохранение и восстановление модели

Модели можно сохранять и восстанавливать в Tensorflow с помощью API tf.keras.Model.

model.compile(optimizer=tf.train.AdamOptimizer(), 
              loss='sparse_categorical_crossentropy',
              metrics=['accuracy'])
# Save weights to a TensorFlow Checkpoint file
model.save_weights('./weights/my_model')
# Restore the model's state,
# this requires a model with the same architecture.
model.load_weights('./weights/my_model')
'''It also can be saved in keras HDF5 format'''
# Save weights to a HDF5 file
model.save_weights('my_model.h5', save_format='h5')
# Restore the model's state
model.load_weights('my_model.h5')
#The model arch can also be saved to a json file
# Serialize a model to JSON format
json_string = model.to_json()
json_string
#Then it can be restored like below
latest_model = tf.keras.models.model_from_json(json_string)

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

Вы можете узнать больше о моем репозитории Git Hub.



sambit9238 / Tensorflow_Guide
Участвуйте в разработке sambit9238 / Tensorflow_Guide, создав учетную запись на GitHub. github.com