סיכום מאמר ויקיפדיה באמצעות המודל המתקדם בעולם T5 של גוגל

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

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

סיכום טקסט ארוך באמצעות טרנספורמרים

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

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

לחץ להורדת קובץ Jupyter Notebook עם הקוד אותו נפתח במדריך

 

1. גירוד תוכן מהאינטרנט

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


הספריות שישמשו לגירוד הם beautiful soup עליו כתבתי במדריך גירוד דפי רשת באמצעות פייתון ו-requests.

from bs4 import BeautifulSoup
import requests

ויקיפדיה מאפשר חיפוש באמצעות API. נחפש את המונח "Transformer_(machine_learning_model)".

# search wikipedia for the any term
wikipedia_api_link = "https://en.wikipedia.org/w/api.php?format=json&action=query&list=search&srsearch="
 
search_term = "Transformer_(machine_learning_model)"
 
url = wikipedia_api_link + search_term
 
# get the url of the first article that the search provides
r = requests.get(url)
 
json_output = r.json()

ה-API יחזיר מספר מאמרים. ניקח את ה-URL של הראשון:

article_title = json_output['query']['search'][0]['title']
 
article_title = article_title.replace(' ', '_')
 
wikipedia_link_article = "https://en.wikipedia.org/wiki/" + article_title
 
wikipedia_link_article

התוצאה היא קישור למאמר ויקיפדיה:

https://en.wikipedia.org/wiki/Transformer_(machine_learning_model)

נגרד את תוכן המאמר לתוך המשתנה text:

# scrape the HTML content from the page
def request_webpage(url):
 res = requests.get(url)
 try:
   res.raise_for_status()
 except Exception as exc:
   print('There is a problem with the request')
 return res
 
page = request_webpage(wikipedia_link_article)
 
bs_page = BeautifulSoup(page.text, 'html.parser')
 
# get only specific HTML tags
tags = bs_page.find_all(["h1","h2","p"])
 
# extract the text from these tags
text = ''
for tag in tags:
 text += tag.getText()

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

# sanitation
import re

נחליף את הסימנים המתווים שורות חדשות:

# replace new lines
text = text.replace('\n', ' ').replace('\r', ' ')

נסיר תווים מיוחדים שאינם ascii:

# remove non-ascii characters
import string
printable = set(string.printable)
''.join(filter(lambda x: x in printable, text))

נסיר את הקישורים לרפרנסים (כל מה שצורתו הכללית [X]):

# use regex to remove '[x]' -
# reference links in the wikipedia text
text = re.sub(r'\[\d+?\]','',text)

 

2. סיכום המאמר באמצעות טרנספורמר

עכשיו שיש לנו טקסט נקי אנחנו צריכים להכין אותו ללמידת מכונה באמצעות טרנספורמר. כשאחת התכונות של הטרנספורמרים היא שניתן להזין אותם במספר מוגבל של מילים (טוקנים) בכל פעם. במקרה של המודל שאיתו אנו עובדים, T5, המגבלה היא 512. עליה נתגבר באמצעות חלוקת הטקסטי הארוך לחתיכות של 400 מילים (למה 400 ולא 512? כי זה נתן לי את התוצאות הכי טובות בניסוי מקדים שערכתי).

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

# separate into list of sentences
text = re.sub(r'[.\?!]',"#eos#",text)

sentences = text.split('#eos#')

sentences = [item.strip() + '.' for item in sentences]

ועכשיו יש לנו רשימה (מערך) של משפטים המאכלסת את המשתנה sentences.

הקוד הבא מחבר מרשימת המשפטים פסקאות שאורכם קצר מ-400 מילים:

# transformers have a limit on the number of tokens
# here I put a limit of 400 tokens since that's what
# worked in a preliminary experiment
MAX_LEN = 400
 
# put into paragraphs with max length of 400 tokens
paragraphs = ['']
x = 0
for sentence in sentences:
 sentence_len = len(sentence.split())
 paragraph_len = len(paragraphs[x].split())
 if (paragraph_len + sentence_len) <= MAX_LEN:
     paragraphs[x] += ' ' + sentence
 else:
   paragraphs.append(sentence)
   x+=1

התוצאה היא רשימה (מערך) של פסקאות אותה נציב לתוך המשתנה paragraphs.

האם זה עבד? מה אורך הפסקאות?

# did it work? what's the actual length?
paragraphs_len = [len(paragraph.split()) for paragraph in paragraphs]

התוצאה:

[375, 374, 397, 374, 378, 128]

נתקין את הספרייה, ונאתחל את הפונקציה pipeline על ידי העברת הפרמטר "summarization" כמוסבר במדריך הטרנספומרים משנים את עולם הבינה המלאכותית.

# HuggingFace transformers library does the heavy lifting
!pip install transformers
# the pipeline uses by default the T5 transformer
# for text summarization
# and thanks to the transformers library
# the code is short and sweet
 
# 1. initialize the transformers' pipeline by passing the argument 'summarization'
from transformers import pipeline
 
summarizer = pipeline("summarization")

נסכם כל פסקה בנפרד לתוך רשימה ששמה summary:

# 2. summarize each paragraph separately
summary = []
for paragraph in paragraphs:
 summary.append(summarizer(paragraph, max_length=100, min_length=20))

נמצה את הסיכומים בתוך לולאה:

summaries = []
for item in summary:
 summaries.append(item[0]['summary_text'])

ונחבר את הסיכומים לפסקה אחת ארוכה שאותה נדפיס:

# 4. join the individual summaries into one piece
summary = ' '.join(summaries)
 
# 5. print and read as you go
print(summary)

התוצאה:

Transformers are designed to handle sequential data, such as natural language, for tasks such as translation and text summarization . Unlike RNNs, Transformers do not require that the sequential data be processed in order . Transformers have rapidly become the model of choice for NLP problems . It has enabled training on larger datasets than was possible before it was introduced . Attention mechanisms let a model directly look at, and draw from, the state at any earlier point in the sentence . When added to RNNs, attention mechanisms led to large gains in performance . Transformer is an encoder-decoder architecture . The function of each encoder layer is to process its input to generate encodings, containing information about which parts of the inputs are relevant to each other . Each encoder and decoder layer makes use of an attention mechanism which weighs the relevance of every other input and draws information from them accordingly to produce the output . Attention weights are calculated using the query and key vectors . Attention (Q, K, V ) = softmax (Q K T d k t (W Q K) , W K, W V V is called an attention head, and each layer in a Transformer model has multiple attention heads . The attention calculation for all tokens can be expressed as one large matrix calculation . Transformer consists of three major components: a self-attention mechanism, an attention mechanism over the encodings, and a feed-forward neural network . Transformer-based architectures can be very expensive, especially for long sentences . Transformers is a library produced by Hugging Face which supplies Transformer-based architectures and pretrained models . In 2020, it was shown that the transformer architecture, more specifically GPT-2, could be fine-tuned to play chess . Transformers have also been applied to image processing .

חסכה לי את הצורך להסביר את הטכנולוגיה בעצמי.

 

גם זה יעניין אותך

הטרנספורמרים משנים את עולם הבינה המלאכותית

מערכת שאלות-תשובות מבוססת בינה מלאכותית

לכל המדריכים בנושא של למידת מכונה

 

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

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

 

 

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

 

= 5 + 5

תמונת המגיב

מישהו בתאריך: 07.04.2021

מדהים!