کمک به حفاظت از دیواره بزرگ مرجانی با TensorFlow در Kaggle اضافه کردن چالش

آموزش سفارشی: گام به گام

مشاهده در TensorFlow.org در Google Colab اجرا شود مشاهده منبع در GitHub دانلود دفترچه یادداشت

این راهنمای یادگیری استفاده ماشین به دسته بندی گل زنبق توسط گونه. از TensorFlow برای موارد زیر استفاده می کند:

  1. یک مدل بسازید،
  2. این مدل را بر روی داده های مثال آموزش دهید و
  3. از مدل برای پیش بینی داده های ناشناخته استفاده کنید.

برنامه نویسی TensorFlow

این راهنما از این مفاهیم سطح بالا TensorFlow استفاده می کند:

این آموزش مانند بسیاری از برنامه های TensorFlow ساختار یافته است:

  1. وارد کردن و تجزیه مجموعه داده.
  2. نوع مدل را انتخاب کنید.
  3. مدل را آموزش دهید.
  4. کارایی مدل را ارزیابی کنید.
  5. از مدل آموزش دیده برای پیش بینی استفاده کنید.

برنامه راه اندازی

پیکربندی واردات

TensorFlow و سایر ماژول های مورد نیاز پایتون را وارد کنید. به طور پیش فرض، TensorFlow با استفاده از اجرای مشتاق برای ارزیابی عملیات، بلافاصله، که مقدار برگشتی بتن به جای ایجاد یک نمودار محاسباتی که بعدا اعدام. اگر شما به یک REPL یا استفاده python کنسول های تعاملی، این احساس آشنا.

import os
import matplotlib.pyplot as plt
import tensorflow as tf
print("TensorFlow version: {}".format(tf.__version__))
print("Eager execution: {}".format(tf.executing_eagerly()))
TensorFlow version: 2.6.0
Eager execution: True

مشکل طبقه بندی زنبق

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

جنس زنبق شامل حدود 300 گونه است، اما برنامه ما فقط سه گونه زیر را طبقه بندی می کند:

  • زنبق ستوزا
  • زنبق ویرجینیکا
  • زنبق ورسیکالر
مقایسه هندسه گلبرگ برای سه گونه زنبق: زنبق ستوزا، زنبق ویرجینیکا و زنبق versicolor
شکل 1. جنس زنبق و سوسن setosa (توسط Radomil ، CC BY-SA 3.0)، جنس زنبق و سوسن تنیا ، (توسط Dlanglois ، CC BY-SA 3.0)، و جنس زنبق و سوسن virginica (توسط فرانک میفیلد ، CC BY-SA 2.0).

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

مجموعه داده آموزشی را وارد و تجزیه کنید

فایل مجموعه داده را دانلود کنید و آن را به ساختاری تبدیل کنید که توسط این برنامه پایتون قابل استفاده باشد.

مجموعه داده را دانلود کنید

دانلود فایل آموزش مجموعه داده با استفاده از tf.keras.utils.get_file تابع. این مسیر فایل فایل دانلود شده را برمی گرداند:

train_dataset_url = "https://storage.googleapis.com/download.tensorflow.org/data/iris_training.csv"

train_dataset_fp = tf.keras.utils.get_file(fname=os.path.basename(train_dataset_url),
                                           origin=train_dataset_url)

print("Local copy of the dataset file: {}".format(train_dataset_fp))
Downloading data from https://storage.googleapis.com/download.tensorflow.org/data/iris_training.csv
16384/2194 [================================================================================================================================================================================================================================] - 0s 0us/step
Local copy of the dataset file: /home/kbuilder/.keras/datasets/iris_training.csv

داده ها را بررسی کنید

این مجموعه داده، iris_training.csv ، یک فایل متنی ساده است که فروشگاه داده های جدولی به عنوان ارزش های کاما از هم جدا (CSV) فرمت شده است. استفاده از head -n5 فرمان به زیرچشمی نگاه کردن در پنج نوشته اول:

head -n5 {train_dataset_fp}
120,4,setosa,versicolor,virginica
6.4,2.8,5.6,2.2,2
5.0,2.3,3.3,1.0,1
4.9,2.5,4.5,1.7,2
4.9,3.1,1.5,0.1,0

از این نمای مجموعه داده، به موارد زیر توجه کنید:

  1. خط اول هدر حاوی اطلاعاتی در مورد مجموعه داده است:
    • در مجموع 120 نمونه وجود دارد. هر نمونه دارای چهار ویژگی و یکی از سه نام برچسب ممکن است.
  2. ردیف بعدی پرونده داده ها، یکی به عنوان مثال در هر خط، که در آن:
    • چهار فیلد اول ویژگی های : این ویژگی های یک مثال است. در اینجا، فیلدها دارای اعداد شناور هستند که نشان دهنده اندازه گیری گل هستند.
    • ستون آخر است برچسب : این ارزش ما می خواهیم به پیش بینی است. برای این مجموعه داده، یک مقدار صحیح 0، 1 یا 2 است که با نام گل مطابقت دارد.

بیایید آن را در کد بنویسیم:

# column order in CSV file
column_names = ['sepal_length', 'sepal_width', 'petal_length', 'petal_width', 'species']

feature_names = column_names[:-1]
label_name = column_names[-1]

print("Features: {}".format(feature_names))
print("Label: {}".format(label_name))
Features: ['sepal_length', 'sepal_width', 'petal_length', 'petal_width']
Label: species

هر برچسب با نام رشته مرتبط است (به عنوان مثال، "setosa")، اما یادگیری ماشین معمولاً بر مقادیر عددی متکی است. اعداد برچسب به یک نمایش نامگذاری شده نگاشت می شوند، مانند:

  • 0 : جنس زنبق و سوسن setosa
  • 1 : جنس زنبق و سوسن تنیا
  • 2 : جنس زنبق و سوسن virginica

برای اطلاعات بیشتر درباره ویژگی ها و برچسب، را ببینید بخش ML اصطلاحات از یادگیری ماشین تصادف دوره .

class_names = ['Iris setosa', 'Iris versicolor', 'Iris virginica']

درست tf.data.Dataset

TensorFlow است مجموعه داده API دسته بسیاری از موارد رایج برای بارگذاری داده ها را به یک مدل. این یک API سطح بالا برای خواندن داده ها و تبدیل آن به فرمی است که برای آموزش استفاده می شود.

از آنجا که مجموعه داده یک فایل متنی-CSV فرمت است، استفاده از tf.data.experimental.make_csv_dataset تابع به تجزیه داده ها را به یک فرمت مناسب. از آنجا که این تابع تولید داده برای مدل های آموزش، رفتار پیشفرض است به زدن داده ها ( shuffle=True, shuffle_buffer_size=10000 )، و تکرار مجموعه داده برای همیشه ( num_epochs=None ). ما همچنین مجموعه batch_size پارامتر:

batch_size = 32

train_dataset = tf.data.experimental.make_csv_dataset(
    train_dataset_fp,
    batch_size,
    column_names=column_names,
    label_name=label_name,
    num_epochs=1)

make_csv_dataset تابع بازده یک tf.data.Dataset از (features, label) جفت، که در آن features یک فرهنگ لغت است: {'feature_name': value}

این Dataset اشیاء iterable هستند. بیایید به مجموعه ای از ویژگی ها نگاه کنیم:

features, labels = next(iter(train_dataset))

