Buckets:

|
download
raw
22.2 kB

تعلیم یک توکِنایزر جدید از روی توکِنایزر قدیمی[[training-a-new-tokenizer-from-an-old-one]]

<CourseFloatingBanner chapter={6} classNames="absolute z-10 right-0 top-0" notebooks={[ {label: "Google Colab", value: "https://colab.research.google.com/github/huggingface/notebooks/blob/master/course/en/chapter6/section2.ipynb"}, {label: "Aws Studio", value: "https://studiolab.sagemaker.aws/import/github/huggingface/notebooks/blob/master/course/en/chapter6/section2.ipynb"}, ]} />

اگر مدل زبانی به زبانی که به آن علاقه‌مندید در دسترس نباشد، یا پیکره‌ی شما با پیکره‌ای که مدل زبانی‌تان روی آن تعلیم دیده است تفاوت زیادی داشته باشد، احتمالاً می‌خواهید مدل را از صفر و با استفاده از توکِنایزری متناسب با داده‌های خود دوباره تعلیم دهید. برای این کار باید یک توکِنایزر جدید را روی دیتاست خود تعلیم دهید. اما این کار دقیقاً به چه معناست؟ وقتی برای نخستین بار در فصل ۲ توکِنایزرها را بررسی کردیم، دیدیم که بیشتر مدل‌های ترنسفورمر از الگوریتم توکِن‌سازی زیرواژه‌ای استفاده می‌کنند. توکِنایزر برای شناسایی زیرواژه‌هایی که در پیکره‌ی موردنظر اهمیت دارند و بیشتر تکرار می‌شوند، باید همه‌ی متن‌های پیکره را با دقت بررسی کند — فرایندی که آن را تعلیم می‌نامیم. قواعد دقیقی که این تعلیم را هدایت می‌کنند به نوع توکِنایزر مورد استفاده بستگی دارند و در ادامه‌ی این فصل سه الگوریتم اصلی را بررسی خواهیم کرد.

⚠️ تعلیم توکِنایزر با تعلیم مدل یکسان نیست! در تعلیم مدل، از نزول گرادیان تصادفی استفاده می‌شود تا مقدار تابع هزینه در هر بتچ کمی کاهش یابد. این فرایند ذاتاً تصادفی است (یعنی برای گرفتن نتایج یکسان هنگام تکرار تعلیم، باید seedهایی را تنظیم کنید). تعلیم توکِنایزر فرایندی آماری است که تلاش می‌کند بهترین زیرواژه‌ها را برای انتخاب در یک پیکره‌ی مشخص شناسایی کند و قواعد دقیق انتخاب آن‌ها به الگوریتم توکِن‌سازی بستگی دارد. این فرایند قطعی است؛ یعنی هنگام تعلیم با یک الگوریتم یکسان روی یک پیکره‌ی یکسان، همیشه نتایج یکسانی می‌گیرید.

گردآوری یک پیکره[[assembling-a-corpus]]

در 🤗 Transformers یک API بسیار ساده وجود دارد که می‌توانید با استفاده از آن، توکِنایزر جدیدی با ویژگی‌های یک توکِنایزر موجود تعلیم دهید: AutoTokenizer.train_new_from_iterator(). برای دیدن این قابلیت در عمل، فرض کنید می‌خواهیم GPT-2 را از صفر، اما به زبانی غیر از انگلیسی، تعلیم دهیم. نخستین کار ما گردآوری داده‌های فراوان به آن زبان در یک پیکره‌ی تعلیم خواهد بود. برای اینکه مثال‌ها برای همه قابل فهم باشند، در اینجا از زبانی مانند روسی یا چینی استفاده نمی‌کنیم، بلکه یک زبان تخصصی انگلیسی را انتخاب می‌کنیم: کد پایتون.

کتابخانه‌ی 🤗 Datasets می‌تواند به ما کمک کند پیکره‌ای از کد منبع پایتون گردآوری کنیم. برای دانلود و ذخیره‌ی موقت دیتاست CodeSearchNet از تابع معمول load_dataset() استفاده می‌کنیم. این دیتاست برای چالش CodeSearchNet ساخته شده و شامل میلیون‌ها تابع از کتابخانه‌های متن‌باز موجود در گیت‌هاب و به چندین زبان برنامه‌نویسی است. در اینجا بخش پایتون این دیتاست را بارگذاری می‌کنیم:

from datasets import load_dataset

# This can take a few minutes to load, so grab a coffee or tea while you wait!
raw_datasets = load_dataset("code_search_net", "python")

می‌توانیم نگاهی به split تعلیم بیندازیم تا ببینیم به کدام ستون‌ها دسترسی داریم:

raw_datasets["train"]
Dataset({
    features: ['repository_name', 'func_path_in_repository', 'func_name', 'whole_func_string', 'language',
      'func_code_string', 'func_code_tokens', 'func_documentation_string', 'func_documentation_tokens', 'split_name',
      'func_code_url'
    ],
    num_rows: 412178
})

می‌بینیم که دیتاست، docstringها را از کد جدا می‌کند و برای هرکدام توکِن‌سازی پیشنهادی ارائه می‌دهد. در اینجا فقط از ستون whole_func_string برای تعلیم توکِنایزر خود استفاده می‌کنیم. می‌توانیم با اندیس‌گذاری در split train، نمونه‌ای از این تابع‌ها را ببینیم:

print(raw_datasets["train"][123456]["whole_func_string"])

که باید خروجی زیر را چاپ کند:

def handle_simple_responses(
      self, timeout_ms=None, info_cb=DEFAULT_MESSAGE_CALLBACK):
    """Accepts normal responses from the device.

    Args:
      timeout_ms: Timeout in milliseconds to wait for each response.
      info_cb: Optional callback for text sent from the bootloader.

    Returns:
      OKAY packet's message.
    """
    return self._accept_responses('OKAY', info_cb, timeout_ms=timeout_ms)

نخستین کاری که باید انجام دهیم، تبدیل دیتاست به تکرارکننده‌ای از فهرست‌های متن است — برای مثال، فهرستی از فهرست‌های متن. استفاده از فهرست‌های متن باعث می‌شود توکِنایزر ما سریع‌تر کار کند (چون به‌جای پردازش متن‌ها یکی‌یکی، آن‌ها را به‌صورت بتچی تعلیم می‌دهد) و اگر بخواهیم همه‌چیز را یک‌باره در حافظه قرار ندهیم، این ساختار باید یک تکرارکننده باشد. اگر پیکره‌ی شما بزرگ است، می‌توانید از این ویژگی 🤗 Datasets استفاده کنید که همه‌چیز را در RAM بارگذاری نمی‌کند و عناصر دیتاست را روی دیسک ذخیره می‌کند.

دستور زیر فهرستی از فهرست‌هایی شامل ۱۰۰۰ متن ایجاد می‌کند، اما همه‌چیز را در حافظه بارگذاری خواهد کرد:

# Don't uncomment the following line unless your dataset is small!
# training_corpus = [raw_datasets["train"][i: i + 1000]["whole_func_string"] for i in range(0, len(raw_datasets["train"]), 1000)]

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

training_corpus = (
    raw_datasets["train"][i : i + 1000]["whole_func_string"]
    for i in range(0, len(raw_datasets["train"]), 1000)
)

این خط کد هیچ عنصری از دیتاست را دریافت نمی‌کند؛ فقط شیئی می‌سازد که می‌توانید در یک حلقه‌ی for پایتون از آن استفاده کنید. متن‌ها فقط زمانی بارگذاری می‌شوند که به آن‌ها نیاز داشته باشید (یعنی وقتی در مرحله‌ای از حلقه‌ی for هستید که به آن‌ها نیاز دارد) و هر بار فقط ۱۰۰۰ متن بارگذاری می‌شود. به این ترتیب، حتی هنگام پردازش دیتاستی بسیار بزرگ نیز تمام حافظه‌ی خود را مصرف نخواهید کرد.

مشکل یک شیء generator این است که فقط یک بار می‌توان از آن استفاده کرد. بنابراین، کد زیر به‌جای اینکه فهرست ده رقم اول را دو بار به ما بدهد:

gen = (i for i in range(10))
print(list(gen))
print(list(gen))
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
[]

یک بار آن را به ما می‌دهد و بعد فهرستی خالی برمی‌گرداند. به همین دلیل، تابعی تعریف می‌کنیم که به‌جای آن یک generator برمی‌گرداند:

def get_training_corpus():
    return (
        raw_datasets["train"][i : i + 1000]["whole_func_string"]
        for i in range(0, len(raw_datasets["train"]), 1000)
    )

training_corpus = get_training_corpus()

همچنین می‌توانید generator خود را درون یک حلقه‌ی for با استفاده از دستور yield تعریف کنید:

def get_training_corpus():
    dataset = raw_datasets["train"]
    for start_idx in range(0, len(dataset), 1000):
        samples = dataset[start_idx : start_idx + 1000]
        yield samples["whole_func_string"]

این کد دقیقاً همان generator قبلی را تولید می‌کند، اما به شما اجازه می‌دهد از منطق پیچیده‌تری نسبت به آنچه در یک list comprehension ممکن است استفاده کنید.

تعلیم یک توکِنایزر جدید[[training-a-new-tokenizer]]

حالا که پیکره‌ی خود را به‌شکل تکرارکننده‌ای از بتچ‌های متن داریم، آماده‌ایم یک توکِنایزر جدید تعلیم دهیم. برای این کار، ابتدا باید توکِنایزری را که می‌خواهیم با مدل خود (در اینجا GPT-2) جفت کنیم بارگذاری کنیم:

from transformers import AutoTokenizer

old_tokenizer = AutoTokenizer.from_pretrained("gpt2")

با اینکه قرار است توکِنایزر جدیدی تعلیم دهیم، انجام این کار برای جلوگیری از شروع کاملاً صفر ایده‌ی خوبی است. به این ترتیب لازم نیست چیزی درباره‌ی الگوریتم توکِن‌سازی یا توکِن‌های ویژه‌ای که می‌خواهیم استفاده کنیم مشخص کنیم؛ توکِنایزر جدید ما دقیقاً مانند GPT-2 خواهد بود و تنها چیزی که تغییر می‌کند واژگان است که تعلیم روی پیکره‌ی ما آن را تعیین خواهد کرد.

ابتدا ببینیم این توکِنایزر یک تابع نمونه را چگونه پردازش می‌کند:

example = '''def add_numbers(a, b):
    """Add the two numbers `a` and `b`."""
    return a + b'''

tokens = old_tokenizer.tokenize(example)
tokens
['def', 'Ġadd', '_', 'n', 'umbers', '(', 'a', ',', 'Ġb', '):', 'Ċ', 'Ġ', 'Ġ', 'Ġ', 'Ġ"""', 'Add', 'Ġthe', 'Ġtwo',
 'Ġnumbers', 'Ġ`', 'a', '`', 'Ġand', 'Ġ`', 'b', '`', '."', '""', 'Ċ', 'Ġ', 'Ġ', 'Ġ', 'Ġreturn', 'Ġa', 'Ġ+', 'Ġb']

این توکِنایزر چند نماد ویژه مانند Ġ و Ċ دارد که به‌ترتیب فاصله‌ها و خط‌های جدید را نشان می‌دهند. همان‌طور که می‌بینیم، این فرایند چندان کارآمد نیست: توکِنایزر برای هر فاصله یک توکِن جداگانه برمی‌گرداند، درحالی‌که می‌توانست سطوح تورفتگی را با هم گروه‌بندی کند (چون مجموعه‌های چهار یا هشت‌تایی از فاصله‌ها در کد بسیار رایج‌اند). همچنین نام تابع را کمی عجیب تقسیم کرده است، چون به دیدن کلماتی با نویسه‌ی _ عادت ندارد.

بیایید یک توکِنایزر جدید تعلیم دهیم و ببینیم آیا این مشکلات را حل می‌کند. برای این کار از متد train_new_from_iterator() استفاده می‌کنیم:

tokenizer = old_tokenizer.train_new_from_iterator(training_corpus, 52000)

اگر پیکره‌ی شما بسیار بزرگ باشد، اجرای این دستور ممکن است کمی زمان ببرد، اما برای این دیتاست با ۱٫۶ گیگابایت متن، سرعت آن بسیار زیاد است (روی CPU مدل AMD Ryzen 9 3900X با ۱۲ هسته، ۱ دقیقه و ۱۶ ثانیه).

