Средний

8 мин

0

Описание задачи

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

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

Будет использоваться машинное обучение в Apache Spark.

Выборка исходных данных из БД

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

Данные из тестовой базы выбираются следующим SQL-скриптом.

В примере видно, что type_5 вызвал увеличение нагрузки, но это видно человеку; нужно научить «компьютер» выделять этот тип файлов.

Запуск скриптов машинного обучения

Для запуска скриптов используется PySpark.

Параметры подключения Python-скрипта к Apache Spark серверу вынесены в переменные окружения. Используется Apache Spark в режиме spark-connect.

Параметры подключения к БД соответствуют параметрам описанным, в Docker-compose файле.

Структура PySpark-скриптов машинного обучения

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

Запуск Spark сессии

Все действия с Apache Spark необходимо производить в рамках сессии. Сессия Apache Spark в скриптах создается следующим кодом:

spark = SparkSession.builder \
.appName("Clustering 1") \
.getOrCreate()

В этом коде нет параметров подключения к Apache Spark, они берутся из переменных окружения.

Подключение к исходным данным

Исходные данные для примеров хранятся в базе данных. Их оттуда нужно загрузить в Apache Spark. Для этого используется JDBC‑подключение (да, из Python-скрипта; как это получается, смотрите в описании PySpark):

spark.read
.format("jdbc")
.option("url", os.getenv("DB_URL"))
.option("user", os.getenv("DB_USER_NAME"))
.option("password", os.getenv("DB_USER_PASSWORD"))
.option("query", """
SELECT
rt.file_type, cl."load"
FROM
cpu_load cl
JOIN received_types rt ON
rt.received_at >= cl.time_frame_start
AND rt.received_at < cl.time_frame_finish
""")
.load()

Определение меток (типов файлов)

Метки типов файлов в исходных данных-это строки. Машинное обучение в Apache Spark требует, чтобы все нечисловые параметры (признаки) были превращены в числа. Для этого используется такой код:

indexer = StringIndexer(inputCol = "file_type", outputCol = "label")
indexer_model = indexer.fit(df)
indexed_df = indexer_model.transform(df)

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

Так как смотреть на результаты, где вместо исходного текста будут выводиться «какие‑то» числа не удобно, то выбранные уникальные типы файлов (метки) выгружаются в массив в том порядке, в каком им были выданы индексы:

labels = indexer_model.labels

Теперь в наличии есть метки (типы файлов), для которых нужно изучить признаки.

Определение, что является признаком (анализируемыми данными для меток), в исходных данных

Задача состоит в том, чтобы связать типы файлов с нагрузкой на процессор. Значит, нагрузка на процессор (поле load) ‑ это признак. Следующие две строки показывают, как объявить поле load полем признака, то есть полем, которое анализируется для меток.

assembler = VectorAssembler(inputCols = ["load"], outputCol = "features")
final_df = assembler.transform(indexed_df)

Сравнение типов файлов между собой

Текущая задача состоит в выделении одного типа файла из набора других, что вызывает необходимость сравнения типов файлов. Для решения этой задачи в Apache Spark есть One-vs-Rest classifier. Следующая строка указывает, что нужно применить классификацию к переданным меткам и признакам

ovr = OneVsRest(classifier = LogisticRegression(), featuresCol = "features", labelCol = "label")

Выбор классификаторов будет обсуждаться ниже.

Строка машинного обучения

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

model = ovr.fit(final_df)

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

Выгрузка результатов

Полученные результаты необходимо преобразовать в понимаемый человеком результат. Во всех скриптах применяется механизм выгрузки результатов в массив кортежей/tuples.

type_coef_pairs = []
for i, classifier in enumerate(model.models):
coef = classifier.coefficients[0]
file_type_name = labels[i]
type_coef_pairs.append((file_type_name, coef))

Чтобы результаты были отсортированы в удобный для просмотра вид, они сортируются по первому значению кортежа, которое есть имя типа файла:

type_coef_pairs.sort(key = lambda x: x[0])

Выводятся результаты просто:

for file_type_name, coef in type_coef_pairs:
print(f"{file_type_name}: coefficient = {coef:.4f}")

Поиск моделей, запуск скриптов, получение результата

Выбор моделей

Здравый смысл подсказывает, что текущая задача является задачей классификации. Нужно классифицировать типы файлов и выделить из них один тип файла. В примерах используется Apache Spark, что дает необходимость идти в раздел описания классификаций и регрессии в Apache Spark и, конкретно, в раздел классификаций.

Я перебрал (без фанатизма) все варианты классификации и выбрал 4 описанных ниже. Возможно, среди невыбранных тоже есть хорошие кандидаты на решение этой задачи.