print(features)
OrderedDict([('sepal_length', <tf.Tensor: shape=(32,), dtype=float32, numpy=
array([4.6, 4.5, 7. , 4.9, 6.7, 5.4, 6.2, 5.9, 6.3, 6.4, 6.1, 5.3, 4.6,
       6.5, 5.1, 5.2, 5.6, 4.7, 5.2, 4.4, 4.9, 6.4, 6.8, 6.9, 4.8, 7.6,

       6. , 4.8, 5.4, 6.1, 5.1, 5.4], dtype=float32)>), ('sepal_width', <tf.Tensor: shape=(32,), dtype=float32, numpy=
array([3.1, 2.3, 3.2, 3. , 3. , 3.7, 2.2, 3. , 3.3, 2.8, 2.6, 3.7, 3.2,
       2.8, 3.8, 3.4, 2.9, 3.2, 2.7, 3. , 3.1, 3.2, 3.2, 3.2, 3.4, 3. ,
       2.2, 3. , 3.9, 2.8, 3.7, 3.4], dtype=float32)>), ('petal_length', <tf.Tensor: shape=(32,), dtype=float32, numpy=
array([1.5, 1.3, 4.7, 1.4, 5. , 1.5, 4.5, 5.1, 6. , 5.6, 5.6, 1.5, 1.4,
       4.6, 1.5, 1.4, 3.6, 1.3, 3.9, 1.3, 1.5, 4.5, 5.9, 5.7, 1.6, 6.6,
       5. , 1.4, 1.3, 4.7, 1.5, 1.5], dtype=float32)>), ('petal_width', <tf.Tensor: shape=(32,), dtype=float32, numpy=
array([0.2, 0.3, 1.4, 0.2, 1.7, 0.2, 1.5, 1.8, 2.5, 2.1, 1.4, 0.2, 0.2,
       1.5, 0.3, 0.2, 1.3, 0.2, 1.4, 0.2, 0.1, 1.5, 2.3, 2.3, 0.2, 2.1,
       1.5, 0.3, 0.4, 1.2, 0.4, 0.4], dtype=float32)>)])

توجه داشته باشید که مانند ویژگی ها با هم گروه بندی می شوند، و یا بسته بندی های کوچک. فیلدهای هر ردیف نمونه به آرایه ویژگی مربوطه اضافه می شوند. تغییر batch_size به مجموعه ای از تعدادی از نمونه های ذخیره شده در این آرایه از ویژگی های.

می توانید با ترسیم چند ویژگی از دسته، شروع به دیدن برخی خوشه ها کنید:

plt.scatter(features['petal_length'],
            features['sepal_length'],
            c=labels,
            cmap='viridis')

plt.xlabel("Petal length")
plt.ylabel("Sepal length")
plt.show()

png

برای ساده کردن گام مدل سازی، ایجاد یک تابع برای بسته بندی ویژگی های را به یک آرایه تک با شکل فرهنگ لغت: (batch_size, num_features) .

این تابع با استفاده از tf.stack روش که طول می کشد ارزش از یک لیست از تانسورها و یک تانسور ترکیبی در بعد مشخص ایجاد می کند:

def pack_features_vector(features, labels):
  """Pack the features into a single array."""
  features = tf.stack(list(features.values()), axis=1)
  return features, labels

سپس با استفاده از tf.data.Dataset#map روش برای بسته بندی features هر یک از (features,label) جفت به مجموعه داده آموزش:

train_dataset = train_dataset.map(pack_features_vector)

عنصر ویژگی های Dataset اکنون آرایه با شکل (batch_size, num_features) . بیایید به چند مثال اول نگاه کنیم:

features, labels = next(iter(train_dataset))

print(features[:5])
tf.Tensor(
[[6.7 3.1 4.4 1.4]
 [6.8 2.8 4.8 1.4]
 [5.  3.4 1.5 0.2]
 [7.4 2.8 6.1 1.9]
 [4.5 2.3 1.3 0.3]], shape=(5, 4), dtype=float32)

نوع مدل را انتخاب کنید

چرا مدل؟

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

