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

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

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

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

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

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

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

2) Что делает данный код?

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

Данный код выполняет следующие шаги:

1. Загрузка необходимых библиотек и установка окружения, включая TensorFlow, pandas, numpy, matplotlib для визуализации, и Google Colab для работы с данными на Google Drive.

2. Загрузка набора данных для обучения и тестирования из CSV-файлов.

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

4. Визуализация обучающих данных для проверки.

5. Кодирование категориальных меток классов в формате one-hot encoding.

6. Создание нейронной сети с помощью TensorFlow Sequential API с двумя полносвязными слоями.

7. Компиляция модели с определением функции потерь, оптимизатора и метрик.

8. Обучение нейронной сети на данных обучения.

9. Оценка точности модели на данных валидации.

10. Предсказание классов для данных валидации и визуализация результатов.

Код:

#загржаем нужные библиотеки
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, Flatten
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
%matplotlib inline
from google.colab import drive
drive.mount(‘/content/drive/’)
#укажите свою папку
DIR = “dataset1_bashkort”
PATH = ‘/content/drive/My Drive/’+ DIR + ‘/’
#укажите свои классы
classes = ["Ә", "Җ", "Ң", "Ө", "Ү", "Һ"]
# Размеры изображения
img_width, img_height = 20, 20
# Размерность тензора на основе изображения для входных данных в нейронную сеть
# backend Tensorflow, channels_last
input_shape = (img_width, img_height, 1)
# Размер мини-выборки
batch_size = 128
# количество классификации
N = len(classes)
#Загружаем данные для обучения
train = pd.read_csv(PATH + ‘train.csv’, sep=”,”) #
#Загружаем данные для тестирования
val = pd.read_csv(PATH + ‘validate.csv’)

from tensorflow.keras import utils
y_train1 = utils.to_categorical(y_train, N)
y_val1 = utils.to_categorical(y_val, N)

model = Sequential()
model.add(Dense(900, input_dim=400, activation=”relu”))
model.add(Dense( N, activation=”softmax”))

model.compile(loss=”categorical_crossentropy”, optimizer=”adam”, metrics=["accuracy"])
print(model.summary())

#Обучаем сеть
model.fit(x_train, y_train1,
          batch_size=1200,
          epochs=23,
          verbose=1)

scores1 = model.evaluate(x_val, y_val1, verbose=1)
print(“Доля правильных ответов на валидационных данных, в процентах:”, round(scores1[1] * 100, 4))

predictions = model.predict(x_val)
#Преобразуем результаты распознавания из формата one hot encoding в цифры
predictions = np.argmax(predictions, axis=1)
#Посмотрим на результат распознавания
print(“результат распознавания”)
plt.figure(figsize=(10,10))
start = 0
for i in range(start,start+50):
    plt.subplot(5,10,i-start+1)
    plt.xticks([])
    plt.yticks([])
    plt.grid(False)
    plt.imshow(x_val[i].reshape((img_width, img_height)), cmap=plt.cm.binary)
    plt.xlabel( “Это: ” + classes[predictions[i]] )

Результат:

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

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

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

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

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

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

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

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

В TensorFlow константы создаются с использованием функции: constant(value, dtype=None, shape=None, name=’Const’, verify_shape=False), где value постоянное значение, которое будет использоваться при дальнейших вычислениях, dtype является параметром, указывающим тип данных (например, float32/64, int8/16), shape является необязательным параметром, указывающим размер массива данных, name является необязательным задающим имя для тензора. Если вам нужны константы с определенными значениями внутри вашей обучающей модели, тогда объект типа constant может использоваться как в следующем примере: z = tf.constant(5.2, name=”x”, dtype=tf.float32).

Для создания сверточной нейронной сети была выбрана платформа Google Colab. Она обладает рядом преимуществ, а именно универсальна, является бесплатной платформой, представляет мощные технологии обработки данных и машинного обучения.

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

Решение задачи классификации изображений с помощью сверточных нейронных сетей осуществляет Google Colab — это бесплатный облачный сервис на основе Jupyter Notebook, он предоставляет всё необходимое для машинного обучения прямо в браузере, предоставляет бесплатный доступ.

Google Colab – блокнот для программирования на языке Python. В нем есть возможность для работы с серьезными технологиями при разработке реальных приложений data science и ML, предоставляет все необходимое для решения задач по анализу и обработке данных (с применимостью к Python).

