آموزش شبکه عصبی TensorFlow

TensorFlow یک کتابخانه منبع باز برای برنامه های کاربردی یادگیری ماشین است. این سیستم نسل دوم Google Brain است، پس از جایگزینی DistBelief با منبع نزدیک، و توسط Google برای برنامه های تحقیقاتی و تولیدی استفاده می شود. برنامه‌های TensorFlow را می‌توان به چند زبان نوشت: Python، Go، Java و C. این پست مربوط به نسخه Python آن است و به نصب کتابخانه، اجزای پایه سطح پایین و ایجاد یک شبکه عصبی پیش‌خور از ابتدا می‌پردازد. برای انجام یادگیری روی یک مجموعه داده واقعی

مدت زمان آموزش شبکه های عصبی یادگیری عمیق اغلب در سناریوهای پیچیده تر یک گلوگاه است. از آنجایی که شبکه‌های عصبی، و همچنین سایر الگوریتم‌های ML، عمدتاً با ضرب‌های ماتریسی کار می‌کنند، اجرای آنها بسیار سریع‌تر است. روی واحدهای پردازش گرافیکی (GPU) به جای روی واحدهای پردازش مرکزی استاندارد (CPU).

TensorFlow از هر دو CPU و GPU پشتیبانی می کند و گوگل حتی سخت افزار تخصصی خود را برای محاسبات در فضای ابری تولید کرده است. واحد پردازش تانسور (TPU)، که تولید می کند بهترین عملکرد در میان واحدهای مختلف پردازش

نصب و راه اندازی

در حالی که TPU ها فقط در فضای ابری در دسترس هستند، نصب TensorFlow روی یک کامپیوتر محلی می تواند معماری پردازشگر CPU یا GPU را هدف قرار دهد. برای استفاده از نسخه GPU، رایانه شما باید یک کارت گرافیک NVIDIA داشته باشد و همچنین تعدادی کارت گرافیک دیگر را برآورده کند. الزامات.

اساساً حداقل 5 گزینه مختلف برای نصب وجود دارد که با استفاده از: virtualenv، pip، داکر، آناکوندا و نصب از منبع.

• نصب با virtualenv و Docker ما را قادر می‌سازد تا TensorFlow را در یک محیط جداگانه، جدا از سایر کتابخانه‌های پایتون شما، نصب کنیم.
• Anaconda یک توزیع پایتون است که شامل مجموعه بزرگی از کتابخانه ها برای محاسبات علمی، از جمله TensorFlow است.
• pip به عنوان نصب کننده “بومی” برای بسته های پایتون بدون استفاده از محیط های جداگانه در نظر گرفته می شود.
• در نهایت، نصب از منبع از طریق Git انجام می شود، و بهترین راه برای انتخاب یک نسخه نرم افزار خاص است، با نسخه پایدار فعلی TensorFlow r1.4 (در زمان نوشتن این مقاله).

رایج ترین و ساده ترین راه نصب از طریق virtualenv و pipبنابراین در این پست توضیح داده خواهد شد.

اگر مدتی از پایتون استفاده کرده اید، احتمالاً می دانید pip. در اینجا روش دریافت آن آمده است روی یک ماشین اوبونتو:

sudo apt-get install python-pip python-dev   
sudo apt-get install python3-pip python3-dev 

خطوط زیر نصب TensorFlow را توضیح می دهد روی یک دستگاه اوبونتو و مک OSX:

pip install tensorflow      
pip3 install tensorflow     


pip install tensorflow-gpu  
pip3 install tensorflow-gpu 

دستورات بالا نیز کار خواهند کرد روی یک ماشین ویندوز، اما فقط برای نسخه های Python 3.5.x و 3.6.x.

نصب TensorFlow در یک محیط جداگانه می تواند از طریق virtualenv یا conda (که بخشی از Anaconda است) انجام شود. این process به طور کلی از همان خطوط بالا پیروی می کند، فقط این بار ابتدا باید یک محیط جدید ایجاد و فعال کنید:

virtualenv --system-site-packages ~/tensorflow
source ~/tensorflow/bin/activate

با این کار همه بسته‌های مورد نیاز از بسته‌هایی که در سطح جهانی نصب کرده‌اید جدا نگه می‌دارند روی سیستم شما

اجزای اصلی API

API های مختلفی برای برنامه ریزی TensorFlow وجود دارد. پایین ترین سطح یک به عنوان شناخته شده است هسته و با اجزای اصلی کار می کند: تانسورها، نمودارها و جلسات.

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