می تواند رابطه بین چهار ویژگی و گونه جنس زنبق و سوسن بدون استفاده از یادگیری ماشین شما تعیین میکنید؟ یعنی آیا می توانید از تکنیک های برنامه نویسی سنتی (مثلاً بسیاری از دستورات شرطی) برای ایجاد یک مدل استفاده کنید؟ شاید اگر مجموعه داده را به اندازه کافی برای تعیین روابط بین اندازه گیری گلبرگ و کاسبرگ با یک گونه خاص تجزیه و تحلیل کنید. و این در مجموعه داده‌های پیچیده‌تر دشوار – شاید غیرممکن – می‌شود. روش های یادگیری ماشین خوب مدل تعیین شده برای شما. اگر نمونه های معرف کافی را در نوع مدل یادگیری ماشینی مناسب وارد کنید، برنامه روابط را برای شما مشخص خواهد کرد.

مدل را انتخاب کنید

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

نموداری از معماری شبکه: ورودی ها، 2 لایه پنهان و خروجی ها
شکل 2. یک شبکه عصبی با ویژگی های، لایه های پنهان، و پیش بینی.

هنگامی که مدل شکل 2 آموزش داده می شود و با یک مثال بدون برچسب تغذیه می شود، سه پیش بینی به دست می دهد: احتمال اینکه این گل گونه عنبیه داده شده باشد. این پیش بینی به نام استنتاج . برای این مثال، مجموع پیش‌بینی‌های خروجی 1.0 است. در شکل 2، این پیش بینی را تجزیه می کند به عنوان: 0.02 برای setosa جنس زنبق و سوسن، 0.95 برای تنیا جنس زنبق و سوسن، و 0.03 برای virginica جنس زنبق و سوسن این بدان معنی است که مدل پیش بینی می-با 95٪ احتمال که به عنوان مثال گل بدون برچسب تنیا جنس زنبق و سوسن است.

با استفاده از Keras یک مدل ایجاد کنید

TensorFlow tf.keras API روش ارجح برای ایجاد مدل و لایه است. این کار ساخت مدل‌ها و آزمایش‌ها را آسان می‌کند در حالی که Keras پیچیدگی اتصال همه چیز را با هم انجام می‌دهد.

tf.keras.Sequential مدل پشته خطی از لایه است. سازنده آن طول می کشد یک لیست از موارد لایه، در این مورد، دو tf.keras.layers.Dense هر لایه را با 10 گره، و یک لایه خروجی با 3 گره به نمایندگی پیش بینی برچسب ما. اولین لایه است input_shape مربوط پارامتر به تعدادی از ویژگی های از مجموعه داده ها، و لازم است:

model = tf.keras.Sequential([
  tf.keras.layers.Dense(10, activation=tf.nn.relu, input_shape=(4,)),  # input shape required
  tf.keras.layers.Dense(10, activation=tf.nn.relu),
  tf.keras.layers.Dense(3)
])

تابع فعال شکل خروجی هر گره در لایه تعیین می کند. این غیر خطی ها مهم هستند - بدون آنها مدل معادل یک لایه خواهد بود. بسیاری وجود دارد tf.keras.activations ، اما ReLU برای لایه های پنهان است.

تعداد ایده آل لایه ها و نورون های پنهان به مشکل و مجموعه داده بستگی دارد. مانند بسیاری از جنبه های یادگیری ماشینی، انتخاب بهترین شکل شبکه عصبی به ترکیبی از دانش و آزمایش نیاز دارد. به عنوان یک قاعده کلی، افزایش تعداد لایه‌های پنهان و نورون‌ها معمولاً مدل قدرتمندتری ایجاد می‌کند که برای آموزش مؤثر به داده‌های بیشتری نیاز دارد.

با استفاده از مدل

بیایید نگاهی گذرا به عملکرد این مدل با مجموعه ای از ویژگی ها بیندازیم:

predictions = model(features)
predictions[:5]
<tf.Tensor: shape=(5, 3), dtype=float32, numpy=
array([[3.3970695 , 2.5164433 , 1.6042098 ],
       [3.5879614 , 2.7150419 , 1.7798408 ],
       [2.0230737 , 1.2138845 , 0.5435198 ],
       [4.1191735 , 3.1622481 , 2.1603928 ],
       [1.965474  , 1.2190092 , 0.54945964]], dtype=float32)>