Python – высокоуровневый язык программирования, который опирается на повышение производительности разработчика и читаемости кода. Это интерпретируемый язык программирования, то есть не требует компиляции в байт-код.

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

– достаточность — число обучающих примеров должно быть достаточным для обучения;

– разнообразие;

– равномерность представления классов.

Датасеты – это то, на чем основывается наука о данных, материал, на котором основаны все исследования. В основном рассматривают два типа данных: традиционные и большие (Big Data).

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

Большие данные (массивнее, чем традиционные, основываются как на разнообразии (числа, текст, изображения, аудио, видео и т. д.), так и скорости извлечения и вычисления в реальном времени, и объема.)

Датасеты разделяются на три категории:

1. Простая запись – это самая простая форма, не имеющая явной связи между строками-наблюдениями или столбцами-признаками (каждая строка имеет одинаковый набор характеристик).

2. Графы (отношения между объектами фиксируются связями).

3. Упорядоченные записи (некоторые данные упорядочены во времени или пространстве).

Разработка моделей нейронной сети выполняется в облачном сервисе Google Colab. На первом этапе создается папка, в которой будет находится датасет и скрипт с нейронной сетью.

Работа над нейронной сетью начинается с добавления библиотек Tensorflow. Загружаем нужные библиотеки:

from tensorflow.keras.models import Sequential

from tensorflow.keras.layers import Dense, Flatten

import pandas as pd

import numpy as np

import matplotlib.pyplot as plt

Так как нейронная сеть создается на сервисе Google Colab, датасет находится на Google диске, необходимо подключить диск к сети.

from google.colab import drive

drive.mount(‘/content/drive/’)

В случае успешного подключения к диску появляется всплывающее окно, говорящее об успешном подключении к нему.

Drive mounted at /content/drive/; to attempt to forcibly remount, call drive.mount(“/content/drive/”, force_remount=True).

Переменная PATH показывает путь сети к ранее созданному датасету.

PATH = ‘/content/drive/My Drive/II/nf/’

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

target_name = ["✖","✚","<",">","±","•","–","="]

DIR = “dataset_ _mathdeystvo ”

PATH = ‘/content/drive/My Drive/’+ DIR + ‘/’

PATH – корневой каталог для всех имеющихся на диске датасетов.

Переменные train_dir, test_dir, pred_dir – это пути, которые указывают на каталоги с данными для: обучения, тестирования, предсказания.

Следующим шагом указываем размер изображения. Тензоры можно рассматривать как матрицы, с формами. В Keras сам входной слой – это не слой, а тензор. Это стартовый тензор, который отправляется на первый скрытый слой. Этот тензор должен иметь ту же форму, что и тренировочные данные. Размер изображений в датасете составляет 20*20. Более удобно вводить переменную input_shape, которая в себе содержит сразу размерность изображений и количество фильтров.

В данной сети фильтр 1, так как используемые изображения в черно-белом цвете. Указываем размер мини-выборки с помощью переменной batch_size, которая отображает количество изображений, которые изучает модель за один проход. Нейронная сеть работает с данными постепенно, обработка происходит последовательно (частями).

# Размеры изображения

img_width, img_height = 20, 20

input_shape = (img_width, img_height, 1)

# Размер мини-выборки

batch_size = 128

# количество классификации

N = len(classes)

Загружаем данные для обучения с помощью метода pd.read_csv:

train = pd.read_csv(PATH + ‘train.csv’, sep=”,”) #, nrows=3975

Загружаем данные для тестирования:

val = pd.read_csv(PATH + ‘validate.csv’)

Исследуем данные. Просматриваем данные для обучения:

train[:5]

Выбираем 8 видов изображений (знак умножения, знак сложения, знак больше, знак меньше, знак плюс-минус, точка, знак минус, знак равно). Посмотрим на тренировочные данные:

plt.figure(figsize=(10,10))

start = 0

for i in range(start,start+50):

plt.subplot(5,10,i-start+1)

plt.xticks([])

plt.yticks([])

plt.grid(False)

plt.imshow(x_train[i].reshape((img_width, img_height)), cmap=plt.cm.binary)

plt.xlabel(classes[y_train[i]])

