www.machinelearningmastery.ru

Машинное обучение, нейронные сети, искусственный интеллект
Header decor

Home

Многослойный персептрон с использованием Tensorflow

Дата публикации Sep 12, 2018

В этом блоге мы собираемся построить нейронную сеть (многослойный персептрон) с использованием TensorFlow и успешно обучить ее распознавать цифры на изображении. Tensorflow - очень популярная платформа глубокого обучения, выпущенная компанией, и этот ноутбук поможет вам создать нейронную сеть с этой библиотекой. Если вы хотите понять, что такое многослойный персептрон, вы можете посмотреть на мойпредыдущий блоггде я построил многослойный персептрон с нуля, используя Numpy.

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

## Loading MNIST dataset from keras
import keras
from sklearn.preprocessing import LabelBinarizer
import matplotlib.pyplot as plt
%matplotlib inlinedef load_dataset(flatten=False):
(X_train, y_train), (X_test, y_test) = keras.datasets.mnist.load_data() # normalize x
X_train = X_train.astype(float) / 255.
X_test = X_test.astype(float) / 255. # we reserve the last 10000 training examples for validation
X_train, X_val = X_train[:-10000], X_train[-10000:]
y_train, y_val = y_train[:-10000], y_train[-10000:] if flatten:
X_train = X_train.reshape([X_train.shape[0], -1])
X_val = X_val.reshape([X_val.shape[0], -1])
X_test = X_test.reshape([X_test.shape[0], -1]) return X_train, y_train, X_val, y_val, X_test, y_testX_train, y_train, X_val, y_val, X_test, y_test = load_dataset()
## Printing dimensions
print(X_train.shape, y_train.shape)
## Visualizing the first digit
plt.imshow(X_train[0], cmap="Greys");

Как мы видим, наши текущие данные имеют размерность N28 *28, мы начнем с выравнивания изображения в N * 784 и закодируем нашу целевую переменную в одно касание.

## Changing dimension of input images from N*28*28 to  N*784
X_train = X_train.reshape((X_train.shape[0],X_train.shape[1]*X_train.shape[2]))
X_test = X_test.reshape((X_test.shape[0],X_test.shape[1]*X_test.shape[2]))print('Train dimension:');print(X_train.shape)
print('Test dimension:');print(X_test.shape)## Changing labels to one-hot encoded vector
lb = LabelBinarizer()
y_train = lb.fit_transform(y_train)
y_test = lb.transform(y_test)
print('Train labels dimension:');print(y_train.shape)
print('Test labels dimension:');print(y_test.shape)

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

## Importing required libraries
import numpy as np
import tensorflow as tf
from sklearn.metrics import roc_auc_score, accuracy_score
s = tf.InteractiveSession()

tf.InteractiveSession ()это способ напрямую запустить модель тензорного потока без создания экземпляра графа всякий раз, когда мы хотим запустить модель. Мы будем строить модель нейронной сети 784 (Вход) -512 (Скрытый слой 1) -256 (Скрытый слой 2) -10 (Выход). Давайте начнем конструирование нашей модели с определения переменных инициализации.

## Defining various initialization parameters for 784-512-256-10 MLP model
num_classes = y_train.shape[1]
num_features = X_train.shape[1]
num_output = y_train.shape[1]
num_layers_0 = 512
num_layers_1 = 256
starter_learning_rate = 0.001
regularizer_rate = 0.1

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

# Placeholders for the input data
input_X = tf.placeholder('float32',shape =(None,num_features),name="input_X")
input_y = tf.placeholder('float32',shape = (None,num_classes),name='input_Y')
## for dropout layer
keep_prob = tf.placeholder(tf.float32)

Поскольку плотные слои требуют весов и смещений, их необходимо инициализировать случайным нормальным распределением с нулевым средним и малой дисперсией (1 / квадратный корень из числа объектов).

## Weights initialized by random normal function with std_dev = 1/sqrt(number of input features)
weights_0 = tf.Variable(tf.random_normal([num_features,num_layers_0], stddev=(1/tf.sqrt(float(num_features)))))
bias_0 = tf.Variable(tf.random_normal([num_layers_0]))weights_1 = tf.Variable(tf.random_normal([num_layers_0,num_layers_1], stddev=(1/tf.sqrt(float(num_layers_0)))))
bias_1 = tf.Variable(tf.random_normal([num_layers_1]))weights_2 = tf.Variable(tf.random_normal([num_layers_1,num_output], stddev=(1/tf.sqrt(float(num_layers_1)))))
bias_2 = tf.Variable(tf.random_normal([num_output]))

