Tensorflow 2.0: حل مسائل طبقه بندی و رگرسیون

پس از هیاهوی بسیار، سرانجام گوگل منتشر شد TensorFlow 2.0 که آخرین نسخه پلتفرم یادگیری عمیق پرچمدار گوگل است. بسیاری از ویژگی‌های مورد انتظار در 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. تعمیر و نگهداری (هزینه تعمیر و نگهداری)
3. درب (تعداد درب)
4. افراد (ظرفیت صندلی)
5. lug_capacity (ظرفیت چمدان)
6. ایمنی (ماشین چقدر ایمن است)
7. خروجی (وضعیت ماشین)

با توجه به 6 ستون اول، وظیفه پیش بینی مقدار برای ستون 7 یعنی خروجی است. ستون خروجی می تواند یکی از سه مقدار را داشته باشد unacc (غیر قابل قبول)، acc (قابل قبول) good، و very good.

واردات کتابخانه ها

قبل از ما import مجموعه داده را در برنامه ما نیاز داریم import کتابخانه های مورد نیاز

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 ردیف اول مجموعه داده را از طریق the ببینیم 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 و very good. در مجموعه داده برچسب کدگذاری شده یک داغ، می توانید چهار ستون را ببینید، یکی برای هر یک از مقادیر منحصر به فرد در ستون خروجی. می توانید 1 را در ستون برای مقدار منحصر به فردی که در ابتدا در آن سطر وجود داشت، ببینید. به عنوان مثال، در پنج سطر اول ستون خروجی، مقدار ستون بود unacc. در ستون برچسب‌ها، می‌توانید 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)

آموزش مدل

برای آموزش مدل، بیایید import کلاس های TensorFlow 2.0. اسکریپت زیر را اجرا کنید:

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

همانطور که قبلاً گفتم، TensorFlow 2.0 از Keras API برای آموزش مدل استفاده می کند. در اسکریپت بالا ما اساسا import 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: <class 'pandas.core.frame.DataFrame'>, <class 'NoneType'>
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')

اجازه دهید print پنج ردیف اول مجموعه داده از طریق head() تابع:

petrol_cons.head()

خروجی:

می بینید که پنج ستون در مجموعه داده وجود دارد. مدل رگرسیون آموزش داده خواهد شد روی چهار ستون اول، یعنی Petrol_tax، Average_income، Paved_Highways، و Population_Driver_License(%). مقدار آخرین ستون یعنی Petrol_Consumption پیش بینی خواهد شد. همانطور که می بینید هیچ مقدار گسسته ای برای ستون خروجی وجود ندارد، بلکه مقدار پیش بینی شده می تواند هر مقدار پیوسته باشد.

پیش پردازش داده ها

در مرحله پیش پردازش داده ها، ما به سادگی داده ها را به ویژگی ها و برچسب ها تقسیم می کنیم و سپس داده ها را به مجموعه های آزمایشی و آموزشی تقسیم می کنیم. در نهایت داده ها عادی خواهند شد. برای مشکلات رگرسیون به طور کلی، و برای مشکلات رگرسیون با یادگیری عمیق، به شدت توصیه می شود که مجموعه داده خود را عادی کنید. در نهایت، از آنجایی که تمام ستون ها عددی هستند، در اینجا نیازی به کدگذاری یکباره ستون ها نیست.

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 ماژول برای مقیاس بندی مجموعه داده استفاده می شود.

آموزش مدل

قدم بعدی آموزش مدل خود است. این process کاملا شبیه به آموزش طبقه بندی است. تنها تغییر در تابع ضرر و تعداد گره ها در لایه متراکم خروجی خواهد بود. از آنجایی که اکنون یک مقدار پیوسته را پیش‌بینی می‌کنیم، لایه خروجی فقط 1 خواهد داشت node.

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 تشکیل شده است. node، به ترتیب. برای مشکلات رگرسیون، یکی از متداول ترین توابع از دست دادن استفاده می شود 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

برای ارزیابی عملکرد یک مدل رگرسیون روی یک مجموعه تست، یکی از متداول ترین معیارهای مورد استفاده است root خطای میانگین مربعات. ما می توانیم میانگین مربعات خطا را بین مقادیر پیش بینی شده و واقعی از طریق the پیدا کنیم mean_squared_error کلاس از sklearn.metrics مدول. سپس می توانیم مربع را بگیریم root از میانگین مجذور خطای حاصل. به اسکریپت زیر نگاه کنید:

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)))

خروجی میانگین مربعات خطا را برای هر دو مجموعه آموزشی و آزمایشی نشان می دهد. نتایج نشان می دهد که عملکرد مدل بهتر است روی مجموعه آموزشی از زمان root میانگین مقدار خطای مربع برای مجموعه آموزشی کمتر است. مدل ما بیش از حد مناسب است. دلیل آن واضح است، ما فقط 48 رکورد در مجموعه داده داشتیم. سعی کنید مدل های رگرسیون را با مجموعه داده بزرگتر آموزش دهید تا نتایج بهتری بگیرید.

50.43599665058207
84.31961060849562

نتیجه

TensorFlow 2.0 آخرین نسخه کتابخانه TensorFlow گوگل برای یادگیری عمیق است. این مقاله به طور خلاصه روش ایجاد مدل های طبقه بندی و رگرسیون را با TensorFlow 2.0 پوشش می دهد. دست داشتن -روی پیشنهاد می‌کنم مثال‌های ارائه شده در این مقاله را تمرین کنید و سعی کنید مدل‌های رگرسیون و طبقه‌بندی ساده را با TensorFlow 2.0 با استفاده از مجموعه‌های داده دیگر ایجاد کنید.