Был собран датасет в количестве нескольки тысяч изображений в черно-белом цвете (рисунок 6), так как для отработки нейронной сети необходимо большое количество изображений (при малых объемах датасета сеть свою работу не выполняет).

Рисунок 1. Датасет

Работа нейронной сети рассматривается в трех моделях.

1.    Двухслойная нейронная сеть.

Рассматривается сеть из двух нейронных слоев. Для создания модели используется класс Sequential. На входном слое находятся 1000 нейронов. Функция активации (запуска) relu, размер входных данных = 1024. На последнем слое должно быть 4 нейрона, так как это количество должно совпадать с количеством классификаций изображений (треугольник, квадрат, окружность, ромб).

Активация последнего слоя выполняется с помощью функции softmax.

Рисунок 2. Характеристики двухслойной модели

Рисунок 3. Предсказание нейронной сети

С помощью функции summary просматриваются все характеристики полученной трехслойной модели (рисунок 5).

Рисунок 4. Характеристики трехслойной модели

Полносвязная нейронная сеть недостаточно качественно выполняет работу с изображениями. Прогресс обучения двуслойной нейронной сети (78 %) и трехслойной нейронной сети (79 %) растет достаточно медленно, за счет увеличения количества слоев. Более качественный результат можно получить лишь, построив сверточную нейронную сеть.

Рисунок 5. Характеристики сверточной нейронной сети

Для распознавания дальнейших изображений используется метод predict, который позволяет распознавать, а далее выводить распознанные и истинные объекты. Подготовим в Paint собственные изображения и загрузим их на гугл-диск (рисунок 6)

Рисунок 6. Собственные изображения для проверки работы нейронной сети

По итогам распознавания собственных изображений можно сделать следующий вывод (таблица 1):

Таблица 1. Качество распознавания собственных изображений

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

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

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

Современные технологии искусственного интеллекта (ИИ) и машинного обучения (МО) приобретают все большую популярность и находят применение в различных сферах деятельности. Одним из наиболее перспективных направлений является использование нейронных сетей для решения задач распознавания и классификации. В данной статье рассматриваются возможности и методы применения нейронных сетей для распознавания согласных букв.

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

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

Для разработки и обучения нейронных сетей широко используется библиотека TensorFlow, предоставляемая Google. Она обеспечивает высокую производительность и гибкость при создании сложных моделей МО. TensorFlow поддерживает работу как на CPU, так и на GPU, что позволяет значительно ускорить процесс обучения нейронных сетей.

Google Colab предоставляет удобную среду для разработки и обучения моделей машинного обучения. Это облачный сервис, который позволяет использовать мощные вычислительные ресурсы Google без необходимости установки дополнительного программного обеспечения. Colab поддерживает работу с Jupyter Notebook и позволяет совместно работать над проектами в реальном времени​.

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

Формат данных выборки для обучения train.csv выглядит следующим образом: каждая строка представляет собой описание одного изображения; первый столбец содержит метки классов, к которым принадлежит изображение; оставшиеся столбцы содержат пиксельные значения изображения, например, в виде плоского вектора, где каждое значение соответствует яркости соответствующего пикселя на изображении [1].

У нас будут следующие классы согласных букв:

classes = ["к","л","м","н","п","р","с","т"]

Загрузим и посмотрим на датасет (рисунок 1):

Рисунок 1. Датасет согласных букв

После подготовки данных, создаются и обучаются модели нейронных сетей. Используются различные архитектуры, такие как сверточные нейронные сети (CNN), которые особенно эффективны в задачах распознавания образов. Обучение модели проводится на обучающем наборе данных с последующей проверкой на валидационном наборе для оценки её производительности.

Работа нейронной сети рассматривается в трех моделях.

1.    Двухслойная нейронная сеть.

На первом шаге рассматривается сеть из двух нейронных слоев [2]. Для создания модели используется класс Sequential. На входном слое находятся 700 нейронов. Функция активации (запуска) relu, размер входных данных равен 400 (у нас картинки 20 на 20). На последнем слое должно быть 8 нейронов, так как это количество должно совпадать с количеством классификаций изображений [3] (у нас согласные буквы “к”,”л”,”м”,”н”,”п”,”р”,”с”,”т”). Модель нейронной сети строится с помощью класса Sequential [4].

N = 8

model = Sequential()

model.add(Dense(700, input_dim=400, activation=”relu”))

model.add(Dense( N, activation=”softmax”))

