Решение проблем классификации и регрессии

4 min


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

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

Если вы когда-либо работали с библиотекой Keras, вас ждет удовольствие. TensorFlow 2.0 теперь использует Keras API в качестве библиотеки по умолчанию для обучения моделей классификации и регрессии. До TensorFlow 2.0 одна из основных критических ситуаций, с которыми сталкивались более ранние версии TensorFlow, была связана со сложностью создания модели. Ранее вам нужно было объединить графики, сессии и заполнители, чтобы создать даже простую модель логистической регрессии. С TensorFlow 2.0 создание классификационных и регрессионных моделей стало простым делом.

Итак, без лишних слов, давайте разработаем модель классификации с TensorFlow.

Набор данных

Набор данных для примера классификации можно загрузить бесплатно с эта ссылка, Загрузите файл в формате CSV. Если вы откроете загруженный файл CSV, вы увидите, что файл не содержит никаких заголовков. Детали колонок доступны на UCI репозиторий машинного обучения, Я рекомендую вам подробно прочитать информацию о наборе данных по ссылке для скачивания. Я кратко изложу набор данных в этом разделе.

Набор данных в основном состоит из 7 столбцов:

  1. цена (цена покупки автомобиля)
  2. maint (стоимость обслуживания)
  3. двери (количество дверей)
  4. человек (количество мест)
  5. lug_capacity (объем багажного отделения)
  6. безопасность (насколько безопасна машина)
  7. выход (состояние автомобиля)

Учитывая первые 6 столбцов, задача состоит в том, чтобы предсказать значение для 7-го столбца, то есть выходных данных. Выходной столбец может иметь одно из трех значений: «unacc» (неприемлемо), «acc» (приемлемо), «хорошо» и «очень хорошо».

Импорт библиотек

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

import pandas as pd
import numpy as np
import tensorflow as tf

import matplotlib.pyplot as plt
%matplotlib inline

import seaborn as sns
sns.set(style="darkgrid")

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

print(tf.__version__)

Если у вас не установлен TensorFlow 2.0, вы можете обновить его до последней версии с помощью следующей команды:

$ pip install --upgrade tensorflow

Импорт набора данных

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

cols = ('price', 'maint', 'doors', 'persons', 'lug_capacity', 'safety','output')
cars = pd.read_csv(r'/content/drive/My Drive/datasets/car_dataset.csv', names=cols, header=None)

Поскольку файл CSV по умолчанию не содержит заголовков столбцов, мы передали список заголовков столбцов pd.read_csv() метод.

Давайте теперь посмотрим первые 5 строк набора данных через head() метод.

cars.head()

Выход:

Вы можете увидеть 7 столбцов в наборе данных.

Анализ данных и предварительная обработка

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

plot_size = plt.rcParams("figure.figsize")
plot_size (0) = 8
plot_size (1) = 6
plt.rcParams("figure.figsize") = plot_size

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

cars.output.value_counts().plot(kind='pie', autopct='%0.05f%%', colors=('lightblue', 'lightgreen', 'orange', 'pink'), explode=(0.05, 0.05, 0.05,0.05))

Выход:

Результаты показывают, что большинство автомобилей (70%) находятся в неприемлемом состоянии, в то время как 20% автомобилей находятся в приемлемых условиях. Соотношение автомобилей в хорошем и очень хорошем состоянии очень низкое.

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

Следующий скрипт преобразует категориальные столбцы в числовые столбцы:

price = pd.get_dummies(cars.price, prefix='price')
maint = pd.get_dummies(cars.maint, prefix='maint')

doors = pd.get_dummies(cars.doors, prefix='doors')
persons = pd.get_dummies(cars.persons, prefix='persons')

lug_capacity = pd.get_dummies(cars.lug_capacity, prefix='lug_capacity')
safety = pd.get_dummies(cars.safety, prefix='safety')

labels = pd.get_dummies(cars.output, prefix='condition')

Чтобы создать наш набор функций, мы можем объединить первые шесть столбцов по горизонтали:

X = pd.concat((price, maint, doors, persons, lug_capacity, safety) , axis=1)

Давайте посмотрим, как теперь выглядит наш столбец метки:

labels.head()

Выход:

Столбец метки – это в основном версия выходного столбца с горячим кодированием, которая была у нас в наборе данных. Выходной столбец имел четыре уникальных значения: unacc, acc, good и очень good. В наборе меток с горячим кодированием вы видите четыре столбца, по одному для каждого из уникальных значений в выходном столбце. Вы можете увидеть 1 в столбце для уникального значения, которое изначально существовало в этой строке. Например, в первых пяти строках выходного столбца значение столбца было недоступно. В столбце метки вы можете видеть 1 в первых пяти строках столбца condition_unacc.

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

