ארכיטקטורות של מודל RNN

מחבר:
בתאריך:

אחרי שבמדריך קודם למדנו כיצד להשתמש ברשת נאורונית מסוג RNN כדי לאפשר למחשב ללמוד רצפים, במדריך זה נלמד 4 סוגי מבנים שבהם אנו יכולים להשתמש כדי ליצור את המודל שלנו.

4 סוגי המבנים הם:

  1. RNN פשוט (Vanilla)
  2. RNN מרובה שכבות (Stacked)
  3. RNN דו-כיווני (Bidirectional)
  4. RNN מרובה שכבות דו-כיווני

המדריך הזה הוא המשכו של המדריך הקודם על חיזוי טמפרטורות באמצעות למידת מכונה. בעוד המדריך הקודם השתמש בארכיטקטורת מודל בלי להסביר את השיקולים מאחורי בנייתה, המדריך הנוכחי מפרט את האפשרויות הקיימות בבניית מודל RNN באמצעות TensorFlow.

 

הנתונים והכנה ללמידת מכונה

את סט הנתונים ואת הצעדים המקדימים ללמידת מכונה לקחתי מהמדריך הקודם בסדרת המדריכים ללמידת מכונה - חיזוי טמפרטורות באמצעות למידת מכונה. אתם מוזמנים להסתכל שם בהסבר של השלבים המקדימים או להוריד את הקוד המצורף שבו הפירוט המלא של כל שלבי התהליך (לחץ להורדת המחברת).

 

1. RNN פשוט (Vanilla)

RNN פשוט משתמש בשכבה אחת של LSTM.

# define vanilla model
model = Sequential()
model.add(LSTM(50, activation='relu', input_shape=(x_train.shape[1], n_features)))
model.add(Dense(1))

מכיוון שהמודל מיועד לפלוט מספר אחד כנגד כל סדרה של מספרים שאנו מזינים לתוכו, שכבת הפלט מכילה נאורון בודד.

 

הערכת ביצועי המודל

את הערכת ביצועי המודל אני עושה בתוך פונקציה כדי שנוכל להשתמש בה כדי להעריך את ביצועי כל אחד מהמודלים.

import math
from sklearn.metrics import mean_squared_error

def eval_predictions(model, dataset_test, x_test, n_features):
  # predict on the test dataset
  x_test = x_test.reshape((x_test.shape[0], x_test.shape[1], n_features))
  predictions = model.predict(x_test)

  # convert back to the original values
  predictions = scaler.inverse_transform(predictions)

  y_test_rescaled = scaler.inverse_transform(y_test)

  x_axis = dataset_test.index[30:]

  plt.plot(x_axis, y_test_rescaled)
  plt.plot(x_axis, predictions, alpha=.35, color='red')
  plt.legend(['actual','predicted'])
  plt.title("Actual vs predicted in the test dataset")
  plt.show()

  test_score = math.sqrt(mean_squared_error(y_test_rescaled, predictions))
  print('Test Score: %.2f RMSE' % (test_score))

אחרי הרצת המודל, נעריך את הביצועים שלו באמצעות הפונקציה (כל השלבים מפורטים במחברת):

eval_predictions(model, dataset_test, x_test, n_features)

התוצאה:

תוצאות של מודל Vanilla RNN

עם שגיאה של:

Test Score: 1.29 RMSE

סטייה של 1.29 מעלות בין התחזית לבין הנתונים בפועל בקבוצת הבקרה (שעליה המודל לא אומן).

מהסתכלות בתמונה אנחנו יכולים לראות שהמודל מצליח לזהות את המגמה ולחקות את הפלקטואציות היומיות של הטמפרטורות בדיוק רב.

עד כה ראינו את ביצועי המודל הפשוט ביותר. מעניין עד כמה יצליחו המודלים המורכבים יותר.

 

2. RNN מרובה שכבות (Stacked)