Приступаем к обучению модели с помощью метода fit модели (рисунок 2).

Рисунок 2. Ход обучения нейронной сети

Можно посмотреть, как нейронная сеть делает предсказание на тестовых данных. Для этого применяется метод predict:

Рисунок 3. Валидация нейронной сети

2. Трехслойная нейронная сеть.

Усложним нейронную сеть, сделав 3 слоя. Рассматривается сеть из трех нейронных слоев:

model = Sequential()

model.add(Dense(700, input_dim=400, activation=”relu”))

model.add(Dense(100, activation=”relu”))

model.add(Dense( N, activation=”softmax”))

Остальные шаги проделываются аналогично.

3. Сверточная нейронная сеть.

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

model = Sequential()

model.add(Conv2D(32, (3, 3),

input_shape=(img_width, img_height, 1), activation=’relu’))

model.add(MaxPooling2D(pool_size=(2,2)))

model.add(Conv2D(64, (3, 3), activation=’relu’))

model.add(MaxPooling2D(pool_size=(2, 2)))

model.add(Flatten())

model.add( Dense( 700, activation = ‘relu’))

model.add( Dense( N, activation=’softmax’))

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

Таблица 1 – Качество распознавания изображений нейронными сетями

Подготовим также в Paint собственные изображения и загрузим их на гугл-диск (рисунок 4).

Рисунок 4. Собственные изображения для проверки

работы нейронной сети

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

Рисунок 5. Распознавание и предсказание нейронной сети

Сверточная нейронная сеть будет, как и ожидалось, давать наилучшее предсказание.

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

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

Рисунок 1. Архитектура сверточной нейронной сети

Алгоритм решения задачи

- импортируем библиотеки `tensorflow.keras`, `pandas`, `numpy`, `matplotlib` и инструменты для аугментации;

- загружаем и проверяем структуру данных через `pd.read_csv()`;

- извлекаем метки и изображения, нормализуем их и преобразуем форму для подачи в модель;

- создаем сверточную модель с помощью `Sequential()`, добавляя слои Conv2D, MaxPooling2D, Dropout;

- компилируем модель, указывая функцию потерь и оптимизатор;

- задаем коллбеки для ранней остановки и снижения скорости обучения;

- делим данные на обучающую и валидационную выборки;

- применяем аугментацию данных через `ImageDataGenerator`;

- обучаем модель с помощью метода `fit()`, использующего генератор и коллбеки;

- визуализируем процесс обучения, строя графики точности и потерь;

- делаем предсказания на тестовом наборе и сохраняем их в CSV файл.

Рисунок 2. Схема процесса обучения

Код:

python

# Создаем модель

model = Sequential()

model.add(Conv2D(32, (3,3), activation=’relu’, padding=’same’, input_shape=(28,28,1)))

model.add(BatchNormalization())

model.add(MaxPooling2D(pool_size=(2,2)))

model.add(Dropout(0.25))

# (добавляем дополнительные слои)

model.add(Dense(10, activation=’softmax’))

# Компиляция модели

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

…

…

# Обучение модели с аугментацией

history = model.fit(

datagen.flow(x_train_part, y_train_part, batch_size=128),

epochs=100,

validation_data=(x_val, y_val),

callbacks=[early_stop, reduce_lr, lr_scheduler],

verbose=1

)

…

…

python

# Визуализация результатов

plt.plot(history.history['accuracy'], label=’Train Accuracy’)

plt.plot(history.history['val_accuracy'], label=’Validation Accuracy’)

plt.legend()

…

Вывод:

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

В данной работе для классификации ирисов используется полносвязная нейронная сеть, реализованная на Keras. Модель принимает на вход четыре нормализованных признака: длину и ширину чашелистика, длину и ширину лепестка. Архитектура сети включает скрытые слои с функцией активации ReLU и выходной слой с функцией softmax для многоклассовой классификации. Обучение проводится с оптимизатором Adam на протяжении 20 эпох, а процесс отслеживается по графикам точности на обучающей и проверочной выборках. Такой подход позволяет достичь высокой точности предсказания и служит примером стандартного пайплайна для задач классификации табличных данных.

Рисунок 1. Динамика точности модели в процессе обучения

Алгоритм решения задачи по построению модели классификации для набора данных Ирисов Фишера включает следующие последовательные шаги с использованием языка Python и библиотек TensorFlow/Keras.

