Buckets:

|
download
raw
32.5 kB
# به‌اشتراک‌گذاری مدل‌های از پیش تعلیم دیده[[sharing-pretrained-models]]
{#if fw === 'pt'}
<CourseFloatingBanner chapter={4}
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/chapter4/section3_pt.ipynb"},
{label: "Aws Studio", value: "https://studiolab.sagemaker.aws/import/github/huggingface/notebooks/blob/master/course/en/chapter4/section3_pt.ipynb"},
]} />
{:else}
<CourseFloatingBanner chapter={4}
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/chapter4/section3_tf.ipynb"},
{label: "Aws Studio", value: "https://studiolab.sagemaker.aws/import/github/huggingface/notebooks/blob/master/course/en/chapter4/section3_tf.ipynb"},
]} />
{/if}
در مراحل زیر، ساده‌ترین راه‌های به‌اشتراک‌گذاری مدل‌های از پیش تعلیم دیده در 🤗 هاب را بررسی می‌کنیم. ابزارها و امکاناتی وجود دارند که اشتراک‌گذاری و به‌روزرسانی مستقیم مدل‌ها در هاب را آسان می‌کنند و در ادامه آن‌ها را بررسی خواهیم کرد.
از همه‌ی کاربرانی که مدل تعلیم می‌دهند دعوت می‌کنیم با به‌اشتراک‌گذاری آن‌ها در جامعه مشارکت کنند — اشتراک‌گذاری مدل‌ها، حتی زمانی که روی دیتاست‌های بسیار خاص تعلیم داده شده باشند، به دیگران کمک می‌کند، در زمان و منابع محاسباتی آن‌ها صرفه‌جویی می‌کند و امکان دسترسی به مصنوعات تعلیم‌دیده‌ی مفید را فراهم می‌سازد. در مقابل، شما هم می‌توانید از کارهایی که دیگران انجام داده‌اند بهره ببرید!
برای ایجاد مخزن‌های مدل جدید، سه راه وجود دارد:
- استفاده از API `push_to_hub`
- استفاده از کتابخانه‌ی پایتون `huggingface_hub`
- استفاده از رابط وب
پس از ایجاد یک مخزن، می‌توانید فایل‌ها را از طریق git و git-lfs در آن بارگذاری کنید. در بخش‌های بعدی، ایجاد مخزن‌های مدل و بارگذاری فایل‌ها در آن‌ها را قدم‌به‌قدم توضیح می‌دهیم.
## استفاده از API `push_to_hub`[[using-the-pushtohub-api]]
{#if fw === 'pt'}
{:else}
{/if}
ساده‌ترین راه برای بارگذاری فایل‌ها در هاب، استفاده از API `push_to_hub` است.
پیش از ادامه، باید یک توکِن احراز هویت بسازید تا API `huggingface_hub` بداند شما چه کسی هستید و به کدام فضای نام دسترسی نوشتن دارید. مطمئن شوید در محیطی هستید که `transformers` در آن نصب شده است (به [راه‌اندازی](/course/chapter0) مراجعه کنید). اگر در یک نوت‌بوک هستید، می‌توانید برای ورود به سیستم از تابع زیر استفاده کنید:
```python
from huggingface_hub import notebook_login
notebook_login()
```
در یک ترمینال، می‌توانید دستور زیر را اجرا کنید:
```bash
huggingface-cli login
```
در هر دو حالت، از شما خواسته می‌شود نام کاربری و گذرواژه‌ی خود را وارد کنید؛ همان اطلاعاتی که برای ورود به هاب استفاده می‌کنید. اگر هنوز نمایه‌ای در هاب ندارید، می‌توانید [از اینجا](https://huggingface.co/join) یکی بسازید.
عالی است! حالا توکِن احراز هویت شما در پوشه‌ی cache ذخیره شده است. بیایید چند مخزن ایجاد کنیم!
{#if fw === 'pt'}
اگر با API `Trainer` برای تعلیم یک مدل کار کرده‌اید، ساده‌ترین راه برای بارگذاری آن در هاب این است که هنگام تعریف `TrainingArguments`، مقدار `push_to_hub=True` را تنظیم کنید:
```py
from transformers import TrainingArguments
training_args = TrainingArguments(
"bert-finetuned-mrpc", save_strategy="epoch", push_to_hub=True
)
```
وقتی `trainer.train()` را فراخوانی می‌کنید، `Trainer` مدل شما را هر بار که ذخیره شود (در اینجا در پایان هر epoch) در یک مخزن در فضای نام شما بارگذاری می‌کند. نام آن مخزن مانند پوشه‌ی خروجی‌ای خواهد بود که انتخاب کرده‌اید (در اینجا `bert-finetuned-mrpc`)، اما می‌توانید با `hub_model_id = "a_different_name"` نام دیگری انتخاب کنید.
برای بارگذاری مدل در یک سازمان که عضو آن هستید، کافی است مقدار `hub_model_id = "my_organization/my_repo_name"` را به آن بدهید.
پس از پایان تعلیم، باید یک بار نهایی `trainer.push_to_hub()` را اجرا کنید تا آخرین نسخه‌ی مدل بارگذاری شود. این کار همچنین یک model card با تمام فراداده‌ی مرتبط ایجاد می‌کند و ابرپارامترهای استفاده‌شده و نتایج ارزیابی را گزارش می‌دهد! در ادامه نمونه‌ای از محتوایی را می‌بینید که ممکن است در چنین model cardای پیدا کنید:
{:else}
اگر برای تعلیم مدل خود از Keras استفاده می‌کنید، ساده‌ترین راه برای بارگذاری آن در هاب این است که هنگام فراخوانی `model.fit()`، یک `PushToHubCallback` به آن بدهید:
```py
from transformers import PushToHubCallback
callback = PushToHubCallback(
"bert-finetuned-mrpc", save_strategy="epoch", tokenizer=tokenizer
)
```
سپس باید `callbacks=[callback]` را به فراخوانی `model.fit()` خود اضافه کنید. callback هر بار که مدل ذخیره شود (در اینجا در پایان هر epoch)، آن را در یک مخزن در فضای نام شما بارگذاری می‌کند. نام آن مخزن مانند پوشه‌ی خروجی‌ای خواهد بود که انتخاب کرده‌اید (در اینجا `bert-finetuned-mrpc`)، اما می‌توانید با `hub_model_id = "a_different_name"` نام دیگری انتخاب کنید.
برای بارگذاری مدل در یک سازمان که عضو آن هستید، کافی است مقدار `hub_model_id = "my_organization/my_repo_name"` را به آن بدهید.
{/if}
در سطحی پایین‌تر، می‌توان با استفاده از متد `push_to_hub()` مستقیماً روی مدل‌ها، توکِنایزرها و اشیای پیکربندی به هاب دسترسی داشت. این متد هم ایجاد مخزن و هم push کردن فایل‌های مدل و توکِنایزر را مستقیماً در مخزن بر عهده می‌گیرد. برخلاف APIای که در ادامه می‌بینیم، به مدیریت دستی نیازی نیست.
برای درک نحوه‌ی کار، ابتدا یک مدل و یک توکِنایزر را مقداردهی اولیه می‌کنیم:
{#if fw === 'pt'}
```py
from transformers import AutoModelForMaskedLM, AutoTokenizer
checkpoint = "camembert-base"
model = AutoModelForMaskedLM.from_pretrained(checkpoint)
tokenizer = AutoTokenizer.from_pretrained(checkpoint)
```
{:else}
```py
from transformers import TFAutoModelForMaskedLM, AutoTokenizer
checkpoint = "camembert-base"
model = TFAutoModelForMaskedLM.from_pretrained(checkpoint)
tokenizer = AutoTokenizer.from_pretrained(checkpoint)
```
{/if}
با این‌ها آزاد هستید هر کاری که می‌خواهید انجام دهید — توکِن‌هایی به توکِنایزر اضافه کنید، مدل را تعلیم دهید یا آن را کوک کنید. وقتی از مدل، وزن‌ها و توکِنایزر حاصل راضی بودید، می‌توانید از متد `push_to_hub()` که مستقیماً روی شیء `model` در دسترس است استفاده کنید:
```py
model.push_to_hub("dummy-model")
```
این کار مخزن جدید `dummy-model` را در نمایه‌ی شما ایجاد و آن را با فایل‌های مدل پر می‌کند. همین کار را با توکِنایزر نیز انجام دهید تا همه‌ی فایل‌ها در این مخزن در دسترس باشند:
```py
tokenizer.push_to_hub("dummy-model")
```
اگر عضو یک سازمان هستید، کافی است برای بارگذاری در فضای نام آن سازمان، آرگومان `organization` را مشخص کنید:
```py
tokenizer.push_to_hub("dummy-model", organization="huggingface")
```
اگر می‌خواهید از یک توکِن مشخص هاگینگ‌فِیس استفاده کنید، می‌توانید آن را به متد `push_to_hub()` نیز بدهید:
```py
tokenizer.push_to_hub("dummy-model", organization="huggingface", use_auth_token="<TOKEN>")
```
اکنون به هاب مدل بروید تا مدل تازه‌بارگذاری‌شده‌ی خود را پیدا کنید: *https://huggingface.co/user-or-organization/dummy-model*.
روی زبانه‌ی «Files and versions» کلیک کنید؛ باید فایل‌ها را مانند تصویر زیر ببینید:
{#if fw === 'pt'}
{:else}
{/if}
> [!TIP]
> ✏️ **امتحان کنید!** مدل و توکِنایزر مربوط به نقطه تعلیم `bert-base-cased` را بردارید و با استفاده از متد `push_to_hub()` آن‌ها را در مخزنی در فضای نام خود بارگذاری کنید. پیش از حذف مخزن، دوباره بررسی کنید که به‌درستی در صفحه‌ی شما ظاهر شده باشد.
همان‌طور که دیدید، متد `push_to_hub()` چندین آرگومان می‌پذیرد و به شما امکان می‌دهد در مخزن یا فضای نام سازمانی مشخصی بارگذاری کنید یا از توکِن API متفاوتی استفاده کنید. پیشنهاد می‌کنیم برای آشنایی با امکانات موجود، نگاهی به مشخصات این متد در [مستندات 🤗 Transformers](https://huggingface.co/transformers/model_sharing) بیندازید.
متد `push_to_hub()` بر پایه‌ی بسته‌ی پایتونی [`huggingface_hub`](https://github.com/huggingface/huggingface_hub) ساخته شده است که API مستقیمی برای هاب مدل‌ها و دیتاست‌ها ارائه می‌دهد. این بسته در 🤗 Transformers و چندین کتابخانه‌ی دیگر یادگیری ماشین، مانند [`allenlp`](https://github.com/allenai/allennlp)، یکپارچه شده است. اگرچه در این فصل بر یکپارچه‌سازی با 🤗 Transformers تمرکز داریم، یکپارچه‌سازی آن با کتابخانه یا کد خودتان ساده است.
برای دیدن نحوه‌ی بارگذاری فایل‌ها در مخزن تازه‌ساخته‌شده، به بخش آخر بروید!
## استفاده از کتابخانه‌ی پایتونی `huggingface_hub`[[using-the-huggingfacehub-python-library]]
کتابخانه‌ی پایتونی `huggingface_hub` بسته‌ای است که مجموعه‌ای از ابزارها را برای هاب‌های مدل و دیتاست ارائه می‌دهد. این کتابخانه روش‌ها و کلاس‌های ساده‌ای برای کارهای متداول، مانند دریافت اطلاعات مخزن‌ها در هاب و مدیریت آن‌ها، فراهم می‌کند. APIهای ساده‌ی آن بر پایه‌ی git کار می‌کنند تا محتوای مخزن‌ها و یکپارچه‌سازی هاب با پروژه‌ها و کتابخانه‌های شما را مدیریت کنند.
مشابه استفاده از API `push_to_hub`، در اینجا نیز باید توکِن API خود را در cache ذخیره کرده باشید. برای این کار باید از دستور `login` در CLI استفاده کنید؛ همان‌طور که در بخش قبل گفته شد (دوباره یادآوری می‌کنیم که اگر در Google Colab هستید، این دستورات را با نویسه‌ی `!` آغاز کنید):
```bash
huggingface-cli login
```
بسته‌ی `huggingface_hub` روش‌ها و کلاس‌های مفیدی برای هدف ما ارائه می‌دهد. ابتدا چند روش برای مدیریت ایجاد و حذف مخزن و کارهای دیگر داریم:
```python no-format
from huggingface_hub import (
# User management
login,
logout,
whoami,
# Repository creation and management
create_repo,
delete_repo,
update_repo_visibility,
# And some methods to retrieve/change information about the content
list_models,
list_datasets,
list_metrics,
list_repo_files,
upload_file,
delete_file,
)
```
علاوه بر این، کلاس بسیار قدرتمند `Repository` را برای مدیریت یک مخزن محلی در اختیار داریم. در بخش بعدی، این روش‌ها و کلاس را بررسی می‌کنیم تا نحوه‌ی استفاده از آن‌ها را بهتر بفهمیم.
از متد `create_repo` می‌توان برای ایجاد یک مخزن جدید در هاب استفاده کرد:
```py
from huggingface_hub import create_repo
create_repo("dummy-model")
```
این کار مخزن `dummy-model` را در فضای نام شما ایجاد می‌کند. اگر بخواهید مخزن به یک سازمان تعلق داشته باشد، می‌توانید با استفاده از آرگومان `organization` مشخص کنید متعلق به کدام سازمان باشد:
```py
from huggingface_hub import create_repo
create_repo("dummy-model", organization="huggingface")
```
این کار مخزن `dummy-model` را در فضای نام `huggingface` ایجاد می‌کند، البته به شرطی که عضو آن سازمان باشید. آرگومان‌های مفید دیگر عبارت‌اند از:
- `private` برای مشخص کردن اینکه مخزن برای دیگران قابل مشاهده باشد یا نه.
- `token` برای جایگزین کردن توکِن ذخیره‌شده در cache با توکِنی که خودتان می‌دهید.
- `repo_type` برای ایجاد `dataset` یا `space` به‌جای یک مدل. مقادیر پذیرفته‌شده `"dataset"` و `"space"` هستند.
پس از ایجاد مخزن، باید فایل‌هایی به آن اضافه کنیم! برای دیدن سه روش انجام این کار به بخش بعدی بروید.
## استفاده از رابط وب[[using-the-web-interface]]
رابط وب ابزارهایی برای مدیریت مستقیم مخزن‌ها در هاب ارائه می‌دهد. با استفاده از این رابط، می‌توانید به‌سادگی مخزن بسازید، فایل‌ها (حتی فایل‌های بزرگ!) را اضافه کنید، مدل‌ها را بررسی کنید، تفاوت‌ها را ببینید و کارهای بسیار بیشتری انجام دهید.
برای ایجاد یک مخزن جدید، به [huggingface.co/new](https://huggingface.co/new) بروید:
ابتدا مالک مخزن را مشخص کنید: این مالک می‌تواند خود شما یا هر سازمانی باشد که به آن وابسته‌اید. اگر یک سازمان را انتخاب کنید، مدل در صفحه‌ی سازمان نمایش داده می‌شود و همه‌ی اعضای آن سازمان امکان مشارکت در مخزن را خواهند داشت.
سپس نام مدل خود را وارد کنید. این نام، نام مخزن نیز خواهد بود. در نهایت می‌توانید مشخص کنید مدل عمومی یا خصوصی باشد. مدل‌های خصوصی از دید عموم پنهان هستند.
پس از ایجاد مخزن مدل، باید صفحه‌ای مانند صفحه‌ی زیر ببینید:
در اینجا مدل شما میزبانی خواهد شد. برای شروع پر کردن مخزن، می‌توانید یک فایل README را مستقیماً از رابط وب اضافه کنید.
فایل README با Markdown نوشته می‌شود — پس با خیال راحت هر طور می‌خواهید آن را بسازید! بخش سوم این فصل به ساختن model card اختصاص دارد. این کارت‌ها برای ارزشمند کردن مدل شما اهمیت زیادی دارند، چون در آن‌ها به دیگران می‌گویید مدل شما چه کاری می‌تواند انجام دهد.
اگر به زبانه‌ی «Files and versions» نگاه کنید، می‌بینید هنوز فایل‌های زیادی در آنجا وجود ندارد — فقط *README.md* که همین حالا ساختید و فایل *.gitattributes* که فایل‌های بزرگ را ردیابی می‌کند.
در ادامه، نحوه‌ی افزودن چند فایل جدید را بررسی می‌کنیم.
## بارگذاری فایل‌های مدل[[uploading-the-model-files]]
سامانه‌ی مدیریت فایل‌ها در هاب هاگینگ‌فِیس برای فایل‌های معمولی بر git و برای فایل‌های بزرگ‌تر بر git-lfs (که مخفف [Git Large File Storage](https://git-lfs.github.com/) است) تکیه دارد.
در بخش بعدی، سه روش متفاوت بارگذاری فایل‌ها در هاب را بررسی می‌کنیم: از طریق `huggingface_hub` و از طریق دستورات git.
### روش `upload_file`[[the-uploadfile-approach]]
برای استفاده از `upload_file` لازم نیست git و git-lfs روی سیستم شما نصب باشند. این روش فایل‌ها را با درخواست‌های HTTP POST مستقیماً به 🤗 هاب push می‌کند. محدودیت آن این است که فایل‌های بزرگ‌تر از ۵GB را مدیریت نمی‌کند. اگر فایل‌های شما بزرگ‌تر از ۵GB هستند، از دو روش دیگری که در ادامه توضیح داده می‌شوند استفاده کنید.
API را می‌توان به شکل زیر به کار برد:
```py
from huggingface_hub import upload_file
upload_file(
"<path_to_file>/config.json",
path_in_repo="config.json",
repo_id="<namespace>/dummy-model",
)
```
این کار فایل `config.json` موجود در `<path_to_file>` را با نام `config.json` در ریشه‌ی مخزن `dummy-model` بارگذاری می‌کند. آرگومان‌های مفید دیگر عبارت‌اند از:
- `token` برای جایگزین کردن توکِن ذخیره‌شده در cache با توکِنی که خودتان می‌دهید.
- `repo_type` برای بارگذاری در یک `dataset` یا `space` به‌جای مدل. مقادیر پذیرفته‌شده `"dataset"` و `"space"` هستند.
### کلاس `Repository`[[the-repository-class]]
کلاس `Repository` یک مخزن محلی را به روشی شبیه git مدیریت می‌کند. این کلاس بسیاری از دشواری‌های کار با git را انتزاع می‌کند تا همه‌ی قابلیت‌های موردنیاز ما را فراهم کند.
برای استفاده از این کلاس باید git و git-lfs نصب باشند؛ بنابراین پیش از شروع مطمئن شوید git-lfs را نصب کرده و راه‌اندازی کرده‌اید (دستورالعمل نصب را [اینجا](https://git-lfs.github.com/) ببینید).
برای شروع کار با مخزنی که همین حالا ایجاد کرده‌ایم، آن را با clone کردن مخزن راه دور در یک پوشه‌ی محلی مقداردهی اولیه می‌کنیم:
```py
from huggingface_hub import Repository
repo = Repository("<path_to_dummy_folder>", clone_from="<namespace>/dummy-model")
```
این کار پوشه‌ی `<path_to_dummy_folder>` را در شاخه‌ی کاری ما ایجاد می‌کند. این پوشه فقط فایل `.gitattributes` را دارد، چون هنگام ایجاد مخزن با `create_repo` تنها همین فایل ایجاد می‌شود.
از اینجا به بعد، می‌توانیم از چند متد سنتی git استفاده کنیم:
```py
repo.git_pull()
repo.git_add()
repo.git_commit()
repo.git_push()
repo.git_tag()
```
و متدهای دیگر! برای آشنایی با همه‌ی آن‌ها، پیشنهاد می‌کنیم مستندات `Repository` را [اینجا](https://github.com/huggingface/huggingface_hub/tree/main/src/huggingface_hub#advanced-programmatic-repository-management) ببینید.
در حال حاضر یک مدل و یک توکِنایزر داریم که می‌خواهیم آن‌ها را به هاب push کنیم. مخزن را با موفقیت clone کرده‌ایم، بنابراین اکنون می‌توانیم فایل‌ها را در آن مخزن ذخیره کنیم.
ابتدا مطمئن می‌شویم clone محلی ما با pull کردن آخرین تغییرات به‌روز است:
```py
repo.git_pull()
```
حالا فایل‌های مدل و توکِنایزر را ذخیره می‌کنیم:
```py
model.save_pretrained("<path_to_dummy_folder>")
tokenizer.save_pretrained("<path_to_dummy_folder>")
```
پوشه‌ی `<path_to_dummy_folder>` اکنون همه‌ی فایل‌های مدل و توکِنایزر را دارد. با پیروی از روند معمول git، فایل‌ها را به ناحیه‌ی stage اضافه می‌کنیم، commit می‌کنیم و به هاب push می‌کنیم:
```py
repo.git_add()
repo.git_commit("Add model and tokenizer files")
repo.git_push()
```
تبریک می‌گوییم! شما همین حالا نخستین فایل‌های خود را به هاب push کردید.
### روش مبتنی بر git[[the-git-based-approach]]
این روش بسیار پایه‌ایِ بارگذاری فایل‌هاست: مستقیماً از git و git-lfs استفاده می‌کنیم. بیشتر دشواری‌ها در روش‌های قبلی انتزاع شده‌اند، اما روش زیر چند نکته‌ی مهم دارد؛ بنابراین یک مورد کاربردی پیچیده‌تر را دنبال می‌کنیم.
برای استفاده از این کلاس باید git و git-lfs نصب باشند؛ بنابراین پیش از شروع مطمئن شوید [git-lfs](https://git-lfs.github.com/) را نصب و راه‌اندازی کرده‌اید.
ابتدا git-lfs را مقداردهی اولیه کنید:
```bash
git lfs install
```
```bash
Updated git hooks.
Git LFS initialized.
```
پس از آن، نخستین گام clone کردن مخزن مدل است:
```bash
git clone https://huggingface.co/<namespace>/<your-model-id>
```
نام کاربری من `lysandre` است و از نام مدل `dummy` استفاده کرده‌ام، بنابراین دستور من به شکل زیر خواهد بود:
```
git clone https://huggingface.co/lysandre/dummy
```
اکنون پوشه‌ای با نام *dummy* در شاخه‌ی کاری خود دارم. می‌توانم با `cd` وارد پوشه شوم و محتوای آن را ببینم:
```bash
cd dummy && ls
```
```bash
README.md
```
اگر مخزن را با روش `create_repo` از هاب هاگینگ‌فِیس ایجاد کرده باشید، این پوشه فقط فایل مخفی `.gitattributes` را خواهد داشت. اگر در بخش قبل با استفاده از رابط وب مخزن را ایجاد کرده باشید، همان‌طور که در تصویر زیر می‌بینید، پوشه باید یک فایل *README.md* در کنار فایل مخفی *.gitattributes* داشته باشد.
افزودن فایل‌های معمولی، مانند فایل پیکربندی، فایل واژگان یا تقریباً هر فایل کوچک‌تر از چند مگابایت، دقیقاً مانند هر سامانه‌ی مبتنی بر git انجام می‌شود. بااین‌حال، برای push کردن فایل‌های بزرگ‌تر به *huggingface.co*، باید آن‌ها را از طریق git-lfs ثبت کنید.
بیایید برای مدتی به پایتون برگردیم و مدل و توکِنایزری تولید کنیم که می‌خواهیم در مخزن ساختگی خود commit کنیم:
{#if fw === 'pt'}
```py
from transformers import AutoModelForMaskedLM, AutoTokenizer
checkpoint = "camembert-base"
model = AutoModelForMaskedLM.from_pretrained(checkpoint)
tokenizer = AutoTokenizer.from_pretrained(checkpoint)
# Do whatever with the model, train it, fine-tune it...
model.save_pretrained("<path_to_dummy_folder>")
tokenizer.save_pretrained("<path_to_dummy_folder>")
```
{:else}
```py
from transformers import TFAutoModelForMaskedLM, AutoTokenizer
checkpoint = "camembert-base"
model = TFAutoModelForMaskedLM.from_pretrained(checkpoint)
tokenizer = AutoTokenizer.from_pretrained(checkpoint)
# Do whatever with the model, train it, fine-tune it...
model.save_pretrained("<path_to_dummy_folder>")
tokenizer.save_pretrained("<path_to_dummy_folder>")
```
{/if}
حالا که چند مصنوع مدل و توکِنایزر را ذخیره کرده‌ایم، دوباره نگاهی به پوشه‌ی *dummy* می‌اندازیم:
```bash
ls
```
{#if fw === 'pt'}
```bash
config.json pytorch_model.bin README.md sentencepiece.bpe.model special_tokens_map.json tokenizer_config.json tokenizer.json
```
اگر اندازه‌ی فایل‌ها را بررسی کنید (برای مثال با `ls -lh`)، می‌بینید فایل state dict مدل (*pytorch_model.bin*) تنها مورد متفاوت است و اندازه‌ای بیش از ۴۰۰ مگابایت دارد.
{:else}
```bash
config.json README.md sentencepiece.bpe.model special_tokens_map.json tf_model.h5 tokenizer_config.json tokenizer.json
```
اگر اندازه‌ی فایل‌ها را بررسی کنید (برای مثال با `ls -lh`)، می‌بینید فایل state dict مدل (*t5_model.h5*) تنها مورد متفاوت است و اندازه‌ای بیش از ۴۰۰ مگابایت دارد.
{/if}
> [!TIP]
> ✏️ هنگام ایجاد مخزن از رابط وب، فایل *.gitattributes* به‌طور خودکار تنظیم می‌شود تا فایل‌هایی با پسوندهای خاص، مانند *.bin* و *.h5*، به‌عنوان فایل‌های بزرگ در نظر گرفته شوند؛ بنابراین git-lfs بدون نیاز به تنظیمات اضافی از طرف شما آن‌ها را ردیابی می‌کند.
اکنون می‌توانیم مانند مخزن‌های سنتی Git پیش برویم. با استفاده از دستور `git add` همه‌ی فایل‌ها را به محیط stage گیت اضافه می‌کنیم:
```bash
git add .
```
سپس می‌توانیم فایل‌هایی را که در حال حاضر stage شده‌اند ببینیم:
```bash
git status
```
{#if fw === 'pt'}
```bash
On branch main
Your branch is up to date with 'origin/main'.
Changes to be committed:
(use "git restore --staged <file>..." to unstage)
modified: .gitattributes
new file: config.json
new file: pytorch_model.bin
new file: sentencepiece.bpe.model
new file: special_tokens_map.json
new file: tokenizer.json
new file: tokenizer_config.json
```
{:else}
```bash
On branch main
Your branch is up to date with 'origin/main'.
Changes to be committed:
(use "git restore --staged <file>..." to unstage)
modified: .gitattributes
new file: config.json
new file: sentencepiece.bpe.model
new file: special_tokens_map.json
new file: tf_model.h5
new file: tokenizer.json
new file: tokenizer_config.json
```
{/if}
به همین شکل، می‌توانیم با استفاده از دستور `status` در git-lfs مطمئن شویم که git-lfs فایل‌های درست را ردیابی می‌کند:
```bash
git lfs status
```
{#if fw === 'pt'}
```bash
On branch main
Objects to be pushed to origin/main:
Objects to be committed:
config.json (Git: bc20ff2)
pytorch_model.bin (LFS: 35686c2)
sentencepiece.bpe.model (LFS: 988bc5a)
special_tokens_map.json (Git: cb23931)
tokenizer.json (Git: 851ff3e)
tokenizer_config.json (Git: f0f7783)
Objects not staged for commit:
```
می‌بینیم همه‌ی فایل‌ها handler نوع `Git` دارند، به‌جز *pytorch_model.bin* و *sentencepiece.bpe.model* که handler آن‌ها `LFS` است. عالی است!
{:else}
```bash
On branch main
Objects to be pushed to origin/main:
Objects to be committed:
config.json (Git: bc20ff2)
sentencepiece.bpe.model (LFS: 988bc5a)
special_tokens_map.json (Git: cb23931)
tf_model.h5 (LFS: 86fce29)
tokenizer.json (Git: 851ff3e)
tokenizer_config.json (Git: f0f7783)
Objects not staged for commit:
```
می‌بینیم همه‌ی فایل‌ها handler نوع `Git` دارند، به‌جز *t5_model.h5* که handler آن `LFS` است. عالی است!
{/if}
حالا آماده‌ایم مثل همیشه با مخزن‌های سنتی Git ادامه دهیم و فایل‌ها را commit کنیم:
```bash
git commit -m "First model version"
```
{#if fw === 'pt'}
```bash
[main b08aab1] First model version
7 files changed, 29027 insertions(+)
6 files changed, 36 insertions(+)
create mode 100644 config.json
create mode 100644 pytorch_model.bin
create mode 100644 sentencepiece.bpe.model
create mode 100644 special_tokens_map.json
create mode 100644 tokenizer.json
create mode 100644 tokenizer_config.json
```
{:else}
```bash
[main b08aab1] First model version
6 files changed, 36 insertions(+)
create mode 100644 config.json
create mode 100644 sentencepiece.bpe.model
create mode 100644 special_tokens_map.json
create mode 100644 tf_model.h5
create mode 100644 tokenizer.json
create mode 100644 tokenizer_config.json
```
{/if}
بسته به سرعت اتصال اینترنت و اندازه‌ی فایل‌ها، push کردن می‌تواند کمی زمان ببرد:
```bash
git push
```
```bash
Uploading LFS objects: 100% (1/1), 433 MB | 1.3 MB/s, done.
Enumerating objects: 11, done.
Counting objects: 100% (11/11), done.
Delta compression using up to 12 threads
Compressing objects: 100% (9/9), done.
Writing objects: 100% (9/9), 288.27 KiB | 6.27 MiB/s, done.
Total 9 (delta 1), reused 0 (delta 0), pack-reused 0
To https://huggingface.co/lysandre/dummy
891b41d..b08aab1 main -> main
```
{#if fw === 'pt'}
اگر پس از پایان کار نگاهی به مخزن مدل بیندازیم، همه‌ی فایل‌های تازه‌بارگذاری‌شده را می‌بینیم:
رابط کاربری به شما اجازه می‌دهد فایل‌ها و commitهای مدل را بررسی کنید و تفاوت ایجادشده در هر commit را ببینید:
{:else}
اگر پس از پایان کار نگاهی به مخزن مدل بیندازیم، همه‌ی فایل‌های تازه‌بارگذاری‌شده را می‌بینیم:
رابط کاربری به شما اجازه می‌دهد فایل‌ها و commitهای مدل را بررسی کنید و تفاوت ایجادشده در هر commit را ببینید:
{/if}

Xet Storage Details

Size:
32.5 kB
·
Xet hash:
6bca920016cdee4ccad7f87e7b18fc0f720836bb82fb19df5fdf0a46d10c3bef

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