در اینجا، هر مثال یک گرداند لوجیت برای هر کلاس.

برای تبدیل این logits به احتمال برای هر کلاس، استفاده از softmax تابع:

tf.nn.softmax(predictions[:5])
<tf.Tensor: shape=(5, 3), dtype=float32, numpy=
array([[0.6325084 , 0.26218945, 0.10530216],
       [0.6322343 , 0.26410332, 0.10366239],
       [0.5977436 , 0.26612675, 0.13612968],
       [0.6556937 , 0.25183356, 0.09247267],
       [0.5825066 , 0.27613106, 0.1413623 ]], dtype=float32)>

با توجه به tf.argmax در کلاس های ما می دهد شاخص کلاس پیش بینی کرد. اما، این مدل هنوز آموزش ندیده است، بنابراین این ها پیش بینی های خوبی نیستند:

print("Prediction: {}".format(tf.argmax(predictions, axis=1)))
print("    Labels: {}".format(labels))
Prediction: [0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0]
    Labels: [1 1 0 2 0 2 2 0 2 2 1 1 0 2 0 2 2 2 0 0 0 0 0 2 1 2 0 1 0 1 1 1]

مدل را آموزش دهید

آموزش مرحله از یادگیری ماشین است که مدل بهینه سازی شده است که به تدریج، و یا مدل مجموعه داده را می آموزد. هدف این است که به اندازه کافی در مورد ساختار مجموعه داده آموزشی یاد بگیریم تا بتوان در مورد داده های دیده نشده پیش بینی کرد. اگر شما یاد بگیرند بیش از حد در مورد مجموعه داده آموزش، پس از آن پیش بینی تنها برای داده های آن را دیده است کار خواهد شد و نه تعمیم. این مشکل به نام Over-fitting خواهد به آن را مانند حفظ پاسخ به جای درک چگونه به حل یک مشکل.

مشکل طبقه بندی جنس زنبق و سوسن نمونه ای از یادگیری ماشین تحت نظارت : مدل از نمونه هایی که حاوی برچسب های آموزش داده است. در یادگیری ماشین بدون نظارت ، نمونه حاوی برچسب نیست. در عوض، مدل معمولاً الگوهایی را در میان ویژگی‌ها پیدا می‌کند.

تابع افت و گرادیان را تعریف کنید

هر دو آموزش و ارزیابی مراحل نیاز به محاسبه مدل از دست دادن . این نشان می‌دهد که پیش‌بینی‌های یک مدل چقدر از برچسب مورد نظر دور هستند، به عبارت دیگر، عملکرد مدل چقدر بد است. ما می خواهیم این مقدار را به حداقل برسانیم یا بهینه کنیم.

مدل ما از دست دادن آن با استفاده از محاسبه tf.keras.losses.SparseCategoricalCrossentropy تابع که پیش بینی احتمال کلاس مدل و برچسب مورد نظر طول می کشد، و از دست دادن به طور متوسط در سراسر نمونه گرداند.

loss_object = tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True)
def loss(model, x, y, training):
  # training=training is needed only if there are layers with different
  # behavior during training versus inference (e.g. Dropout).
  y_ = model(x, training=training)

  return loss_object(y_true=y, y_pred=y_)


l = loss(model, features, labels, training=False)
print("Loss test: {}".format(l))
Loss test: 1.3074543476104736

استفاده از tf.GradientTape زمینه برای محاسبه شیب استفاده برای بهینه سازی مدل شما:

def grad(model, inputs, targets):
  with tf.GradientTape() as tape:
    loss_value = loss(model, inputs, targets, training=True)
  return loss_value, tape.gradient(loss_value, model.trainable_variables)

یک بهینه ساز ایجاد کنید