توجه داشته باشید که AutoTokenizer.train_new_from_iterator() فقط زمانی کار می‌کند که توکِنایزر مورد استفاده‌ی شما «سریع» باشد. همان‌طور که در بخش بعد خواهید دید، کتابخانه‌ی 🤗 Transformers شامل دو نوع توکِنایزر است: برخی کاملاً با پایتون نوشته شده‌اند و برخی دیگر (توکِنایزرهای سریع) به کتابخانه‌ی 🤗 Tokenizers متکی هستند که با زبان برنامه‌نویسی Rust نوشته شده است. پایتون زبانی است که بیشتر برای علم داده و برنامه‌های یادگیری عمیق استفاده می‌شود، اما هر چیزی که برای سریع بودن نیاز به موازی‌سازی داشته باشد باید با زبان دیگری نوشته شود. برای مثال، ضرب‌های ماتریسی که در هسته‌ی محاسبات مدل قرار دارند با CUDA، یک کتابخانه‌ی بهینه‌شده‌ی C برای GPUها، نوشته شده‌اند.

تعلیم یک توکِنایزر کاملاً جدید با پایتون خالص به‌شدت کند خواهد بود؛ به همین دلیل کتابخانه‌ی 🤗 Tokenizers را توسعه دادیم. توجه کنید همان‌طور که برای اجرای مدل خود روی یک بتچ از ورودی‌ها در GPU لازم نبود زبان CUDA را یاد بگیرید، برای استفاده از توکِنایزر سریع نیز نیازی به یادگیری Rust ندارید. کتابخانه‌ی 🤗 Tokenizers برای بسیاری از متدها bindingهای پایتون فراهم می‌کند که در پشت صحنه بخشی از کد Rust را فراخوانی می‌کنند؛ برای مثال، برای موازی‌سازی تعلیم توکِنایزر جدید یا همان‌طور که در فصل ۳ دیدیم، توکِن‌سازی یک بتچ از ورودی‌ها.

بیشتر مدل‌های ترنسفورمر توکِنایزر سریعی دارند (چند استثنا وجود دارد که می‌توانید آن‌ها را اینجا بررسی کنید) و API AutoTokenizer، اگر توکِنایزر سریع موجود باشد، همیشه آن را برای شما انتخاب می‌کند. در بخش بعدی نگاهی به برخی قابلیت‌های ویژه‌ی دیگر توکِنایزرهای سریع می‌اندازیم که برای وظایفی مانند دسته‌بندی توکِن و پاسخ‌گویی به پرسش بسیار مفید خواهند بود. بااین‌حال، پیش از ورود به آن بخش، بیایید توکِنایزر کاملاً جدید خود را روی مثال قبلی امتحان کنیم:

tokens = tokenizer.tokenize(example)
tokens
['def', 'Ġadd', '_', 'numbers', '(', 'a', ',', 'Ġb', '):', 'ĊĠĠĠ', 'Ġ"""', 'Add', 'Ġthe', 'Ġtwo', 'Ġnumbers', 'Ġ`',
 'a', '`', 'Ġand', 'Ġ`', 'b', '`."""', 'ĊĠĠĠ', 'Ġreturn', 'Ġa', 'Ġ+', 'Ġb']

