Машинное обучение в целом: классификация текста с помощью нейронных сетей и TensorFlow

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

1. Как работает TensorFlow

2. Что такое модель машинного обучения?

3. Что такое нейронная сеть

4. Как нейронная сеть обучается

5. Как манипулировать данными и передавать их на входы нейронной сети.

6. Как запустить модель и получить результаты прогноза.

Автор также предоставил код, который можно запустить в блокноте Jupyter. Я рассмотрю эти шесть тем и объединю их со своим собственным опытом.

1. Обзор TensorFlow:

TensorFlow - одна из самых популярных библиотек AI с открытым исходным кодом. Его высокая вычислительная эффективность и богатые ресурсы разработки делают его широко применяемым компаниями и отдельными разработчиками. На мой взгляд, лучший способ изучить TensorFlow - это посетить его официальный сайт: https://www.tensorflow.org/. На этом веб-сайте вы можете ознакомиться с руководством по началу работы и списком всех символов в TensorFlow.

Сначала я дам вам фундаментальное определение и основные характеристики TensorFlow. Тензор - это своего рода структура данных, которая может преобразовывать примитивные значения в массив любого количества измерений [1]. Ранг тензора - это его размерное число. Здесь я рекомендую прочитать API Python для TensorFlow, потому что он очень удобен для новичков в TensorFlow. Вам следует установить TensorFlow и настроить среду, просто следуя инструкциям с официальных сайтов. Чтобы проверить, правильно ли вы установили TensorFlow, нужно импортировать библиотеку TensorFlow. В TensorFlow вычислительный граф является основным компонентом. График потока данных используется для представления процесса вычислений. Под графиком операция предназначена для единиц вычисления, а тензор представляет единицы данных. Чтобы запустить код, мы должны инициализировать функцию Session. Вот полный код для выполнения операций суммирования:

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

2. Прогностическая модель:

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

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

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

3. Нейронные сети:

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

Чтобы понять механизм работы нейронной сети, автор построил архитектуру нейронной сети с помощью TensorFlow.

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

Здесь автор использует 2 скрытых слоя, и задача каждого скрытого слоя состоит в том, чтобы преобразовать входные данные во что-то, что может использовать выходной слой [1]. Количество узлов в первом скрытом слое должно быть определено. Эти узлы, называемые нейронами, умножаются на веса. Фаза обучения заключается в корректировке этих значений для получения правильного результата. В сети также присутствует систематическая ошибка, позволяющая смещать функцию активации влево или вправо и помогать прогнозу лучше соответствовать [2]. Данные также проходят через функцию активации, которая определяет конечный результат каждого нейрона. Здесь автор использует активацию выпрямленного линейного блока (ReLU), которая может улучшить нелинейность. Эта функция определяется как:

f (x) = max (0, x) (вывод - x или 0 (ноль), в зависимости от того, что больше)

Для 2-го скрытого слоя входом является 1-й слой, и функция такая же, как и для 1-го скрытого слоя.

Для выходного слоя автор использует горячую кодировку для получения результатов. При однократном кодировании все биты получают значение 0, за исключением одного бита, имеющего значение 1. Здесь автор использует в качестве примера три категории, показанные на следующем рисунке:

Мы можем обнаружить, что количество выходных узлов - это количество классов. Если мы хотим классифицировать разные категории, мы используем функцию Softmax, которая преобразует вывод каждой единицы в значение от 0 до 1 и делает сумму всех единиц равной 1. Она сообщает нам вероятность каждой категории.

Вышеуказанное можно представить в виде кода:

Здесь он вызывает функцию matmul (), чтобы реализовать функцию умножения между матрицами, и вызывает функцию add (), чтобы добавить смещения в функцию.

4. Как обучается нейронная сеть:

Мы можем видеть, что основная цель приведенного выше раздела - построить разумную структуру и сделать веса сети достаточно оптимальными, чтобы сделать прогноз. Итак, ниже я расскажу, как обучать нейронную сеть в TensorFlow. В TensorFlow мы используем Variable для хранения весов и смещений. Здесь мы должны сравнить выходные значения с ожидаемыми и направить функции для получения результатов с минимальными потерями. Существует множество методов вычисления функции потерь. Поскольку это задача классификации, мы должны использовать ошибку кросс-энтропии. Предыдущая работа Джеймса Д. Маккаффри [3] проанализировала и пришла к выводу, что причина использования кросс-энтропии состоит в том, чтобы избежать остановки обучения. Таким образом, мы используем ошибку кросс-энтропии, вызывая функцию: tf.nn.softmax_cross_entropy_with_logits (), мы также вычислим среднюю ошибку, вызвав функцию
: tf.reduced_mean ().

Мы должны найти лучшее значение, чтобы минимизировать ошибку вывода. Здесь мы используем стохастический градиентный спуск (SGD):

Путем многих итераций мы получим веса, близкие к глобальному минимуму затрат. Скорость обучения не должна быть слишком большой. Функция адаптивной оценки момента часто используется для вычисления градиентного спуска. В этом алгоритме оптимизации используются средние значения как градиентов, так и вторых моментов градиентов [4].

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

5. Обработка данных:

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

Counter () в Python - это хеш-таблица. Когда вводится «Привет из Бразилии», матрица будет [1, 1, 1]. Для другого входа, которым является «Hi», будет другая матрица:

6. Запускаем и получаем результат:

В этой части мы будем использовать 20 групп новостей в качестве набора данных. Он состоит из 18 000 постов по 20 темам. Библиотека scilit-learn используется для загрузки этого набора данных. Здесь автор использует 3 категории: comp.graphics, sci.space и rec.sport.baseball. Он состоит из двух подмножеств: для обучения и для тестирования. Ниже приведен способ загрузки набора данных:

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

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

Здесь мы должны разделить обучающие данные на пакеты, потому что мы будем кормить dict большим пакетом при тестировании модели. Мы вызываем функцию get_batches (), чтобы получить количество текстов с размером пакета. Мы можем запустить модель.

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

Тогда мы сможем получить результаты.

Вывод:

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

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

Завершенный код показан ниже:

import pandas as pd
import numpy as np
import tensorflow as tf
from collections import Counter
from sklearn.datasets import fetch_20newsgroups
# if you didn't download the twenty_newsgroups datasets, it will run with error
# this logging can help to solve the error
import logging
logging.basicConfig()
categories = ["comp.graphics","sci.space","rec.sport.baseball"]
newsgroups_train = fetch_20newsgroups(subset='train', categories=categories)
newsgroups_test = fetch_20newsgroups(subset='test', categories=categories)
print('total texts in train:',len(newsgroups_train.data))
print('total texts in test:',len(newsgroups_test.data))
vocab = Counter()
for text in newsgroups_train.data:
 for word in text.split(' '):
 vocab[word.lower()]+=1
 
for text in newsgroups_test.data:
 for word in text.split(' '):
 vocab[word.lower()]+=1

total_words = len(vocab)
def get_word_2_index(vocab):
 word2index = {}
 for i,word in enumerate(vocab):
 word2index[word.lower()] = i
 
 return word2index
word2index = get_word_2_index(vocab)
def get_batch(df,i,batch_size):
 batches = []
 results = []
 texts = df.data[i*batch_size:i*batch_size+batch_size]
 categories = df.target[i*batch_size:i*batch_size+batch_size]
 for text in texts:
 layer = np.zeros(total_words,dtype=float)
 for word in text.split(' '):
 layer[word2index[word.lower()]] += 1
 
 batches.append(layer)
 
 for category in categories:
 y = np.zeros((3),dtype=float)
 if category == 0:
 y[0] = 1.
 elif category == 1:
 y[1] = 1.
 else:
 y[2] = 1.
 results.append(y)
 
 
 return np.array(batches),np.array(results)