بهینه ساز شیب محاسبه به متغیرهای الگو به امر به حداقل رساندن loss عملکرد. می‌توانید تابع تلفات را به عنوان یک سطح منحنی در نظر بگیرید (شکل 3 را ببینید) و ما می‌خواهیم با قدم زدن در اطراف، پایین‌ترین نقطه آن را پیدا کنیم. شیب ها در جهت شیب دارترین صعود قرار می گیرند—بنابراین ما مسیر مخالف را طی می کنیم و از تپه پایین می رویم. با محاسبه مکرر تلفات و گرادیان برای هر دسته، مدل را در طول آموزش تنظیم می کنیم. به تدریج، مدل بهترین ترکیب وزن و سوگیری را برای به حداقل رساندن کاهش پیدا خواهد کرد. و هرچه ضرر کمتر باشد، پیش‌بینی مدل بهتر است.

الگوریتم های بهینه سازی در طول زمان در فضای سه بعدی تجسم شده اند.
شکل الگوریتم 3. بهینه سازی در طول زمان در فضای 3D قابل مشاهده است.
(منبع: استنفورد کلاس CS231n ، مجوز MIT، تصویر های اعتباری: الک رادفورد )

TensorFlow الگوریتم های بهینه سازی زیادی برای آموزش در دسترس دارد. این مدل با استفاده از tf.keras.optimizers.SGD است که پیاده سازی گرادیان نزولی تصادفی (SGD) الگوریتم است. learning_rate مجموعه به اندازه گام به برای هر تکرار پایین تپه. این hyperparameter است که شما معمولا باید تنظیم برای دستیابی به نتایج بهتر است.

بیایید بهینه ساز را راه اندازی کنیم:

optimizer = tf.keras.optimizers.SGD(learning_rate=0.01)

ما از این برای محاسبه یک مرحله بهینه سازی استفاده می کنیم:

loss_value, grads = grad(model, features, labels)

print("Step: {}, Initial Loss: {}".format(optimizer.iterations.numpy(),
                                          loss_value.numpy()))

optimizer.apply_gradients(zip(grads, model.trainable_variables))

print("Step: {},         Loss: {}".format(optimizer.iterations.numpy(),
                                          loss(model, features, labels, training=True).numpy()))
Step: 0, Initial Loss: 1.3074543476104736
Step: 1,         Loss: 1.2451764345169067

حلقه آموزشی

با تمام قطعات در جای خود، مدل برای آموزش آماده است! یک حلقه آموزشی، نمونه‌های مجموعه داده را به مدل تغذیه می‌کند تا به پیش‌بینی بهتر کمک کند. بلوک کد زیر این مراحل آموزشی را تنظیم می کند:

  1. تکرار هر دوره. یک دوره یک گذر از مجموعه داده است.
  2. در یک عصر تکرار بیش از هر مثال در آموزش Dataset گرفتن ویژگی های آن ( x ) و برچسب ( y ).
  3. با استفاده از ویژگی های مثال، یک پیش بینی انجام دهید و آن را با برچسب مقایسه کنید. عدم دقت پیش‌بینی را اندازه‌گیری کنید و از آن برای محاسبه تلفات و گرادیان‌های مدل استفاده کنید.
  4. استفاده از optimizer برای به روز رسانی متغیرهای الگو.
  5. برخی از آمارها را برای تجسم پیگیری کنید.
  6. برای هر دوره تکرار کنید.

num_epochs متغیر تعداد دفعاتی به حلقه بیش از مجموعه مجموعه داده است. به طور غیر شهودی، آموزش طولانی تر یک مدل، مدل بهتر را تضمین نمی کند. num_epochs است hyperparameter که شما می توانید تنظیم. انتخاب عدد مناسب معمولاً به تجربه و آزمایش نیاز دارد:

## Note: Rerunning this cell uses the same model variables

# Keep results for plotting
train_loss_results = []
train_accuracy_results = []

num_epochs = 201