• импортируем необходимые библиотеки: TensorFlow/Keras, pandas, numpy и matplotlib;
• подключаем Google Drive и загружаем обучающий и тестовый наборы данных из CSV-файлов;
• выделяем матрицу признаков и вектор целевой переменной из обучающих данных;
• проводим стандартизацию признаков, вычитая среднее значение и деля на стандартное отклонение;
• создаём последовательную модель нейронной сети с двумя скрытыми полносвязными слоями и выходным слоем на 3 нейрона;
• компилируем модель, выбирая оптимизатор Adam и функцию потерь sparse_categorical_crossentropy;
• обучаем модель на подготовленных данных, выделяя часть для валидации;
• строим график изменения точности на обучающей и проверочной выборках по эпохам;
• используем обученную модель для предсказания классов на тестовом наборе данных;
• сохраняем результаты предсказаний в файл для отправки или последующего анализа.

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

Ниже приведен фрагмент кода, реализующий ключевые шаги алгоритма:

from tensorflow.keras.models import Sequential

from tensorflow.keras.layers import Dense

import pandas as pd

import numpy as np

import matplotlib.pyplot as plt

train = pd.read_csv(‘train.csv’)

test = pd.read_csv(‘test.csv’)

features = ["SepalLength", "SepalWidth", "PetalLength", "PetalWidth"]

target = ‘Species’

x_train = train[features].values

y_train = train[target].values

x_test = test[features].values

mean = x_train.mean(axis=0)

std = x_train.std(axis=0)

x_train -= mean

x_train /= std

x_test -= mean

x_test /= std

model = Sequential()

model.add(Dense(100, activation=’relu’, input_shape=(x_train.shape[1],)))

model.add(Dense(16, activation=’relu’))

model.add(Dense(3, activation=’softmax’))

model.compile(optimizer=’adam’,

loss=’sparse_categorical_crossentropy’,

metrics=['accuracy'])

history = model.fit(x_train, y_train, epochs=20, validation_split=0.1, verbose=2)

plt.plot(history.history['accuracy'], label=’Точность на обучении’)

plt.plot(history.history['val_accuracy'], label=’Точность на валидации’)

plt.xlabel(‘Эпоха’)

plt.ylabel(‘Точность’)

plt.legend()

plt.show()

predictions = model.predict(x_test)

predictions = np.argmax(predictions, axis=1)

Процесс обучения модели визуализирован на Рисунке 2 (изображение сгенерировано нейросетью):

Рисунок 2. Архитектура используемой нейронной сети

Заключение

Задача классификации Ирисов Фишера, несмотря на свою простоту и давнюю историю, продолжает оставаться важным учебным и тестовым инструментом в области машинного обучения. Использование нейронных сетей, как показано в работе, позволяет эффективно решать эту задачу, демонстрируя типичный пайплайн для обработки табличных данных. Ключевыми этапами являются корректная предобработка данных, выбор архитектуры сети и мониторинг процесса обучения. Модель успешно справляется с классификацией, что подтверждает применимость полносвязных сетей для подобных задач. Освоение работы с этим набором данных формирует прочную основу для перехода к более сложным современным проблемам искусственного интеллекта.

Алгоритм решения задачи по классификации цветков ириса на три вида включает следующие последовательные шаги реализации на Python с использованием нейронной сети.

1. импортируем необходимые библиотеки: pandas, numpy, tensorflow/keras, scikit-learn, matplotlib;

2.  подключаем Google Drive и загружаем файлы с данными (train.csv, test.csv) и шаблоном для ответов (sample_submission.csv);

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

4.  выделяем из данных признаки (sepal length, sepal width, petal length, petal width) и целевую переменную (species);

5.  преобразуем данные в массивы NumPy для дальнейшей обработки;

6.  выполняем стандартизацию признаков с помощью StandardScaler, вычитая среднее и деля на стандартное отклонение;

7.  разделяем обучающие данные на тренировочную и валидационную выборки;

8.  создаем архитектуру последовательной нейронной сети с использованием Dense-слоев, BatchNormalization и Dropout для регуляризации;

9.  компилируем модель, задавая оптимизатор Adam, функцию потерь sparse_categorical_crossentropy и метрику accuracy;