y = labels.values

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

from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.20, random_state=42)

Модельное Обучение

Для обучения модели давайте импортируем классы TensorFlow 2.0. Выполните следующий скрипт:

from tensorflow.keras.layers import Input, Dense, Activation,Dropout
from tensorflow.keras.models import Model

Как я уже говорил ранее, TensorFlow 2.0 использует API Keras для обучения модели. В скрипте выше мы в основном импортируем Input, Dense, Activation, а также Dropout классы от tensorflow.keras.layers модуль. Точно так же мы также import Model класс из tensorflow.keras.models модуль.

Следующим шагом является создание нашей модели классификации:

input_layer = Input(shape=(X.shape(1),))
dense_layer_1 = Dense(15, activation='relu')(input_layer)
dense_layer_2 = Dense(10, activation='relu')(dense_layer_1)
output = Dense(y.shape(1), activation='softmax')(dense_layer_2)

model = Model(inputs=input_layer, outputs=output)
model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=('acc'))

Как видно из сценария, модель содержит три плотных слоя. Первые два плотных слоя содержат 15 и 10 узлов соответственно с relu функция активации. Конечный плотный слой содержит 4 узла (y.shape(1) == 4) а также softmax функция активации, так как это задача классификации. Модель обучена с использованием categorical_crossentropy функция потерь и adam оптимизатор. Метрика оценки – точность.

Следующий скрипт показывает сводку модели:

print(model.summary())

Выход:

Model: "model"
_________________________________________________________________
Layer (type)                 Output Shape              Param #
=================================================================
input_1 (InputLayer)         ((None, 21))              0
_________________________________________________________________
dense (Dense)                (None, 15)                330
_________________________________________________________________
dense_1 (Dense)              (None, 10)                160
_________________________________________________________________
dense_2 (Dense)              (None, 4)                 44
=================================================================
Total params: 534
Trainable params: 534
Non-trainable params: 0
_________________________________________________________________
None

Наконец, для обучения модели выполните следующий скрипт:

history = model.fit(X_train, y_train, batch_size=8, epochs=50, verbose=1, validation_split=0.2)

Модель будет обучаться в течение 50 эпох, но здесь ради пространства отображается результат только последних 5 эпох:

Epoch 45/50
1105/1105 (==============================) - 0s 219us/sample - loss: 0.0114 - acc: 1.0000 - val_loss: 0.0606 - val_acc: 0.9856
Epoch 46/50
1105/1105 (==============================) - 0s 212us/sample - loss: 0.0113 - acc: 1.0000 - val_loss: 0.0497 - val_acc: 0.9856
Epoch 47/50
1105/1105 (==============================) - 0s 219us/sample - loss: 0.0102 - acc: 1.0000 - val_loss: 0.0517 - val_acc: 0.9856
Epoch 48/50
1105/1105 (==============================) - 0s 218us/sample - loss: 0.0091 - acc: 1.0000 - val_loss: 0.0536 - val_acc: 0.9856
Epoch 49/50
1105/1105 (==============================) - 0s 213us/sample - loss: 0.0095 - acc: 1.0000 - val_loss: 0.0513 - val_acc: 0.9819
Epoch 50/50
1105/1105 (==============================) - 0s 209us/sample - loss: 0.0080 - acc: 1.0000 - val_loss: 0.0536 - val_acc: 0.9856

К концу 50-й эпохи точность обучения составляет 100%, а достоверность проверки – 98,56%, что впечатляет.

Давайте, наконец, оценим производительность нашей модели классификации на тестовом наборе:

score = model.evaluate(X_test, y_test, verbose=1)

print("Test Score:", score(0))
print("Test Accuracy:", score(1))

Вот вывод:

WARNING:tensorflow:Falling back from v2 loop because of error: Failed to find data adapter that can handle input: , 
346/346 (==============================) - 0s 55us/sample - loss: 0.0605 - acc: 0.9740
Test Score: 0.06045335989359314
Test Accuracy: 0.9739884

Наша модель достигает точности 97,39% на тестовом наборе. Хотя это немного меньше, чем точность обучения в 100%, она все же очень хороша, учитывая тот факт, что мы случайным образом выбрали количество слоев и узлов. Вы можете добавить больше слоев в модель с большим количеством узлов и посмотреть, сможете ли вы получить лучшие результаты для наборов проверки и тестирования.

Регрессия с TensorFlow 2.0

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

Набор данных

Набор данных для этой проблемы можно загрузить бесплатно с эта ссылка, Загрузите файл CSV.

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