for epoch in range(num_epochs):
  epoch_loss_avg = tf.keras.metrics.Mean()
  epoch_accuracy = tf.keras.metrics.SparseCategoricalAccuracy()

  # Training loop - using batches of 32
  for x, y in train_dataset:
    # Optimize the model
    loss_value, grads = grad(model, x, y)
    optimizer.apply_gradients(zip(grads, model.trainable_variables))

    # Track progress
    epoch_loss_avg.update_state(loss_value)  # Add current batch loss
    # Compare predicted label to actual label
    # training=True is needed only if there are layers with different
    # behavior during training versus inference (e.g. Dropout).
    epoch_accuracy.update_state(y, model(x, training=True))

  # End epoch
  train_loss_results.append(epoch_loss_avg.result())
  train_accuracy_results.append(epoch_accuracy.result())

  if epoch % 50 == 0:
    print("Epoch {:03d}: Loss: {:.3f}, Accuracy: {:.3%}".format(epoch,
                                                                epoch_loss_avg.result(),
                                                                epoch_accuracy.result()))
Epoch 000: Loss: 1.195, Accuracy: 35.000%
Epoch 050: Loss: 0.462, Accuracy: 86.667%
Epoch 100: Loss: 0.287, Accuracy: 93.333%
Epoch 150: Loss: 0.193, Accuracy: 98.333%
Epoch 200: Loss: 0.158, Accuracy: 97.500%

عملکرد ضرر را در طول زمان تجسم کنید

در حالی که این برای چاپ کردن پیشرفت آموزشی مدل های مفید، آن را اغلب مفید تر برای دیدن این پیشرفت است. TensorBoard یک ابزار تجسم خوب است که با TensorFlow بسته بندی است، اما ما می توانید نمودار پایه با استفاده از ایجاد matplotlib ماژول.

تفسیر این نمودار طول می کشد برخی از تجربه، اما شما واقعا می خواهید برای دیدن از دست دادن پایین و دقت بالا برود:

fig, axes = plt.subplots(2, sharex=True, figsize=(12, 8))
fig.suptitle('Training Metrics')

axes[0].set_ylabel("Loss", fontsize=14)
axes[0].plot(train_loss_results)

axes[1].set_ylabel("Accuracy", fontsize=14)
axes[1].set_xlabel("Epoch", fontsize=14)
axes[1].plot(train_accuracy_results)
plt.show()

png

کارایی مدل را ارزیابی کنید

اکنون که مدل آموزش دیده است، می توانیم آماری از عملکرد آن به دست آوریم.

ارزیابی یعنی تعیین این که چگونه به طور موثر مدل باعث می شود پیش بینی. برای تعیین اثربخشی مدل در طبقه‌بندی عنبیه، اندازه‌گیری‌های کاسبرگ و گلبرگ را به مدل منتقل کنید و از مدل بخواهید تا پیش‌بینی کند که چه گونه‌های زنبق را نشان می‌دهند. سپس پیش بینی های مدل را با برچسب واقعی مقایسه کنید. برای مثال، یک مدل است که از گونه های صحیح در نیمه مثال ورودی برداشت است دقت از 0.5 . شکل 4 یک مدل کمی موثرتر را نشان می دهد که 4 از 5 پیش بینی را با دقت 80 درصد درست می کند:

ویژگی های نمونه برچسب پیش بینی مدل
5.9 3.0 4.3 1.5 1 1
6.9 3.1 5.4 2.1 2 2
5.1 3.3 1.7 0.5 0 0
6.0 3.4 4.5 1.6 1 2
5.5 2.5 4.0 1.3 1 1
طبقه بندی شکل 4. جنس زنبق و سوسن است که 80٪ دقیق است.

مجموعه داده آزمایشی را تنظیم کنید

ارزیابی مدل مشابه آموزش مدل است. بزرگترین تفاوت این است نمونه های از یک جداگانه آمده مجموعه تست به جای مجموعه آموزش. برای ارزیابی منصفانه اثربخشی یک مدل، مثال‌هایی که برای ارزیابی یک مدل استفاده می‌شوند باید متفاوت از نمونه‌های مورد استفاده برای آموزش مدل باشند.

راه اندازی برای آزمون Dataset شبیه به راه اندازی برای آموزش است Dataset . فایل متنی CSV را دانلود کنید و مقادیر آن را تجزیه کنید، سپس کمی آن را به هم بزنید:

test_url = "https://storage.googleapis.com/download.tensorflow.org/data/iris_test.csv"

test_fp = tf.keras.utils.get_file(fname=os.path.basename(test_url),
                                  origin=test_url)
Downloading data from https://storage.googleapis.com/download.tensorflow.org/data/iris_test.csv
16384/573 [=========================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================] - 0s 0us/step
test_dataset = tf.data.experimental.make_csv_dataset(
    test_fp,
    batch_size,
    column_names=column_names,
    label_name='species',
    num_epochs=1,
    shuffle=False)

test_dataset = test_dataset.map(pack_features_vector)

مدل را روی مجموعه داده آزمایشی ارزیابی کنید

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

test_accuracy = tf.keras.metrics.Accuracy()

for (x, y) in test_dataset:
  # training=False is needed only if there are layers with different
  # behavior during training versus inference (e.g. Dropout).
  logits = model(x, training=False)
  prediction = tf.argmax(logits, axis=1, output_type=tf.int32)
  test_accuracy(prediction, y)

print("Test set accuracy: {:.3%}".format(test_accuracy.result()))
Test set accuracy: 100.000%

برای مثال می‌توانیم در آخرین دسته ببینیم که مدل معمولاً درست است:

tf.stack([y,prediction],axis=1)
<tf.Tensor: shape=(30, 2), dtype=int32, numpy=
array([[1, 1],
       [2, 2],
       [0, 0],
       [1, 1],
       [1, 1],
       [1, 1],
       [0, 0],
       [2, 2],
       [1, 1],
       [2, 2],
       [2, 2],
       [0, 0],
       [2, 2],
       [1, 1],
       [1, 1],
       [0, 0],
       [1, 1],
       [0, 0],
       [0, 0],
       [2, 2],
       [0, 0],
       [1, 1],
       [2, 2],
       [1, 1],
       [1, 1],
       [1, 1],
       [0, 0],
       [1, 1],
       [2, 2],
       [1, 1]], dtype=int32)>

از مدل آموزش دیده برای پیش بینی استفاده کنید

ما مدلی را آموزش داده‌ایم و "اثبات" کرده‌ایم که در طبقه‌بندی گونه‌های زنبق خوب – اما نه کامل است. حالا بیایید با استفاده از مدل آموزش دیده را به برخی از پیش بینی ها در نمونه های بدون برچسب ؛ یعنی روی نمونه هایی که دارای ویژگی هستند اما برچسب ندارند.

در زندگی واقعی، نمونه‌های بدون برچسب می‌توانند از منابع مختلفی از جمله برنامه‌ها، فایل‌های CSV و فیدهای داده‌ای بیایند. در حال حاضر، ما به صورت دستی سه نمونه بدون برچسب را برای پیش بینی برچسب آنها ارائه می کنیم. به یاد بیاورید، اعداد برچسب به یک نمایش نامگذاری شده به صورت زیر نگاشت می شوند:

  • 0 : جنس زنبق و سوسن setosa
  • 1 : جنس زنبق و سوسن تنیا
  • 2 : جنس زنبق و سوسن virginica
predict_dataset = tf.convert_to_tensor([
    [5.1, 3.3, 1.7, 0.5,],
    [5.9, 3.0, 4.2, 1.5,],
    [6.9, 3.1, 5.4, 2.1]
])

# training=False is needed only if there are layers with different
# behavior during training versus inference (e.g. Dropout).
predictions = model(predict_dataset, training=False)

for i, logits in enumerate(predictions):
  class_idx = tf.argmax(logits).numpy()
  p = tf.nn.softmax(logits)[class_idx]
  name = class_names[class_idx]
  print("Example {} prediction: {} ({:4.1f}%)".format(i, name, 100*p))
Example 0 prediction: Iris setosa (97.6%)
Example 1 prediction: Iris versicolor (90.4%)
Example 2 prediction: Iris virginica (63.3%)