تمام هدف Core API این است که a نمودار محاسباتی که شامل یک سری عملیات است که در یک گراف از گره ها مرتب شده اند. هر یک node ممکن است چندتایی داشته باشد تانسورها (ساختار داده پایه) به عنوان ورودی و انجام عملیات روی آنها را به منظور محاسبه یک خروجی، که پس از آن ممکن است یک ورودی به گره های دیگر در یک شبکه چند لایه را نشان دهد. این نوع معماری برای کاربردهای یادگیری ماشینی مانند شبکه های عصبی مناسب است.

تانسورها

تانسورها ساختار داده پایه در TensorFlow هستند که داده ها را در ابعاد مختلف ذخیره می کنند، مشابه آرایه های چند بعدی در NumPy. سه نوع اصلی تانسور وجود دارد: ثابت، متغیر و مکان نگهدار.

• ثابت ها نوع تغییرناپذیر تانسورها هستند. آنها می توانند به عنوان گره های بدون ورودی دیده شوند و یک مقدار واحد را که در داخل ذخیره می کنند، خروجی می دهند.
• متغیرها نوع قابل تغییر تنوسر هستند که مقدار آنها می تواند در طول اجرای یک نمودار تغییر کند. در برنامه های کاربردی ML، متغیرها معمولاً پارامترهایی را که نیاز به بهینه سازی دارند (مثلاً وزن بین گره ها در یک شبکه عصبی) ذخیره می کنند. متغیرها باید قبل از اجرای نمودار با فراخوانی صریح یک عملیات ویژه مقداردهی اولیه شوند.
• متغیرهای تانسورهایی هستند که داده ها را از منابع خارجی ذخیره می کنند. آنها یک “وعده” را نشان می دهند که هنگام اجرای نمودار یک مقدار ارائه می شود. در برنامه های کاربردی ML معمولاً از متغیرهایی برای ورود داده ها به مدل یادگیری استفاده می شود.

چند خط زیر نمونه ای از سه نوع تانسور را نشان می دهد:

import tensorflow as tf

tf.reset_default_graph()


a = tf.placeholder("float", name='pholdA')
print("a:", a)


b = tf.Variable(2.0, name='varB')
print("b:", b)


c = tf.constant((1., 2., 3., 4.), name='consC')
print("c:", c)

a: Tensor("pholdA:0", dtype=float32)
b: <tf.Variable 'varB:0' shape=() dtype=float32_ref>
c: Tensor("consC:0", shape=(4,), dtype=float32)

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

نمودارها

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

d = a * b + c
d

<tf.Tensor 'add:0' shape=<unknown> dtype=float32>

خروجی حاصل دوباره یک تانسور به نام “افزودن” است و مدل ما اکنون مانند تصویر زیر به نظر می رسد. با استفاده از ویژگی داخلی TensorFlow می توانید نمودار خود و همچنین پارامترهای دیگر را کاوش کنید TensorBoard.

شکل 1: نمودار TensorFlow شامل ضرب و جمع است.

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

graph = tf.get_default_graph()


for op in graph.get_operations():
    print(op.name)

pholdA
varB/initial_value
varB
varB/Assign
varB/read
consC
mul
add

جلسات

در نهایت، نمودار ما باید در یک جلسه اجرا شود. توجه داشته باشید که متغیرها از قبل مقداردهی اولیه می شوند، در حالی که تانسور مکان نگهدار مقادیر مشخص را از طریق دریافت می کند feed_dict صفت.

init = tf.global_variables_initializer()


sess = tf.Session()
sess.run(init)
print(sess.run(d, feed_dict={a: ((0.5), (2), (3))}))
sess.close()

((  2.   3.   4.   5.)
 (  5.   6.   7.   8.)
 (  7.   8.   9.  10.))

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

در بخش زیر از Core API برای ایجاد یک شبکه عصبی برای یادگیری ماشین استفاده خواهیم کرد روی داده های واقعی

مدل شبکه عصبی

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

مجموعه داده عنبیه

ما از ساده استفاده می کنیم مجموعه داده عنبیه، که از 150 نمونه گیاه تشکیل شده است که هر کدام با 4 بعد (به عنوان ویژگی های ورودی) و نوع آن (مقدار خروجی که باید پیش بینی شود) آورده شده است. یک گیاه می تواند به یکی از سه نوع ممکن (ستوزا، ویرجینیکا و ورسیکالر) تعلق داشته باشد. بیایید ابتدا داده‌ها را از وب‌سایت تنسورفلو دانلود کنیم – به زیر مجموعه‌های آموزشی و آزمایشی با 120 و 30 مثال تقسیم می‌شود.