Теперь мы начнем писать расчет графика для разработки нашего784 (Вход) -512 (Скрытый слой 1) -256 (Скрытый слой 2) -10 (Выход) модель, Мы умножим входные данные для каждого слоя с соответствующими весами и добавим термин смещения. После весов и уклонов нам нужно добавить активацию; мы будем использовать активацию ReLU для скрытых слоев и softmax для окончательного выходного слоя, чтобы получить оценку вероятности класса. Также для предотвращения переоснащения; давайте добавим выпадение после каждого скрытого слоя. Выпадение является важной концепцией в создании избыточности в нашей сети, что приводит к лучшему обобщению.

## Initializing weigths and biases
hidden_output_0 = tf.nn.relu(tf.matmul(input_X,weights_0)+bias_0)
hidden_output_0_0 = tf.nn.dropout(hidden_output_0, keep_prob)hidden_output_1 = tf.nn.relu(tf.matmul(hidden_output_0_0,weights_1)+bias_1)
hidden_output_1_1 = tf.nn.dropout(hidden_output_1, keep_prob)predicted_y = tf.sigmoid(tf.matmul(hidden_output_1_1,weights_2) + bias_2)

Теперь нам нужно определить функцию потерь для оптимизации наших весов и смещений, и мы будем использовать кросс-энтропию softmax с логитами для предсказанной и правильной метки. Мы также добавим некоторую регуляризацию L2 в нашу сеть.

## Defining the loss function
loss = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits_v2(logits=predicted_y,labels=input_y)) \
+ regularizer_rate*(tf.reduce_sum(tf.square(bias_0)) + tf.reduce_sum(tf.square(bias_1)))

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

## Variable learning rate
learning_rate = tf.train.exponential_decay(starter_learning_rate, 0, 5, 0.85, staircase=True)
## Adam optimzer for finding the right weight
optimizer = tf.train.AdamOptimizer(learning_rate).minimize(loss,var_list=[weights_0,weights_1,weights_2,
bias_0,bias_1,bias_2])

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

## Metrics definition
correct_prediction = tf.equal(tf.argmax(y_train,1), tf.argmax(predicted_y,1))
accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))

Теперь мы приступим к обучению нашей сети по данным о поездах и оценим нашу сеть по тестовому набору данных одновременно. Мы будем использовать пакетную оптимизацию размером 128 и обучим ее в течение 14 эпох, чтобы получить точность 98% +.

## Training parameters
batch_size = 128
epochs=14
dropout_prob = 0.6training_accuracy = []
training_loss = []
testing_accuracy = []s.run(tf.global_variables_initializer())
for epoch in range(epochs):
arr = np.arange(X_train.shape[0])
np.random.shuffle(arr)
for index in range(0,X_train.shape[0],batch_size):
s.run(optimizer, {input_X: X_train[arr[index:index+batch_size]],
input_y: y_train[arr[index:index+batch_size]],
keep_prob:dropout_prob})
training_accuracy.append(s.run(accuracy, feed_dict= {input_X:X_train,
input_y: y_train,keep_prob:1}))
training_loss.append(s.run(loss, {input_X: X_train,
input_y: y_train,keep_prob:1}))

## Evaluation of model
testing_accuracy.append(accuracy_score(y_test.argmax(1),
s.run(predicted_y, {input_X: X_test,keep_prob:1}).argmax(1)))
print("Epoch:{0}, Train loss: {1:.2f} Train acc: {2:.3f}, Test acc:{3:.3f}".format(epoch,
training_loss[epoch],
training_accuracy[epoch],
testing_accuracy[epoch]))

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

## Plotting chart of training and testing accuracy as a function of iterations
iterations = list(range(epochs))
plt.plot(iterations, training_accuracy, label='Train')
plt.plot(iterations, testing_accuracy, label='Test')
plt.ylabel('Accuracy')
plt.xlabel('iterations')
plt.show()
print("Train Accuracy: {0:.2f}".format(training_accuracy[-1]))
print("Test Accuracy:{0:.2f}".format(testing_accuracy[-1]))

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

Надеюсь, вам понравилось читать, и вы можете использовать мой код (также доступен втетрадь Jupyter) чтобы попробовать это в ваших целях. Кроме того, если есть какие-либо отзывы о коде или просто сообщение в блоге, не стесняйтесь обратиться наLinkedInили напишите мне по электронной почте [email protected]

Оригинальная статья

Footer decor

© www.machinelearningmastery.ru | Ссылки на оригиналы и авторов сохранены. | map