RNN מרובה שכבות (stacked) מכיל מספר שכבות של LSTM. לדוגמה 2 שכבות:

# define stacked LSTM model
model = Sequential()
model.add(LSTM(50, activation='relu', return_sequences=True, input_shape=(x_test.shape[1], n_features)))
model.add(LSTM(50, return_sequences=False, activation='relu'))
model.add(Dense(1))

כל שכבות ה-LSTM מלבד האחרונה צריכות להחזיר רצפים (return_sequences=True) מכיוון ששכבת RNN פולטת כברירת מחדל מערך דו-ממדי אבל כדי להזין שכבת LSTM אנחנו צריכים מערך תלת-ממדי.

אחרי הרצת המודל, נעריך את הביצועים שלו באמצעות הפונקציה מהסעיף הקודם:

תוצאות של מודל stacked RNN

Test Score: 2.33 RMSE

שיעור סטייה של 2.3 מעלות צלזיוס בין הערכים החזויים והערכים בפועל.

הסתכלות על הנתונים מראה שהמודל הכולל יותר משכבה אחת מצליח ללמוד את המגמה הכללית אבל מתקשה בשחזור הפלקטואציות היומיות.

תוכל לראות את כל השלבים במחברת המצ"ב.

מעניין האם מודל יותר מתוחכם יצליח יותר?

 

3. RNN דו-כיווני (Bidirectional)

במקרים מסוימים, דוגמת למידה של שפה טבעית (NLP), נרצה שמודל ה-RNN יקרא את הנתונים משני הכיוונים - קדימה ואחורה - למידה דו-כיוונית - Bidirectional. נעטוף את שכבת ה-RNN בפונקציה Bidirectional כדי לבנות מודל דו-כיווני:

# define model
model = Sequential()
model.add(Bidirectional(LSTM(50, activation='relu'), input_shape=(x_test.shape[1], n_features)))
model.add(Dense(1))

נבחן את התוצאות לאחר הרצת המודל:

תוצאות של מודל Bidirectional RNN

Test Score: 1.27 RMSE

שיעור סטייה של 1.3 מעלות בין הערכים שחוזה המודל והערכים בפועל, בדומה לסטייה במודל הפשוט.

 

4. RNN מרובה שכבות דו-כיווני

ניתן להשתמש בכל אחת משלוש הארכיטקטורות שהוזכרו במדריך כמו שהם וגם ניתן לשלב כדי ליצור מודל RNN מרובה שכבות כשאחת או יותר משכבות ה-RNN הם דו-כיווניות בדומה למודל שבו השתמשתי לצורך פיתוח מודל לאנליזת סנטימנט.

# define model
model = Sequential()
model.add(LSTM(units=50, return_sequences=True, input_shape=(x_test.shape[1], n_features)))
model.add(LSTM(units=50, return_sequences=True))
model.add(LSTM(units=50))
model.add(Dense(units=1))

התוצאות:

תוצאות של מודל Stacked Bidirectional RNN

Test Score: 2.32 RMSE

הביצועים של המודלים מסוג stacked הם פחות טובים מאשר מודלים הכוללים שכבה אחת.

 

מסקנות

במדריך זה ראינו 4 ארכיטקטורות לבניית רשת נוירונית מסוג RNN, וערכנו ניסוי שבו גילינו שמודלים בארכיטקטורות מסוימות הם טובים יותר מאחרים בפתרון הבעיה. לפיכך, כדאי להכיר את הארכיטקטורות השונות, וגם כדאי לערוך ניסויים כדי לזהות את הארכיטקטורה שנותנת את המענה הטוב ביותר לבעיה שעל הפרק.

לכל המדריכים בסדרה על למידת מכונה

 

אהבתם? לא אהבתם? דרגו!

0 הצבעות, ממוצע 0 מתוך 5 כוכבים

 

 

הוסף תגובה חדשה

 

= 7 + 7