10. определяем коллбэки для управления процессом обучения: EarlyStopping для остановки при переобучении и ReduceLROnPlateau для динамического снижения скорости обучения;

11. обучаем модель на тренировочных данных, используя валидационную выборку для контроля;

12. визуализируем историю обучения, строя графики точности на тренировочном и проверочном наборах;

13. выполняем предсказание на тестовых данных, преобразованных с помощью того же scaler;

14. преобразуем выходные вероятности модели в предсказанные классы с помощью argmax;

15. сохраняем результаты предсказаний в файл формата CSV для последующей отправки или анализа.

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

Код реализации ключевых этапов:

import pandas as pd

import numpy as np

import tensorflow as tf

from sklearn.preprocessing import StandardScaler

from tensorflow.keras.models import Sequential

from tensorflow.keras.layers import Dense, Dropout, BatchNormalization

# … загрузка данных train и test …

features = ["SepalLength", "SepalWidth", "PetalLength", "PetalWidth"]

target = ‘Species’

x_train = train[features].values

y_train = train[target].values

x_test = test[features].values

scaler = StandardScaler()

x_train = scaler.fit_transform(x_train)

x_test = scaler.transform(x_test)

model = Sequential([

Dense(128, activation='relu', input_shape=(4,)),

BatchNormalization(),

Dropout(0.4),

Dense(64, activation='relu'),

BatchNormalization(),

Dropout(0.3),

Dense(32, activation='relu'),

Dropout(0.2),

Dense(3, activation='softmax')

])

model.compile(optimizer=tf.keras.optimizers.Adam(learning_rate=0.0005),

loss=’sparse_categorical_crossentropy’,

metrics=['accuracy'])

# … определение callbacks и обучение модели …

predictions = model.predict(x_test)

predicted_classes = np.argmax(predictions, axis=1)

Заключение

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

Введение

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

Инструментарий

В качестве инструментария для решения поставленной задачи была выбрана библиотека TensorFlow с высокоуровневым фреймворком Keras, которые предоставляют удобные средства для создания и обучения нейронных сетей различной архитектуры. Для работы с табличными данными используется библиотека Pandas, для математических операций и работы с массивами – NumPy, для визуализации результатов – Matplotlib.

Загрузка данных

Поскольку работа выполнялась в среде Google Colab, потребовалось подключение Google Drive для доступа к файлам датасета:

from google.colab import drive

drive.mount(‘/content/drive/’)

Путь к данным задается через переменную PATH, после чего загружаются тренировочный и тестовый наборы данных, а также файл с примером формата ответов sample_submission.csv:

DIR = “Titanic”

PATH = ‘/content/drive/My Drive/’+ DIR + ‘/’

train = pd.read_csv(PATH + ‘train.csv’)

test = pd.read_csv(PATH + ‘test.csv’)

sample_submission = pd.read_csv(PATH + ‘sample_submission.csv’, index_col=’PassengerId’)

Предобработка данных

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

Замена категориальных признаков

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

train = train.replace(‘male’, 1).replace(‘female’, 0)

test = test.replace(‘male’, 1).replace(‘female’, 0)

Создание дамми-переменных

Далее создаются дамми-переменные для категориальных признаков Embarked (порт посадки) и Pclass (класс билета), что позволяет представить эти признаки в виде бинарных векторов:

train = pd.concat([train, pd.get_dummies(train.Embarked, prefix="Emb")], axis=1)

train = pd.concat([train, pd.get_dummies(train.Pclass, prefix="Pclass")], axis=1)

test = pd.concat([test, pd.get_dummies(test.Embarked, prefix="Emb")], axis=1)

test = pd.concat([test, pd.get_dummies(test.Pclass, prefix="Pclass")], axis=1)

Создание новых признаков

Важным этапом инженерного анализа данных является создание новых признаков, которые могут нести дополнительную информацию для модели. На основе имеющихся признаков Parch (количество родителей и детей) и SibSp (количество братьев, сестер, супругов) был создан новый бинарный признак “наличие более одного родственника”, принимающий значение 1, если у пассажира было более одного родственника на борту, и 0 в противном случае.

train['more than one relative'] = train.Parch + train.SibSp > 1

train = train.replace(True, 1).replace(False, 0)

test['more than one relative'] = test.Parch + test.SibSp > 1

test = test.replace(True, 1).replace(False, 0)

Анализ пропущенных значений