Все классификаторы используются с параметрами по умолчанию.

Логистическая регрессия

Документацию по логистической регрессии можно найти на сайте Apache Spark.

Скрипт можно найти в GitHub.

Код использования логистической регрессии следующий:

ovr = OneVsRest(classifier = LogisticRegression(), featuresCol = "features", labelCol = "label")
model = ovr.fit(final_df)

Запуск дает следующий результат:

Результаты классификации с LogisticRegression (OneVsRest):
type_0: coefficient = -0.0246
type_1: coefficient = -0.0275
type_2: coefficient = -0.0222
type_3: coefficient = -0.0252
type_4: coefficient = -0.0248
type_5: coefficient = 0.1313
type_6: coefficient = -0.0220
type_7: coefficient = -0.0205
type_8: coefficient = -0.0284
type_9: coefficient = -0.0217

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

Очень поверхностное описание

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

Классификатор дерева принятия решений

Документацию по логистической регрессии можно найти на сайте Apache Spark.

Скрипт можно найти в GitHub.

Код использования классификатора дерева принятия решений следующий:

ovr = OneVsRest(classifier = DecisionTreeClassifier(), featuresCol = "features", labelCol = "label")
model = ovr.fit(final_df)

Запуск скрипта дает следующий результат:

Результаты классификации с DecisionTreeClassifier (OneVsRest):
type_0: feature importance = 0.0000
type_1: feature importance = 0.0000
type_2: feature importance = 0.0000
type_3: feature importance = 0.0000
type_4: feature importance = 0.0000
type_5: feature importance = 1.0000
type_6: feature importance = 0.0000
type_7: feature importance = 0.0000
type_8: feature importance = 0.0000
type_9: feature importance = 0.0000

Тип файла, вызывающий нагрузку на процессор, найден.

Очень поверхностное описание

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

Результат соответствует человеческому смыслу: только при наличии файла с type_5 компьютер принимает решение об увеличении нагрузки на процессор.

Классификатор случайных лесов

Документацию по классификатору случайных лесов можно найти на сайте Apache Spark.

Скрипт можно найти в GitHub.

Код использования классификатора случайных лесов:

ovr = OneVsRest(classifier=RandomForestClassifier(), featuresCol="features", labelCol="label")
model = ovr.fit(final_df)

Запуск скрипта дает следующий результат:

Результаты классификации с RandomForestClassifier (OneVsRest):
type_0: feature importance = 0.0000
type_1: feature importance = 0.0000
type_2: feature importance = 0.0000
type_3: feature importance = 0.0000
type_4: feature importance = 0.0000
type_5: feature importance = 1.0000
type_6: feature importance = 0.0000
type_7: feature importance = 0.0000
type_8: feature importance = 0.0000
type_9: feature importance = 0.0000

Тип файла, вызывающий нагрузку на процессор найден.

Очень поверхностное описание

Здесь применен алгоритм, который является расширением предыдущего алгоритма, только здесь применяется «ансамбль решающих деревьев», в чем можно убедиться на сайте Wikipedia. Соответственно, все, что описано для деревьев принятия решения, применимо и здесь.

Линейная опорная векторная машина

Документацию по алгоритму «линейная опорная векторная машина» можно найти на сайте Apache Spark.

Скрипт можно найти в GitHub.

Код использования алгоритма «линейная опорная векторная машина»:

ovr = OneVsRest(classifier=LinearSVC(), featuresCol="features", labelCol="label")
model = ovr.fit(final_df)

Запуск скрипта дает следующий результат:

type_0: coefficient = 0.0000
type_1: coefficient = 0.0000
type_2: coefficient = 0.0000
type_3: coefficient = 0.0000
type_4: coefficient = 0.0000
type_5: coefficient = 0.0442
type_6: coefficient = 0.0000
type_7: coefficient = 0.0000
type_8: coefficient = 0.0000
type_9: coefficient = 0.0000

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

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

Очень поверхностное описание

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

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

Выводы

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

При наличии инфраструктуры Apache Spark (которую тоже удалось поднять на удивление просто и что описано в первой части) решить эту задачу можно немного дольше чем SQL-решение.

Однако, если предположить, что время прихода файлов и загрузка процессора в периодах времени будут храниться не в одной базе данных, как сделано в этом примере, а в разных местах, к обоим из которых есть доступ из Apache Spark, то данное решение может выиграть по скорости и простоте так как, Apache Spark без проблем объединит данные из двух разнородных источников, а загрузка всех данных в один источник может потребовать дополнительных времени и сил.