petrol_cons = pd.read_csv(r'/content/drive/My Drive/datasets/petrol_consumption.csv')

Давайте напечатаем первые пять строк набора данных через head() функция:

petrol_cons.head()

Выход:

Вы можете видеть, что в наборе данных есть пять столбцов. Модель регрессии будет обучаться в первых четырех столбцах, то есть Petrol_tax, Average_income, Paved_Highways и Population_Driver_License (%). Значение для последнего столбца, т. Е. Petrol_Consuration, будет предсказано. Как вы можете видеть, что нет никакого дискретного значения для выходного столбца, скорее предсказанное значение может быть любым непрерывным значением.

Предварительная обработка данных

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

X = petrol_cons.iloc(:, 0:4).values
y = petrol_cons.iloc(:, 4).values

from sklearn.model_selection import train_test_split

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0)

from sklearn.preprocessing import StandardScaler

sc = StandardScaler()
X_train = sc.fit_transform(X_train)
X_test = sc.transform(X_test)

В приведенном выше сценарии, в наборе функций X, первые четыре столбца набора данных включены. В наборе этикеток y, только 5-й столбец включен. Затем набор данных делится на размер обучения и теста с помощью train_test_split метод sklearn.model_selection модуль. Значение для test_size Атрибут равен 0,2, что означает, что тестовый набор будет содержать 20% исходных данных, а обучающий набор будет состоять из оставшихся 80% исходного набора данных. Наконец, StandardScaler класс из sklearn.preprocessing Модуль используется для масштабирования набора данных.

Модельное Обучение

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

input_layer = Input(shape=(X.shape(1),))
dense_layer_1 = Dense(100, activation='relu')(input_layer)
dense_layer_2 = Dense(50, activation='relu')(dense_layer_1)
dense_layer_3 = Dense(25, activation='relu')(dense_layer_2)
output = Dense(1)(dense_layer_3)

model = Model(inputs=input_layer, outputs=output)
model.compile(loss="mean_squared_error" , optimizer="adam", metrics=("mean_squared_error"))

Наша модель состоит из четырех плотных слоев с 100, 50, 25 и 1 узлом соответственно. Для задач регрессии одна из наиболее часто используемых функций потерь mean_squared_error, Следующий скрипт печатает сводку модели:

Model: "model_2"
_________________________________________________________________
Layer (type)                 Output Shape              Param #
=================================================================
input_4 (InputLayer)         ((None, 4))               0
_________________________________________________________________
dense_10 (Dense)             (None, 100)               500
_________________________________________________________________
dense_11 (Dense)             (None, 50)                5050
_________________________________________________________________
dense_12 (Dense)             (None, 25)                1275
_________________________________________________________________
dense_13 (Dense)             (None, 1)                 26
=================================================================
Total params: 6,851
Trainable params: 6,851
Non-trainable params: 0

Наконец, мы можем обучить модель с помощью следующего скрипта:

history = model.fit(X_train, y_train, batch_size=2, epochs=100, verbose=1, validation_split=0.2)

Вот результат последних 5 тренировочных эпох:

Epoch 96/100
30/30 (==============================) - 0s 2ms/sample - loss: 510.3316 - mean_squared_error: 510.3317 - val_loss: 10383.5234 - val_mean_squared_error: 10383.5234
Epoch 97/100
30/30 (==============================) - 0s 2ms/sample - loss: 523.3454 - mean_squared_error: 523.3453 - val_loss: 10488.3036 - val_mean_squared_error: 10488.3037
Epoch 98/100
30/30 (==============================) - 0s 2ms/sample - loss: 514.8281 - mean_squared_error: 514.8281 - val_loss: 10379.5087 - val_mean_squared_error: 10379.5088
Epoch 99/100
30/30 (==============================) - 0s 2ms/sample - loss: 504.0919 - mean_squared_error: 504.0919 - val_loss: 10301.3304 - val_mean_squared_error: 10301.3311
Epoch 100/100
30/30 (==============================) - 0s 2ms/sample - loss: 532.7809 - mean_squared_error: 532.7809 - val_loss: 10325.1699 - val_mean_squared_error: 10325.1709

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

from sklearn.metrics import mean_squared_error
from math import sqrt

pred_train = model.predict(X_train)
print(np.sqrt(mean_squared_error(y_train,pred_train)))

pred = model.predict(X_test)
print(np.sqrt(mean_squared_error(y_test,pred)))

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

50.43599665058207
84.31961060849562

Вывод

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


0 Comments

Ваш e-mail не будет опубликован. Обязательные поля помечены *