import numpy as np
import pandas as pd
import tensorflow as tf
import urllib.request as request
import matplotlib.pyplot as plt


IRIS_TRAIN_URL = "http://download.tensorflow.org/data/iris_training.csv"
IRIS_TEST_URL = "http://download.tensorflow.org/data/iris_test.csv"

names = ('sepal-length', 'sepal-width', 'petal-length', 'petal-width', 'species')
train = pd.read_csv(IRIS_TRAIN_URL, names=names, skiprows=1)
test = pd.read_csv(IRIS_TEST_URL, names=names, skiprows=1)


Xtrain = train.drop("species", axis=1)
Xtest = test.drop("species", axis=1)


ytrain = pd.get_dummies(train.species)
ytest = pd.get_dummies(test.species)

مدل و یادگیری

شکل لایه‌های ورودی و خروجی شبکه عصبی ما با شکل داده‌ها مطابقت دارد، یعنی لایه ورودی شامل چهار نورون است که نمایانگر چهار ویژگی ورودی است، در حالی که لایه خروجی شامل سه نورون به دلیل سه بیت مورد استفاده برای رمزگذاری است. یک گونه گیاهی در a یک داغ سبک. به عنوان مثال، گونه “setosa” را می توان با یک بردار (1، 0، 0)، “virginica” با (0، 1، 0) و غیره رمزگذاری کرد.

ما سه مقدار را برای تعداد نورون‌های لایه پنهان انتخاب می‌کنیم: 5، 10 و 20، که در نتیجه اندازه‌های شبکه (4-5-3)، (4-10-3) و (4-20-3) ایجاد می‌شود. این بدان معناست که برای مثال، اولین شبکه ما دارای 4 نورون ورودی، 5 نورون “پنهان” و 3 نورون خروجی خواهد بود.

شکل 2: شبکه عصبی پیشخور سه لایه ما.

کد زیر تابعی را تعریف می‌کند که در آن مدل را ایجاد می‌کنیم، یک تابع ضرر تعریف می‌کنیم که باید حداقل شود، و یک جلسه با ۲۰۰۰ تکرار اجرا می‌کنیم تا وزن‌های بهینه را یاد بگیریم. W_1 و W_2. همانطور که قبلا ذکر شد، ماتریس های ورودی و خروجی به آنها تغذیه می شوند tf.placeholder تانسورها و وزن ها به عنوان متغیر نشان داده می شوند زیرا مقادیر آنها در هر تکرار تغییر می کند. تابع ضرر به عنوان میانگین مجذور خطا بین پیش بینی ما تعریف می شود y_est و نوع واقعی گونه yو تابع فعال سازی که استفاده می کنیم است سیگموئید. این create_train_model تابع وزن های آموخته شده را برمی گرداند و مقدار نهایی تابع ضرر را چاپ می کند.

def create_train_model(hidden_nodes, num_iters):
    
    
    tf.reset_default_graph()

    
    X = tf.placeholder(shape=(120, 4), dtype=tf.float64, name='X')
    y = tf.placeholder(shape=(120, 3), dtype=tf.float64, name='y')

    
    W1 = tf.Variable(np.random.rand(4, hidden_nodes), dtype=tf.float64)
    W2 = tf.Variable(np.random.rand(hidden_nodes, 3), dtype=tf.float64)

    
    A1 = tf.sigmoid(tf.matmul(X, W1))
    y_est = tf.sigmoid(tf.matmul(A1, W2))

    
    deltas = tf.square(y_est - y)
    loss = tf.reduce_sum(deltas)

    
    optimizer = tf.train.GradientDescentOptimizer(0.005)
    train = optimizer.minimize(loss)

    
    init = tf.global_variables_initializer()
    sess = tf.Session()
    sess.run(init)

    
    for i in range(num_iters):
        sess.run(train, feed_dict={X: Xtrain, y: ytrain})
        loss_plot(hidden_nodes).append(sess.run(loss, feed_dict={X: Xtrain.as_matrix(), y: ytrain.as_matrix()}))
        weights1 = sess.run(W1)
        weights2 = sess.run(W2)
        
    print("loss (hidden nodes: %d, iterations: %d): %.2f" % (hidden_nodes, num_iters, loss_plot(hidden_nodes)(-1)))
    sess.close()
    return weights1, weights2