Производится анализ пропущенных значений с помощью методов isnull().sum():

train.isnull().sum()

Для визуализации используется тепловая карта библиотеки Seaborn, что позволяет наглядно увидеть, в каких колонках присутствуют пропуски:

import seaborn as sns

sns.heatmap(train.isnull(), cbar = False).set_title(“Карта пропущенных значений”)

Заполнение пропусков

На основе анализа принимается решение о заполнении пропущенных значений. Для числовых колонок Age и Fare пропуски заменяются средними значениями:

numeric_cols = ['Age', 'Fare']

train[numeric_cols] = train[numeric_cols].fillna(train[numeric_cols].mean())

test[numeric_cols] = test[numeric_cols].fillna(train[numeric_cols].mean())

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

Формирование признакового пространства

После завершения предобработки формируется список признаков features и целевая переменная target:

features = ['Pclass_1', 'Pclass_2', 'Pclass_3', 'Age', 'Sex', 'Fare', 'more than one relative', 'Emb_C', 'Emb_Q', 'Emb_S']

target = ‘Survived’

Данные преобразуются в массивы NumPy для подачи в нейронную сеть:

X_train = train[features].values

Y_train = train[target].values

X_test = test[features].values

Нормализация данных

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

mean = X_train.mean(axis=0)

std = X_train.std(axis=0)

X_train = X_train – mean

X_train /= std

X_test = X_test – mean

X_test /= std

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

Для построения модели используется последовательная архитектура Sequential с импортом необходимых слоев:

from tensorflow.keras.models import Sequential

from tensorflow.keras.layers import Dense, Dropout

Модель состоит из трех полносвязных слоев. Первый слой содержит 200 нейронов с функцией активации ReLU и принимает на вход данные размерности, соответствующей количеству признаков. Второй скрытый слой содержит 20 нейронов также с функцией активации ReLU. Выходной слой содержит один нейрон с сигмоидной функцией активации, что позволяет получать на выходе вероятность принадлежности к классу 1 (выживший) в диапазоне от 0 до 1.

Для предотвращения переобучения после каждого скрытого слоя добавляется слой Dropout с вероятностью отключения нейронов 0.1:

model = Sequential()

model.add(Dense(200, activation=’relu’, input_shape=(X_train.shape[1],)))

model.add(Dropout(0.1))

model.add(Dense(20, activation=’relu’))

model.add(Dropout(0.1))

model.add(Dense(1, activation=’sigmoid’))

После создания модели выводится ее краткое описание:

print(model.summary())

Компиляция модели

Компиляция модели производится с использованием оптимизатора Adam. В качестве функции потерь используется binary_crossentropy, подходящая для бинарной классификации. Метрикой качества выбрана accuracy – доля правильных ответов:

model.compile(optimizer=’adam’, loss=’binary_crossentropy’, metrics=['accuracy'])

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

Обучение модели производится на тренировочных данных с валидационным разделением 10% от обучающей выборки. Количество эпох обучения установлено равным 2, размер пакета batch_size равен 1:

history = model.fit(X_train, Y_train,

                    epochs=2,

                    batch_size=1,

                    validation_split=0.1,

                    verbose=2)

Визуализация процесса обучения

Для визуализации процесса обучения строится график изменения точности на обучающем и проверочном наборах данных:

plt.plot(history.history['accuracy'], label=’Точность на обучающем наборе’)

plt.plot(history.history['val_accuracy'], label=’Точность на проверочном наборе’)

plt.xlabel(‘Эпоха обучения’)

plt.ylabel(‘Точность’)

plt.legend()

plt.show()

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

Предсказание на тестовых данных

После завершения обучения производится предсказание на тестовых данных:

predictions = model.predict(X_test)

Полученные предсказания представляют собой вероятности принадлежности к классу 1. Для преобразования вероятностей в бинарные метки используется пороговое значение 0.5:

sample_submission[target] = [0 if pred < 0.5 else 1 for pred in predictions]

Экспорт результатов

Полученные предсказания записываются в файл-образец и сохраняются в файл titanic_submission.csv:

sample_submission.to_csv(‘titanic_submission.csv’)

Поскольку работа велась в Google Colab, для загрузки файла на локальный компьютер используется модуль files:

from google.colab import files

files.download(‘titanic_submission.csv’)

Заключение

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

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