# Parameters
learning_rate = 0.01
training_epochs = 10
batch_size = 150
display_step = 1
# Network Parameters
n_hidden_1 = 100 # 1st layer number of features
n_hidden_2 = 100 # 2nd layer number of features
n_input = total_words # Words in vocab
n_classes = 3 # Categories: graphics, sci.space and baseball
input_tensor = tf.placeholder(tf.float32,[None, n_input],name="input")
output_tensor = tf.placeholder(tf.float32,[None, n_classes],name="output") 
def multilayer_perceptron(input_tensor, weights, biases):
 layer_1_multiplication = tf.matmul(input_tensor, weights['h1'])
 layer_1_addition = tf.add(layer_1_multiplication, biases['b1'])
 layer_1 = tf.nn.relu(layer_1_addition)
 
 # Hidden layer with RELU activation
 layer_2_multiplication = tf.matmul(layer_1, weights['h2'])
 layer_2_addition = tf.add(layer_2_multiplication, biases['b2'])
 layer_2 = tf.nn.relu(layer_2_addition)
 
 # Output layer 
 out_layer_multiplication = tf.matmul(layer_2, weights['out'])
 out_layer_addition = out_layer_multiplication + biases['out']
 
 return out_layer_addition
# Store layers weight & bias
weights = {
 'h1': tf.Variable(tf.random_normal([n_input, n_hidden_1])),
 'h2': tf.Variable(tf.random_normal([n_hidden_1, n_hidden_2])),
 'out': tf.Variable(tf.random_normal([n_hidden_2, n_classes]))
}
biases = {
 'b1': tf.Variable(tf.random_normal([n_hidden_1])),
 'b2': tf.Variable(tf.random_normal([n_hidden_2])),
 'out': tf.Variable(tf.random_normal([n_classes]))
}
# Construct model
prediction = multilayer_perceptron(input_tensor, weights, biases)
# Define loss and optimizer
loss = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits=prediction, labels=output_tensor))
optimizer = tf.train.AdamOptimizer(learning_rate=learning_rate).minimize(loss)
# Initializing the variables
init = tf.initialize_all_variables()
# Launch the graph
with tf.Session() as sess:
 sess.run(init)
 # Training cycle
 for epoch in range(training_epochs):
 avg_cost = 0.
 total_batch = int(len(newsgroups_train.data)/batch_size)
 # Loop over all batches
 for i in range(total_batch):
 batch_x,batch_y = get_batch(newsgroups_train,i,batch_size)
 # Run optimization op (backprop) and cost op (to get loss value)
 c,_ = sess.run([loss,optimizer], feed_dict={input_tensor: batch_x,output_tensor:batch_y})
 # Compute average loss
 avg_cost += c / total_batch
 # Display logs per epoch step
 if epoch % display_step == 0:
 print("Epoch:", '%04d' % (epoch+1), "loss=", \
 "{:.9f}".format(avg_cost))
 print("Optimization Finished!")
 # Test model
 correct_prediction = tf.equal(tf.argmax(prediction, 1), tf.argmax(output_tensor, 1))
 # Calculate accuracy
 accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float"))
 total_test_data = len(newsgroups_test.target)
 batch_x_test,batch_y_test = get_batch(newsgroups_test,0,total_test_data)
 print("Accuracy:", accuracy.eval({input_tensor: batch_x_test, output_tensor: batch_y_test}))

Ссылка:

[1] https://stats.stackexchange.com/questions/63152/what-does-the-hidden-layer-in-a-neural-network-compute
[2] http: // stackoverflow.com/questions/2480650/role-of-bias-in-neural-networks
[3] https://jamesmccaffrey.wordpress.com/2013/11/05/why-you-should- используйте-кросс-энтропийную-ошибку-вместо-ошибки-классификации-или-среднеквадратической-ошибки-для-обучения-классификатора-нейронной сети /
[4] https: //en.wikipedia .org / wiki / Stochastic_gradient_descent

Автор: Шиксин Гу | Локализовано Synced Global Team: Junpei Zhong