خوب، بیایید سه معماری شبکه را ایجاد کنیم و تابع ضرر را روی تکرارها رسم کنیم.

num_hidden_nodes = (5, 10, 20)
loss_plot = {5: (), 10: (), 20: ()}
weights1 = {5: None, 10: None, 20: None}
weights2 = {5: None, 10: None, 20: None}
num_iters = 2000

plt.figure(figsize=(12,8))
for hidden_nodes in num_hidden_nodes:
    weights1(hidden_nodes), weights2(hidden_nodes) = create_train_model(hidden_nodes, num_iters)
    plt.plot(range(num_iters), loss_plot(hidden_nodes), label="nn: 4-%d-3" % hidden_nodes)
    
plt.xlabel('Iteration', fontsize=12)
plt.ylabel('Loss', fontsize=12)
plt.legend(fontsize=12)

loss (hidden nodes: 5, iterations: 2000): 31.82
loss (hidden nodes: 10, iterations: 2000): 5.90
loss (hidden nodes: 20, iterations: 2000): 5.61

<matplotlib.legend.Legend at 0x123b157f0>

شکل 3: تابع از دست دادن بیش از 2000 تکرار برای معماری های مختلف شبکه.

می بینیم که شبکه با 20 نورون پنهان زمان بیشتری برای رسیدن به حداقل نیاز دارد که به دلیل پیچیدگی بالاتر آن است. شبکه با 5 نورون پنهان در حداقل محلی گیر می کند و نتایج خوبی نخواهد داشت.

به هر حال، برای مجموعه داده ای به سادگی Iris، حتی شبکه کوچک با 5 نورون پنهان نیز باید بتواند یک مدل خوب یاد بگیرد. در مورد ما، این فقط یک رویداد تصادفی بود که مدل در حداقل محلی گیر کرد، و اگر کد را بارها و بارها اجرا کنیم، اغلب اتفاق نمی افتد.

ارزیابی مدل

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

X = tf.placeholder(shape=(30, 4), dtype=tf.float64, name='X')
y = tf.placeholder(shape=(30, 3), dtype=tf.float64, name='y')

for hidden_nodes in num_hidden_nodes:

    
    W1 = tf.Variable(weights1(hidden_nodes))
    W2 = tf.Variable(weights2(hidden_nodes))
    A1 = tf.sigmoid(tf.matmul(X, W1))
    y_est = tf.sigmoid(tf.matmul(A1, W2))

    
    init = tf.global_variables_initializer()
    with tf.Session() as sess:
        sess.run(init)
        y_est_np = sess.run(y_est, feed_dict={X: Xtest, y: ytest})

    
    correct = (estimate.argmax(axis=0) == target.argmax(axis=0) 
               for estimate, target in zip(y_est_np, ytest.as_matrix()))
    accuracy = 100 * sum(correct) / len(correct)
    print('Network architecture 4-%d-3, accuracy: %.2f%%' % (hidden_nodes, accuracy))

Network architecture 4-5-3, accuracy: 90.00%
Network architecture 4-10-3, accuracy: 96.67%
Network architecture 4-20-3, accuracy: 96.67%

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

می توانید با استفاده از API سطح بالای TensorFlow به مثال ساده تری نگاه کنید اینجا.

منابع

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

نتیجه گیری

در این پست ما کتابخانه TensorFlow را برای یادگیری ماشین معرفی کردیم، راهنمایی های مختصری برای نصب ارائه کردیم، اجزای اصلی Core API سطح پایین TensorFlow را معرفی کردیم: تانسورها، نمودارها و جلسات، و در نهایت یک مدل شبکه عصبی برای طبقه بندی داده های واقعی ساختیم. مجموعه داده عنبیه.

به طور کلی، درک فلسفه کدگذاری TensorFlow ممکن است کمی طول بکشد، زیرا یک کتابخانه نمادین است، اما زمانی که با اجزای اصلی آشنا شدید، برای ساخت اپلیکیشن‌های یادگیری ماشین بسیار راحت است. در این پست از Core API سطح پایین برای ارائه اجزای اصلی و کنترل کامل مدل استفاده کردیم، اما معمولاً استفاده از API سطح بالاتر بسیار ساده تر است، مانند tf.estimator، یا حتی یک کتابخانه خارجی، مانند کراس.