در اینجا نیز نمادهای ویژه‌ی Ġ و Ċ را می‌بینیم که فاصله‌ها و خط‌های جدید را نشان می‌دهند، اما می‌توانیم ببینیم که توکِنایزر ما توکِن‌هایی را یاد گرفته است که برای پیکره‌ای از تابع‌های پایتون بسیار خاص هستند: برای مثال، توکِن ĊĠĠĠ یک تورفتگی و توکِن Ġ""" سه نقل‌قول آغازکننده‌ی یک docstring را نمایش می‌دهد. توکِنایزر همچنین نام تابع را به‌درستی در محل _ جدا کرده است. این نمایش بسیار فشرده است؛ در مقایسه، استفاده از توکِنایزر ساده‌ی انگلیسی روی همین مثال جمله‌ای طولانی‌تر به ما می‌دهد:

print(len(tokens))
print(len(old_tokenizer.tokenize(example)))
27
36

بیایید یک مثال دیگر را بررسی کنیم:

example = """class LinearLayer():
    def __init__(self, input_size, output_size):
        self.weight = torch.randn(input_size, output_size)
        self.bias = torch.zeros(output_size)

    def __call__(self, x):
        return x @ self.weights + self.bias
    """
tokenizer.tokenize(example)
['class', 'ĠLinear', 'Layer', '():', 'ĊĠĠĠ', 'Ġdef', 'Ġ__', 'init', '__(', 'self', ',', 'Ġinput', '_', 'size', ',',
 'Ġoutput', '_', 'size', '):', 'ĊĠĠĠĠĠĠĠ', 'Ġself', '.', 'weight', 'Ġ=', 'Ġtorch', '.', 'randn', '(', 'input', '_',
 'size', ',', 'Ġoutput', '_', 'size', ')', 'ĊĠĠĠĠĠĠĠ', 'Ġself', '.', 'bias', 'Ġ=', 'Ġtorch', '.', 'zeros', '(',
 'output', '_', 'size', ')', 'ĊĊĠĠĠ', 'Ġdef', 'Ġ__', 'call', '__(', 'self', ',', 'Ġx', '):', 'ĊĠĠĠĠĠĠĠ',
 'Ġreturn', 'Ġx', 'Ġ@', 'Ġself', '.', 'weights', 'Ġ+', 'Ġself', '.', 'bias', 'ĊĠĠĠĠ']

علاوه بر توکِنی که متناظر با یک تورفتگی است، در اینجا توکِنی برای تورفتگی دوبرابری نیز می‌بینیم: ĊĠĠĠĠĠĠĠ. واژه‌های ویژه‌ی پایتون مانند class، init، call، self و return هرکدام به‌صورت یک توکِن توکِن‌سازی شده‌اند. همچنین می‌بینیم که توکِنایزر، علاوه بر جدا کردن نام‌ها در محل _ و ., حتی نام‌های camel-case را نیز به‌درستی جدا می‌کند: LinearLayer به‌صورت ["ĠLinear", "Layer"] توکِن‌سازی می‌شود.

ذخیره‌سازی توکِنایزر[[saving-the-tokenizer]]

برای اینکه بعداً بتوانیم از توکِنایزر جدید استفاده کنیم، باید آن را ذخیره کنیم. این کار، درست مانند مدل‌ها، با متد save_pretrained() انجام می‌شود:

tokenizer.save_pretrained("code-search-net-tokenizer")

این کار پوشه‌ی جدیدی به نام code-search-net-tokenizer می‌سازد که شامل همه‌ی فایل‌های موردنیاز برای بارگذاری دوباره‌ی توکِنایزر است. اگر بخواهید این توکِنایزر را با همکاران و دوستان خود به اشتراک بگذارید، می‌توانید پس از ورود به حساب خود آن را در هاب بارگذاری کنید. اگر در یک نوت‌بوک کار می‌کنید، تابعی کاربردی برای کمک به این کار وجود دارد:

from huggingface_hub import notebook_login

notebook_login()

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

huggingface-cli login

پس از ورود، می‌توانید با اجرای دستور زیر توکِنایزر خود را در هاب بارگذاری کنید:

tokenizer.push_to_hub("code-search-net-tokenizer")

این کار مخزن جدیدی با نام code-search-net-tokenizer در فضای نام شما ایجاد می‌کند که شامل فایل توکِنایزر است. سپس می‌توانید با متد from_pretrained() توکِنایزر را از هر جایی بارگذاری کنید:

# Replace "huggingface-course" below with your actual namespace to use your own tokenizer
tokenizer = AutoTokenizer.from_pretrained("huggingface-course/code-search-net-tokenizer")

حالا برای تعلیم یک مدل زبانی از صفر و کوک کردن آن روی مسئله‌ی خود آماده‌اید! در فصل ۷ به این موضوع می‌پردازیم، اما ابتدا در ادامه‌ی این فصل نگاهی دقیق‌تر به توکِنایزرهای سریع می‌اندازیم و بررسی می‌کنیم هنگام فراخوانی متد train_new_from_iterator() دقیقاً چه اتفاقی می‌افتد.

Xet Storage Details

Size:
22.2 kB
·
Xet hash:
c7893adebf63e36d0cb8d5da61301313c5d247f4498089094110b3e3f3cc5ea8

Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.