repo_id
stringclasses 55
values | file_path
stringlengths 42
186
| content
stringlengths 1
333k
| __index_level_0__
int64 0
0
|
|---|---|---|---|
mavonic_private_repos/transformers/docs/source/en | mavonic_private_repos/transformers/docs/source/en/model_doc/roc_bert.md | <!--Copyright 2022 The HuggingFace Team. All rights reserved.
Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
the License. You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
specific language governing permissions and limitations under the License.
โ ๏ธ Note that this file is in Markdown but contain specific syntax for our doc-builder (similar to MDX) that may not be
rendered properly in your Markdown viewer.
-->
# RoCBert
## Overview
The RoCBert model was proposed in [RoCBert: Robust Chinese Bert with Multimodal Contrastive Pretraining](https://aclanthology.org/2022.acl-long.65.pdf) by HuiSu, WeiweiShi, XiaoyuShen, XiaoZhou, TuoJi, JiaruiFang, JieZhou.
It's a pretrained Chinese language model that is robust under various forms of adversarial attacks.
The abstract from the paper is the following:
*Large-scale pretrained language models have achieved SOTA results on NLP tasks. However, they have been shown
vulnerable to adversarial attacks especially for logographic languages like Chinese. In this work, we propose
ROCBERT: a pretrained Chinese Bert that is robust to various forms of adversarial attacks like word perturbation,
synonyms, typos, etc. It is pretrained with the contrastive learning objective which maximizes the label consistency
under different synthesized adversarial examples. The model takes as input multimodal information including the
semantic, phonetic and visual features. We show all these features are important to the model robustness since the
attack can be performed in all the three forms. Across 5 Chinese NLU tasks, ROCBERT outperforms strong baselines under
three blackbox adversarial algorithms without sacrificing the performance on clean testset. It also performs the best
in the toxic content detection task under human-made attacks.*
This model was contributed by [weiweishi](https://huggingface.co/weiweishi).
## Resources
- [Text classification task guide](../tasks/sequence_classification)
- [Token classification task guide](../tasks/token_classification)
- [Question answering task guide](../tasks/question_answering)
- [Causal language modeling task guide](../tasks/language_modeling)
- [Masked language modeling task guide](../tasks/masked_language_modeling)
- [Multiple choice task guide](../tasks/multiple_choice)
## RoCBertConfig
[[autodoc]] RoCBertConfig
- all
## RoCBertTokenizer
[[autodoc]] RoCBertTokenizer
- build_inputs_with_special_tokens
- get_special_tokens_mask
- create_token_type_ids_from_sequences
- save_vocabulary
## RoCBertModel
[[autodoc]] RoCBertModel
- forward
## RoCBertForPreTraining
[[autodoc]] RoCBertForPreTraining
- forward
## RoCBertForCausalLM
[[autodoc]] RoCBertForCausalLM
- forward
## RoCBertForMaskedLM
[[autodoc]] RoCBertForMaskedLM
- forward
## RoCBertForSequenceClassification
[[autodoc]] transformers.RoCBertForSequenceClassification
- forward
## RoCBertForMultipleChoice
[[autodoc]] transformers.RoCBertForMultipleChoice
- forward
## RoCBertForTokenClassification
[[autodoc]] transformers.RoCBertForTokenClassification
- forward
## RoCBertForQuestionAnswering
[[autodoc]] RoCBertForQuestionAnswering
- forward
| 0 |
mavonic_private_repos/transformers/docs/source/en | mavonic_private_repos/transformers/docs/source/en/model_doc/dinov2.md | <!--Copyright 2023 The HuggingFace Team. All rights reserved.
Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
the License. You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
specific language governing permissions and limitations under the License.
-->
# DINOv2
## Overview
The DINOv2 model was proposed in [DINOv2: Learning Robust Visual Features without Supervision](https://arxiv.org/abs/2304.07193) by
Maxime Oquab, Timothรฉe Darcet, Thรฉo Moutakanni, Huy Vo, Marc Szafraniec, Vasil Khalidov, Pierre Fernandez, Daniel Haziza, Francisco Massa, Alaaeldin El-Nouby, Mahmoud Assran, Nicolas Ballas, Wojciech Galuba, Russell Howes, Po-Yao Huang, Shang-Wen Li, Ishan Misra, Michael Rabbat, Vasu Sharma, Gabriel Synnaeve, Hu Xu, Hervรฉ Jegou, Julien Mairal, Patrick Labatut, Armand Joulin, Piotr Bojanowski.
DINOv2 is an upgrade of [DINO](https://arxiv.org/abs/2104.14294), a self-supervised method applied on [Vision Transformers](vit). This method enables all-purpose visual features, i.e., features that work across image distributions and tasks without finetuning.
The abstract from the paper is the following:
*The recent breakthroughs in natural language processing for model pretraining on large quantities of data have opened the way for similar foundation models in computer vision. These models could greatly simplify the use of images in any system by producing all-purpose visual features, i.e., features that work across image distributions and tasks without finetuning. This work shows that existing pretraining methods, especially self-supervised methods, can produce such features if trained on enough curated data from diverse sources. We revisit existing approaches and combine different techniques to scale our pretraining in terms of data and model size. Most of the technical contributions aim at accelerating and stabilizing the training at scale. In terms of data, we propose an automatic pipeline to build a dedicated, diverse, and curated image dataset instead of uncurated data, as typically done in the self-supervised literature. In terms of models, we train a ViT model (Dosovitskiy et al., 2020) with 1B parameters and distill it into a series of smaller models that surpass the best available all-purpose features, OpenCLIP (Ilharco et al., 2021) on most of the benchmarks at image and pixel levels.*
This model was contributed by [nielsr](https://huggingface.co/nielsr).
The original code can be found [here](https://github.com/facebookresearch/dinov2).
## Usage tips
The model can be traced using `torch.jit.trace` which leverages JIT compilation to optimize the model making it faster to run. Note this still produces some mis-matched elements and the difference between the original model and the traced model is of the order of 1e-4.
```python
import torch
from transformers import AutoImageProcessor, AutoModel
from PIL import Image
import requests
url = 'http://images.cocodataset.org/val2017/000000039769.jpg'
image = Image.open(requests.get(url, stream=True).raw)
processor = AutoImageProcessor.from_pretrained('facebook/dinov2-base')
model = AutoModel.from_pretrained('facebook/dinov2-base')
inputs = processor(images=image, return_tensors="pt")
outputs = model(**inputs)
last_hidden_states = outputs[0]
# We have to force return_dict=False for tracing
model.config.return_dict = False
with torch.no_grad():
traced_model = torch.jit.trace(model, [inputs.pixel_values])
traced_outputs = traced_model(inputs.pixel_values)
print((last_hidden_states - traced_outputs[0]).abs().max())
```
## Resources
A list of official Hugging Face and community (indicated by ๐) resources to help you get started with DPT.
- Demo notebooks for DINOv2 can be found [here](https://github.com/NielsRogge/Transformers-Tutorials/tree/master/DINOv2). ๐
<PipelineTag pipeline="image-classification"/>
- [`Dinov2ForImageClassification`] is supported by this [example script](https://github.com/huggingface/transformers/tree/main/examples/pytorch/image-classification) and [notebook](https://colab.research.google.com/github/huggingface/notebooks/blob/main/examples/image_classification.ipynb).
- See also: [Image classification task guide](../tasks/image_classification)
If you're interested in submitting a resource to be included here, please feel free to open a Pull Request and we'll review it! The resource should ideally demonstrate something new instead of duplicating an existing resource.
## Dinov2Config
[[autodoc]] Dinov2Config
## Dinov2Model
[[autodoc]] Dinov2Model
- forward
## Dinov2ForImageClassification
[[autodoc]] Dinov2ForImageClassification
- forward
| 0 |
mavonic_private_repos/transformers/docs/source/en | mavonic_private_repos/transformers/docs/source/en/model_doc/musicgen_melody.md | <!--Copyright 2024 The HuggingFace Team. All rights reserved.
Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
the License. You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
specific language governing permissions and limitations under the License.
:warning: Note that this file is in Markdown but contain specific syntax for our doc-builder (similar to MDX) that may not be
rendered properly in your Markdown viewer.
-->
# MusicGen Melody
## Overview
The MusicGen Melody model was proposed in [Simple and Controllable Music Generation](https://arxiv.org/abs/2306.05284) by Jade Copet, Felix Kreuk, Itai Gat, Tal Remez, David Kant, Gabriel Synnaeve, Yossi Adi and Alexandre Dรฉfossez.
MusicGen Melody is a single stage auto-regressive Transformer model capable of generating high-quality music samples conditioned on text descriptions or audio prompts. The text descriptions are passed through a frozen text encoder model to obtain a sequence of hidden-state representations. MusicGen is then trained to predict discrete audio tokens, or *audio codes*, conditioned on these hidden-states. These audio tokens are then decoded using an audio compression model, such as EnCodec, to recover the audio waveform.
Through an efficient token interleaving pattern, MusicGen does not require a self-supervised semantic representation of the text/audio prompts, thus eliminating the need to cascade multiple models to predict a set of codebooks (e.g. hierarchically or upsampling). Instead, it is able to generate all the codebooks in a single forward pass.
The abstract from the paper is the following:
*We tackle the task of conditional music generation. We introduce MusicGen, a single Language Model (LM) that operates over several streams of compressed discrete music representation, i.e., tokens. Unlike prior work, MusicGen is comprised of a single-stage transformer LM together with efficient token interleaving patterns, which eliminates the need for cascading several models, e.g., hierarchically or upsampling. Following this approach, we demonstrate how MusicGen can generate high-quality samples, while being conditioned on textual description or melodic features, allowing better controls over the generated output. We conduct extensive empirical evaluation, considering both automatic and human studies, showing the proposed approach is superior to the evaluated baselines on a standard text-to-music benchmark. Through ablation studies, we shed light over the importance of each of the components comprising MusicGen.*
This model was contributed by [ylacombe](https://huggingface.co/ylacombe). The original code can be found [here](https://github.com/facebookresearch/audiocraft). The pre-trained checkpoints can be found on the [Hugging Face Hub](https://huggingface.co/models?sort=downloads&search=facebook%2Fmusicgen).
## Difference with [MusicGen](https://huggingface.co/docs/transformers/main/en/model_doc/musicgen)
There are two key differences with MusicGen:
1. The audio prompt is used here as a conditional signal for the generated audio sample, whereas it's used for audio continuation in [MusicGen](https://huggingface.co/docs/transformers/main/en/model_doc/musicgen).
2. Conditional text and audio signals are concatenated to the decoder's hidden states instead of being used as a cross-attention signal, as in MusicGen.
## Generation
MusicGen Melody is compatible with two generation modes: greedy and sampling. In practice, sampling leads to significantly better results than greedy, thus we encourage sampling mode to be used where possible. Sampling is enabled by default, and can be explicitly specified by setting `do_sample=True` in the call to [`MusicgenMelodyForConditionalGeneration.generate`], or by overriding the model's generation config (see below).
Transformers supports both mono (1-channel) and stereo (2-channel) variants of MusicGen Melody. The mono channel versions generate a single set of codebooks. The stereo versions generate 2 sets of codebooks, 1 for each channel (left/right), and each set of codebooks is decoded independently through the audio compression model. The audio streams for each channel are combined to give the final stereo output.
#### Audio Conditional Generation
The model can generate an audio sample conditioned on a text and an audio prompt through use of the [`MusicgenMelodyProcessor`] to pre-process the inputs.
In the following examples, we load an audio file using the ๐ค Datasets library, which can be pip installed through the command below:
```
pip install --upgrade pip
pip install datasets[audio]
```
The audio file we are about to use is loaded as follows:
```python
>>> from datasets import load_dataset
>>> dataset = load_dataset("sanchit-gandhi/gtzan", split="train", streaming=True)
>>> sample = next(iter(dataset))["audio"]
```
The audio prompt should ideally be free of the low-frequency signals usually produced by instruments such as drums and bass. The [Demucs](https://github.com/adefossez/demucs/tree/main) model can be used to separate vocals and other signals from the drums and bass components.
If you wish to use Demucs, you first need to follow the installation steps [here](https://github.com/adefossez/demucs/tree/main?tab=readme-ov-file#for-musicians) before using the following snippet:
```python
from demucs import pretrained
from demucs.apply import apply_model
from demucs.audio import convert_audio
import torch
wav = torch.tensor(sample["array"]).to(torch.float32)
demucs = pretrained.get_model('htdemucs')
wav = convert_audio(wav[None], sample["sampling_rate"], demucs.samplerate, demucs.audio_channels)
wav = apply_model(demucs, wav[None])
```
You can then use the following snippet to generate music:
```python
>>> from transformers import AutoProcessor, MusicgenMelodyForConditionalGeneration
>>> processor = AutoProcessor.from_pretrained("facebook/musicgen-melody")
>>> model = MusicgenMelodyForConditionalGeneration.from_pretrained("facebook/musicgen-melody")
>>> inputs = processor(
... audio=wav,
... sampling_rate=demucs.samplerate,
... text=["80s blues track with groovy saxophone"],
... padding=True,
... return_tensors="pt",
... )
>>> audio_values = model.generate(**inputs, do_sample=True, guidance_scale=3, max_new_tokens=256)
```
You can also pass the audio signal directly without using Demucs, although the quality of the generation will probably be degraded:
```python
>>> from transformers import AutoProcessor, MusicgenMelodyForConditionalGeneration
>>> processor = AutoProcessor.from_pretrained("facebook/musicgen-melody")
>>> model = MusicgenMelodyForConditionalGeneration.from_pretrained("facebook/musicgen-melody")
>>> inputs = processor(
... audio=sample["array"],
... sampling_rate=sample["sampling_rate"],
... text=["80s blues track with groovy saxophone"],
... padding=True,
... return_tensors="pt",
... )
>>> audio_values = model.generate(**inputs, do_sample=True, guidance_scale=3, max_new_tokens=256)
```
The audio outputs are a three-dimensional Torch tensor of shape `(batch_size, num_channels, sequence_length)`. To listen to the generated audio samples, you can either play them in an ipynb notebook:
```python
from IPython.display import Audio
sampling_rate = model.config.audio_encoder.sampling_rate
Audio(audio_values[0].numpy(), rate=sampling_rate)
```
Or save them as a `.wav` file using a third-party library, e.g. `soundfile`:
```python
>>> import soundfile as sf
>>> sampling_rate = model.config.audio_encoder.sampling_rate
>>> sf.write("musicgen_out.wav", audio_values[0].T.numpy(), sampling_rate)
```
### Text-only Conditional Generation
The same [`MusicgenMelodyProcessor`] can be used to pre-process a text-only prompt.
```python
>>> from transformers import AutoProcessor, MusicgenMelodyForConditionalGeneration
>>> processor = AutoProcessor.from_pretrained("facebook/musicgen-melody")
>>> model = MusicgenMelodyForConditionalGeneration.from_pretrained("facebook/musicgen-melody")
>>> inputs = processor(
... text=["80s pop track with bassy drums and synth", "90s rock song with loud guitars and heavy drums"],
... padding=True,
... return_tensors="pt",
... )
>>> audio_values = model.generate(**inputs, do_sample=True, guidance_scale=3, max_new_tokens=256)
```
The `guidance_scale` is used in classifier free guidance (CFG), setting the weighting between the conditional logits (which are predicted from the text prompts) and the unconditional logits (which are predicted from an unconditional or 'null' prompt). Higher guidance scale encourages the model to generate samples that are more closely linked to the input prompt, usually at the expense of poorer audio quality. CFG is enabled by setting `guidance_scale > 1`. For best results, use `guidance_scale=3` (default).
You can also generate in batch:
```python
>>> from transformers import AutoProcessor, MusicgenMelodyForConditionalGeneration
>>> from datasets import load_dataset
>>> processor = AutoProcessor.from_pretrained("facebook/musicgen-melody")
>>> model = MusicgenMelodyForConditionalGeneration.from_pretrained("facebook/musicgen-melody")
>>> # take the first quarter of the audio sample
>>> sample_1 = sample["array"][: len(sample["array"]) // 4]
>>> # take the first half of the audio sample
>>> sample_2 = sample["array"][: len(sample["array"]) // 2]
>>> inputs = processor(
... audio=[sample_1, sample_2],
... sampling_rate=sample["sampling_rate"],
... text=["80s blues track with groovy saxophone", "90s rock song with loud guitars and heavy drums"],
... padding=True,
... return_tensors="pt",
... )
>>> audio_values = model.generate(**inputs, do_sample=True, guidance_scale=3, max_new_tokens=256)
```
### Unconditional Generation
The inputs for unconditional (or 'null') generation can be obtained through the method [`MusicgenMelodyProcessor.get_unconditional_inputs`]:
```python
>>> from transformers import MusicgenMelodyForConditionalGeneration, MusicgenMelodyProcessor
>>> model = MusicgenMelodyForConditionalGeneration.from_pretrained("facebook/musicgen-melody")
>>> unconditional_inputs = MusicgenMelodyProcessor.from_pretrained("facebook/musicgen-melody").get_unconditional_inputs(num_samples=1)
>>> audio_values = model.generate(**unconditional_inputs, do_sample=True, max_new_tokens=256)
```
### Generation Configuration
The default parameters that control the generation process, such as sampling, guidance scale and number of generated tokens, can be found in the model's generation config, and updated as desired:
```python
>>> from transformers import MusicgenMelodyForConditionalGeneration
>>> model = MusicgenMelodyForConditionalGeneration.from_pretrained("facebook/musicgen-melody")
>>> # inspect the default generation config
>>> model.generation_config
>>> # increase the guidance scale to 4.0
>>> model.generation_config.guidance_scale = 4.0
>>> # decrease the max length to 256 tokens
>>> model.generation_config.max_length = 256
```
Note that any arguments passed to the generate method will **supersede** those in the generation config, so setting `do_sample=False` in the call to generate will supersede the setting of `model.generation_config.do_sample` in the generation config.
## Model Structure
The MusicGen model can be de-composed into three distinct stages:
1. Text encoder: maps the text inputs to a sequence of hidden-state representations. The pre-trained MusicGen models use a frozen text encoder from either T5 or Flan-T5.
2. MusicGen Melody decoder: a language model (LM) that auto-regressively generates audio tokens (or codes) conditional on the encoder hidden-state representations
3. Audio decoder: used to recover the audio waveform from the audio tokens predicted by the decoder.
Thus, the MusicGen model can either be used as a standalone decoder model, corresponding to the class [`MusicgenMelodyForCausalLM`], or as a composite model that includes the text encoder and audio encoder, corresponding to the class [`MusicgenMelodyForConditionalGeneration`]. If only the decoder needs to be loaded from the pre-trained checkpoint, it can be loaded by first specifying the correct config, or be accessed through the `.decoder` attribute of the composite model:
```python
>>> from transformers import AutoConfig, MusicgenMelodyForCausalLM, MusicgenMelodyForConditionalGeneration
>>> # Option 1: get decoder config and pass to `.from_pretrained`
>>> decoder_config = AutoConfig.from_pretrained("facebook/musicgen-melody").decoder
>>> decoder = MusicgenMelodyForCausalLM.from_pretrained("facebook/musicgen-melody", **decoder_config.to_dict())
>>> # Option 2: load the entire composite model, but only return the decoder
>>> decoder = MusicgenMelodyForConditionalGeneration.from_pretrained("facebook/musicgen-melody").decoder
```
Since the text encoder and audio encoder models are frozen during training, the MusicGen decoder [`MusicgenMelodyForCausalLM`] can be trained standalone on a dataset of encoder hidden-states and audio codes. For inference, the trained decoder can be combined with the frozen text encoder and audio encoder to recover the composite [`MusicgenMelodyForConditionalGeneration`] model.
## Checkpoint Conversion
- After downloading the original checkpoints from [here](https://github.com/facebookresearch/audiocraft/blob/main/docs/MUSICGEN.md#importing--exporting-models), you can convert them using the **conversion script** available at `src/transformers/models/musicgen_melody/convert_musicgen_melody_transformers.py` with the following command:
```bash
python src/transformers/models/musicgen_melody/convert_musicgen_melody_transformers.py \
--checkpoint="facebook/musicgen-melody" --pytorch_dump_folder /output/path
```
Tips:
* MusicGen is trained on the 32kHz checkpoint of Encodec. You should ensure you use a compatible version of the Encodec model.
* Sampling mode tends to deliver better results than greedy - you can toggle sampling with the variable `do_sample` in the call to [`MusicgenMelodyForConditionalGeneration.generate`]
## MusicgenMelodyDecoderConfig
[[autodoc]] MusicgenMelodyDecoderConfig
## MusicgenMelodyProcessor
[[autodoc]] MusicgenMelodyProcessor
- get_unconditional_inputs
## MusicgenMelodyFeatureExtractor
[[autodoc]] MusicgenMelodyFeatureExtractor
- _extract_stem_indices
## MusicgenMelodyConfig
[[autodoc]] MusicgenMelodyConfig
## MusicgenMelodyModel
[[autodoc]] MusicgenMelodyModel
- forward
## MusicgenMelodyForCausalLM
[[autodoc]] MusicgenMelodyForCausalLM
- forward
## MusicgenMelodyForConditionalGeneration
[[autodoc]] MusicgenMelodyForConditionalGeneration
- forward | 0 |
mavonic_private_repos/transformers/docs/source/en | mavonic_private_repos/transformers/docs/source/en/model_doc/clipseg.md | <!--Copyright 2022 The HuggingFace Team. All rights reserved.
Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
the License. You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
specific language governing permissions and limitations under the License.
โ ๏ธ Note that this file is in Markdown but contain specific syntax for our doc-builder (similar to MDX) that may not be
rendered properly in your Markdown viewer.
-->
# CLIPSeg
## Overview
The CLIPSeg model was proposed in [Image Segmentation Using Text and Image Prompts](https://arxiv.org/abs/2112.10003) by Timo Lรผddecke
and Alexander Ecker. CLIPSeg adds a minimal decoder on top of a frozen [CLIP](clip) model for zero- and one-shot image segmentation.
The abstract from the paper is the following:
*Image segmentation is usually addressed by training a
model for a fixed set of object classes. Incorporating additional classes or more complex queries later is expensive
as it requires re-training the model on a dataset that encompasses these expressions. Here we propose a system
that can generate image segmentations based on arbitrary
prompts at test time. A prompt can be either a text or an
image. This approach enables us to create a unified model
(trained once) for three common segmentation tasks, which
come with distinct challenges: referring expression segmentation, zero-shot segmentation and one-shot segmentation.
We build upon the CLIP model as a backbone which we extend with a transformer-based decoder that enables dense
prediction. After training on an extended version of the
PhraseCut dataset, our system generates a binary segmentation map for an image based on a free-text prompt or on
an additional image expressing the query. We analyze different variants of the latter image-based prompts in detail.
This novel hybrid input allows for dynamic adaptation not
only to the three segmentation tasks mentioned above, but
to any binary segmentation task where a text or image query
can be formulated. Finally, we find our system to adapt well
to generalized queries involving affordances or properties*
<img src="https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/transformers/model_doc/clipseg_architecture.png"
alt="drawing" width="600"/>
<small> CLIPSeg overview. Taken from the <a href="https://arxiv.org/abs/2112.10003">original paper.</a> </small>
This model was contributed by [nielsr](https://huggingface.co/nielsr).
The original code can be found [here](https://github.com/timojl/clipseg).
## Usage tips
- [`CLIPSegForImageSegmentation`] adds a decoder on top of [`CLIPSegModel`]. The latter is identical to [`CLIPModel`].
- [`CLIPSegForImageSegmentation`] can generate image segmentations based on arbitrary prompts at test time. A prompt can be either a text
(provided to the model as `input_ids`) or an image (provided to the model as `conditional_pixel_values`). One can also provide custom
conditional embeddings (provided to the model as `conditional_embeddings`).
## Resources
A list of official Hugging Face and community (indicated by ๐) resources to help you get started with CLIPSeg. If you're interested in submitting a resource to be included here, please feel free to open a Pull Request and we'll review it! The resource should ideally demonstrate something new instead of duplicating an existing resource.
<PipelineTag pipeline="image-segmentation"/>
- A notebook that illustrates [zero-shot image segmentation with CLIPSeg](https://github.com/NielsRogge/Transformers-Tutorials/blob/master/CLIPSeg/Zero_shot_image_segmentation_with_CLIPSeg.ipynb).
## CLIPSegConfig
[[autodoc]] CLIPSegConfig
- from_text_vision_configs
## CLIPSegTextConfig
[[autodoc]] CLIPSegTextConfig
## CLIPSegVisionConfig
[[autodoc]] CLIPSegVisionConfig
## CLIPSegProcessor
[[autodoc]] CLIPSegProcessor
## CLIPSegModel
[[autodoc]] CLIPSegModel
- forward
- get_text_features
- get_image_features
## CLIPSegTextModel
[[autodoc]] CLIPSegTextModel
- forward
## CLIPSegVisionModel
[[autodoc]] CLIPSegVisionModel
- forward
## CLIPSegForImageSegmentation
[[autodoc]] CLIPSegForImageSegmentation
- forward | 0 |
mavonic_private_repos/transformers/docs/source/en | mavonic_private_repos/transformers/docs/source/en/model_doc/tapas.md | <!--Copyright 2020 The HuggingFace Team. All rights reserved.
Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
the License. You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
specific language governing permissions and limitations under the License.
โ ๏ธ Note that this file is in Markdown but contain specific syntax for our doc-builder (similar to MDX) that may not be
rendered properly in your Markdown viewer.
-->
# TAPAS
## Overview
The TAPAS model was proposed in [TAPAS: Weakly Supervised Table Parsing via Pre-training](https://www.aclweb.org/anthology/2020.acl-main.398)
by Jonathan Herzig, Paweล Krzysztof Nowak, Thomas Mรผller, Francesco Piccinno and Julian Martin Eisenschlos. It's a BERT-based model specifically
designed (and pre-trained) for answering questions about tabular data. Compared to BERT, TAPAS uses relative position embeddings and has 7
token types that encode tabular structure. TAPAS is pre-trained on the masked language modeling (MLM) objective on a large dataset comprising
millions of tables from English Wikipedia and corresponding texts.
For question answering, TAPAS has 2 heads on top: a cell selection head and an aggregation head, for (optionally) performing aggregations (such as counting or summing) among selected cells. TAPAS has been fine-tuned on several datasets:
- [SQA](https://www.microsoft.com/en-us/download/details.aspx?id=54253) (Sequential Question Answering by Microsoft)
- [WTQ](https://github.com/ppasupat/WikiTableQuestions) (Wiki Table Questions by Stanford University)
- [WikiSQL](https://github.com/salesforce/WikiSQL) (by Salesforce).
It achieves state-of-the-art on both SQA and WTQ, while having comparable performance to SOTA on WikiSQL, with a much simpler architecture.
The abstract from the paper is the following:
*Answering natural language questions over tables is usually seen as a semantic parsing task. To alleviate the collection cost of full logical forms, one popular approach focuses on weak supervision consisting of denotations instead of logical forms. However, training semantic parsers from weak supervision poses difficulties, and in addition, the generated logical forms are only used as an intermediate step prior to retrieving the denotation. In this paper, we present TAPAS, an approach to question answering over tables without generating logical forms. TAPAS trains from weak supervision, and predicts the denotation by selecting table cells and optionally applying a corresponding aggregation operator to such selection. TAPAS extends BERT's architecture to encode tables as input, initializes from an effective joint pre-training of text segments and tables crawled from Wikipedia, and is trained end-to-end. We experiment with three different semantic parsing datasets, and find that TAPAS outperforms or rivals semantic parsing models by improving state-of-the-art accuracy on SQA from 55.1 to 67.2 and performing on par with the state-of-the-art on WIKISQL and WIKITQ, but with a simpler model architecture. We additionally find that transfer learning, which is trivial in our setting, from WIKISQL to WIKITQ, yields 48.7 accuracy, 4.2 points above the state-of-the-art.*
In addition, the authors have further pre-trained TAPAS to recognize **table entailment**, by creating a balanced dataset of millions of automatically created training examples which are learned in an intermediate step prior to fine-tuning. The authors of TAPAS call this further pre-training intermediate pre-training (since TAPAS is first pre-trained on MLM, and then on another dataset). They found that intermediate pre-training further improves performance on SQA, achieving a new state-of-the-art as well as state-of-the-art on [TabFact](https://github.com/wenhuchen/Table-Fact-Checking), a large-scale dataset with 16k Wikipedia tables for table entailment (a binary classification task). For more details, see their follow-up paper: [Understanding tables with intermediate pre-training](https://www.aclweb.org/anthology/2020.findings-emnlp.27/) by Julian Martin Eisenschlos, Syrine Krichene and Thomas Mรผller.
<img src="https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/tapas_architecture.png"
alt="drawing" width="600"/>
<small> TAPAS architecture. Taken from the <a href="https://ai.googleblog.com/2020/04/using-neural-networks-to-find-answers.html">original blog post</a>.</small>
This model was contributed by [nielsr](https://huggingface.co/nielsr). The Tensorflow version of this model was contributed by [kamalkraj](https://huggingface.co/kamalkraj). The original code can be found [here](https://github.com/google-research/tapas).
## Usage tips
- TAPAS is a model that uses relative position embeddings by default (restarting the position embeddings at every cell of the table). Note that this is something that was added after the publication of the original TAPAS paper. According to the authors, this usually results in a slightly better performance, and allows you to encode longer sequences without running out of embeddings. This is reflected in the `reset_position_index_per_cell` parameter of [`TapasConfig`], which is set to `True` by default. The default versions of the models available on the [hub](https://huggingface.co/models?search=tapas) all use relative position embeddings. You can still use the ones with absolute position embeddings by passing in an additional argument `revision="no_reset"` when calling the `from_pretrained()` method. Note that it's usually advised to pad the inputs on the right rather than the left.
- TAPAS is based on BERT, so `TAPAS-base` for example corresponds to a `BERT-base` architecture. Of course, `TAPAS-large` will result in the best performance (the results reported in the paper are from `TAPAS-large`). Results of the various sized models are shown on the [original GitHub repository](https://github.com/google-research/tapas).
- TAPAS has checkpoints fine-tuned on SQA, which are capable of answering questions related to a table in a conversational set-up. This means that you can ask follow-up questions such as "what is his age?" related to the previous question. Note that the forward pass of TAPAS is a bit different in case of a conversational set-up: in that case, you have to feed every table-question pair one by one to the model, such that the `prev_labels` token type ids can be overwritten by the predicted `labels` of the model to the previous question. See "Usage" section for more info.
- TAPAS is similar to BERT and therefore relies on the masked language modeling (MLM) objective. It is therefore efficient at predicting masked tokens and at NLU in general, but is not optimal for text generation. Models trained with a causal language modeling (CLM) objective are better in that regard. Note that TAPAS can be used as an encoder in the EncoderDecoderModel framework, to combine it with an autoregressive text decoder such as GPT-2.
## Usage: fine-tuning
Here we explain how you can fine-tune [`TapasForQuestionAnswering`] on your own dataset.
**STEP 1: Choose one of the 3 ways in which you can use TAPAS - or experiment**
Basically, there are 3 different ways in which one can fine-tune [`TapasForQuestionAnswering`], corresponding to the different datasets on which Tapas was fine-tuned:
1. SQA: if you're interested in asking follow-up questions related to a table, in a conversational set-up. For example if you first ask "what's the name of the first actor?" then you can ask a follow-up question such as "how old is he?". Here, questions do not involve any aggregation (all questions are cell selection questions).
2. WTQ: if you're not interested in asking questions in a conversational set-up, but rather just asking questions related to a table, which might involve aggregation, such as counting a number of rows, summing up cell values or averaging cell values. You can then for example ask "what's the total number of goals Cristiano Ronaldo made in his career?". This case is also called **weak supervision**, since the model itself must learn the appropriate aggregation operator (SUM/COUNT/AVERAGE/NONE) given only the answer to the question as supervision.
3. WikiSQL-supervised: this dataset is based on WikiSQL with the model being given the ground truth aggregation operator during training. This is also called **strong supervision**. Here, learning the appropriate aggregation operator is much easier.
To summarize:
| **Task** | **Example dataset** | **Description** |
|-------------------------------------|---------------------|---------------------------------------------------------------------------------------------------------|
| Conversational | SQA | Conversational, only cell selection questions |
| Weak supervision for aggregation | WTQ | Questions might involve aggregation, and the model must learn this given only the answer as supervision |
| Strong supervision for aggregation | WikiSQL-supervised | Questions might involve aggregation, and the model must learn this given the gold aggregation operator |
<frameworkcontent>
<pt>
Initializing a model with a pre-trained base and randomly initialized classification heads from the hub can be done as shown below.
```py
>>> from transformers import TapasConfig, TapasForQuestionAnswering
>>> # for example, the base sized model with default SQA configuration
>>> model = TapasForQuestionAnswering.from_pretrained("google/tapas-base")
>>> # or, the base sized model with WTQ configuration
>>> config = TapasConfig.from_pretrained("google/tapas-base-finetuned-wtq")
>>> model = TapasForQuestionAnswering.from_pretrained("google/tapas-base", config=config)
>>> # or, the base sized model with WikiSQL configuration
>>> config = TapasConfig("google-base-finetuned-wikisql-supervised")
>>> model = TapasForQuestionAnswering.from_pretrained("google/tapas-base", config=config)
```
Of course, you don't necessarily have to follow one of these three ways in which TAPAS was fine-tuned. You can also experiment by defining any hyperparameters you want when initializing [`TapasConfig`], and then create a [`TapasForQuestionAnswering`] based on that configuration. For example, if you have a dataset that has both conversational questions and questions that might involve aggregation, then you can do it this way. Here's an example:
```py
>>> from transformers import TapasConfig, TapasForQuestionAnswering
>>> # you can initialize the classification heads any way you want (see docs of TapasConfig)
>>> config = TapasConfig(num_aggregation_labels=3, average_logits_per_cell=True)
>>> # initializing the pre-trained base sized model with our custom classification heads
>>> model = TapasForQuestionAnswering.from_pretrained("google/tapas-base", config=config)
```
</pt>
<tf>
Initializing a model with a pre-trained base and randomly initialized classification heads from the hub can be done as shown below. Be sure to have installed the [tensorflow_probability](https://github.com/tensorflow/probability) dependency:
```py
>>> from transformers import TapasConfig, TFTapasForQuestionAnswering
>>> # for example, the base sized model with default SQA configuration
>>> model = TFTapasForQuestionAnswering.from_pretrained("google/tapas-base")
>>> # or, the base sized model with WTQ configuration
>>> config = TapasConfig.from_pretrained("google/tapas-base-finetuned-wtq")
>>> model = TFTapasForQuestionAnswering.from_pretrained("google/tapas-base", config=config)
>>> # or, the base sized model with WikiSQL configuration
>>> config = TapasConfig("google-base-finetuned-wikisql-supervised")
>>> model = TFTapasForQuestionAnswering.from_pretrained("google/tapas-base", config=config)
```
Of course, you don't necessarily have to follow one of these three ways in which TAPAS was fine-tuned. You can also experiment by defining any hyperparameters you want when initializing [`TapasConfig`], and then create a [`TFTapasForQuestionAnswering`] based on that configuration. For example, if you have a dataset that has both conversational questions and questions that might involve aggregation, then you can do it this way. Here's an example:
```py
>>> from transformers import TapasConfig, TFTapasForQuestionAnswering
>>> # you can initialize the classification heads any way you want (see docs of TapasConfig)
>>> config = TapasConfig(num_aggregation_labels=3, average_logits_per_cell=True)
>>> # initializing the pre-trained base sized model with our custom classification heads
>>> model = TFTapasForQuestionAnswering.from_pretrained("google/tapas-base", config=config)
```
</tf>
</frameworkcontent>
What you can also do is start from an already fine-tuned checkpoint. A note here is that the already fine-tuned checkpoint on WTQ has some issues due to the L2-loss which is somewhat brittle. See [here](https://github.com/google-research/tapas/issues/91#issuecomment-735719340) for more info.
For a list of all pre-trained and fine-tuned TAPAS checkpoints available on HuggingFace's hub, see [here](https://huggingface.co/models?search=tapas).
**STEP 2: Prepare your data in the SQA format**
Second, no matter what you picked above, you should prepare your dataset in the [SQA](https://www.microsoft.com/en-us/download/details.aspx?id=54253) format. This format is a TSV/CSV file with the following columns:
- `id`: optional, id of the table-question pair, for bookkeeping purposes.
- `annotator`: optional, id of the person who annotated the table-question pair, for bookkeeping purposes.
- `position`: integer indicating if the question is the first, second, third,... related to the table. Only required in case of conversational setup (SQA). You don't need this column in case you're going for WTQ/WikiSQL-supervised.
- `question`: string
- `table_file`: string, name of a csv file containing the tabular data
- `answer_coordinates`: list of one or more tuples (each tuple being a cell coordinate, i.e. row, column pair that is part of the answer)
- `answer_text`: list of one or more strings (each string being a cell value that is part of the answer)
- `aggregation_label`: index of the aggregation operator. Only required in case of strong supervision for aggregation (the WikiSQL-supervised case)
- `float_answer`: the float answer to the question, if there is one (np.nan if there isn't). Only required in case of weak supervision for aggregation (such as WTQ and WikiSQL)
The tables themselves should be present in a folder, each table being a separate csv file. Note that the authors of the TAPAS algorithm used conversion scripts with some automated logic to convert the other datasets (WTQ, WikiSQL) into the SQA format. The author explains this [here](https://github.com/google-research/tapas/issues/50#issuecomment-705465960). A conversion of this script that works with HuggingFace's implementation can be found [here](https://github.com/NielsRogge/tapas_utils). Interestingly, these conversion scripts are not perfect (the `answer_coordinates` and `float_answer` fields are populated based on the `answer_text`), meaning that WTQ and WikiSQL results could actually be improved.
**STEP 3: Convert your data into tensors using TapasTokenizer**
<frameworkcontent>
<pt>
Third, given that you've prepared your data in this TSV/CSV format (and corresponding CSV files containing the tabular data), you can then use [`TapasTokenizer`] to convert table-question pairs into `input_ids`, `attention_mask`, `token_type_ids` and so on. Again, based on which of the three cases you picked above, [`TapasForQuestionAnswering`] requires different
inputs to be fine-tuned:
| **Task** | **Required inputs** |
|------------------------------------|---------------------------------------------------------------------------------------------------------------------|
| Conversational | `input_ids`, `attention_mask`, `token_type_ids`, `labels` |
| Weak supervision for aggregation | `input_ids`, `attention_mask`, `token_type_ids`, `labels`, `numeric_values`, `numeric_values_scale`, `float_answer` |
| Strong supervision for aggregation | `input ids`, `attention mask`, `token type ids`, `labels`, `aggregation_labels` |
[`TapasTokenizer`] creates the `labels`, `numeric_values` and `numeric_values_scale` based on the `answer_coordinates` and `answer_text` columns of the TSV file. The `float_answer` and `aggregation_labels` are already in the TSV file of step 2. Here's an example:
```py
>>> from transformers import TapasTokenizer
>>> import pandas as pd
>>> model_name = "google/tapas-base"
>>> tokenizer = TapasTokenizer.from_pretrained(model_name)
>>> data = {"Actors": ["Brad Pitt", "Leonardo Di Caprio", "George Clooney"], "Number of movies": ["87", "53", "69"]}
>>> queries = [
... "What is the name of the first actor?",
... "How many movies has George Clooney played in?",
... "What is the total number of movies?",
... ]
>>> answer_coordinates = [[(0, 0)], [(2, 1)], [(0, 1), (1, 1), (2, 1)]]
>>> answer_text = [["Brad Pitt"], ["69"], ["209"]]
>>> table = pd.DataFrame.from_dict(data)
>>> inputs = tokenizer(
... table=table,
... queries=queries,
... answer_coordinates=answer_coordinates,
... answer_text=answer_text,
... padding="max_length",
... return_tensors="pt",
... )
>>> inputs
{'input_ids': tensor([[ ... ]]), 'attention_mask': tensor([[...]]), 'token_type_ids': tensor([[[...]]]),
'numeric_values': tensor([[ ... ]]), 'numeric_values_scale: tensor([[ ... ]]), labels: tensor([[ ... ]])}
```
Note that [`TapasTokenizer`] expects the data of the table to be **text-only**. You can use `.astype(str)` on a dataframe to turn it into text-only data.
Of course, this only shows how to encode a single training example. It is advised to create a dataloader to iterate over batches:
```py
>>> import torch
>>> import pandas as pd
>>> tsv_path = "your_path_to_the_tsv_file"
>>> table_csv_path = "your_path_to_a_directory_containing_all_csv_files"
>>> class TableDataset(torch.utils.data.Dataset):
... def __init__(self, data, tokenizer):
... self.data = data
... self.tokenizer = tokenizer
... def __getitem__(self, idx):
... item = data.iloc[idx]
... table = pd.read_csv(table_csv_path + item.table_file).astype(
... str
... ) # be sure to make your table data text only
... encoding = self.tokenizer(
... table=table,
... queries=item.question,
... answer_coordinates=item.answer_coordinates,
... answer_text=item.answer_text,
... truncation=True,
... padding="max_length",
... return_tensors="pt",
... )
... # remove the batch dimension which the tokenizer adds by default
... encoding = {key: val.squeeze(0) for key, val in encoding.items()}
... # add the float_answer which is also required (weak supervision for aggregation case)
... encoding["float_answer"] = torch.tensor(item.float_answer)
... return encoding
... def __len__(self):
... return len(self.data)
>>> data = pd.read_csv(tsv_path, sep="\t")
>>> train_dataset = TableDataset(data, tokenizer)
>>> train_dataloader = torch.utils.data.DataLoader(train_dataset, batch_size=32)
```
</pt>
<tf>
Third, given that you've prepared your data in this TSV/CSV format (and corresponding CSV files containing the tabular data), you can then use [`TapasTokenizer`] to convert table-question pairs into `input_ids`, `attention_mask`, `token_type_ids` and so on. Again, based on which of the three cases you picked above, [`TFTapasForQuestionAnswering`] requires different
inputs to be fine-tuned:
| **Task** | **Required inputs** |
|------------------------------------|---------------------------------------------------------------------------------------------------------------------|
| Conversational | `input_ids`, `attention_mask`, `token_type_ids`, `labels` |
| Weak supervision for aggregation | `input_ids`, `attention_mask`, `token_type_ids`, `labels`, `numeric_values`, `numeric_values_scale`, `float_answer` |
| Strong supervision for aggregation | `input ids`, `attention mask`, `token type ids`, `labels`, `aggregation_labels` |
[`TapasTokenizer`] creates the `labels`, `numeric_values` and `numeric_values_scale` based on the `answer_coordinates` and `answer_text` columns of the TSV file. The `float_answer` and `aggregation_labels` are already in the TSV file of step 2. Here's an example:
```py
>>> from transformers import TapasTokenizer
>>> import pandas as pd
>>> model_name = "google/tapas-base"
>>> tokenizer = TapasTokenizer.from_pretrained(model_name)
>>> data = {"Actors": ["Brad Pitt", "Leonardo Di Caprio", "George Clooney"], "Number of movies": ["87", "53", "69"]}
>>> queries = [
... "What is the name of the first actor?",
... "How many movies has George Clooney played in?",
... "What is the total number of movies?",
... ]
>>> answer_coordinates = [[(0, 0)], [(2, 1)], [(0, 1), (1, 1), (2, 1)]]
>>> answer_text = [["Brad Pitt"], ["69"], ["209"]]
>>> table = pd.DataFrame.from_dict(data)
>>> inputs = tokenizer(
... table=table,
... queries=queries,
... answer_coordinates=answer_coordinates,
... answer_text=answer_text,
... padding="max_length",
... return_tensors="tf",
... )
>>> inputs
{'input_ids': tensor([[ ... ]]), 'attention_mask': tensor([[...]]), 'token_type_ids': tensor([[[...]]]),
'numeric_values': tensor([[ ... ]]), 'numeric_values_scale: tensor([[ ... ]]), labels: tensor([[ ... ]])}
```
Note that [`TapasTokenizer`] expects the data of the table to be **text-only**. You can use `.astype(str)` on a dataframe to turn it into text-only data.
Of course, this only shows how to encode a single training example. It is advised to create a dataloader to iterate over batches:
```py
>>> import tensorflow as tf
>>> import pandas as pd
>>> tsv_path = "your_path_to_the_tsv_file"
>>> table_csv_path = "your_path_to_a_directory_containing_all_csv_files"
>>> class TableDataset:
... def __init__(self, data, tokenizer):
... self.data = data
... self.tokenizer = tokenizer
... def __iter__(self):
... for idx in range(self.__len__()):
... item = self.data.iloc[idx]
... table = pd.read_csv(table_csv_path + item.table_file).astype(
... str
... ) # be sure to make your table data text only
... encoding = self.tokenizer(
... table=table,
... queries=item.question,
... answer_coordinates=item.answer_coordinates,
... answer_text=item.answer_text,
... truncation=True,
... padding="max_length",
... return_tensors="tf",
... )
... # remove the batch dimension which the tokenizer adds by default
... encoding = {key: tf.squeeze(val, 0) for key, val in encoding.items()}
... # add the float_answer which is also required (weak supervision for aggregation case)
... encoding["float_answer"] = tf.convert_to_tensor(item.float_answer, dtype=tf.float32)
... yield encoding["input_ids"], encoding["attention_mask"], encoding["numeric_values"], encoding[
... "numeric_values_scale"
... ], encoding["token_type_ids"], encoding["labels"], encoding["float_answer"]
... def __len__(self):
... return len(self.data)
>>> data = pd.read_csv(tsv_path, sep="\t")
>>> train_dataset = TableDataset(data, tokenizer)
>>> output_signature = (
... tf.TensorSpec(shape=(512,), dtype=tf.int32),
... tf.TensorSpec(shape=(512,), dtype=tf.int32),
... tf.TensorSpec(shape=(512,), dtype=tf.float32),
... tf.TensorSpec(shape=(512,), dtype=tf.float32),
... tf.TensorSpec(shape=(512, 7), dtype=tf.int32),
... tf.TensorSpec(shape=(512,), dtype=tf.int32),
... tf.TensorSpec(shape=(512,), dtype=tf.float32),
... )
>>> train_dataloader = tf.data.Dataset.from_generator(train_dataset, output_signature=output_signature).batch(32)
```
</tf>
</frameworkcontent>
Note that here, we encode each table-question pair independently. This is fine as long as your dataset is **not conversational**. In case your dataset involves conversational questions (such as in SQA), then you should first group together the `queries`, `answer_coordinates` and `answer_text` per table (in the order of their `position`
index) and batch encode each table with its questions. This will make sure that the `prev_labels` token types (see docs of [`TapasTokenizer`]) are set correctly. See [this notebook](https://github.com/NielsRogge/Transformers-Tutorials/blob/master/TAPAS/Fine_tuning_TapasForQuestionAnswering_on_SQA.ipynb) for more info. See [this notebook](https://github.com/kamalkraj/Tapas-Tutorial/blob/master/TAPAS/Fine_tuning_TapasForQuestionAnswering_on_SQA.ipynb) for more info regarding using the TensorFlow model.
**STEP 4: Train (fine-tune) the model
<frameworkcontent>
<pt>
You can then fine-tune [`TapasForQuestionAnswering`] as follows (shown here for the weak supervision for aggregation case):
```py
>>> from transformers import TapasConfig, TapasForQuestionAnswering, AdamW
>>> # this is the default WTQ configuration
>>> config = TapasConfig(
... num_aggregation_labels=4,
... use_answer_as_supervision=True,
... answer_loss_cutoff=0.664694,
... cell_selection_preference=0.207951,
... huber_loss_delta=0.121194,
... init_cell_selection_weights_to_zero=True,
... select_one_column=True,
... allow_empty_column_selection=False,
... temperature=0.0352513,
... )
>>> model = TapasForQuestionAnswering.from_pretrained("google/tapas-base", config=config)
>>> optimizer = AdamW(model.parameters(), lr=5e-5)
>>> model.train()
>>> for epoch in range(2): # loop over the dataset multiple times
... for batch in train_dataloader:
... # get the inputs;
... input_ids = batch["input_ids"]
... attention_mask = batch["attention_mask"]
... token_type_ids = batch["token_type_ids"]
... labels = batch["labels"]
... numeric_values = batch["numeric_values"]
... numeric_values_scale = batch["numeric_values_scale"]
... float_answer = batch["float_answer"]
... # zero the parameter gradients
... optimizer.zero_grad()
... # forward + backward + optimize
... outputs = model(
... input_ids=input_ids,
... attention_mask=attention_mask,
... token_type_ids=token_type_ids,
... labels=labels,
... numeric_values=numeric_values,
... numeric_values_scale=numeric_values_scale,
... float_answer=float_answer,
... )
... loss = outputs.loss
... loss.backward()
... optimizer.step()
```
</pt>
<tf>
You can then fine-tune [`TFTapasForQuestionAnswering`] as follows (shown here for the weak supervision for aggregation case):
```py
>>> import tensorflow as tf
>>> from transformers import TapasConfig, TFTapasForQuestionAnswering
>>> # this is the default WTQ configuration
>>> config = TapasConfig(
... num_aggregation_labels=4,
... use_answer_as_supervision=True,
... answer_loss_cutoff=0.664694,
... cell_selection_preference=0.207951,
... huber_loss_delta=0.121194,
... init_cell_selection_weights_to_zero=True,
... select_one_column=True,
... allow_empty_column_selection=False,
... temperature=0.0352513,
... )
>>> model = TFTapasForQuestionAnswering.from_pretrained("google/tapas-base", config=config)
>>> optimizer = tf.keras.optimizers.Adam(learning_rate=5e-5)
>>> for epoch in range(2): # loop over the dataset multiple times
... for batch in train_dataloader:
... # get the inputs;
... input_ids = batch[0]
... attention_mask = batch[1]
... token_type_ids = batch[4]
... labels = batch[-1]
... numeric_values = batch[2]
... numeric_values_scale = batch[3]
... float_answer = batch[6]
... # forward + backward + optimize
... with tf.GradientTape() as tape:
... outputs = model(
... input_ids=input_ids,
... attention_mask=attention_mask,
... token_type_ids=token_type_ids,
... labels=labels,
... numeric_values=numeric_values,
... numeric_values_scale=numeric_values_scale,
... float_answer=float_answer,
... )
... grads = tape.gradient(outputs.loss, model.trainable_weights)
... optimizer.apply_gradients(zip(grads, model.trainable_weights))
```
</tf>
</frameworkcontent>
## Usage: inference
<frameworkcontent>
<pt>
Here we explain how you can use [`TapasForQuestionAnswering`] or [`TFTapasForQuestionAnswering`] for inference (i.e. making predictions on new data). For inference, only `input_ids`, `attention_mask` and `token_type_ids` (which you can obtain using [`TapasTokenizer`]) have to be provided to the model to obtain the logits. Next, you can use the handy [`~models.tapas.tokenization_tapas.convert_logits_to_predictions`] method to convert these into predicted coordinates and optional aggregation indices.
However, note that inference is **different** depending on whether or not the setup is conversational. In a non-conversational set-up, inference can be done in parallel on all table-question pairs of a batch. Here's an example of that:
```py
>>> from transformers import TapasTokenizer, TapasForQuestionAnswering
>>> import pandas as pd
>>> model_name = "google/tapas-base-finetuned-wtq"
>>> model = TapasForQuestionAnswering.from_pretrained(model_name)
>>> tokenizer = TapasTokenizer.from_pretrained(model_name)
>>> data = {"Actors": ["Brad Pitt", "Leonardo Di Caprio", "George Clooney"], "Number of movies": ["87", "53", "69"]}
>>> queries = [
... "What is the name of the first actor?",
... "How many movies has George Clooney played in?",
... "What is the total number of movies?",
... ]
>>> table = pd.DataFrame.from_dict(data)
>>> inputs = tokenizer(table=table, queries=queries, padding="max_length", return_tensors="pt")
>>> outputs = model(**inputs)
>>> predicted_answer_coordinates, predicted_aggregation_indices = tokenizer.convert_logits_to_predictions(
... inputs, outputs.logits.detach(), outputs.logits_aggregation.detach()
... )
>>> # let's print out the results:
>>> id2aggregation = {0: "NONE", 1: "SUM", 2: "AVERAGE", 3: "COUNT"}
>>> aggregation_predictions_string = [id2aggregation[x] for x in predicted_aggregation_indices]
>>> answers = []
>>> for coordinates in predicted_answer_coordinates:
... if len(coordinates) == 1:
... # only a single cell:
... answers.append(table.iat[coordinates[0]])
... else:
... # multiple cells
... cell_values = []
... for coordinate in coordinates:
... cell_values.append(table.iat[coordinate])
... answers.append(", ".join(cell_values))
>>> display(table)
>>> print("")
>>> for query, answer, predicted_agg in zip(queries, answers, aggregation_predictions_string):
... print(query)
... if predicted_agg == "NONE":
... print("Predicted answer: " + answer)
... else:
... print("Predicted answer: " + predicted_agg + " > " + answer)
What is the name of the first actor?
Predicted answer: Brad Pitt
How many movies has George Clooney played in?
Predicted answer: COUNT > 69
What is the total number of movies?
Predicted answer: SUM > 87, 53, 69
```
</pt>
<tf>
Here we explain how you can use [`TFTapasForQuestionAnswering`] for inference (i.e. making predictions on new data). For inference, only `input_ids`, `attention_mask` and `token_type_ids` (which you can obtain using [`TapasTokenizer`]) have to be provided to the model to obtain the logits. Next, you can use the handy [`~models.tapas.tokenization_tapas.convert_logits_to_predictions`] method to convert these into predicted coordinates and optional aggregation indices.
However, note that inference is **different** depending on whether or not the setup is conversational. In a non-conversational set-up, inference can be done in parallel on all table-question pairs of a batch. Here's an example of that:
```py
>>> from transformers import TapasTokenizer, TFTapasForQuestionAnswering
>>> import pandas as pd
>>> model_name = "google/tapas-base-finetuned-wtq"
>>> model = TFTapasForQuestionAnswering.from_pretrained(model_name)
>>> tokenizer = TapasTokenizer.from_pretrained(model_name)
>>> data = {"Actors": ["Brad Pitt", "Leonardo Di Caprio", "George Clooney"], "Number of movies": ["87", "53", "69"]}
>>> queries = [
... "What is the name of the first actor?",
... "How many movies has George Clooney played in?",
... "What is the total number of movies?",
... ]
>>> table = pd.DataFrame.from_dict(data)
>>> inputs = tokenizer(table=table, queries=queries, padding="max_length", return_tensors="tf")
>>> outputs = model(**inputs)
>>> predicted_answer_coordinates, predicted_aggregation_indices = tokenizer.convert_logits_to_predictions(
... inputs, outputs.logits, outputs.logits_aggregation
... )
>>> # let's print out the results:
>>> id2aggregation = {0: "NONE", 1: "SUM", 2: "AVERAGE", 3: "COUNT"}
>>> aggregation_predictions_string = [id2aggregation[x] for x in predicted_aggregation_indices]
>>> answers = []
>>> for coordinates in predicted_answer_coordinates:
... if len(coordinates) == 1:
... # only a single cell:
... answers.append(table.iat[coordinates[0]])
... else:
... # multiple cells
... cell_values = []
... for coordinate in coordinates:
... cell_values.append(table.iat[coordinate])
... answers.append(", ".join(cell_values))
>>> display(table)
>>> print("")
>>> for query, answer, predicted_agg in zip(queries, answers, aggregation_predictions_string):
... print(query)
... if predicted_agg == "NONE":
... print("Predicted answer: " + answer)
... else:
... print("Predicted answer: " + predicted_agg + " > " + answer)
What is the name of the first actor?
Predicted answer: Brad Pitt
How many movies has George Clooney played in?
Predicted answer: COUNT > 69
What is the total number of movies?
Predicted answer: SUM > 87, 53, 69
```
</tf>
</frameworkcontent>
In case of a conversational set-up, then each table-question pair must be provided **sequentially** to the model, such that the `prev_labels` token types can be overwritten by the predicted `labels` of the previous table-question pair. Again, more info can be found in [this notebook](https://github.com/NielsRogge/Transformers-Tutorials/blob/master/TAPAS/Fine_tuning_TapasForQuestionAnswering_on_SQA.ipynb) (for PyTorch) and [this notebook](https://github.com/kamalkraj/Tapas-Tutorial/blob/master/TAPAS/Fine_tuning_TapasForQuestionAnswering_on_SQA.ipynb) (for TensorFlow).
## Resources
- [Text classification task guide](../tasks/sequence_classification)
- [Masked language modeling task guide](../tasks/masked_language_modeling)
## TAPAS specific outputs
[[autodoc]] models.tapas.modeling_tapas.TableQuestionAnsweringOutput
## TapasConfig
[[autodoc]] TapasConfig
## TapasTokenizer
[[autodoc]] TapasTokenizer
- __call__
- convert_logits_to_predictions
- save_vocabulary
<frameworkcontent>
<pt>
## TapasModel
[[autodoc]] TapasModel
- forward
## TapasForMaskedLM
[[autodoc]] TapasForMaskedLM
- forward
## TapasForSequenceClassification
[[autodoc]] TapasForSequenceClassification
- forward
## TapasForQuestionAnswering
[[autodoc]] TapasForQuestionAnswering
- forward
</pt>
<tf>
## TFTapasModel
[[autodoc]] TFTapasModel
- call
## TFTapasForMaskedLM
[[autodoc]] TFTapasForMaskedLM
- call
## TFTapasForSequenceClassification
[[autodoc]] TFTapasForSequenceClassification
- call
## TFTapasForQuestionAnswering
[[autodoc]] TFTapasForQuestionAnswering
- call
</tf>
</frameworkcontent>
| 0 |
mavonic_private_repos/transformers/docs/source/en | mavonic_private_repos/transformers/docs/source/en/model_doc/van.md | <!--Copyright 2022 The HuggingFace Team. All rights reserved.
Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
the License. You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
specific language governing permissions and limitations under the License.
โ ๏ธ Note that this file is in Markdown but contain specific syntax for our doc-builder (similar to MDX) that may not be
rendered properly in your Markdown viewer.
-->
# VAN
<Tip warning={true}>
This model is in maintenance mode only, we don't accept any new PRs changing its code.
If you run into any issues running this model, please reinstall the last version that supported this model: v4.30.0.
You can do so by running the following command: `pip install -U transformers==4.30.0`.
</Tip>
## Overview
The VAN model was proposed in [Visual Attention Network](https://arxiv.org/abs/2202.09741) by Meng-Hao Guo, Cheng-Ze Lu, Zheng-Ning Liu, Ming-Ming Cheng, Shi-Min Hu.
This paper introduces a new attention layer based on convolution operations able to capture both local and distant relationships. This is done by combining normal and large kernel convolution layers. The latter uses a dilated convolution to capture distant correlations.
The abstract from the paper is the following:
*While originally designed for natural language processing tasks, the self-attention mechanism has recently taken various computer vision areas by storm. However, the 2D nature of images brings three challenges for applying self-attention in computer vision. (1) Treating images as 1D sequences neglects their 2D structures. (2) The quadratic complexity is too expensive for high-resolution images. (3) It only captures spatial adaptability but ignores channel adaptability. In this paper, we propose a novel large kernel attention (LKA) module to enable self-adaptive and long-range correlations in self-attention while avoiding the above issues. We further introduce a novel neural network based on LKA, namely Visual Attention Network (VAN). While extremely simple, VAN outperforms the state-of-the-art vision transformers and convolutional neural networks with a large margin in extensive experiments, including image classification, object detection, semantic segmentation, instance segmentation, etc. Code is available at [this https URL](https://github.com/Visual-Attention-Network/VAN-Classification).*
Tips:
- VAN does not have an embedding layer, thus the `hidden_states` will have a length equal to the number of stages.
The figure below illustrates the architecture of a Visual Attention Layer. Taken from the [original paper](https://arxiv.org/abs/2202.09741).
<img width="600" src="https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/van_architecture.png"/>
This model was contributed by [Francesco](https://huggingface.co/Francesco). The original code can be found [here](https://github.com/Visual-Attention-Network/VAN-Classification).
## Resources
A list of official Hugging Face and community (indicated by ๐) resources to help you get started with VAN.
<PipelineTag pipeline="image-classification"/>
- [`VanForImageClassification`] is supported by this [example script](https://github.com/huggingface/transformers/tree/main/examples/pytorch/image-classification) and [notebook](https://colab.research.google.com/github/huggingface/notebooks/blob/main/examples/image_classification.ipynb).
- See also: [Image classification task guide](../tasks/image_classification)
If you're interested in submitting a resource to be included here, please feel free to open a Pull Request and we'll review it! The resource should ideally demonstrate something new instead of duplicating an existing resource.
## VanConfig
[[autodoc]] VanConfig
## VanModel
[[autodoc]] VanModel
- forward
## VanForImageClassification
[[autodoc]] VanForImageClassification
- forward
| 0 |
mavonic_private_repos/transformers/docs/source/en | mavonic_private_repos/transformers/docs/source/en/model_doc/efficientnet.md | <!--Copyright 2023 The HuggingFace Team. All rights reserved.
Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
the License. You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
specific language governing permissions and limitations under the License.
โ ๏ธ Note that this file is in Markdown but contain specific syntax for our doc-builder (similar to MDX) that may not be
rendered properly in your Markdown viewer.
-->
# EfficientNet
## Overview
The EfficientNet model was proposed in [EfficientNet: Rethinking Model Scaling for Convolutional Neural Networks](https://arxiv.org/abs/1905.11946)
by Mingxing Tan and Quoc V. Le. EfficientNets are a family of image classification models, which achieve state-of-the-art accuracy, yet being an order-of-magnitude smaller and faster than previous models.
The abstract from the paper is the following:
*Convolutional Neural Networks (ConvNets) are commonly developed at a fixed resource budget, and then scaled up for better accuracy if more resources are available. In this paper, we systematically study model scaling and identify that carefully balancing network depth, width, and resolution can lead to better performance. Based on this observation, we propose a new scaling method that uniformly scales all dimensions of depth/width/resolution using a simple yet highly effective compound coefficient. We demonstrate the effectiveness of this method on scaling up MobileNets and ResNet.
To go even further, we use neural architecture search to design a new baseline network and scale it up to obtain a family of models, called EfficientNets, which achieve much better accuracy and efficiency than previous ConvNets. In particular, our EfficientNet-B7 achieves state-of-the-art 84.3% top-1 accuracy on ImageNet, while being 8.4x smaller and 6.1x faster on inference than the best existing ConvNet. Our EfficientNets also transfer well and achieve state-of-the-art accuracy on CIFAR-100 (91.7%), Flowers (98.8%), and 3 other transfer learning datasets, with an order of magnitude fewer parameters.*
This model was contributed by [adirik](https://huggingface.co/adirik).
The original code can be found [here](https://github.com/tensorflow/tpu/tree/master/models/official/efficientnet).
## EfficientNetConfig
[[autodoc]] EfficientNetConfig
## EfficientNetImageProcessor
[[autodoc]] EfficientNetImageProcessor
- preprocess
## EfficientNetModel
[[autodoc]] EfficientNetModel
- forward
## EfficientNetForImageClassification
[[autodoc]] EfficientNetForImageClassification
- forward
| 0 |
mavonic_private_repos/transformers/docs/source/en | mavonic_private_repos/transformers/docs/source/en/model_doc/encoder-decoder.md | <!--Copyright 2020 The HuggingFace Team. All rights reserved.
Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
the License. You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
specific language governing permissions and limitations under the License.
โ ๏ธ Note that this file is in Markdown but contain specific syntax for our doc-builder (similar to MDX) that may not be
rendered properly in your Markdown viewer.
-->
# Encoder Decoder Models
## Overview
The [`EncoderDecoderModel`] can be used to initialize a sequence-to-sequence model with any
pretrained autoencoding model as the encoder and any pretrained autoregressive model as the decoder.
The effectiveness of initializing sequence-to-sequence models with pretrained checkpoints for sequence generation tasks
was shown in [Leveraging Pre-trained Checkpoints for Sequence Generation Tasks](https://arxiv.org/abs/1907.12461) by
Sascha Rothe, Shashi Narayan, Aliaksei Severyn.
After such an [`EncoderDecoderModel`] has been trained/fine-tuned, it can be saved/loaded just like
any other models (see the examples for more information).
An application of this architecture could be to leverage two pretrained [`BertModel`] as the encoder
and decoder for a summarization model as was shown in: [Text Summarization with Pretrained Encoders](https://arxiv.org/abs/1908.08345) by Yang Liu and Mirella Lapata.
## Randomly initializing `EncoderDecoderModel` from model configurations.
[`EncoderDecoderModel`] can be randomly initialized from an encoder and a decoder config. In the following example, we show how to do this using the default [`BertModel`] configuration for the encoder and the default [`BertForCausalLM`] configuration for the decoder.
```python
>>> from transformers import BertConfig, EncoderDecoderConfig, EncoderDecoderModel
>>> config_encoder = BertConfig()
>>> config_decoder = BertConfig()
>>> config = EncoderDecoderConfig.from_encoder_decoder_configs(config_encoder, config_decoder)
>>> model = EncoderDecoderModel(config=config)
```
## Initialising `EncoderDecoderModel` from a pretrained encoder and a pretrained decoder.
[`EncoderDecoderModel`] can be initialized from a pretrained encoder checkpoint and a pretrained decoder checkpoint. Note that any pretrained auto-encoding model, *e.g.* BERT, can serve as the encoder and both pretrained auto-encoding models, *e.g.* BERT, pretrained causal language models, *e.g.* GPT2, as well as the pretrained decoder part of sequence-to-sequence models, *e.g.* decoder of BART, can be used as the decoder.
Depending on which architecture you choose as the decoder, the cross-attention layers might be randomly initialized.
Initializing [`EncoderDecoderModel`] from a pretrained encoder and decoder checkpoint requires the model to be fine-tuned on a downstream task, as has been shown in [the *Warm-starting-encoder-decoder blog post*](https://huggingface.co/blog/warm-starting-encoder-decoder).
To do so, the `EncoderDecoderModel` class provides a [`EncoderDecoderModel.from_encoder_decoder_pretrained`] method.
```python
>>> from transformers import EncoderDecoderModel, BertTokenizer
>>> tokenizer = BertTokenizer.from_pretrained("google-bert/bert-base-uncased")
>>> model = EncoderDecoderModel.from_encoder_decoder_pretrained("google-bert/bert-base-uncased", "google-bert/bert-base-uncased")
```
## Loading an existing `EncoderDecoderModel` checkpoint and perform inference.
To load fine-tuned checkpoints of the `EncoderDecoderModel` class, [`EncoderDecoderModel`] provides the `from_pretrained(...)` method just like any other model architecture in Transformers.
To perform inference, one uses the [`generate`] method, which allows to autoregressively generate text. This method supports various forms of decoding, such as greedy, beam search and multinomial sampling.
```python
>>> from transformers import AutoTokenizer, EncoderDecoderModel
>>> # load a fine-tuned seq2seq model and corresponding tokenizer
>>> model = EncoderDecoderModel.from_pretrained("patrickvonplaten/bert2bert_cnn_daily_mail")
>>> tokenizer = AutoTokenizer.from_pretrained("patrickvonplaten/bert2bert_cnn_daily_mail")
>>> # let's perform inference on a long piece of text
>>> ARTICLE_TO_SUMMARIZE = (
... "PG&E stated it scheduled the blackouts in response to forecasts for high winds "
... "amid dry conditions. The aim is to reduce the risk of wildfires. Nearly 800 thousand customers were "
... "scheduled to be affected by the shutoffs which were expected to last through at least midday tomorrow."
... )
>>> input_ids = tokenizer(ARTICLE_TO_SUMMARIZE, return_tensors="pt").input_ids
>>> # autoregressively generate summary (uses greedy decoding by default)
>>> generated_ids = model.generate(input_ids)
>>> generated_text = tokenizer.batch_decode(generated_ids, skip_special_tokens=True)[0]
>>> print(generated_text)
nearly 800 thousand customers were affected by the shutoffs. the aim is to reduce the risk of wildfires. nearly 800, 000 customers were expected to be affected by high winds amid dry conditions. pg & e said it scheduled the blackouts to last through at least midday tomorrow.
```
## Loading a PyTorch checkpoint into `TFEncoderDecoderModel`.
[`TFEncoderDecoderModel.from_pretrained`] currently doesn't support initializing the model from a
pytorch checkpoint. Passing `from_pt=True` to this method will throw an exception. If there are only pytorch
checkpoints for a particular encoder-decoder model, a workaround is:
```python
>>> # a workaround to load from pytorch checkpoint
>>> from transformers import EncoderDecoderModel, TFEncoderDecoderModel
>>> _model = EncoderDecoderModel.from_pretrained("patrickvonplaten/bert2bert-cnn_dailymail-fp16")
>>> _model.encoder.save_pretrained("./encoder")
>>> _model.decoder.save_pretrained("./decoder")
>>> model = TFEncoderDecoderModel.from_encoder_decoder_pretrained(
... "./encoder", "./decoder", encoder_from_pt=True, decoder_from_pt=True
... )
>>> # This is only for copying some specific attributes of this particular model.
>>> model.config = _model.config
```
## Training
Once the model is created, it can be fine-tuned similar to BART, T5 or any other encoder-decoder model.
As you can see, only 2 inputs are required for the model in order to compute a loss: `input_ids` (which are the
`input_ids` of the encoded input sequence) and `labels` (which are the `input_ids` of the encoded
target sequence).
```python
>>> from transformers import BertTokenizer, EncoderDecoderModel
>>> tokenizer = BertTokenizer.from_pretrained("google-bert/bert-base-uncased")
>>> model = EncoderDecoderModel.from_encoder_decoder_pretrained("google-bert/bert-base-uncased", "google-bert/bert-base-uncased")
>>> model.config.decoder_start_token_id = tokenizer.cls_token_id
>>> model.config.pad_token_id = tokenizer.pad_token_id
>>> input_ids = tokenizer(
... "The tower is 324 metres (1,063 ft) tall, about the same height as an 81-storey building, and the tallest structure in Paris. Its base is square, measuring 125 metres (410 ft) on each side.During its construction, the Eiffel Tower surpassed the Washington Monument to become the tallest man-made structure in the world, a title it held for 41 years until the Chrysler Building in New York City was finished in 1930. It was the first structure to reach a height of 300 metres. Due to the addition of a broadcasting aerial at the top of the tower in 1957, it is now taller than the Chrysler Building by 5.2 metres (17 ft).Excluding transmitters, the Eiffel Tower is the second tallest free-standing structure in France after the Millau Viaduct.",
... return_tensors="pt",
... ).input_ids
>>> labels = tokenizer(
... "the eiffel tower surpassed the washington monument to become the tallest structure in the world. it was the first structure to reach a height of 300 metres in paris in 1930. it is now taller than the chrysler building by 5. 2 metres ( 17 ft ) and is the second tallest free - standing structure in paris.",
... return_tensors="pt",
... ).input_ids
>>> # the forward function automatically creates the correct decoder_input_ids
>>> loss = model(input_ids=input_ids, labels=labels).loss
```
Detailed [colab](https://colab.research.google.com/drive/1WIk2bxglElfZewOHboPFNj8H44_VAyKE?usp=sharing#scrollTo=ZwQIEhKOrJpl) for training.
This model was contributed by [thomwolf](https://github.com/thomwolf). This model's TensorFlow and Flax versions
were contributed by [ydshieh](https://github.com/ydshieh).
## EncoderDecoderConfig
[[autodoc]] EncoderDecoderConfig
<frameworkcontent>
<pt>
## EncoderDecoderModel
[[autodoc]] EncoderDecoderModel
- forward
- from_encoder_decoder_pretrained
</pt>
<tf>
## TFEncoderDecoderModel
[[autodoc]] TFEncoderDecoderModel
- call
- from_encoder_decoder_pretrained
</tf>
<jax>
## FlaxEncoderDecoderModel
[[autodoc]] FlaxEncoderDecoderModel
- __call__
- from_encoder_decoder_pretrained
</jax>
</frameworkcontent>
| 0 |
mavonic_private_repos/transformers/docs/source/en | mavonic_private_repos/transformers/docs/source/en/model_doc/bartpho.md | <!--Copyright 2021 The HuggingFace Team. All rights reserved.
Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
the License. You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
specific language governing permissions and limitations under the License.
โ ๏ธ Note that this file is in Markdown but contain specific syntax for our doc-builder (similar to MDX) that may not be
rendered properly in your Markdown viewer.
-->
# BARTpho
## Overview
The BARTpho model was proposed in [BARTpho: Pre-trained Sequence-to-Sequence Models for Vietnamese](https://arxiv.org/abs/2109.09701) by Nguyen Luong Tran, Duong Minh Le and Dat Quoc Nguyen.
The abstract from the paper is the following:
*We present BARTpho with two versions -- BARTpho_word and BARTpho_syllable -- the first public large-scale monolingual
sequence-to-sequence models pre-trained for Vietnamese. Our BARTpho uses the "large" architecture and pre-training
scheme of the sequence-to-sequence denoising model BART, thus especially suitable for generative NLP tasks. Experiments
on a downstream task of Vietnamese text summarization show that in both automatic and human evaluations, our BARTpho
outperforms the strong baseline mBART and improves the state-of-the-art. We release BARTpho to facilitate future
research and applications of generative Vietnamese NLP tasks.*
This model was contributed by [dqnguyen](https://huggingface.co/dqnguyen). The original code can be found [here](https://github.com/VinAIResearch/BARTpho).
## Usage example
```python
>>> import torch
>>> from transformers import AutoModel, AutoTokenizer
>>> bartpho = AutoModel.from_pretrained("vinai/bartpho-syllable")
>>> tokenizer = AutoTokenizer.from_pretrained("vinai/bartpho-syllable")
>>> line = "Chรบng tรดi lร nhแปฏng nghiรชn cแปฉu viรชn."
>>> input_ids = tokenizer(line, return_tensors="pt")
>>> with torch.no_grad():
... features = bartpho(**input_ids) # Models outputs are now tuples
>>> # With TensorFlow 2.0+:
>>> from transformers import TFAutoModel
>>> bartpho = TFAutoModel.from_pretrained("vinai/bartpho-syllable")
>>> input_ids = tokenizer(line, return_tensors="tf")
>>> features = bartpho(**input_ids)
```
## Usage tips
- Following mBART, BARTpho uses the "large" architecture of BART with an additional layer-normalization layer on top of
both the encoder and decoder. Thus, usage examples in the [documentation of BART](bart), when adapting to use
with BARTpho, should be adjusted by replacing the BART-specialized classes with the mBART-specialized counterparts.
For example:
```python
>>> from transformers import MBartForConditionalGeneration
>>> bartpho = MBartForConditionalGeneration.from_pretrained("vinai/bartpho-syllable")
>>> TXT = "Chรบng tรดi lร <mask> nghiรชn cแปฉu viรชn."
>>> input_ids = tokenizer([TXT], return_tensors="pt")["input_ids"]
>>> logits = bartpho(input_ids).logits
>>> masked_index = (input_ids[0] == tokenizer.mask_token_id).nonzero().item()
>>> probs = logits[0, masked_index].softmax(dim=0)
>>> values, predictions = probs.topk(5)
>>> print(tokenizer.decode(predictions).split())
```
- This implementation is only for tokenization: "monolingual_vocab_file" consists of Vietnamese-specialized types
extracted from the pre-trained SentencePiece model "vocab_file" that is available from the multilingual XLM-RoBERTa.
Other languages, if employing this pre-trained multilingual SentencePiece model "vocab_file" for subword
segmentation, can reuse BartphoTokenizer with their own language-specialized "monolingual_vocab_file".
## BartphoTokenizer
[[autodoc]] BartphoTokenizer
| 0 |
mavonic_private_repos/transformers/docs/source/en | mavonic_private_repos/transformers/docs/source/en/model_doc/roberta.md | <!--Copyright 2020 The HuggingFace Team. All rights reserved.
Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
the License. You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
specific language governing permissions and limitations under the License.
โ ๏ธ Note that this file is in Markdown but contain specific syntax for our doc-builder (similar to MDX) that may not be
rendered properly in your Markdown viewer.
-->
# RoBERTa
<div class="flex flex-wrap space-x-1">
<a href="https://huggingface.co/models?filter=roberta">
<img alt="Models" src="https://img.shields.io/badge/All_model_pages-roberta-blueviolet">
</a>
<a href="https://huggingface.co/spaces/docs-demos/roberta-base">
<img alt="Spaces" src="https://img.shields.io/badge/%F0%9F%A4%97%20Hugging%20Face-Spaces-blue">
</a>
<a href="https://huggingface.co/papers/1907.11692">
<img alt="Paper page" src="https://img.shields.io/badge/Paper%20page-1907.11692-green">
</a>
</div>
## Overview
The RoBERTa model was proposed in [RoBERTa: A Robustly Optimized BERT Pretraining Approach](https://arxiv.org/abs/1907.11692) by Yinhan Liu, [Myle Ott](https://huggingface.co/myleott), Naman Goyal, Jingfei Du, Mandar Joshi, Danqi Chen, Omer
Levy, Mike Lewis, Luke Zettlemoyer, Veselin Stoyanov. It is based on Google's BERT model released in 2018.
It builds on BERT and modifies key hyperparameters, removing the next-sentence pretraining objective and training with
much larger mini-batches and learning rates.
The abstract from the paper is the following:
*Language model pretraining has led to significant performance gains but careful comparison between different
approaches is challenging. Training is computationally expensive, often done on private datasets of different sizes,
and, as we will show, hyperparameter choices have significant impact on the final results. We present a replication
study of BERT pretraining (Devlin et al., 2019) that carefully measures the impact of many key hyperparameters and
training data size. We find that BERT was significantly undertrained, and can match or exceed the performance of every
model published after it. Our best model achieves state-of-the-art results on GLUE, RACE and SQuAD. These results
highlight the importance of previously overlooked design choices, and raise questions about the source of recently
reported improvements. We release our models and code.*
This model was contributed by [julien-c](https://huggingface.co/julien-c). The original code can be found [here](https://github.com/pytorch/fairseq/tree/master/examples/roberta).
## Usage tips
- This implementation is the same as [`BertModel`] with a tiny embeddings tweak as well as a setup
for Roberta pretrained models.
- RoBERTa has the same architecture as BERT, but uses a byte-level BPE as a tokenizer (same as GPT-2) and uses a
different pretraining scheme.
- RoBERTa doesn't have `token_type_ids`, you don't need to indicate which token belongs to which segment. Just
separate your segments with the separation token `tokenizer.sep_token` (or `</s>`)
- Same as BERT with better pretraining tricks:
* dynamic masking: tokens are masked differently at each epoch, whereas BERT does it once and for all
* together to reach 512 tokens (so the sentences are in an order than may span several documents)
* train with larger batches
* use BPE with bytes as a subunit and not characters (because of unicode characters)
- [CamemBERT](camembert) is a wrapper around RoBERTa. Refer to this page for usage examples.
## Resources
A list of official Hugging Face and community (indicated by ๐) resources to help you get started with RoBERTa. If you're interested in submitting a resource to be included here, please feel free to open a Pull Request and we'll review it! The resource should ideally demonstrate something new instead of duplicating an existing resource.
<PipelineTag pipeline="text-classification"/>
- A blog on [Getting Started with Sentiment Analysis on Twitter](https://huggingface.co/blog/sentiment-analysis-twitter) using RoBERTa and the [Inference API](https://huggingface.co/inference-api).
- A blog on [Opinion Classification with Kili and Hugging Face AutoTrain](https://huggingface.co/blog/opinion-classification-with-kili) using RoBERTa.
- A notebook on how to [finetune RoBERTa for sentiment analysis](https://colab.research.google.com/github/DhavalTaunk08/NLP_scripts/blob/master/sentiment_analysis_using_roberta.ipynb). ๐
- [`RobertaForSequenceClassification`] is supported by this [example script](https://github.com/huggingface/transformers/tree/main/examples/pytorch/text-classification) and [notebook](https://colab.research.google.com/github/huggingface/notebooks/blob/main/examples/text_classification.ipynb).
- [`TFRobertaForSequenceClassification`] is supported by this [example script](https://github.com/huggingface/transformers/tree/main/examples/tensorflow/text-classification) and [notebook](https://colab.research.google.com/github/huggingface/notebooks/blob/main/examples/text_classification-tf.ipynb).
- [`FlaxRobertaForSequenceClassification`] is supported by this [example script](https://github.com/huggingface/transformers/tree/main/examples/flax/text-classification) and [notebook](https://colab.research.google.com/github/huggingface/notebooks/blob/main/examples/text_classification_flax.ipynb).
- [Text classification task guide](../tasks/sequence_classification)
<PipelineTag pipeline="token-classification"/>
- [`RobertaForTokenClassification`] is supported by this [example script](https://github.com/huggingface/transformers/tree/main/examples/pytorch/token-classification) and [notebook](https://colab.research.google.com/github/huggingface/notebooks/blob/main/examples/token_classification.ipynb).
- [`TFRobertaForTokenClassification`] is supported by this [example script](https://github.com/huggingface/transformers/tree/main/examples/tensorflow/token-classification) and [notebook](https://colab.research.google.com/github/huggingface/notebooks/blob/main/examples/token_classification-tf.ipynb).
- [`FlaxRobertaForTokenClassification`] is supported by this [example script](https://github.com/huggingface/transformers/tree/main/examples/flax/token-classification).
- [Token classification](https://huggingface.co/course/chapter7/2?fw=pt) chapter of the ๐ค Hugging Face Course.
- [Token classification task guide](../tasks/token_classification)
<PipelineTag pipeline="fill-mask"/>
- A blog on [How to train a new language model from scratch using Transformers and Tokenizers](https://huggingface.co/blog/how-to-train) with RoBERTa.
- [`RobertaForMaskedLM`] is supported by this [example script](https://github.com/huggingface/transformers/tree/main/examples/pytorch/language-modeling#robertabertdistilbert-and-masked-language-modeling) and [notebook](https://colab.research.google.com/github/huggingface/notebooks/blob/main/examples/language_modeling.ipynb).
- [`TFRobertaForMaskedLM`] is supported by this [example script](https://github.com/huggingface/transformers/tree/main/examples/tensorflow/language-modeling#run_mlmpy) and [notebook](https://colab.research.google.com/github/huggingface/notebooks/blob/main/examples/language_modeling-tf.ipynb).
- [`FlaxRobertaForMaskedLM`] is supported by this [example script](https://github.com/huggingface/transformers/tree/main/examples/flax/language-modeling#masked-language-modeling) and [notebook](https://colab.research.google.com/github/huggingface/notebooks/blob/main/examples/masked_language_modeling_flax.ipynb).
- [Masked language modeling](https://huggingface.co/course/chapter7/3?fw=pt) chapter of the ๐ค Hugging Face Course.
- [Masked language modeling task guide](../tasks/masked_language_modeling)
<PipelineTag pipeline="question-answering"/>
- A blog on [Accelerated Inference with Optimum and Transformers Pipelines](https://huggingface.co/blog/optimum-inference) with RoBERTa for question answering.
- [`RobertaForQuestionAnswering`] is supported by this [example script](https://github.com/huggingface/transformers/tree/main/examples/pytorch/question-answering) and [notebook](https://colab.research.google.com/github/huggingface/notebooks/blob/main/examples/question_answering.ipynb).
- [`TFRobertaForQuestionAnswering`] is supported by this [example script](https://github.com/huggingface/transformers/tree/main/examples/tensorflow/question-answering) and [notebook](https://colab.research.google.com/github/huggingface/notebooks/blob/main/examples/question_answering-tf.ipynb).
- [`FlaxRobertaForQuestionAnswering`] is supported by this [example script](https://github.com/huggingface/transformers/tree/main/examples/flax/question-answering).
- [Question answering](https://huggingface.co/course/chapter7/7?fw=pt) chapter of the ๐ค Hugging Face Course.
- [Question answering task guide](../tasks/question_answering)
**Multiple choice**
- [`RobertaForMultipleChoice`] is supported by this [example script](https://github.com/huggingface/transformers/tree/main/examples/pytorch/multiple-choice) and [notebook](https://colab.research.google.com/github/huggingface/notebooks/blob/main/examples/multiple_choice.ipynb).
- [`TFRobertaForMultipleChoice`] is supported by this [example script](https://github.com/huggingface/transformers/tree/main/examples/tensorflow/multiple-choice) and [notebook](https://colab.research.google.com/github/huggingface/notebooks/blob/main/examples/multiple_choice-tf.ipynb).
- [Multiple choice task guide](../tasks/multiple_choice)
## RobertaConfig
[[autodoc]] RobertaConfig
## RobertaTokenizer
[[autodoc]] RobertaTokenizer
- build_inputs_with_special_tokens
- get_special_tokens_mask
- create_token_type_ids_from_sequences
- save_vocabulary
## RobertaTokenizerFast
[[autodoc]] RobertaTokenizerFast
- build_inputs_with_special_tokens
<frameworkcontent>
<pt>
## RobertaModel
[[autodoc]] RobertaModel
- forward
## RobertaForCausalLM
[[autodoc]] RobertaForCausalLM
- forward
## RobertaForMaskedLM
[[autodoc]] RobertaForMaskedLM
- forward
## RobertaForSequenceClassification
[[autodoc]] RobertaForSequenceClassification
- forward
## RobertaForMultipleChoice
[[autodoc]] RobertaForMultipleChoice
- forward
## RobertaForTokenClassification
[[autodoc]] RobertaForTokenClassification
- forward
## RobertaForQuestionAnswering
[[autodoc]] RobertaForQuestionAnswering
- forward
</pt>
<tf>
## TFRobertaModel
[[autodoc]] TFRobertaModel
- call
## TFRobertaForCausalLM
[[autodoc]] TFRobertaForCausalLM
- call
## TFRobertaForMaskedLM
[[autodoc]] TFRobertaForMaskedLM
- call
## TFRobertaForSequenceClassification
[[autodoc]] TFRobertaForSequenceClassification
- call
## TFRobertaForMultipleChoice
[[autodoc]] TFRobertaForMultipleChoice
- call
## TFRobertaForTokenClassification
[[autodoc]] TFRobertaForTokenClassification
- call
## TFRobertaForQuestionAnswering
[[autodoc]] TFRobertaForQuestionAnswering
- call
</tf>
<jax>
## FlaxRobertaModel
[[autodoc]] FlaxRobertaModel
- __call__
## FlaxRobertaForCausalLM
[[autodoc]] FlaxRobertaForCausalLM
- __call__
## FlaxRobertaForMaskedLM
[[autodoc]] FlaxRobertaForMaskedLM
- __call__
## FlaxRobertaForSequenceClassification
[[autodoc]] FlaxRobertaForSequenceClassification
- __call__
## FlaxRobertaForMultipleChoice
[[autodoc]] FlaxRobertaForMultipleChoice
- __call__
## FlaxRobertaForTokenClassification
[[autodoc]] FlaxRobertaForTokenClassification
- __call__
## FlaxRobertaForQuestionAnswering
[[autodoc]] FlaxRobertaForQuestionAnswering
- __call__
</jax>
</frameworkcontent>
| 0 |
mavonic_private_repos/transformers/docs/source/en | mavonic_private_repos/transformers/docs/source/en/model_doc/oneformer.md | <!--Copyright 2022 The HuggingFace Team. All rights reserved.
Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
the License. You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
specific language governing permissions and limitations under the License.
โ ๏ธ Note that this file is in Markdown but contain specific syntax for our doc-builder (similar to MDX) that may not be
rendered properly in your Markdown viewer.
-->
# OneFormer
## Overview
The OneFormer model was proposed in [OneFormer: One Transformer to Rule Universal Image Segmentation](https://arxiv.org/abs/2211.06220) by Jitesh Jain, Jiachen Li, MangTik Chiu, Ali Hassani, Nikita Orlov, Humphrey Shi. OneFormer is a universal image segmentation framework that can be trained on a single panoptic dataset to perform semantic, instance, and panoptic segmentation tasks. OneFormer uses a task token to condition the model on the task in focus, making the architecture task-guided for training, and task-dynamic for inference.
<img width="600" src="https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/transformers/model_doc/oneformer_teaser.png"/>
The abstract from the paper is the following:
*Universal Image Segmentation is not a new concept. Past attempts to unify image segmentation in the last decades include scene parsing, panoptic segmentation, and, more recently, new panoptic architectures. However, such panoptic architectures do not truly unify image segmentation because they need to be trained individually on the semantic, instance, or panoptic segmentation to achieve the best performance. Ideally, a truly universal framework should be trained only once and achieve SOTA performance across all three image segmentation tasks. To that end, we propose OneFormer, a universal image segmentation framework that unifies segmentation with a multi-task train-once design. We first propose a task-conditioned joint training strategy that enables training on ground truths of each domain (semantic, instance, and panoptic segmentation) within a single multi-task training process. Secondly, we introduce a task token to condition our model on the task at hand, making our model task-dynamic to support multi-task training and inference. Thirdly, we propose using a query-text contrastive loss during training to establish better inter-task and inter-class distinctions. Notably, our single OneFormer model outperforms specialized Mask2Former models across all three segmentation tasks on ADE20k, CityScapes, and COCO, despite the latter being trained on each of the three tasks individually with three times the resources. With new ConvNeXt and DiNAT backbones, we observe even more performance improvement. We believe OneFormer is a significant step towards making image segmentation more universal and accessible.*
The figure below illustrates the architecture of OneFormer. Taken from the [original paper](https://arxiv.org/abs/2211.06220).
<img width="600" src="https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/transformers/model_doc/oneformer_architecture.png"/>
This model was contributed by [Jitesh Jain](https://huggingface.co/praeclarumjj3). The original code can be found [here](https://github.com/SHI-Labs/OneFormer).
## Usage tips
- OneFormer requires two inputs during inference: *image* and *task token*.
- During training, OneFormer only uses panoptic annotations.
- If you want to train the model in a distributed environment across multiple nodes, then one should update the
`get_num_masks` function inside in the `OneFormerLoss` class of `modeling_oneformer.py`. When training on multiple nodes, this should be
set to the average number of target masks across all nodes, as can be seen in the original implementation [here](https://github.com/SHI-Labs/OneFormer/blob/33ebb56ed34f970a30ae103e786c0cb64c653d9a/oneformer/modeling/criterion.py#L287).
- One can use [`OneFormerProcessor`] to prepare input images and task inputs for the model and optional targets for the model. [`OneformerProcessor`] wraps [`OneFormerImageProcessor`] and [`CLIPTokenizer`] into a single instance to both prepare the images and encode the task inputs.
- To get the final segmentation, depending on the task, you can call [`~OneFormerProcessor.post_process_semantic_segmentation`] or [`~OneFormerImageProcessor.post_process_instance_segmentation`] or [`~OneFormerImageProcessor.post_process_panoptic_segmentation`]. All three tasks can be solved using [`OneFormerForUniversalSegmentation`] output, panoptic segmentation accepts an optional `label_ids_to_fuse` argument to fuse instances of the target object/s (e.g. sky) together.
## Resources
A list of official Hugging Face and community (indicated by ๐) resources to help you get started with OneFormer.
- Demo notebooks regarding inference + fine-tuning on custom data can be found [here](https://github.com/NielsRogge/Transformers-Tutorials/tree/master/OneFormer).
If you're interested in submitting a resource to be included here, please feel free to open a Pull Request and we will review it.
The resource should ideally demonstrate something new instead of duplicating an existing resource.
## OneFormer specific outputs
[[autodoc]] models.oneformer.modeling_oneformer.OneFormerModelOutput
[[autodoc]] models.oneformer.modeling_oneformer.OneFormerForUniversalSegmentationOutput
## OneFormerConfig
[[autodoc]] OneFormerConfig
## OneFormerImageProcessor
[[autodoc]] OneFormerImageProcessor
- preprocess
- encode_inputs
- post_process_semantic_segmentation
- post_process_instance_segmentation
- post_process_panoptic_segmentation
## OneFormerProcessor
[[autodoc]] OneFormerProcessor
## OneFormerModel
[[autodoc]] OneFormerModel
- forward
## OneFormerForUniversalSegmentation
[[autodoc]] OneFormerForUniversalSegmentation
- forward
| 0 |
mavonic_private_repos/transformers/docs/source/en | mavonic_private_repos/transformers/docs/source/en/model_doc/code_llama.md | <!--Copyright 2023 The HuggingFace Team. All rights reserved.
Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
the License. You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
specific language governing permissions and limitations under the License.
โ ๏ธ Note that this file is in Markdown but contains specific syntax for our doc-builder (similar to MDX) that may not be
rendered properly in your Markdown viewer.
-->
# CodeLlama
## Overview
The Code Llama model was proposed in [Code Llama: Open Foundation Models for Code](https://ai.meta.com/research/publications/code-llama-open-foundation-models-for-code/) by Baptiste Roziรจre, Jonas Gehring, Fabian Gloeckle, Sten Sootla, Itai Gat, Xiaoqing Ellen Tan, Yossi Adi, Jingyu Liu, Tal Remez, Jรฉrรฉmy Rapin, Artyom Kozhevnikov, Ivan Evtimov, Joanna Bitton, Manish Bhatt, Cristian Canton Ferrer, Aaron Grattafiori, Wenhan Xiong, Alexandre Dรฉfossez, Jade Copet, Faisal Azhar, Hugo Touvron, Louis Martin, Nicolas Usunier, Thomas Scialom, Gabriel Synnaeve.
The abstract from the paper is the following:
*We release Code Llama, a family of large language models for code based on Llama 2 providing state-of-the-art performance among open models, infilling capabilities, support for large input contexts, and zero-shot instruction following ability for programming tasks. We provide multiple flavors to cover a wide range of applications: foundation models (Code Llama), Python specializations (Code Llama - Python), and instruction-following models (Code Llama - Instruct) with 7B, 13B and 34B parameters each. All models are trained on sequences of 16k tokens and show improvements on inputs with up to 100k tokens. 7B and 13B Code Llama and Code Llama - Instruct variants support infilling based on surrounding content. Code Llama reaches state-of-the-art performance among open models on several code benchmarks, with scores of up to 53% and 55% on HumanEval and MBPP, respectively. Notably, Code Llama - Python 7B outperforms Llama 2 70B on HumanEval and MBPP, and all our models outperform every other publicly available model on MultiPL-E. We release Code Llama under a permissive license that allows for both research and commercial use.*
Check out all Code Llama model checkpoints [here](https://huggingface.co/models?search=code_llama) and the officially released ones in the [codellama org](https://huggingface.co/codellama).
This model was contributed by [ArthurZucker](https://huggingface.co/ArthurZ). The original code of the authors can be found [here](https://github.com/facebookresearch/llama).
## Usage tips and examples
<Tip warning={true}>
The `Llama2` family models, on which Code Llama is based, were trained using `bfloat16`, but the original inference uses `float16`. Let's look at the different precisions:
* `float32`: PyTorch convention on model initialization is to load models in `float32`, no matter with which `dtype` the model weights were stored. `transformers` also follows this convention for consistency with PyTorch. This will be picked by default. If you want the `AutoModel` API to cast the load the checkpoints with the storage weights type, you must specify `torch_dtype="auto"`, e.g. `model = AutoModelForCausalLM.from_pretrained("path", torch_dtype = "auto")`.
* `bfloat16`: Code Llama was trained with this precision, so we recommend using it for further training or fine-tuning.
* `float16`: We recommend running inference using this precision, as it's usually faster than `bfloat16`, and evaluation metrics show no discernible degradation with respect to `bfloat16`. You can also run inference using `bfloat16`, and we recommend you check inference results with both `float16` and `bfloat16` after fine-tuning.
As mentioned above, the `dtype` of the storage weights is mostly irrelevant unless you are using `torch_dtype="auto"` when initializing a model using. The reason is that the model will first be downloaded (using the `dtype` of the checkpoints online) and then will be casted to the default `dtype` of `torch` (becomes `torch.float32`). If there is a specified `torch_dtype`, it will be used instead.
</Tip>
Tips:
- The infilling task is supported out of the box. You should be using the `tokenizer.fill_token` where you want your input to be filled.
- The model conversion script is the same as for the `Llama2` family:
Here is a sample usage:
```bash
python src/transformers/models/llama/convert_llama_weights_to_hf.py \
--input_dir /path/to/downloaded/llama/weights --model_size 7B --output_dir /output/path
```
Note that executing the script requires enough CPU RAM to host the whole model in float16 precision (even if the biggest versions
come in several checkpoints they each contain a part of each weight of the model, so we need to load them all in RAM).
After conversion, the model and tokenizer can be loaded via:
```python
>>> from transformers import LlamaForCausalLM, CodeLlamaTokenizer
>>> tokenizer = CodeLlamaTokenizer.from_pretrained("codellama/CodeLlama-7b-hf")
>>> model = LlamaForCausalLM.from_pretrained("codellama/CodeLlama-7b-hf")
>>> PROMPT = '''def remove_non_ascii(s: str) -> str:
... """ <FILL_ME>
... return result
... '''
>>> input_ids = tokenizer(PROMPT, return_tensors="pt")["input_ids"]
>>> generated_ids = model.generate(input_ids, max_new_tokens=128)
>>> filling = tokenizer.batch_decode(generated_ids[:, input_ids.shape[1]:], skip_special_tokens = True)[0]
>>> print(PROMPT.replace("<FILL_ME>", filling))
def remove_non_ascii(s: str) -> str:
""" Remove non-ASCII characters from a string.
<BLANKLINE>
Args:
s: The string to remove non-ASCII characters from.
<BLANKLINE>
Returns:
The string with non-ASCII characters removed.
"""
result = ""
for c in s:
if ord(c) < 128:
result += c
return result
<BLANKLINE>
```
If you only want the infilled part:
```python
>>> from transformers import pipeline
>>> import torch
>>> generator = pipeline("text-generation",model="codellama/CodeLlama-7b-hf",torch_dtype=torch.float16, device_map="auto")
>>> generator('def remove_non_ascii(s: str) -> str:\n """ <FILL_ME>\n return result', max_new_tokens = 128)
[{'generated_text': 'def remove_non_ascii(s: str) -> str:\n """ <FILL_ME>\n return resultRemove non-ASCII characters from a string. """\n result = ""\n for c in s:\n if ord(c) < 128:\n result += c'}]
```
Under the hood, the tokenizer [automatically splits by `<FILL_ME>`](https://huggingface.co/docs/transformers/main/model_doc/code_llama#transformers.CodeLlamaTokenizer.fill_token) to create a formatted input string that follows [the original training pattern](https://github.com/facebookresearch/codellama/blob/cb51c14ec761370ba2e2bc351374a79265d0465e/llama/generation.py#L402). This is more robust than preparing the pattern yourself: it avoids pitfalls, such as token glueing, that are very hard to debug. To see how much CPU and GPU memory you need for this model or others, try [this calculator](https://huggingface.co/spaces/hf-accelerate/model-memory-usage) which can help determine that value.
The LLaMA tokenizer is a BPE model based on [sentencepiece](https://github.com/google/sentencepiece). One quirk of sentencepiece is that when decoding a sequence, if the first token is the start of the word (e.g. "Banana"), the tokenizer does not prepend the prefix space to the string.
<Tip>
Code Llama has the same architecture as the `Llama2` models, refer to [Llama2's documentation page](llama2) for the API reference.
Find Code Llama tokenizer reference below.
</Tip>
## CodeLlamaTokenizer
[[autodoc]] CodeLlamaTokenizer
- build_inputs_with_special_tokens
- get_special_tokens_mask
- create_token_type_ids_from_sequences
- save_vocabulary
## CodeLlamaTokenizerFast
[[autodoc]] CodeLlamaTokenizerFast
- build_inputs_with_special_tokens
- get_special_tokens_mask
- create_token_type_ids_from_sequences
- update_post_processor
- save_vocabulary
| 0 |
mavonic_private_repos/transformers/docs/source/en | mavonic_private_repos/transformers/docs/source/en/model_doc/flan-t5.md | <!--Copyright 2022 The HuggingFace Team. All rights reserved.
Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
the License. You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
specific language governing permissions and limitations under the License.
โ ๏ธ Note that this file is in Markdown but contain specific syntax for our doc-builder (similar to MDX) that may not be
rendered properly in your Markdown viewer.
-->
# FLAN-T5
## Overview
FLAN-T5 was released in the paper [Scaling Instruction-Finetuned Language Models](https://arxiv.org/pdf/2210.11416.pdf) - it is an enhanced version of T5 that has been finetuned in a mixture of tasks.
One can directly use FLAN-T5 weights without finetuning the model:
```python
>>> from transformers import AutoModelForSeq2SeqLM, AutoTokenizer
>>> model = AutoModelForSeq2SeqLM.from_pretrained("google/flan-t5-small")
>>> tokenizer = AutoTokenizer.from_pretrained("google/flan-t5-small")
>>> inputs = tokenizer("A step by step recipe to make bolognese pasta:", return_tensors="pt")
>>> outputs = model.generate(**inputs)
>>> print(tokenizer.batch_decode(outputs, skip_special_tokens=True))
['Pour a cup of bolognese into a large bowl and add the pasta']
```
FLAN-T5 includes the same improvements as T5 version 1.1 (see [here](https://huggingface.co/docs/transformers/model_doc/t5v1.1) for the full details of the model's improvements.)
Google has released the following variants:
- [google/flan-t5-small](https://huggingface.co/google/flan-t5-small)
- [google/flan-t5-base](https://huggingface.co/google/flan-t5-base)
- [google/flan-t5-large](https://huggingface.co/google/flan-t5-large)
- [google/flan-t5-xl](https://huggingface.co/google/flan-t5-xl)
- [google/flan-t5-xxl](https://huggingface.co/google/flan-t5-xxl).
The original checkpoints can be found [here](https://github.com/google-research/t5x/blob/main/docs/models.md#flan-t5-checkpoints).
<Tip>
Refer to [T5's documentation page](t5) for all API reference, code examples and notebooks. For more details regarding training and evaluation of the FLAN-T5, refer to the model card.
</Tip> | 0 |
mavonic_private_repos/transformers/docs/source/en | mavonic_private_repos/transformers/docs/source/en/model_doc/deit.md | <!--Copyright 2021 The HuggingFace Team. All rights reserved.
Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
the License. You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
specific language governing permissions and limitations under the License.
โ ๏ธ Note that this file is in Markdown but contain specific syntax for our doc-builder (similar to MDX) that may not be
rendered properly in your Markdown viewer.
-->
# DeiT
## Overview
The DeiT model was proposed in [Training data-efficient image transformers & distillation through attention](https://arxiv.org/abs/2012.12877) by Hugo Touvron, Matthieu Cord, Matthijs Douze, Francisco Massa, Alexandre
Sablayrolles, Hervรฉ Jรฉgou. The [Vision Transformer (ViT)](vit) introduced in [Dosovitskiy et al., 2020](https://arxiv.org/abs/2010.11929) has shown that one can match or even outperform existing convolutional neural
networks using a Transformer encoder (BERT-like). However, the ViT models introduced in that paper required training on
expensive infrastructure for multiple weeks, using external data. DeiT (data-efficient image transformers) are more
efficiently trained transformers for image classification, requiring far less data and far less computing resources
compared to the original ViT models.
The abstract from the paper is the following:
*Recently, neural networks purely based on attention were shown to address image understanding tasks such as image
classification. However, these visual transformers are pre-trained with hundreds of millions of images using an
expensive infrastructure, thereby limiting their adoption. In this work, we produce a competitive convolution-free
transformer by training on Imagenet only. We train them on a single computer in less than 3 days. Our reference vision
transformer (86M parameters) achieves top-1 accuracy of 83.1% (single-crop evaluation) on ImageNet with no external
data. More importantly, we introduce a teacher-student strategy specific to transformers. It relies on a distillation
token ensuring that the student learns from the teacher through attention. We show the interest of this token-based
distillation, especially when using a convnet as a teacher. This leads us to report results competitive with convnets
for both Imagenet (where we obtain up to 85.2% accuracy) and when transferring to other tasks. We share our code and
models.*
This model was contributed by [nielsr](https://huggingface.co/nielsr). The TensorFlow version of this model was added by [amyeroberts](https://huggingface.co/amyeroberts).
## Usage tips
- Compared to ViT, DeiT models use a so-called distillation token to effectively learn from a teacher (which, in the
DeiT paper, is a ResNet like-model). The distillation token is learned through backpropagation, by interacting with
the class ([CLS]) and patch tokens through the self-attention layers.
- There are 2 ways to fine-tune distilled models, either (1) in a classic way, by only placing a prediction head on top
of the final hidden state of the class token and not using the distillation signal, or (2) by placing both a
prediction head on top of the class token and on top of the distillation token. In that case, the [CLS] prediction
head is trained using regular cross-entropy between the prediction of the head and the ground-truth label, while the
distillation prediction head is trained using hard distillation (cross-entropy between the prediction of the
distillation head and the label predicted by the teacher). At inference time, one takes the average prediction
between both heads as final prediction. (2) is also called "fine-tuning with distillation", because one relies on a
teacher that has already been fine-tuned on the downstream dataset. In terms of models, (1) corresponds to
[`DeiTForImageClassification`] and (2) corresponds to
[`DeiTForImageClassificationWithTeacher`].
- Note that the authors also did try soft distillation for (2) (in which case the distillation prediction head is
trained using KL divergence to match the softmax output of the teacher), but hard distillation gave the best results.
- All released checkpoints were pre-trained and fine-tuned on ImageNet-1k only. No external data was used. This is in
contrast with the original ViT model, which used external data like the JFT-300M dataset/Imagenet-21k for
pre-training.
- The authors of DeiT also released more efficiently trained ViT models, which you can directly plug into
[`ViTModel`] or [`ViTForImageClassification`]. Techniques like data
augmentation, optimization, and regularization were used in order to simulate training on a much larger dataset
(while only using ImageNet-1k for pre-training). There are 4 variants available (in 3 different sizes):
*facebook/deit-tiny-patch16-224*, *facebook/deit-small-patch16-224*, *facebook/deit-base-patch16-224* and
*facebook/deit-base-patch16-384*. Note that one should use [`DeiTImageProcessor`] in order to
prepare images for the model.
## Resources
A list of official Hugging Face and community (indicated by ๐) resources to help you get started with DeiT.
<PipelineTag pipeline="image-classification"/>
- [`DeiTForImageClassification`] is supported by this [example script](https://github.com/huggingface/transformers/tree/main/examples/pytorch/image-classification) and [notebook](https://colab.research.google.com/github/huggingface/notebooks/blob/main/examples/image_classification.ipynb).
- See also: [Image classification task guide](../tasks/image_classification)
Besides that:
- [`DeiTForMaskedImageModeling`] is supported by this [example script](https://github.com/huggingface/transformers/tree/main/examples/pytorch/image-pretraining).
If you're interested in submitting a resource to be included here, please feel free to open a Pull Request and we'll review it! The resource should ideally demonstrate something new instead of duplicating an existing resource.
## DeiTConfig
[[autodoc]] DeiTConfig
## DeiTFeatureExtractor
[[autodoc]] DeiTFeatureExtractor
- __call__
## DeiTImageProcessor
[[autodoc]] DeiTImageProcessor
- preprocess
<frameworkcontent>
<pt>
## DeiTModel
[[autodoc]] DeiTModel
- forward
## DeiTForMaskedImageModeling
[[autodoc]] DeiTForMaskedImageModeling
- forward
## DeiTForImageClassification
[[autodoc]] DeiTForImageClassification
- forward
## DeiTForImageClassificationWithTeacher
[[autodoc]] DeiTForImageClassificationWithTeacher
- forward
</pt>
<tf>
## TFDeiTModel
[[autodoc]] TFDeiTModel
- call
## TFDeiTForMaskedImageModeling
[[autodoc]] TFDeiTForMaskedImageModeling
- call
## TFDeiTForImageClassification
[[autodoc]] TFDeiTForImageClassification
- call
## TFDeiTForImageClassificationWithTeacher
[[autodoc]] TFDeiTForImageClassificationWithTeacher
- call
</tf>
</frameworkcontent> | 0 |
mavonic_private_repos/transformers/docs/source/en | mavonic_private_repos/transformers/docs/source/en/model_doc/switch_transformers.md | <!--Copyright 2022 The HuggingFace Team. All rights reserved.
Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
the License. You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
specific language governing permissions and limitations under the License.
โ ๏ธ Note that this file is in Markdown but contain specific syntax for our doc-builder (similar to MDX) that may not be
rendered properly in your Markdown viewer.
-->
# SwitchTransformers
## Overview
The SwitchTransformers model was proposed in [Switch Transformers: Scaling to Trillion Parameter Models with Simple and Efficient Sparsity](https://arxiv.org/abs/2101.03961) by William Fedus, Barret Zoph, Noam Shazeer.
The Switch Transformer model uses a sparse T5 encoder-decoder architecture, where the MLP are replaced by a Mixture of Experts (MoE). A routing mechanism (top 1 in this case) associates each token to one of the expert, where each expert is a dense MLP. While switch transformers have a lot more weights than their equivalent dense models, the sparsity allows better scaling and better finetuning performance at scale.
During a forward pass, only a fraction of the weights are used. The routing mechanism allows the model to select relevant weights on the fly which increases the model capacity without increasing the number of operations.
The abstract from the paper is the following:
*In deep learning, models typically reuse the same parameters for all inputs. Mixture of Experts (MoE) defies this and instead selects different parameters for each incoming example. The result is a sparsely-activated model -- with outrageous numbers of parameters -- but a constant computational cost. However, despite several notable successes of MoE, widespread adoption has been hindered by complexity, communication costs and training instability -- we address these with the Switch Transformer. We simplify the MoE routing algorithm and design intuitive improved models with reduced communication and computational costs. Our proposed training techniques help wrangle the instabilities and we show large sparse models may be trained, for the first time, with lower precision (bfloat16) formats. We design models based off T5-Base and T5-Large to obtain up to 7x increases in pre-training speed with the same computational resources. These improvements extend into multilingual settings where we measure gains over the mT5-Base version across all 101 languages. Finally, we advance the current scale of language models by pre-training up to trillion parameter models on the "Colossal Clean Crawled Corpus" and achieve a 4x speedup over the T5-XXL model.*
This model was contributed by [Younes Belkada](https://huggingface.co/ybelkada) and [Arthur Zucker](https://huggingface.co/ArthurZ).
The original code can be found [here](https://github.com/google/flaxformer/tree/main/flaxformer/architectures/moe).
## Usage tips
- SwitchTransformers uses the [`T5Tokenizer`], which can be loaded directly from each model's repository.
- The released weights are pretrained on English [Masked Language Modeling](https://moon-ci-docs.huggingface.co/docs/transformers/pr_19323/en/glossary#general-terms) task, and should be finetuned.
## Resources
- [Translation task guide](../tasks/translation)
- [Summarization task guide](../tasks/summarization)
## SwitchTransformersConfig
[[autodoc]] SwitchTransformersConfig
## SwitchTransformersTop1Router
[[autodoc]] SwitchTransformersTop1Router
- _compute_router_probabilities
- forward
## SwitchTransformersSparseMLP
[[autodoc]] SwitchTransformersSparseMLP
- forward
## SwitchTransformersModel
[[autodoc]] SwitchTransformersModel
- forward
## SwitchTransformersForConditionalGeneration
[[autodoc]] SwitchTransformersForConditionalGeneration
- forward
## SwitchTransformersEncoderModel
[[autodoc]] SwitchTransformersEncoderModel
- forward
| 0 |
mavonic_private_repos/transformers/docs/source/en | mavonic_private_repos/transformers/docs/source/en/model_doc/llava_next.md | <!--Copyright 2024 The HuggingFace Team. All rights reserved.
Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
the License. You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
specific language governing permissions and limitations under the License.
โ ๏ธ Note that this file is in Markdown but contain specific syntax for our doc-builder (similar to MDX) that may not be
rendered properly in your Markdown viewer.
-->
# LLaVA-NeXT
## Overview
The LLaVA-NeXT model was proposed in [LLaVA-NeXT: Improved reasoning, OCR, and world knowledge](https://llava-vl.github.io/blog/2024-01-30-llava-next/) by Haotian Liu, Chunyuan Li, Yuheng Li, Bo Li, Yuanhan Zhang, Sheng Shen, Yong Jae Lee. LLaVa-NeXT (also called LLaVa-1.6) improves upon [LLaVa](llava) by increasing the input image resolution and training on an improved visual instruction tuning dataset to improve OCR and common sense reasoning.
The introduction from the blog is the following:
*In October 2023, we released LLaVA-1.5 with a simple and efficient design along with great performance on a benchmark suite of 12 datasets. It has since served as the foundation of many comprehensive studies of data, model, and capabilities of large multimodal models (LMM), and has enabled various new applications.
Today, we are thrilled to present LLaVA-NeXT, with improved reasoning, OCR, and world knowledge. LLaVA-NeXT even exceeds Gemini Pro on several benchmarks.
Compared with LLaVA-1.5, LLaVA-NeXT has several improvements:
Increasing the input image resolution to 4x more pixels. This allows it to grasp more visual details. It supports three aspect ratios, up to 672x672, 336x1344, 1344x336 resolution.
Better visual reasoning and OCR capability with an improved visual instruction tuning data mixture.
Better visual conversation for more scenarios, covering different applications. Better world knowledge and logical reasoning.
Efficient deployment and inference with SGLang.
Along with performance improvements, LLaVA-NeXT maintains the minimalist design and data efficiency of LLaVA-1.5. It re-uses the pretrained connector of LLaVA-1.5, and still uses less than 1M visual instruction tuning samples. The largest 34B variant finishes training in ~1 day with 32 A100s.*
<img src="https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/transformers/model_doc/llava_next_overview.png"
alt="drawing" width="600"/>
<small> LLaVa-NeXT incorporates a higher input resolution by encoding various patches of the input image. Taken from the <a href="https://arxiv.org/abs/2310.03744">original paper.</a> </small>
This model was contributed by [nielsr](https://huggingface.co/nielsr).
The original code can be found [here](https://github.com/haotian-liu/LLaVA/tree/main).
## Usage tips
- We advise users to use `padding_side="left"` when computing batched generation as it leads to more accurate results. Simply make sure to call `processor.tokenizer.padding_side = "left"` before generating.
- Note that each checkpoint has been trained with a specific prompt format, depending on which large language model (LLM) was used. Below, we list the correct prompt formats to use for the text prompt "What is shown in this image?":
[llava-v1.6-mistral-7b-hf](https://huggingface.co/llava-hf/llava-v1.6-mistral-7b-hf) requires the following format:
```bash
"[INST] <image>\nWhat is shown in this image? [/INST]"
```
[llava-v1.6-vicuna-7b-hf](https://huggingface.co/llava-hf/llava-v1.6-vicuna-7b-hf) and [llava-v1.6-vicuna-13b-hf](https://huggingface.co/llava-hf/llava-v1.6-vicuna-13b-hf) require the following format:
```bash
"A chat between a curious human and an artificial intelligence assistant. The assistant gives helpful, detailed, and polite answers to the human's questions. USER: <image>\nWhat is shown in this image? ASSISTANT:"
```
[llava-v1.6-34b-hf](https://huggingface.co/llava-hf/llava-v1.6-34b-hf) requires the following format:
```bash
"<|im_start|>system\nAnswer the questions.<|im_end|><|im_start|>user\n<image>\nWhat is shown in this image?<|im_end|><|im_start|>assistant\n"
```
## Usage example
Here's how to load the model and perform inference in half-precision (`torch.float16`):
```python
from transformers import LlavaNextProcessor, LlavaNextForConditionalGeneration
import torch
from PIL import Image
import requests
processor = LlavaNextProcessor.from_pretrained("llava-hf/llava-v1.6-mistral-7b-hf")
model = LlavaNextForConditionalGeneration.from_pretrained("llava-hf/llava-v1.6-mistral-7b-hf", torch_dtype=torch.float16, low_cpu_mem_usage=True)
model.to("cuda:0")
# prepare image and text prompt, using the appropriate prompt template
url = "https://github.com/haotian-liu/LLaVA/blob/1a91fc274d7c35a9b50b3cb29c4247ae5837ce39/images/llava_v1_5_radar.jpg?raw=true"
image = Image.open(requests.get(url, stream=True).raw)
prompt = "[INST] <image>\nWhat is shown in this image? [/INST]"
inputs = processor(prompt, image, return_tensors="pt").to("cuda:0")
# autoregressively complete prompt
output = model.generate(**inputs, max_new_tokens=100)
print(processor.decode(output[0], skip_special_tokens=True))
```
## Model optimization
### Quantization using Bitsandbytes
The model can be loaded in 8 or 4 bits, greatly reducing the memory requirements while maintaining the performance of the original model. First make sure to install bitsandbytes, `pip install bitsandbytes` and make sure to have access to a CUDA compatible GPU device. Simply change the snippet above with:
```python
from transformers import LlavaNextForConditionalGeneration, BitsAndBytesConfig
# specify how to quantize the model
quantization_config = BitsAndBytesConfig(
load_in_4bit=True,
bnb_4bit_quant_type="nf4",
bnb_4bit_compute_dtype=torch.float16,
)
model = LlavaNextForConditionalGeneration.from_pretrained("llava-hf/llava-v1.6-mistral-7b-hf", quantization_config=quantization_config, device_map="auto")
```
### Use Flash-Attention 2 to further speed-up generation
First make sure to install flash-attn. Refer to the [original repository of Flash Attention](https://github.com/Dao-AILab/flash-attention) regarding that package installation. Simply change the snippet above with:
```python
from transformers import LlavaNextForConditionalGeneration
model = LlavaNextForConditionalGeneration.from_pretrained(
model_id,
torch_dtype=torch.float16,
low_cpu_mem_usage=True,
use_flash_attention_2=True
).to(0)
```
## LlavaNextConfig
[[autodoc]] LlavaNextConfig
## LlavaNextImageProcessor
[[autodoc]] LlavaNextImageProcessor
- preprocess
## LlavaNextProcessor
[[autodoc]] LlavaNextProcessor
## LlavaNextForConditionalGeneration
[[autodoc]] LlavaNextForConditionalGeneration
- forward
| 0 |
mavonic_private_repos/transformers/docs/source/en | mavonic_private_repos/transformers/docs/source/en/model_doc/altclip.md | <!--Copyright 2022 The HuggingFace Team. All rights reserved.
Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
the License. You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
specific language governing permissions and limitations under the License.
โ ๏ธ Note that this file is in Markdown but contain specific syntax for our doc-builder (similar to MDX) that may not be
rendered properly in your Markdown viewer.
-->
# AltCLIP
## Overview
The AltCLIP model was proposed in [AltCLIP: Altering the Language Encoder in CLIP for Extended Language Capabilities](https://arxiv.org/abs/2211.06679v2) by Zhongzhi Chen, Guang Liu, Bo-Wen Zhang, Fulong Ye, Qinghong Yang, Ledell Wu. AltCLIP
(Altering the Language Encoder in CLIP) is a neural network trained on a variety of image-text and text-text pairs. By switching CLIP's
text encoder with a pretrained multilingual text encoder XLM-R, we could obtain very close performances with CLIP on almost all tasks, and extended original CLIP's capabilities such as multilingual understanding.
The abstract from the paper is the following:
*In this work, we present a conceptually simple and effective method to train a strong bilingual multimodal representation model.
Starting from the pretrained multimodal representation model CLIP released by OpenAI, we switched its text encoder with a pretrained
multilingual text encoder XLM-R, and aligned both languages and image representations by a two-stage training schema consisting of
teacher learning and contrastive learning. We validate our method through evaluations of a wide range of tasks. We set new state-of-the-art
performances on a bunch of tasks including ImageNet-CN, Flicker30k- CN, and COCO-CN. Further, we obtain very close performances with
CLIP on almost all tasks, suggesting that one can simply alter the text encoder in CLIP for extended capabilities such as multilingual understanding.*
This model was contributed by [jongjyh](https://huggingface.co/jongjyh).
## Usage tips and example
The usage of AltCLIP is very similar to the CLIP. the difference between CLIP is the text encoder. Note that we use bidirectional attention instead of casual attention
and we take the [CLS] token in XLM-R to represent text embedding.
AltCLIP is a multi-modal vision and language model. It can be used for image-text similarity and for zero-shot image
classification. AltCLIP uses a ViT like transformer to get visual features and a bidirectional language model to get the text
features. Both the text and visual features are then projected to a latent space with identical dimension. The dot
product between the projected image and text features is then used as a similar score.
To feed images to the Transformer encoder, each image is split into a sequence of fixed-size non-overlapping patches,
which are then linearly embedded. A [CLS] token is added to serve as representation of an entire image. The authors
also add absolute position embeddings, and feed the resulting sequence of vectors to a standard Transformer encoder.
The [`CLIPImageProcessor`] can be used to resize (or rescale) and normalize images for the model.
The [`AltCLIPProcessor`] wraps a [`CLIPImageProcessor`] and a [`XLMRobertaTokenizer`] into a single instance to both
encode the text and prepare the images. The following example shows how to get the image-text similarity scores using
[`AltCLIPProcessor`] and [`AltCLIPModel`].
```python
>>> from PIL import Image
>>> import requests
>>> from transformers import AltCLIPModel, AltCLIPProcessor
>>> model = AltCLIPModel.from_pretrained("BAAI/AltCLIP")
>>> processor = AltCLIPProcessor.from_pretrained("BAAI/AltCLIP")
>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw)
>>> inputs = processor(text=["a photo of a cat", "a photo of a dog"], images=image, return_tensors="pt", padding=True)
>>> outputs = model(**inputs)
>>> logits_per_image = outputs.logits_per_image # this is the image-text similarity score
>>> probs = logits_per_image.softmax(dim=1) # we can take the softmax to get the label probabilities
```
<Tip>
This model is based on `CLIPModel`, use it like you would use the original [CLIP](clip).
</Tip>
## AltCLIPConfig
[[autodoc]] AltCLIPConfig
- from_text_vision_configs
## AltCLIPTextConfig
[[autodoc]] AltCLIPTextConfig
## AltCLIPVisionConfig
[[autodoc]] AltCLIPVisionConfig
## AltCLIPProcessor
[[autodoc]] AltCLIPProcessor
## AltCLIPModel
[[autodoc]] AltCLIPModel
- forward
- get_text_features
- get_image_features
## AltCLIPTextModel
[[autodoc]] AltCLIPTextModel
- forward
## AltCLIPVisionModel
[[autodoc]] AltCLIPVisionModel
- forward | 0 |
mavonic_private_repos/transformers/docs/source/en | mavonic_private_repos/transformers/docs/source/en/model_doc/swin.md | <!--Copyright 2022 The HuggingFace Team. All rights reserved.
Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
the License. You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
specific language governing permissions and limitations under the License.
โ ๏ธ Note that this file is in Markdown but contain specific syntax for our doc-builder (similar to MDX) that may not be
rendered properly in your Markdown viewer.
-->
# Swin Transformer
## Overview
The Swin Transformer was proposed in [Swin Transformer: Hierarchical Vision Transformer using Shifted Windows](https://arxiv.org/abs/2103.14030)
by Ze Liu, Yutong Lin, Yue Cao, Han Hu, Yixuan Wei, Zheng Zhang, Stephen Lin, Baining Guo.
The abstract from the paper is the following:
*This paper presents a new vision Transformer, called Swin Transformer, that capably serves as a general-purpose backbone
for computer vision. Challenges in adapting Transformer from language to vision arise from differences between the two domains,
such as large variations in the scale of visual entities and the high resolution of pixels in images compared to words in text.
To address these differences, we propose a hierarchical Transformer whose representation is computed with \bold{S}hifted
\bold{win}dows. The shifted windowing scheme brings greater efficiency by limiting self-attention computation to non-overlapping
local windows while also allowing for cross-window connection. This hierarchical architecture has the flexibility to model at
various scales and has linear computational complexity with respect to image size. These qualities of Swin Transformer make it
compatible with a broad range of vision tasks, including image classification (87.3 top-1 accuracy on ImageNet-1K) and dense
prediction tasks such as object detection (58.7 box AP and 51.1 mask AP on COCO test-dev) and semantic segmentation
(53.5 mIoU on ADE20K val). Its performance surpasses the previous state-of-the-art by a large margin of +2.7 box AP and
+2.6 mask AP on COCO, and +3.2 mIoU on ADE20K, demonstrating the potential of Transformer-based models as vision backbones.
The hierarchical design and the shifted window approach also prove beneficial for all-MLP architectures.*
<img src="https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/swin_transformer_architecture.png"
alt="drawing" width="600"/>
<small> Swin Transformer architecture. Taken from the <a href="https://arxiv.org/abs/2102.03334">original paper</a>.</small>
This model was contributed by [novice03](https://huggingface.co/novice03). The Tensorflow version of this model was contributed by [amyeroberts](https://huggingface.co/amyeroberts). The original code can be found [here](https://github.com/microsoft/Swin-Transformer).
## Usage tips
- Swin pads the inputs supporting any input height and width (if divisible by `32`).
- Swin can be used as a *backbone*. When `output_hidden_states = True`, it will output both `hidden_states` and `reshaped_hidden_states`. The `reshaped_hidden_states` have a shape of `(batch, num_channels, height, width)` rather than `(batch_size, sequence_length, num_channels)`.
## Resources
A list of official Hugging Face and community (indicated by ๐) resources to help you get started with Swin Transformer.
<PipelineTag pipeline="image-classification"/>
- [`SwinForImageClassification`] is supported by this [example script](https://github.com/huggingface/transformers/tree/main/examples/pytorch/image-classification) and [notebook](https://colab.research.google.com/github/huggingface/notebooks/blob/main/examples/image_classification.ipynb).
- See also: [Image classification task guide](../tasks/image_classification)
Besides that:
- [`SwinForMaskedImageModeling`] is supported by this [example script](https://github.com/huggingface/transformers/tree/main/examples/pytorch/image-pretraining).
If you're interested in submitting a resource to be included here, please feel free to open a Pull Request and we'll review it! The resource should ideally demonstrate something new instead of duplicating an existing resource.
## SwinConfig
[[autodoc]] SwinConfig
<frameworkcontent>
<pt>
## SwinModel
[[autodoc]] SwinModel
- forward
## SwinForMaskedImageModeling
[[autodoc]] SwinForMaskedImageModeling
- forward
## SwinForImageClassification
[[autodoc]] transformers.SwinForImageClassification
- forward
</pt>
<tf>
## TFSwinModel
[[autodoc]] TFSwinModel
- call
## TFSwinForMaskedImageModeling
[[autodoc]] TFSwinForMaskedImageModeling
- call
## TFSwinForImageClassification
[[autodoc]] transformers.TFSwinForImageClassification
- call
</tf>
</frameworkcontent> | 0 |
mavonic_private_repos/transformers/docs/source/en | mavonic_private_repos/transformers/docs/source/en/model_doc/opt.md | <!--Copyright 2022 The HuggingFace Team. All rights reserved.
Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
the License. You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
specific language governing permissions and limitations under the License.
โ ๏ธ Note that this file is in Markdown but contain specific syntax for our doc-builder (similar to MDX) that may not be
rendered properly in your Markdown viewer.
-->
# OPT
## Overview
The OPT model was proposed in [Open Pre-trained Transformer Language Models](https://arxiv.org/pdf/2205.01068) by Meta AI.
OPT is a series of open-sourced large causal language models which perform similar in performance to GPT3.
The abstract from the paper is the following:
*Large language models, which are often trained for hundreds of thousands of compute days, have shown remarkable capabilities for zero- and few-shot learning. Given their computational cost, these models are difficult to replicate without significant capital. For the few that are available through APIs, no access is granted to the full model weights, making them difficult to study. We present Open Pre-trained Transformers (OPT), a suite of decoder-only pre-trained transformers ranging from 125M to 175B parameters, which we aim to fully and responsibly share with interested researchers. We show that OPT-175B is comparable to GPT-3, while requiring only 1/7th the carbon footprint to develop. We are also releasing our logbook detailing the infrastructure challenges we faced, along with code for experimenting with all of the released models.*
This model was contributed by [Arthur Zucker](https://huggingface.co/ArthurZ), [Younes Belkada](https://huggingface.co/ybelkada), and [Patrick Von Platen](https://huggingface.co/patrickvonplaten).
The original code can be found [here](https://github.com/facebookresearch/metaseq).
Tips:
- OPT has the same architecture as [`BartDecoder`].
- Contrary to GPT2, OPT adds the EOS token `</s>` to the beginning of every prompt.
## Resources
A list of official Hugging Face and community (indicated by ๐) resources to help you get started with OPT. If you're
interested in submitting a resource to be included here, please feel free to open a Pull Request and we will review it.
The resource should ideally demonstrate something new instead of duplicating an existing resource.
<PipelineTag pipeline="text-generation" />
- A notebook on [fine-tuning OPT with PEFT, bitsandbytes, and Transformers](https://colab.research.google.com/drive/1jCkpikz0J2o20FBQmYmAGdiKmJGOMo-o?usp=sharing). ๐
- A blog post on [decoding strategies with OPT](https://huggingface.co/blog/introducing-csearch#62-example-two---opt).
- [Causal language modeling](https://huggingface.co/course/en/chapter7/6?fw=pt#training-a-causal-language-model-from-scratch) chapter of the ๐ค Hugging Face Course.
- [`OPTForCausalLM`] is supported by this [causal language modeling example script](https://github.com/huggingface/transformers/tree/main/examples/pytorch/language-modeling#gpt-2gpt-and-causal-language-modeling) and [notebook](https://colab.research.google.com/github/huggingface/notebooks/blob/main/examples/language_modeling.ipynb).
- [`TFOPTForCausalLM`] is supported by this [causal language modeling example script](https://github.com/huggingface/transformers/tree/main/examples/tensorflow/language-modeling#run_clmpy) and [notebook](https://colab.research.google.com/github/huggingface/notebooks/blob/main/examples/language_modeling-tf.ipynb).
- [`FlaxOPTForCausalLM`] is supported by this [causal language modeling example script](https://github.com/huggingface/transformers/tree/main/examples/flax/language-modeling#causal-language-modeling).
<PipelineTag pipeline="text-classification" />
- [Text classification task guide](sequence_classification.md)
- [`OPTForSequenceClassification`] is supported by this [example script](https://github.com/huggingface/transformers/tree/main/examples/pytorch/text-classification) and [notebook](https://colab.research.google.com/github/huggingface/notebooks/blob/main/examples/text_classification.ipynb).
<PipelineTag pipeline="question-answering" />
- [`OPTForQuestionAnswering`] is supported by this [question answering example script](https://github.com/huggingface/transformers/tree/main/examples/pytorch/question-answering) and [notebook](https://colab.research.google.com/github/huggingface/notebooks/blob/main/examples/question_answering.ipynb).
- [Question answering](https://huggingface.co/course/chapter7/7?fw=pt) chapter
of the ๐ค Hugging Face Course.
โก๏ธ Inference
- A blog post on [How ๐ค Accelerate runs very large models thanks to PyTorch](https://huggingface.co/blog/accelerate-large-models) with OPT.
## Combining OPT and Flash Attention 2
First, make sure to install the latest version of Flash Attention 2 to include the sliding window attention feature.
```bash
pip install -U flash-attn --no-build-isolation
```
Make also sure that you have a hardware that is compatible with Flash-Attention 2. Read more about it in the official documentation of flash-attn repository. Make also sure to load your model in half-precision (e.g. `torch.float16``)
To load and run a model using Flash Attention 2, refer to the snippet below:
```python
>>> import torch
>>> from transformers import OPTForCausalLM, GPT2Tokenizer
>>> device = "cuda" # the device to load the model onto
>>> model = OPTForCausalLM.from_pretrained("facebook/opt-350m", torch_dtype=torch.float16, attn_implementation="flash_attention_2")
>>> tokenizer = GPT2Tokenizer.from_pretrained("facebook/opt-350m")
>>> prompt = ("A chat between a curious human and the Statue of Liberty.\n\nHuman: What is your name?\nStatue: I am the "
"Statue of Liberty.\nHuman: Where do you live?\nStatue: New York City.\nHuman: How long have you lived "
"there?")
>>> model_inputs = tokenizer([prompt], return_tensors="pt").to(device)
>>> model.to(device)
>>> generated_ids = model.generate(**model_inputs, max_new_tokens=30, do_sample=False)
>>> tokenizer.batch_decode(generated_ids)[0]
'</s>A chat between a curious human and the Statue of Liberty.\n\nHuman: What is your name?\nStatue: I am the Statue of Liberty.\nHuman: Where do you live?\nStatue: New York City.\nHuman: How long have you lived there?\nStatue: I have lived here for about a year.\nHuman: What is your favorite place to eat?\nStatue: I love'
```
### Expected speedups
Below is an expected speedup diagram that compares pure inference time between the native implementation in transformers using `facebook/opt-2.7b` checkpoint and the Flash Attention 2 version of the model using two different sequence lengths.
<div style="text-align: center">
<img src="https://user-images.githubusercontent.com/49240599/281101546-d2fca6d2-ee44-48f3-9534-ba8d5bee4531.png">
</div>
Below is an expected speedup diagram that compares pure inference time between the native implementation in transformers using `facebook/opt-350m` checkpoint and the Flash Attention 2 version of the model using two different sequence lengths.
<div style="text-align: center">
<img src="https://user-images.githubusercontent.com/49240599/281101682-d1144e90-0dbc-46f4-8fc8-c6206cb793c9.png">
</div>
## OPTConfig
[[autodoc]] OPTConfig
<frameworkcontent>
<pt>
## OPTModel
[[autodoc]] OPTModel
- forward
## OPTForCausalLM
[[autodoc]] OPTForCausalLM
- forward
## OPTForSequenceClassification
[[autodoc]] OPTForSequenceClassification
- forward
## OPTForQuestionAnswering
[[autodoc]] OPTForQuestionAnswering
- forward
</pt>
<tf>
## TFOPTModel
[[autodoc]] TFOPTModel
- call
## TFOPTForCausalLM
[[autodoc]] TFOPTForCausalLM
- call
</tf>
<jax>
## FlaxOPTModel
[[autodoc]] FlaxOPTModel
- __call__
## FlaxOPTForCausalLM
[[autodoc]] FlaxOPTForCausalLM
- __call__
</jax>
</frameworkcontent>
| 0 |
mavonic_private_repos/transformers/docs/source/en | mavonic_private_repos/transformers/docs/source/en/model_doc/cohere.md | # Cohere
## Overview
The Cohere Command-R model was proposed in the blogpost [Command-R: Retrieval Augmented Generation at Production Scale](https://txt.cohere.com/command-r/) by the Cohere Team.
The abstract from the paper is the following:
*Command-R is a scalable generative model targeting RAG and Tool Use to enable production-scale AI for enterprise. Today, we are introducing Command-R, a new LLM aimed at large-scale production workloads. Command-R targets the emerging โscalableโ category of models that balance high efficiency with strong accuracy, enabling companies to move beyond proof of concept, and into production.*
*Command-R is a generative model optimized for long context tasks such as retrieval augmented generation (RAG) and using external APIs and tools. It is designed to work in concert with our industry-leading Embed and Rerank models to provide best-in-class integration for RAG applications and excel at enterprise use cases. As a model built for companies to implement at scale, Command-R boasts:
- Strong accuracy on RAG and Tool Use
- Low latency, and high throughput
- Longer 128k context and lower pricing
- Strong capabilities across 10 key languages
- Model weights available on HuggingFace for research and evaluation
Checkout model checkpoints [here](https://huggingface.co/CohereForAI/c4ai-command-r-v01).
This model was contributed by [Saurabh Dash](https://huggingface.co/saurabhdash) and [Ahmet รstรผn](https://huggingface.co/ahmetustun). The code of the implementation in Hugging Face is based on GPT-NeoX [here](https://github.com/EleutherAI/gpt-neox).
## Usage tips
<Tip warning={true}>
The checkpoints uploaded on the Hub use `torch_dtype = 'float16'`, which will be
used by the `AutoModel` API to cast the checkpoints from `torch.float32` to `torch.float16`.
The `dtype` of the online weights is mostly irrelevant unless you are using `torch_dtype="auto"` when initializing a model using `model = AutoModelForCausalLM.from_pretrained("path", torch_dtype = "auto")`. The reason is that the model will first be downloaded ( using the `dtype` of the checkpoints online), then it will be casted to the default `dtype` of `torch` (becomes `torch.float32`), and finally, if there is a `torch_dtype` provided in the config, it will be used.
Training the model in `float16` is not recommended and is known to produce `nan`; as such, the model should be trained in `bfloat16`.
</Tip>
The model and tokenizer can be loaded via:
```python
# pip install transformers
from transformers import AutoTokenizer, AutoModelForCausalLM
model_id = "CohereForAI/c4ai-command-r-v01"
tokenizer = AutoTokenizer.from_pretrained(model_id)
model = AutoModelForCausalLM.from_pretrained(model_id)
# Format message with the command-r chat template
messages = [{"role": "user", "content": "Hello, how are you?"}]
input_ids = tokenizer.apply_chat_template(messages, tokenize=True, add_generation_prompt=True, return_tensors="pt")
## <BOS_TOKEN><|START_OF_TURN_TOKEN|><|USER_TOKEN|>Hello, how are you?<|END_OF_TURN_TOKEN|><|START_OF_TURN_TOKEN|><|CHATBOT_TOKEN|>
gen_tokens = model.generate(
input_ids,
max_new_tokens=100,
do_sample=True,
temperature=0.3,
)
gen_text = tokenizer.decode(gen_tokens[0])
print(gen_text)
```
- When using Flash Attention 2 via `attn_implementation="flash_attention_2"`, don't pass `torch_dtype` to the `from_pretrained` class method and use Automatic Mixed-Precision training. When using `Trainer`, it is simply specifying either `fp16` or `bf16` to `True`. Otherwise, make sure you are using `torch.autocast`. This is required because the Flash Attention only support `fp16` and `bf16` data type.
## Resources
A list of official Hugging Face and community (indicated by ๐) resources to help you get started with Command-R. If you're interested in submitting a resource to be included here, please feel free to open a Pull Request and we'll review it! The resource should ideally demonstrate something new instead of duplicating an existing resource.
<PipelineTag pipeline="text-generation"/>
Loading FP16 model
```python
# pip install transformers
from transformers import AutoTokenizer, AutoModelForCausalLM
model_id = "CohereForAI/c4ai-command-r-v01"
tokenizer = AutoTokenizer.from_pretrained(model_id)
model = AutoModelForCausalLM.from_pretrained(model_id)
# Format message with the command-r chat template
messages = [{"role": "user", "content": "Hello, how are you?"}]
input_ids = tokenizer.apply_chat_template(messages, tokenize=True, add_generation_prompt=True, return_tensors="pt")
## <BOS_TOKEN><|START_OF_TURN_TOKEN|><|USER_TOKEN|>Hello, how are you?<|END_OF_TURN_TOKEN|><|START_OF_TURN_TOKEN|><|CHATBOT_TOKEN|>
gen_tokens = model.generate(
input_ids,
max_new_tokens=100,
do_sample=True,
temperature=0.3,
)
gen_text = tokenizer.decode(gen_tokens[0])
print(gen_text)
```
Loading bitsnbytes 4bit quantized model
```python
# pip install transformers bitsandbytes accelerate
from transformers import AutoTokenizer, AutoModelForCausalLM, BitsAndBytesConfig
bnb_config = BitsAndBytesConfig(load_in_4bit=True)
model_id = "CohereForAI/c4ai-command-r-v01"
tokenizer = AutoTokenizer.from_pretrained(model_id)
model = AutoModelForCausalLM.from_pretrained(model_id, quantization_config=bnb_config)
gen_tokens = model.generate(
input_ids,
max_new_tokens=100,
do_sample=True,
temperature=0.3,
)
gen_text = tokenizer.decode(gen_tokens[0])
print(gen_text)
```
## CohereConfig
[[autodoc]] CohereConfig
## CohereTokenizerFast
[[autodoc]] CohereTokenizerFast
- build_inputs_with_special_tokens
- get_special_tokens_mask
- create_token_type_ids_from_sequences
- update_post_processor
- save_vocabulary
## CohereModel
[[autodoc]] CohereModel
- forward
## CohereForCausalLM
[[autodoc]] CohereForCausalLM
- forward
| 0 |
mavonic_private_repos/transformers/docs/source/en | mavonic_private_repos/transformers/docs/source/en/model_doc/mluke.md | <!--Copyright 2021 The HuggingFace Team. All rights reserved.
Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
the License. You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
specific language governing permissions and limitations under the License.
โ ๏ธ Note that this file is in Markdown but contain specific syntax for our doc-builder (similar to MDX) that may not be
rendered properly in your Markdown viewer.
-->
# mLUKE
## Overview
The mLUKE model was proposed in [mLUKE: The Power of Entity Representations in Multilingual Pretrained Language Models](https://arxiv.org/abs/2110.08151) by Ryokan Ri, Ikuya Yamada, and Yoshimasa Tsuruoka. It's a multilingual extension
of the [LUKE model](https://arxiv.org/abs/2010.01057) trained on the basis of XLM-RoBERTa.
It is based on XLM-RoBERTa and adds entity embeddings, which helps improve performance on various downstream tasks
involving reasoning about entities such as named entity recognition, extractive question answering, relation
classification, cloze-style knowledge completion.
The abstract from the paper is the following:
*Recent studies have shown that multilingual pretrained language models can be effectively improved with cross-lingual
alignment information from Wikipedia entities. However, existing methods only exploit entity information in pretraining
and do not explicitly use entities in downstream tasks. In this study, we explore the effectiveness of leveraging
entity representations for downstream cross-lingual tasks. We train a multilingual language model with 24 languages
with entity representations and show the model consistently outperforms word-based pretrained models in various
cross-lingual transfer tasks. We also analyze the model and the key insight is that incorporating entity
representations into the input allows us to extract more language-agnostic features. We also evaluate the model with a
multilingual cloze prompt task with the mLAMA dataset. We show that entity-based prompt elicits correct factual
knowledge more likely than using only word representations.*
This model was contributed by [ryo0634](https://huggingface.co/ryo0634). The original code can be found [here](https://github.com/studio-ousia/luke).
## Usage tips
One can directly plug in the weights of mLUKE into a LUKE model, like so:
```python
from transformers import LukeModel
model = LukeModel.from_pretrained("studio-ousia/mluke-base")
```
Note that mLUKE has its own tokenizer, [`MLukeTokenizer`]. You can initialize it as follows:
```python
from transformers import MLukeTokenizer
tokenizer = MLukeTokenizer.from_pretrained("studio-ousia/mluke-base")
```
<Tip>
As mLUKE's architecture is equivalent to that of LUKE, one can refer to [LUKE's documentation page](luke) for all
tips, code examples and notebooks.
</Tip>
## MLukeTokenizer
[[autodoc]] MLukeTokenizer
- __call__
- save_vocabulary
| 0 |
mavonic_private_repos/transformers/docs/source/en | mavonic_private_repos/transformers/docs/source/en/model_doc/table-transformer.md | <!--Copyright 2022 The HuggingFace Team. All rights reserved.
Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
the License. You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
specific language governing permissions and limitations under the License.
โ ๏ธ Note that this file is in Markdown but contain specific syntax for our doc-builder (similar to MDX) that may not be
rendered properly in your Markdown viewer.
-->
# Table Transformer
## Overview
The Table Transformer model was proposed in [PubTables-1M: Towards comprehensive table extraction from unstructured documents](https://arxiv.org/abs/2110.00061) by
Brandon Smock, Rohith Pesala, Robin Abraham. The authors introduce a new dataset, PubTables-1M, to benchmark progress in table extraction from unstructured documents,
as well as table structure recognition and functional analysis. The authors train 2 [DETR](detr) models, one for table detection and one for table structure recognition, dubbed Table Transformers.
The abstract from the paper is the following:
*Recently, significant progress has been made applying machine learning to the problem of table structure inference and extraction from unstructured documents.
However, one of the greatest challenges remains the creation of datasets with complete, unambiguous ground truth at scale. To address this, we develop a new, more
comprehensive dataset for table extraction, called PubTables-1M. PubTables-1M contains nearly one million tables from scientific articles, supports multiple input
modalities, and contains detailed header and location information for table structures, making it useful for a wide variety of modeling approaches. It also addresses a significant
source of ground truth inconsistency observed in prior datasets called oversegmentation, using a novel canonicalization procedure. We demonstrate that these improvements lead to a
significant increase in training performance and a more reliable estimate of model performance at evaluation for table structure recognition. Further, we show that transformer-based
object detection models trained on PubTables-1M produce excellent results for all three tasks of detection, structure recognition, and functional analysis without the need for any
special customization for these tasks.*
<img src="https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/transformers/model_doc/table_transformer_architecture.jpeg"
alt="drawing" width="600"/>
<small> Table detection and table structure recognition clarified. Taken from the <a href="https://arxiv.org/abs/2110.00061">original paper</a>. </small>
The authors released 2 models, one for [table detection](https://huggingface.co/microsoft/table-transformer-detection) in
documents, one for [table structure recognition](https://huggingface.co/microsoft/table-transformer-structure-recognition)
(the task of recognizing the individual rows, columns etc. in a table).
This model was contributed by [nielsr](https://huggingface.co/nielsr). The original code can be
found [here](https://github.com/microsoft/table-transformer).
## Resources
<PipelineTag pipeline="object-detection"/>
- A demo notebook for the Table Transformer can be found [here](https://github.com/NielsRogge/Transformers-Tutorials/tree/master/Table%20Transformer).
- It turns out padding of images is quite important for detection. An interesting Github thread with replies from the authors can be found [here](https://github.com/microsoft/table-transformer/issues/68).
## TableTransformerConfig
[[autodoc]] TableTransformerConfig
## TableTransformerModel
[[autodoc]] TableTransformerModel
- forward
## TableTransformerForObjectDetection
[[autodoc]] TableTransformerForObjectDetection
- forward
| 0 |
mavonic_private_repos/transformers/docs/source/en | mavonic_private_repos/transformers/docs/source/en/model_doc/flaubert.md | <!--Copyright 2020 The HuggingFace Team. All rights reserved.
Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
the License. You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
specific language governing permissions and limitations under the License.
โ ๏ธ Note that this file is in Markdown but contain specific syntax for our doc-builder (similar to MDX) that may not be
rendered properly in your Markdown viewer.
-->
# FlauBERT
<div class="flex flex-wrap space-x-1">
<a href="https://huggingface.co/models?filter=flaubert">
<img alt="Models" src="https://img.shields.io/badge/All_model_pages-flaubert-blueviolet">
</a>
<a href="https://huggingface.co/spaces/docs-demos/flaubert_small_cased">
<img alt="Spaces" src="https://img.shields.io/badge/%F0%9F%A4%97%20Hugging%20Face-Spaces-blue">
</a>
</div>
## Overview
The FlauBERT model was proposed in the paper [FlauBERT: Unsupervised Language Model Pre-training for French](https://arxiv.org/abs/1912.05372) by Hang Le et al. It's a transformer model pretrained using a masked language
modeling (MLM) objective (like BERT).
The abstract from the paper is the following:
*Language models have become a key step to achieve state-of-the art results in many different Natural Language
Processing (NLP) tasks. Leveraging the huge amount of unlabeled texts nowadays available, they provide an efficient way
to pre-train continuous word representations that can be fine-tuned for a downstream task, along with their
contextualization at the sentence level. This has been widely demonstrated for English using contextualized
representations (Dai and Le, 2015; Peters et al., 2018; Howard and Ruder, 2018; Radford et al., 2018; Devlin et al.,
2019; Yang et al., 2019b). In this paper, we introduce and share FlauBERT, a model learned on a very large and
heterogeneous French corpus. Models of different sizes are trained using the new CNRS (French National Centre for
Scientific Research) Jean Zay supercomputer. We apply our French language models to diverse NLP tasks (text
classification, paraphrasing, natural language inference, parsing, word sense disambiguation) and show that most of the
time they outperform other pretraining approaches. Different versions of FlauBERT as well as a unified evaluation
protocol for the downstream tasks, called FLUE (French Language Understanding Evaluation), are shared to the research
community for further reproducible experiments in French NLP.*
This model was contributed by [formiel](https://huggingface.co/formiel). The original code can be found [here](https://github.com/getalp/Flaubert).
Tips:
- Like RoBERTa, without the sentence ordering prediction (so just trained on the MLM objective).
## Resources
- [Text classification task guide](../tasks/sequence_classification)
- [Token classification task guide](../tasks/token_classification)
- [Question answering task guide](../tasks/question_answering)
- [Masked language modeling task guide](../tasks/masked_language_modeling)
- [Multiple choice task guide](../tasks/multiple_choice)
## FlaubertConfig
[[autodoc]] FlaubertConfig
## FlaubertTokenizer
[[autodoc]] FlaubertTokenizer
<frameworkcontent>
<pt>
## FlaubertModel
[[autodoc]] FlaubertModel
- forward
## FlaubertWithLMHeadModel
[[autodoc]] FlaubertWithLMHeadModel
- forward
## FlaubertForSequenceClassification
[[autodoc]] FlaubertForSequenceClassification
- forward
## FlaubertForMultipleChoice
[[autodoc]] FlaubertForMultipleChoice
- forward
## FlaubertForTokenClassification
[[autodoc]] FlaubertForTokenClassification
- forward
## FlaubertForQuestionAnsweringSimple
[[autodoc]] FlaubertForQuestionAnsweringSimple
- forward
## FlaubertForQuestionAnswering
[[autodoc]] FlaubertForQuestionAnswering
- forward
</pt>
<tf>
## TFFlaubertModel
[[autodoc]] TFFlaubertModel
- call
## TFFlaubertWithLMHeadModel
[[autodoc]] TFFlaubertWithLMHeadModel
- call
## TFFlaubertForSequenceClassification
[[autodoc]] TFFlaubertForSequenceClassification
- call
## TFFlaubertForMultipleChoice
[[autodoc]] TFFlaubertForMultipleChoice
- call
## TFFlaubertForTokenClassification
[[autodoc]] TFFlaubertForTokenClassification
- call
## TFFlaubertForQuestionAnsweringSimple
[[autodoc]] TFFlaubertForQuestionAnsweringSimple
- call
</tf>
</frameworkcontent>
| 0 |
mavonic_private_repos/transformers/docs/source/en | mavonic_private_repos/transformers/docs/source/en/model_doc/mobilevit.md | <!--Copyright 2022 The HuggingFace Team. All rights reserved.
Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
the License. You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
specific language governing permissions and limitations under the License.
โ ๏ธ Note that this file is in Markdown but contain specific syntax for our doc-builder (similar to MDX) that may not be
rendered properly in your Markdown viewer.
-->
# MobileViT
## Overview
The MobileViT model was proposed in [MobileViT: Light-weight, General-purpose, and Mobile-friendly Vision Transformer](https://arxiv.org/abs/2110.02178) by Sachin Mehta and Mohammad Rastegari. MobileViT introduces a new layer that replaces local processing in convolutions with global processing using transformers.
The abstract from the paper is the following:
*Light-weight convolutional neural networks (CNNs) are the de-facto for mobile vision tasks. Their spatial inductive biases allow them to learn representations with fewer parameters across different vision tasks. However, these networks are spatially local. To learn global representations, self-attention-based vision trans-formers (ViTs) have been adopted. Unlike CNNs, ViTs are heavy-weight. In this paper, we ask the following question: is it possible to combine the strengths of CNNs and ViTs to build a light-weight and low latency network for mobile vision tasks? Towards this end, we introduce MobileViT, a light-weight and general-purpose vision transformer for mobile devices. MobileViT presents a different perspective for the global processing of information with transformers, i.e., transformers as convolutions. Our results show that MobileViT significantly outperforms CNN- and ViT-based networks across different tasks and datasets. On the ImageNet-1k dataset, MobileViT achieves top-1 accuracy of 78.4% with about 6 million parameters, which is 3.2% and 6.2% more accurate than MobileNetv3 (CNN-based) and DeIT (ViT-based) for a similar number of parameters. On the MS-COCO object detection task, MobileViT is 5.7% more accurate than MobileNetv3 for a similar number of parameters.*
This model was contributed by [matthijs](https://huggingface.co/Matthijs). The TensorFlow version of the model was contributed by [sayakpaul](https://huggingface.co/sayakpaul). The original code and weights can be found [here](https://github.com/apple/ml-cvnets).
## Usage tips
- MobileViT is more like a CNN than a Transformer model. It does not work on sequence data but on batches of images. Unlike ViT, there are no embeddings. The backbone model outputs a feature map. You can follow [this tutorial](https://keras.io/examples/vision/mobilevit) for a lightweight introduction.
- One can use [`MobileViTImageProcessor`] to prepare images for the model. Note that if you do your own preprocessing, the pretrained checkpoints expect images to be in BGR pixel order (not RGB).
- The available image classification checkpoints are pre-trained on [ImageNet-1k](https://huggingface.co/datasets/imagenet-1k) (also referred to as ILSVRC 2012, a collection of 1.3 million images and 1,000 classes).
- The segmentation model uses a [DeepLabV3](https://arxiv.org/abs/1706.05587) head. The available semantic segmentation checkpoints are pre-trained on [PASCAL VOC](http://host.robots.ox.ac.uk/pascal/VOC/).
- As the name suggests MobileViT was designed to be performant and efficient on mobile phones. The TensorFlow versions of the MobileViT models are fully compatible with [TensorFlow Lite](https://www.tensorflow.org/lite).
You can use the following code to convert a MobileViT checkpoint (be it image classification or semantic segmentation) to generate a
TensorFlow Lite model:
```py
from transformers import TFMobileViTForImageClassification
import tensorflow as tf
model_ckpt = "apple/mobilevit-xx-small"
model = TFMobileViTForImageClassification.from_pretrained(model_ckpt)
converter = tf.lite.TFLiteConverter.from_keras_model(model)
converter.optimizations = [tf.lite.Optimize.DEFAULT]
converter.target_spec.supported_ops = [
tf.lite.OpsSet.TFLITE_BUILTINS,
tf.lite.OpsSet.SELECT_TF_OPS,
]
tflite_model = converter.convert()
tflite_filename = model_ckpt.split("/")[-1] + ".tflite"
with open(tflite_filename, "wb") as f:
f.write(tflite_model)
```
The resulting model will be just **about an MB** making it a good fit for mobile applications where resources and network
bandwidth can be constrained.
## Resources
A list of official Hugging Face and community (indicated by ๐) resources to help you get started with MobileViT.
<PipelineTag pipeline="image-classification"/>
- [`MobileViTForImageClassification`] is supported by this [example script](https://github.com/huggingface/transformers/tree/main/examples/pytorch/image-classification) and [notebook](https://colab.research.google.com/github/huggingface/notebooks/blob/main/examples/image_classification.ipynb).
- See also: [Image classification task guide](../tasks/image_classification)
**Semantic segmentation**
- [Semantic segmentation task guide](../tasks/semantic_segmentation)
If you're interested in submitting a resource to be included here, please feel free to open a Pull Request and we'll review it! The resource should ideally demonstrate something new instead of duplicating an existing resource.
## MobileViTConfig
[[autodoc]] MobileViTConfig
## MobileViTFeatureExtractor
[[autodoc]] MobileViTFeatureExtractor
- __call__
- post_process_semantic_segmentation
## MobileViTImageProcessor
[[autodoc]] MobileViTImageProcessor
- preprocess
- post_process_semantic_segmentation
<frameworkcontent>
<pt>
## MobileViTModel
[[autodoc]] MobileViTModel
- forward
## MobileViTForImageClassification
[[autodoc]] MobileViTForImageClassification
- forward
## MobileViTForSemanticSegmentation
[[autodoc]] MobileViTForSemanticSegmentation
- forward
</pt>
<tf>
## TFMobileViTModel
[[autodoc]] TFMobileViTModel
- call
## TFMobileViTForImageClassification
[[autodoc]] TFMobileViTForImageClassification
- call
## TFMobileViTForSemanticSegmentation
[[autodoc]] TFMobileViTForSemanticSegmentation
- call
</tf>
</frameworkcontent> | 0 |
mavonic_private_repos/transformers/docs/source/en | mavonic_private_repos/transformers/docs/source/en/model_doc/bert.md | <!--Copyright 2020 The HuggingFace Team. All rights reserved.
Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
the License. You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
specific language governing permissions and limitations under the License.
โ ๏ธ Note that this file is in Markdown but contain specific syntax for our doc-builder (similar to MDX) that may not be
rendered properly in your Markdown viewer.
-->
# BERT
<div class="flex flex-wrap space-x-1">
<a href="https://huggingface.co/models?filter=bert">
<img alt="Models" src="https://img.shields.io/badge/All_model_pages-bert-blueviolet">
</a>
<a href="https://huggingface.co/spaces/docs-demos/bert-base-uncased">
<img alt="Spaces" src="https://img.shields.io/badge/%F0%9F%A4%97%20Hugging%20Face-Spaces-blue">
</a>
</div>
## Overview
The BERT model was proposed in [BERT: Pre-training of Deep Bidirectional Transformers for Language Understanding](https://arxiv.org/abs/1810.04805) by Jacob Devlin, Ming-Wei Chang, Kenton Lee and Kristina Toutanova. It's a
bidirectional transformer pretrained using a combination of masked language modeling objective and next sentence
prediction on a large corpus comprising the Toronto Book Corpus and Wikipedia.
The abstract from the paper is the following:
*We introduce a new language representation model called BERT, which stands for Bidirectional Encoder Representations
from Transformers. Unlike recent language representation models, BERT is designed to pre-train deep bidirectional
representations from unlabeled text by jointly conditioning on both left and right context in all layers. As a result,
the pre-trained BERT model can be fine-tuned with just one additional output layer to create state-of-the-art models
for a wide range of tasks, such as question answering and language inference, without substantial task-specific
architecture modifications.*
*BERT is conceptually simple and empirically powerful. It obtains new state-of-the-art results on eleven natural
language processing tasks, including pushing the GLUE score to 80.5% (7.7% point absolute improvement), MultiNLI
accuracy to 86.7% (4.6% absolute improvement), SQuAD v1.1 question answering Test F1 to 93.2 (1.5 point absolute
improvement) and SQuAD v2.0 Test F1 to 83.1 (5.1 point absolute improvement).*
This model was contributed by [thomwolf](https://huggingface.co/thomwolf). The original code can be found [here](https://github.com/google-research/bert).
## Usage tips
- BERT is a model with absolute position embeddings so it's usually advised to pad the inputs on the right rather than
the left.
- BERT was trained with the masked language modeling (MLM) and next sentence prediction (NSP) objectives. It is
efficient at predicting masked tokens and at NLU in general, but is not optimal for text generation.
- Corrupts the inputs by using random masking, more precisely, during pretraining, a given percentage of tokens (usually 15%) is masked by:
* a special mask token with probability 0.8
* a random token different from the one masked with probability 0.1
* the same token with probability 0.1
- The model must predict the original sentence, but has a second objective: inputs are two sentences A and B (with a separation token in between). With probability 50%, the sentences are consecutive in the corpus, in the remaining 50% they are not related. The model has to predict if the sentences are consecutive or not.
### Using Scaled Dot Product Attention (SDPA)
PyTorch includes a native scaled dot-product attention (SDPA) operator as part of `torch.nn.functional`. This function
encompasses several implementations that can be applied depending on the inputs and the hardware in use. See the
[official documentation](https://pytorch.org/docs/stable/generated/torch.nn.functional.scaled_dot_product_attention.html)
or the [GPU Inference](https://huggingface.co/docs/transformers/main/en/perf_infer_gpu_one#pytorch-scaled-dot-product-attention)
page for more information.
SDPA is used by default for `torch>=2.1.1` when an implementation is available, but you may also set
`attn_implementation="sdpa"` in `from_pretrained()` to explicitly request SDPA to be used.
```
from transformers import BertModel
model = BertModel.from_pretrained("bert-base-uncased", torch_dtype=torch.float16, attn_implementation="sdpa")
...
```
For the best speedups, we recommend loading the model in half-precision (e.g. `torch.float16` or `torch.bfloat16`).
On a local benchmark (A100-80GB, CPUx12, RAM 96.6GB, PyTorch 2.2.0, OS Ubuntu 22.04) with `float16`, we saw the
following speedups during training and inference.
#### Training
|batch_size|seq_len|Time per batch (eager - s)|Time per batch (sdpa - s)|Speedup (%)|Eager peak mem (MB)|sdpa peak mem (MB)|Mem saving (%)|
|----------|-------|--------------------------|-------------------------|-----------|-------------------|------------------|--------------|
|4 |256 |0.023 |0.017 |35.472 |939.213 |764.834 |22.800 |
|4 |512 |0.023 |0.018 |23.687 |1970.447 |1227.162 |60.569 |
|8 |256 |0.023 |0.018 |23.491 |1594.295 |1226.114 |30.028 |
|8 |512 |0.035 |0.025 |43.058 |3629.401 |2134.262 |70.054 |
|16 |256 |0.030 |0.024 |25.583 |2874.426 |2134.262 |34.680 |
|16 |512 |0.064 |0.044 |46.223 |6964.659 |3961.013 |75.830 |
#### Inference
|batch_size|seq_len|Per token latency eager (ms)|Per token latency SDPA (ms)|Speedup (%)|Mem eager (MB)|Mem BT (MB)|Mem saved (%)|
|----------|-------|----------------------------|---------------------------|-----------|--------------|-----------|-------------|
|1 |128 |5.736 |4.987 |15.022 |282.661 |282.924 |-0.093 |
|1 |256 |5.689 |4.945 |15.055 |298.686 |298.948 |-0.088 |
|2 |128 |6.154 |4.982 |23.521 |314.523 |314.785 |-0.083 |
|2 |256 |6.201 |4.949 |25.303 |347.546 |347.033 |0.148 |
|4 |128 |6.049 |4.987 |21.305 |378.895 |379.301 |-0.107 |
|4 |256 |6.285 |5.364 |17.166 |443.209 |444.382 |-0.264 |
## Resources
A list of official Hugging Face and community (indicated by ๐) resources to help you get started with BERT. If you're interested in submitting a resource to be included here, please feel free to open a Pull Request and we'll review it! The resource should ideally demonstrate something new instead of duplicating an existing resource.
<PipelineTag pipeline="text-classification"/>
- A blog post on [BERT Text Classification in a different language](https://www.philschmid.de/bert-text-classification-in-a-different-language).
- A notebook for [Finetuning BERT (and friends) for multi-label text classification](https://colab.research.google.com/github/NielsRogge/Transformers-Tutorials/blob/master/BERT/Fine_tuning_BERT_(and_friends)_for_multi_label_text_classification.ipynb).
- A notebook on how to [Finetune BERT for multi-label classification using PyTorch](https://colab.research.google.com/github/abhimishra91/transformers-tutorials/blob/master/transformers_multi_label_classification.ipynb). ๐
- A notebook on how to [warm-start an EncoderDecoder model with BERT for summarization](https://colab.research.google.com/github/patrickvonplaten/notebooks/blob/master/BERT2BERT_for_CNN_Dailymail.ipynb).
- [`BertForSequenceClassification`] is supported by this [example script](https://github.com/huggingface/transformers/tree/main/examples/pytorch/text-classification) and [notebook](https://colab.research.google.com/github/huggingface/notebooks/blob/main/examples/text_classification.ipynb).
- [`TFBertForSequenceClassification`] is supported by this [example script](https://github.com/huggingface/transformers/tree/main/examples/tensorflow/text-classification) and [notebook](https://colab.research.google.com/github/huggingface/notebooks/blob/main/examples/text_classification-tf.ipynb).
- [`FlaxBertForSequenceClassification`] is supported by this [example script](https://github.com/huggingface/transformers/tree/main/examples/flax/text-classification) and [notebook](https://colab.research.google.com/github/huggingface/notebooks/blob/main/examples/text_classification_flax.ipynb).
- [Text classification task guide](../tasks/sequence_classification)
<PipelineTag pipeline="token-classification"/>
- A blog post on how to use [Hugging Face Transformers with Keras: Fine-tune a non-English BERT for Named Entity Recognition](https://www.philschmid.de/huggingface-transformers-keras-tf).
- A notebook for [Finetuning BERT for named-entity recognition](https://colab.research.google.com/github/NielsRogge/Transformers-Tutorials/blob/master/BERT/Custom_Named_Entity_Recognition_with_BERT_only_first_wordpiece.ipynb) using only the first wordpiece of each word in the word label during tokenization. To propagate the label of the word to all wordpieces, see this [version](https://github.com/NielsRogge/Transformers-Tutorials/blob/master/BERT/Custom_Named_Entity_Recognition_with_BERT.ipynb) of the notebook instead.
- [`BertForTokenClassification`] is supported by this [example script](https://github.com/huggingface/transformers/tree/main/examples/pytorch/token-classification) and [notebook](https://colab.research.google.com/github/huggingface/notebooks/blob/main/examples/token_classification.ipynb).
- [`TFBertForTokenClassification`] is supported by this [example script](https://github.com/huggingface/transformers/tree/main/examples/tensorflow/token-classification) and [notebook](https://colab.research.google.com/github/huggingface/notebooks/blob/main/examples/token_classification-tf.ipynb).
- [`FlaxBertForTokenClassification`] is supported by this [example script](https://github.com/huggingface/transformers/tree/main/examples/flax/token-classification).
- [Token classification](https://huggingface.co/course/chapter7/2?fw=pt) chapter of the ๐ค Hugging Face Course.
- [Token classification task guide](../tasks/token_classification)
<PipelineTag pipeline="fill-mask"/>
- [`BertForMaskedLM`] is supported by this [example script](https://github.com/huggingface/transformers/tree/main/examples/pytorch/language-modeling#robertabertdistilbert-and-masked-language-modeling) and [notebook](https://colab.research.google.com/github/huggingface/notebooks/blob/main/examples/language_modeling.ipynb).
- [`TFBertForMaskedLM`] is supported by this [example script](https://github.com/huggingface/transformers/tree/main/examples/tensorflow/language-modeling#run_mlmpy) and [notebook](https://colab.research.google.com/github/huggingface/notebooks/blob/main/examples/language_modeling-tf.ipynb).
- [`FlaxBertForMaskedLM`] is supported by this [example script](https://github.com/huggingface/transformers/tree/main/examples/flax/language-modeling#masked-language-modeling) and [notebook](https://colab.research.google.com/github/huggingface/notebooks/blob/main/examples/masked_language_modeling_flax.ipynb).
- [Masked language modeling](https://huggingface.co/course/chapter7/3?fw=pt) chapter of the ๐ค Hugging Face Course.
- [Masked language modeling task guide](../tasks/masked_language_modeling)
<PipelineTag pipeline="question-answering"/>
- [`BertForQuestionAnswering`] is supported by this [example script](https://github.com/huggingface/transformers/tree/main/examples/pytorch/question-answering) and [notebook](https://colab.research.google.com/github/huggingface/notebooks/blob/main/examples/question_answering.ipynb).
- [`TFBertForQuestionAnswering`] is supported by this [example script](https://github.com/huggingface/transformers/tree/main/examples/tensorflow/question-answering) and [notebook](https://colab.research.google.com/github/huggingface/notebooks/blob/main/examples/question_answering-tf.ipynb).
- [`FlaxBertForQuestionAnswering`] is supported by this [example script](https://github.com/huggingface/transformers/tree/main/examples/flax/question-answering).
- [Question answering](https://huggingface.co/course/chapter7/7?fw=pt) chapter of the ๐ค Hugging Face Course.
- [Question answering task guide](../tasks/question_answering)
**Multiple choice**
- [`BertForMultipleChoice`] is supported by this [example script](https://github.com/huggingface/transformers/tree/main/examples/pytorch/multiple-choice) and [notebook](https://colab.research.google.com/github/huggingface/notebooks/blob/main/examples/multiple_choice.ipynb).
- [`TFBertForMultipleChoice`] is supported by this [example script](https://github.com/huggingface/transformers/tree/main/examples/tensorflow/multiple-choice) and [notebook](https://colab.research.google.com/github/huggingface/notebooks/blob/main/examples/multiple_choice-tf.ipynb).
- [Multiple choice task guide](../tasks/multiple_choice)
โก๏ธ **Inference**
- A blog post on how to [Accelerate BERT inference with Hugging Face Transformers and AWS Inferentia](https://huggingface.co/blog/bert-inferentia-sagemaker).
- A blog post on how to [Accelerate BERT inference with DeepSpeed-Inference on GPUs](https://www.philschmid.de/bert-deepspeed-inference).
โ๏ธ **Pretraining**
- A blog post on [Pre-Training BERT with Hugging Face Transformers and Habana Gaudi](https://www.philschmid.de/pre-training-bert-habana).
๐ **Deploy**
- A blog post on how to [Convert Transformers to ONNX with Hugging Face Optimum](https://www.philschmid.de/convert-transformers-to-onnx).
- A blog post on how to [Setup Deep Learning environment for Hugging Face Transformers with Habana Gaudi on AWS](https://www.philschmid.de/getting-started-habana-gaudi#conclusion).
- A blog post on [Autoscaling BERT with Hugging Face Transformers, Amazon SageMaker and Terraform module](https://www.philschmid.de/terraform-huggingface-amazon-sagemaker-advanced).
- A blog post on [Serverless BERT with HuggingFace, AWS Lambda, and Docker](https://www.philschmid.de/serverless-bert-with-huggingface-aws-lambda-docker).
- A blog post on [Hugging Face Transformers BERT fine-tuning using Amazon SageMaker and Training Compiler](https://www.philschmid.de/huggingface-amazon-sagemaker-training-compiler).
- A blog post on [Task-specific knowledge distillation for BERT using Transformers & Amazon SageMaker](https://www.philschmid.de/knowledge-distillation-bert-transformers).
## BertConfig
[[autodoc]] BertConfig
- all
## BertTokenizer
[[autodoc]] BertTokenizer
- build_inputs_with_special_tokens
- get_special_tokens_mask
- create_token_type_ids_from_sequences
- save_vocabulary
<frameworkcontent>
<pt>
## BertTokenizerFast
[[autodoc]] BertTokenizerFast
</pt>
<tf>
## TFBertTokenizer
[[autodoc]] TFBertTokenizer
</tf>
</frameworkcontent>
## Bert specific outputs
[[autodoc]] models.bert.modeling_bert.BertForPreTrainingOutput
[[autodoc]] models.bert.modeling_tf_bert.TFBertForPreTrainingOutput
[[autodoc]] models.bert.modeling_flax_bert.FlaxBertForPreTrainingOutput
<frameworkcontent>
<pt>
## BertModel
[[autodoc]] BertModel
- forward
## BertForPreTraining
[[autodoc]] BertForPreTraining
- forward
## BertLMHeadModel
[[autodoc]] BertLMHeadModel
- forward
## BertForMaskedLM
[[autodoc]] BertForMaskedLM
- forward
## BertForNextSentencePrediction
[[autodoc]] BertForNextSentencePrediction
- forward
## BertForSequenceClassification
[[autodoc]] BertForSequenceClassification
- forward
## BertForMultipleChoice
[[autodoc]] BertForMultipleChoice
- forward
## BertForTokenClassification
[[autodoc]] BertForTokenClassification
- forward
## BertForQuestionAnswering
[[autodoc]] BertForQuestionAnswering
- forward
</pt>
<tf>
## TFBertModel
[[autodoc]] TFBertModel
- call
## TFBertForPreTraining
[[autodoc]] TFBertForPreTraining
- call
## TFBertModelLMHeadModel
[[autodoc]] TFBertLMHeadModel
- call
## TFBertForMaskedLM
[[autodoc]] TFBertForMaskedLM
- call
## TFBertForNextSentencePrediction
[[autodoc]] TFBertForNextSentencePrediction
- call
## TFBertForSequenceClassification
[[autodoc]] TFBertForSequenceClassification
- call
## TFBertForMultipleChoice
[[autodoc]] TFBertForMultipleChoice
- call
## TFBertForTokenClassification
[[autodoc]] TFBertForTokenClassification
- call
## TFBertForQuestionAnswering
[[autodoc]] TFBertForQuestionAnswering
- call
</tf>
<jax>
## FlaxBertModel
[[autodoc]] FlaxBertModel
- __call__
## FlaxBertForPreTraining
[[autodoc]] FlaxBertForPreTraining
- __call__
## FlaxBertForCausalLM
[[autodoc]] FlaxBertForCausalLM
- __call__
## FlaxBertForMaskedLM
[[autodoc]] FlaxBertForMaskedLM
- __call__
## FlaxBertForNextSentencePrediction
[[autodoc]] FlaxBertForNextSentencePrediction
- __call__
## FlaxBertForSequenceClassification
[[autodoc]] FlaxBertForSequenceClassification
- __call__
## FlaxBertForMultipleChoice
[[autodoc]] FlaxBertForMultipleChoice
- __call__
## FlaxBertForTokenClassification
[[autodoc]] FlaxBertForTokenClassification
- __call__
## FlaxBertForQuestionAnswering
[[autodoc]] FlaxBertForQuestionAnswering
- __call__
</jax>
</frameworkcontent>
| 0 |
mavonic_private_repos/transformers/docs/source/en | mavonic_private_repos/transformers/docs/source/en/model_doc/squeezebert.md | <!--Copyright 2020 The HuggingFace Team. All rights reserved.
Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
the License. You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
specific language governing permissions and limitations under the License.
โ ๏ธ Note that this file is in Markdown but contain specific syntax for our doc-builder (similar to MDX) that may not be
rendered properly in your Markdown viewer.
-->
# SqueezeBERT
## Overview
The SqueezeBERT model was proposed in [SqueezeBERT: What can computer vision teach NLP about efficient neural networks?](https://arxiv.org/abs/2006.11316) by Forrest N. Iandola, Albert E. Shaw, Ravi Krishna, Kurt W. Keutzer. It's a
bidirectional transformer similar to the BERT model. The key difference between the BERT architecture and the
SqueezeBERT architecture is that SqueezeBERT uses [grouped convolutions](https://blog.yani.io/filter-group-tutorial)
instead of fully-connected layers for the Q, K, V and FFN layers.
The abstract from the paper is the following:
*Humans read and write hundreds of billions of messages every day. Further, due to the availability of large datasets,
large computing systems, and better neural network models, natural language processing (NLP) technology has made
significant strides in understanding, proofreading, and organizing these messages. Thus, there is a significant
opportunity to deploy NLP in myriad applications to help web users, social networks, and businesses. In particular, we
consider smartphones and other mobile devices as crucial platforms for deploying NLP models at scale. However, today's
highly-accurate NLP neural network models such as BERT and RoBERTa are extremely computationally expensive, with
BERT-base taking 1.7 seconds to classify a text snippet on a Pixel 3 smartphone. In this work, we observe that methods
such as grouped convolutions have yielded significant speedups for computer vision networks, but many of these
techniques have not been adopted by NLP neural network designers. We demonstrate how to replace several operations in
self-attention layers with grouped convolutions, and we use this technique in a novel network architecture called
SqueezeBERT, which runs 4.3x faster than BERT-base on the Pixel 3 while achieving competitive accuracy on the GLUE test
set. The SqueezeBERT code will be released.*
This model was contributed by [forresti](https://huggingface.co/forresti).
## Usage tips
- SqueezeBERT is a model with absolute position embeddings so it's usually advised to pad the inputs on the right
rather than the left.
- SqueezeBERT is similar to BERT and therefore relies on the masked language modeling (MLM) objective. It is therefore
efficient at predicting masked tokens and at NLU in general, but is not optimal for text generation. Models trained
with a causal language modeling (CLM) objective are better in that regard.
- For best results when finetuning on sequence classification tasks, it is recommended to start with the
*squeezebert/squeezebert-mnli-headless* checkpoint.
## Resources
- [Text classification task guide](../tasks/sequence_classification)
- [Token classification task guide](../tasks/token_classification)
- [Question answering task guide](../tasks/question_answering)
- [Masked language modeling task guide](../tasks/masked_language_modeling)
- [Multiple choice task guide](../tasks/multiple_choice)
## SqueezeBertConfig
[[autodoc]] SqueezeBertConfig
## SqueezeBertTokenizer
[[autodoc]] SqueezeBertTokenizer
- build_inputs_with_special_tokens
- get_special_tokens_mask
- create_token_type_ids_from_sequences
- save_vocabulary
## SqueezeBertTokenizerFast
[[autodoc]] SqueezeBertTokenizerFast
## SqueezeBertModel
[[autodoc]] SqueezeBertModel
## SqueezeBertForMaskedLM
[[autodoc]] SqueezeBertForMaskedLM
## SqueezeBertForSequenceClassification
[[autodoc]] SqueezeBertForSequenceClassification
## SqueezeBertForMultipleChoice
[[autodoc]] SqueezeBertForMultipleChoice
## SqueezeBertForTokenClassification
[[autodoc]] SqueezeBertForTokenClassification
## SqueezeBertForQuestionAnswering
[[autodoc]] SqueezeBertForQuestionAnswering
| 0 |
mavonic_private_repos/transformers/docs/source/en | mavonic_private_repos/transformers/docs/source/en/model_doc/nat.md | <!--Copyright 2022 The HuggingFace Team. All rights reserved.
Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
the License. You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
specific language governing permissions and limitations under the License.
โ ๏ธ Note that this file is in Markdown but contain specific syntax for our doc-builder (similar to MDX) that may not be
rendered properly in your Markdown viewer.
-->
# Neighborhood Attention Transformer
## Overview
NAT was proposed in [Neighborhood Attention Transformer](https://arxiv.org/abs/2204.07143)
by Ali Hassani, Steven Walton, Jiachen Li, Shen Li, and Humphrey Shi.
It is a hierarchical vision transformer based on Neighborhood Attention, a sliding-window self attention pattern.
The abstract from the paper is the following:
*We present Neighborhood Attention (NA), the first efficient and scalable sliding-window attention mechanism for vision.
NA is a pixel-wise operation, localizing self attention (SA) to the nearest neighboring pixels, and therefore enjoys a
linear time and space complexity compared to the quadratic complexity of SA. The sliding-window pattern allows NA's
receptive field to grow without needing extra pixel shifts, and preserves translational equivariance, unlike
Swin Transformer's Window Self Attention (WSA). We develop NATTEN (Neighborhood Attention Extension), a Python package
with efficient C++ and CUDA kernels, which allows NA to run up to 40% faster than Swin's WSA while using up to 25% less
memory. We further present Neighborhood Attention Transformer (NAT), a new hierarchical transformer design based on NA
that boosts image classification and downstream vision performance. Experimental results on NAT are competitive;
NAT-Tiny reaches 83.2% top-1 accuracy on ImageNet, 51.4% mAP on MS-COCO and 48.4% mIoU on ADE20K, which is 1.9%
ImageNet accuracy, 1.0% COCO mAP, and 2.6% ADE20K mIoU improvement over a Swin model with similar size. *
<img
src="https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/neighborhood-attention-pattern.jpg"
alt="drawing" width="600"/>
<small> Neighborhood Attention compared to other attention patterns.
Taken from the <a href="https://arxiv.org/abs/2204.07143">original paper</a>.</small>
This model was contributed by [Ali Hassani](https://huggingface.co/alihassanijr).
The original code can be found [here](https://github.com/SHI-Labs/Neighborhood-Attention-Transformer).
## Usage tips
- One can use the [`AutoImageProcessor`] API to prepare images for the model.
- NAT can be used as a *backbone*. When `output_hidden_states = True`,
it will output both `hidden_states` and `reshaped_hidden_states`.
The `reshaped_hidden_states` have a shape of `(batch, num_channels, height, width)` rather than
`(batch_size, height, width, num_channels)`.
Notes:
- NAT depends on [NATTEN](https://github.com/SHI-Labs/NATTEN/)'s implementation of Neighborhood Attention.
You can install it with pre-built wheels for Linux by referring to [shi-labs.com/natten](https://shi-labs.com/natten),
or build on your system by running `pip install natten`.
Note that the latter will likely take time to compile. NATTEN does not support Windows devices yet.
- Patch size of 4 is only supported at the moment.
## Resources
A list of official Hugging Face and community (indicated by ๐) resources to help you get started with NAT.
<PipelineTag pipeline="image-classification"/>
- [`NatForImageClassification`] is supported by this [example script](https://github.com/huggingface/transformers/tree/main/examples/pytorch/image-classification) and [notebook](https://colab.research.google.com/github/huggingface/notebooks/blob/main/examples/image_classification.ipynb).
- See also: [Image classification task guide](../tasks/image_classification)
If you're interested in submitting a resource to be included here, please feel free to open a Pull Request and we'll review it! The resource should ideally demonstrate something new instead of duplicating an existing resource.
## NatConfig
[[autodoc]] NatConfig
## NatModel
[[autodoc]] NatModel
- forward
## NatForImageClassification
[[autodoc]] NatForImageClassification
- forward
| 0 |
mavonic_private_repos/transformers/docs/source/en | mavonic_private_repos/transformers/docs/source/en/model_doc/speech_to_text.md | <!--Copyright 2021 The HuggingFace Team. All rights reserved.
Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
the License. You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
specific language governing permissions and limitations under the License.
โ ๏ธ Note that this file is in Markdown but contain specific syntax for our doc-builder (similar to MDX) that may not be
rendered properly in your Markdown viewer.
-->
# Speech2Text
## Overview
The Speech2Text model was proposed in [fairseq S2T: Fast Speech-to-Text Modeling with fairseq](https://arxiv.org/abs/2010.05171) by Changhan Wang, Yun Tang, Xutai Ma, Anne Wu, Dmytro Okhonko, Juan Pino. It's a
transformer-based seq2seq (encoder-decoder) model designed for end-to-end Automatic Speech Recognition (ASR) and Speech
Translation (ST). It uses a convolutional downsampler to reduce the length of speech inputs by 3/4th before they are
fed into the encoder. The model is trained with standard autoregressive cross-entropy loss and generates the
transcripts/translations autoregressively. Speech2Text has been fine-tuned on several datasets for ASR and ST:
[LibriSpeech](http://www.openslr.org/12), [CoVoST 2](https://github.com/facebookresearch/covost), [MuST-C](https://ict.fbk.eu/must-c/).
This model was contributed by [valhalla](https://huggingface.co/valhalla). The original code can be found [here](https://github.com/pytorch/fairseq/tree/master/examples/speech_to_text).
## Inference
Speech2Text is a speech model that accepts a float tensor of log-mel filter-bank features extracted from the speech
signal. It's a transformer-based seq2seq model, so the transcripts/translations are generated autoregressively. The
`generate()` method can be used for inference.
The [`Speech2TextFeatureExtractor`] class is responsible for extracting the log-mel filter-bank
features. The [`Speech2TextProcessor`] wraps [`Speech2TextFeatureExtractor`] and
[`Speech2TextTokenizer`] into a single instance to both extract the input features and decode the
predicted token ids.
The feature extractor depends on `torchaudio` and the tokenizer depends on `sentencepiece` so be sure to
install those packages before running the examples. You could either install those as extra speech dependencies with
`pip install transformers"[speech, sentencepiece]"` or install the packages separately with `pip install torchaudio sentencepiece`. Also `torchaudio` requires the development version of the [libsndfile](http://www.mega-nerd.com/libsndfile/) package which can be installed via a system package manager. On Ubuntu it can
be installed as follows: `apt install libsndfile1-dev`
- ASR and Speech Translation
```python
>>> import torch
>>> from transformers import Speech2TextProcessor, Speech2TextForConditionalGeneration
>>> from datasets import load_dataset
>>> model = Speech2TextForConditionalGeneration.from_pretrained("facebook/s2t-small-librispeech-asr")
>>> processor = Speech2TextProcessor.from_pretrained("facebook/s2t-small-librispeech-asr")
>>> ds = load_dataset("hf-internal-testing/librispeech_asr_demo", "clean", split="validation")
>>> inputs = processor(ds[0]["audio"]["array"], sampling_rate=ds[0]["audio"]["sampling_rate"], return_tensors="pt")
>>> generated_ids = model.generate(inputs["input_features"], attention_mask=inputs["attention_mask"])
>>> transcription = processor.batch_decode(generated_ids, skip_special_tokens=True)
>>> transcription
['mister quilter is the apostle of the middle classes and we are glad to welcome his gospel']
```
- Multilingual speech translation
For multilingual speech translation models, `eos_token_id` is used as the `decoder_start_token_id` and
the target language id is forced as the first generated token. To force the target language id as the first
generated token, pass the `forced_bos_token_id` parameter to the `generate()` method. The following
example shows how to transate English speech to French text using the *facebook/s2t-medium-mustc-multilingual-st*
checkpoint.
```python
>>> import torch
>>> from transformers import Speech2TextProcessor, Speech2TextForConditionalGeneration
>>> from datasets import load_dataset
>>> model = Speech2TextForConditionalGeneration.from_pretrained("facebook/s2t-medium-mustc-multilingual-st")
>>> processor = Speech2TextProcessor.from_pretrained("facebook/s2t-medium-mustc-multilingual-st")
>>> ds = load_dataset("hf-internal-testing/librispeech_asr_demo", "clean", split="validation")
>>> inputs = processor(ds[0]["audio"]["array"], sampling_rate=ds[0]["audio"]["sampling_rate"], return_tensors="pt")
>>> generated_ids = model.generate(
... inputs["input_features"],
... attention_mask=inputs["attention_mask"],
... forced_bos_token_id=processor.tokenizer.lang_code_to_id["fr"],
... )
>>> translation = processor.batch_decode(generated_ids, skip_special_tokens=True)
>>> translation
["(Vidรฉo) Si M. Kilder est l'apossible des classes moyennes, et nous sommes heureux d'รชtre accueillis dans son รฉvangile."]
```
See the [model hub](https://huggingface.co/models?filter=speech_to_text) to look for Speech2Text checkpoints.
## Speech2TextConfig
[[autodoc]] Speech2TextConfig
## Speech2TextTokenizer
[[autodoc]] Speech2TextTokenizer
- build_inputs_with_special_tokens
- get_special_tokens_mask
- create_token_type_ids_from_sequences
- save_vocabulary
## Speech2TextFeatureExtractor
[[autodoc]] Speech2TextFeatureExtractor
- __call__
## Speech2TextProcessor
[[autodoc]] Speech2TextProcessor
- __call__
- from_pretrained
- save_pretrained
- batch_decode
- decode
<frameworkcontent>
<pt>
## Speech2TextModel
[[autodoc]] Speech2TextModel
- forward
## Speech2TextForConditionalGeneration
[[autodoc]] Speech2TextForConditionalGeneration
- forward
</pt>
<tf>
## TFSpeech2TextModel
[[autodoc]] TFSpeech2TextModel
- call
## TFSpeech2TextForConditionalGeneration
[[autodoc]] TFSpeech2TextForConditionalGeneration
- call
</tf>
</frameworkcontent>
| 0 |
mavonic_private_repos/transformers/docs/source/en | mavonic_private_repos/transformers/docs/source/en/model_doc/rwkv.md | <!--Copyright 2023 The HuggingFace Team. All rights reserved.
Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
the License. You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
specific language governing permissions and limitations under the License.
โ ๏ธ Note that this file is in Markdown but contain specific syntax for our doc-builder (similar to MDX) that may not be
rendered properly in your Markdown viewer.
-->
# RWKV
## Overview
The RWKV model was proposed in [this repo](https://github.com/BlinkDL/RWKV-LM)
It suggests a tweak in the traditional Transformer attention to make it linear. This way, the model can be used as recurrent network: passing inputs for timestamp 0 and timestamp 1 together is the same as passing inputs at timestamp 0, then inputs at timestamp 1 along with the state of timestamp 0 (see example below).
This can be more efficient than a regular Transformer and can deal with sentence of any length (even if the model uses a fixed context length for training).
This model was contributed by [sgugger](https://huggingface.co/sgugger).
The original code can be found [here](https://github.com/BlinkDL/RWKV-LM).
## Usage example
```py
import torch
from transformers import AutoTokenizer, RwkvConfig, RwkvModel
model = RwkvModel.from_pretrained("sgugger/rwkv-430M-pile")
tokenizer = AutoTokenizer.from_pretrained("sgugger/rwkv-430M-pile")
inputs = tokenizer("This is an example.", return_tensors="pt")
# Feed everything to the model
outputs = model(inputs["input_ids"])
output_whole = outputs.last_hidden_state
outputs = model(inputs["input_ids"][:, :2])
output_one = outputs.last_hidden_state
# Using the state computed on the first inputs, we will get the same output
outputs = model(inputs["input_ids"][:, 2:], state=outputs.state)
output_two = outputs.last_hidden_state
torch.allclose(torch.cat([output_one, output_two], dim=1), output_whole, atol=1e-5)
```
If you want to make sure the model stops generating when `'\n\n'` is detected, we recommend using the following stopping criteria:
```python
from transformers import StoppingCriteria
class RwkvStoppingCriteria(StoppingCriteria):
def __init__(self, eos_sequence = [187,187], eos_token_id = 537):
self.eos_sequence = eos_sequence
self.eos_token_id = eos_token_id
def __call__(self, input_ids: torch.LongTensor, scores: torch.FloatTensor, **kwargs) -> bool:
last_2_ids = input_ids[:,-2:].tolist()
return self.eos_sequence in last_2_ids
output = model.generate(inputs["input_ids"], max_new_tokens=64, stopping_criteria = [RwkvStoppingCriteria()])
```
## RwkvConfig
[[autodoc]] RwkvConfig
## RwkvModel
[[autodoc]] RwkvModel
- forward
## RwkvLMHeadModel
[[autodoc]] RwkvForCausalLM
- forward
## Rwkv attention and the recurrent formulas
In a traditional auto-regressive Transformer, attention is written as
$$O = \hbox{softmax}(QK^{T} / \sqrt{d}) V$$
with \\(Q\\), \\(K\\) and \\(V\\) are matrices of shape `seq_len x hidden_size` named query, key and value (they are actually bigger matrices with a batch dimension and an attention head dimension but we're only interested in the last two, which is where the matrix product is taken, so for the sake of simplicity we only consider those two). The product \\(QK^{T}\\) then has shape `seq_len x seq_len` and we can take the matrix product with \\(V\\) to get the output \\(O\\) of the same shape as the others.
Replacing the softmax by its value gives:
$$O_{i} = \frac{\sum_{j=1}^{i} e^{Q_{i} K_{j}^{T} / \sqrt{d}} V_{j}}{\sum_{j=1}^{i} e^{Q_{i} K_{j}^{T} / \sqrt{d}}}$$
Note that the entries in \\(QK^{T}\\) corresponding to \\(j > i\\) are masked (the sum stops at j) because the attention is not allowed to look at future tokens (only past ones).
In comparison, the RWKV attention is given by
$$O_{i} = \sigma(R_{i}) \frac{\sum_{j=1}^{i} e^{W_{i-j} + K_{j}} V_{j}}{\sum_{j=1}^{i} e^{W_{i-j} + K_{j}}}$$
where \\(R\\) is a new matrix called receptance by the author, \\(K\\) and \\(V\\) are still the key and value (\\(\sigma\\) here is the sigmoid function). \\(W\\) is a new vector that represents the position of the token and is given by
$$W_{0} = u \hbox{ and } W_{k} = (k-1)w \hbox{ for } k \geq 1$$
with \\(u\\) and \\(w\\) learnable parameters called in the code `time_first` and `time_decay` respectively. The numerator and denominator can both be expressed recursively. Naming them \\(N_{i}\\) and \\(D_{i}\\) we have:
$$N_{i} = e^{u + K_{i}} V_{i} + \hat{N}_{i} \hbox{ where } \hat{N}_{i} = e^{K_{i-1}} V_{i-1} + e^{w + K_{i-2}} V_{i-2} \cdots + e^{(i-2)w + K_{1}} V_{1}$$
so \\(\hat{N}_{i}\\) (called `numerator_state` in the code) satisfies
$$\hat{N}_{0} = 0 \hbox{ and } \hat{N}_{j+1} = e^{K_{j}} V_{j} + e^{w} \hat{N}_{j}$$
and
$$D_{i} = e^{u + K_{i}} + \hat{D}_{i} \hbox{ where } \hat{D}_{i} = e^{K_{i-1}} + e^{w + K_{i-2}} \cdots + e^{(i-2)w + K_{1}}$$
so \\(\hat{D}_{i}\\) (called `denominator_state` in the code) satisfies
$$\hat{D}_{0} = 0 \hbox{ and } \hat{D}_{j+1} = e^{K_{j}} + e^{w} \hat{D}_{j}$$
The actual recurrent formula used are a tiny bit more complex, as for numerical stability we don't want to compute exponentials of big numbers. Usually the softmax is not computed as is, but the exponential of the maximum term is divided of the numerator and denominator:
$$\frac{e^{x_{i}}}{\sum_{j=1}^{n} e^{x_{j}}} = \frac{e^{x_{i} - M}}{\sum_{j=1}^{n} e^{x_{j} - M}}$$
with \\(M\\) the maximum of all \\(x_{j}\\). So here on top of saving the numerator state (\\(\hat{N}\\)) and the denominator state (\\(\hat{D}\\)) we also keep track of the maximum of all terms encountered in the exponentials. So we actually use
$$\tilde{N}_{i} = e^{-M_{i}} \hat{N}_{i} \hbox{ and } \tilde{D}_{i} = e^{-M_{i}} \hat{D}_{i}$$
defined by the following recurrent formulas:
$$\tilde{N}_{0} = 0 \hbox{ and } \tilde{N}_{j+1} = e^{K_{j} - q} V_{j} + e^{w + M_{j} - q} \tilde{N}_{j} \hbox{ where } q = \max(K_{j}, w + M_{j})$$
and
$$\tilde{D}_{0} = 0 \hbox{ and } \tilde{D}_{j+1} = e^{K_{j} - q} + e^{w + M_{j} - q} \tilde{D}_{j} \hbox{ where } q = \max(K_{j}, w + M_{j})$$
and \\(M_{j+1} = q\\). With those, we can then compute
$$N_{i} = e^{u + K_{i} - q} V_{i} + e^{M_{i}} \tilde{N}_{i} \hbox{ where } q = \max(u + K_{i}, M_{i})$$
and
$$D_{i} = e^{u + K_{i} - q} + e^{M_{i}} \tilde{D}_{i} \hbox{ where } q = \max(u + K_{i}, M_{i})$$
which finally gives us
$$O_{i} = \sigma(R_{i}) \frac{N_{i}}{D_{i}}$$ | 0 |
mavonic_private_repos/transformers/docs/source/en | mavonic_private_repos/transformers/docs/source/en/model_doc/unispeech-sat.md | <!--Copyright 2021 The HuggingFace Team. All rights reserved.
Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
the License. You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
specific language governing permissions and limitations under the License.
โ ๏ธ Note that this file is in Markdown but contain specific syntax for our doc-builder (similar to MDX) that may not be
rendered properly in your Markdown viewer.
-->
# UniSpeech-SAT
## Overview
The UniSpeech-SAT model was proposed in [UniSpeech-SAT: Universal Speech Representation Learning with Speaker Aware
Pre-Training](https://arxiv.org/abs/2110.05752) by Sanyuan Chen, Yu Wu, Chengyi Wang, Zhengyang Chen, Zhuo Chen,
Shujie Liu, Jian Wu, Yao Qian, Furu Wei, Jinyu Li, Xiangzhan Yu .
The abstract from the paper is the following:
*Self-supervised learning (SSL) is a long-standing goal for speech processing, since it utilizes large-scale unlabeled
data and avoids extensive human labeling. Recent years witness great successes in applying self-supervised learning in
speech recognition, while limited exploration was attempted in applying SSL for modeling speaker characteristics. In
this paper, we aim to improve the existing SSL framework for speaker representation learning. Two methods are
introduced for enhancing the unsupervised speaker information extraction. First, we apply the multi-task learning to
the current SSL framework, where we integrate the utterance-wise contrastive loss with the SSL objective function.
Second, for better speaker discrimination, we propose an utterance mixing strategy for data augmentation, where
additional overlapped utterances are created unsupervisedly and incorporate during training. We integrate the proposed
methods into the HuBERT framework. Experiment results on SUPERB benchmark show that the proposed system achieves
state-of-the-art performance in universal representation learning, especially for speaker identification oriented
tasks. An ablation study is performed verifying the efficacy of each proposed method. Finally, we scale up training
dataset to 94 thousand hours public audio data and achieve further performance improvement in all SUPERB tasks.*
This model was contributed by [patrickvonplaten](https://huggingface.co/patrickvonplaten). The Authors' code can be
found [here](https://github.com/microsoft/UniSpeech/tree/main/UniSpeech-SAT).
## Usage tips
- UniSpeechSat is a speech model that accepts a float array corresponding to the raw waveform of the speech signal.
Please use [`Wav2Vec2Processor`] for the feature extraction.
- UniSpeechSat model can be fine-tuned using connectionist temporal classification (CTC) so the model output has to be
decoded using [`Wav2Vec2CTCTokenizer`].
- UniSpeechSat performs especially well on speaker verification, speaker identification, and speaker diarization tasks.
## Resources
- [Audio classification task guide](../tasks/audio_classification)
- [Automatic speech recognition task guide](../tasks/asr)
## UniSpeechSatConfig
[[autodoc]] UniSpeechSatConfig
## UniSpeechSat specific outputs
[[autodoc]] models.unispeech_sat.modeling_unispeech_sat.UniSpeechSatForPreTrainingOutput
## UniSpeechSatModel
[[autodoc]] UniSpeechSatModel
- forward
## UniSpeechSatForCTC
[[autodoc]] UniSpeechSatForCTC
- forward
## UniSpeechSatForSequenceClassification
[[autodoc]] UniSpeechSatForSequenceClassification
- forward
## UniSpeechSatForAudioFrameClassification
[[autodoc]] UniSpeechSatForAudioFrameClassification
- forward
## UniSpeechSatForXVector
[[autodoc]] UniSpeechSatForXVector
- forward
## UniSpeechSatForPreTraining
[[autodoc]] UniSpeechSatForPreTraining
- forward
| 0 |
mavonic_private_repos/transformers/docs/source/en | mavonic_private_repos/transformers/docs/source/en/model_doc/speech-encoder-decoder.md | <!--Copyright 2021 The HuggingFace Team. All rights reserved.
Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
the License. You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
specific language governing permissions and limitations under the License.
โ ๏ธ Note that this file is in Markdown but contain specific syntax for our doc-builder (similar to MDX) that may not be
rendered properly in your Markdown viewer.
-->
# Speech Encoder Decoder Models
The [`SpeechEncoderDecoderModel`] can be used to initialize a speech-to-text model
with any pretrained speech autoencoding model as the encoder (*e.g.* [Wav2Vec2](wav2vec2), [Hubert](hubert)) and any pretrained autoregressive model as the decoder.
The effectiveness of initializing speech-sequence-to-text-sequence models with pretrained checkpoints for speech
recognition and speech translation has *e.g.* been shown in [Large-Scale Self- and Semi-Supervised Learning for Speech
Translation](https://arxiv.org/abs/2104.06678) by Changhan Wang, Anne Wu, Juan Pino, Alexei Baevski, Michael Auli,
Alexis Conneau.
An example of how to use a [`SpeechEncoderDecoderModel`] for inference can be seen in [Speech2Text2](speech_to_text_2).
## Randomly initializing `SpeechEncoderDecoderModel` from model configurations.
[`SpeechEncoderDecoderModel`] can be randomly initialized from an encoder and a decoder config. In the following example, we show how to do this using the default [`Wav2Vec2Model`] configuration for the encoder
and the default [`BertForCausalLM`] configuration for the decoder.
```python
>>> from transformers import BertConfig, Wav2Vec2Config, SpeechEncoderDecoderConfig, SpeechEncoderDecoderModel
>>> config_encoder = Wav2Vec2Config()
>>> config_decoder = BertConfig()
>>> config = SpeechEncoderDecoderConfig.from_encoder_decoder_configs(config_encoder, config_decoder)
>>> model = SpeechEncoderDecoderModel(config=config)
```
## Initialising `SpeechEncoderDecoderModel` from a pretrained encoder and a pretrained decoder.
[`SpeechEncoderDecoderModel`] can be initialized from a pretrained encoder checkpoint and a pretrained decoder checkpoint. Note that any pretrained Transformer-based speech model, *e.g.* [Wav2Vec2](wav2vec2), [Hubert](hubert) can serve as the encoder and both pretrained auto-encoding models, *e.g.* BERT, pretrained causal language models, *e.g.* GPT2, as well as the pretrained decoder part of sequence-to-sequence models, *e.g.* decoder of BART, can be used as the decoder.
Depending on which architecture you choose as the decoder, the cross-attention layers might be randomly initialized.
Initializing [`SpeechEncoderDecoderModel`] from a pretrained encoder and decoder checkpoint requires the model to be fine-tuned on a downstream task, as has been shown in [the *Warm-starting-encoder-decoder blog post*](https://huggingface.co/blog/warm-starting-encoder-decoder).
To do so, the `SpeechEncoderDecoderModel` class provides a [`SpeechEncoderDecoderModel.from_encoder_decoder_pretrained`] method.
```python
>>> from transformers import SpeechEncoderDecoderModel
>>> model = SpeechEncoderDecoderModel.from_encoder_decoder_pretrained(
... "facebook/hubert-large-ll60k", "google-bert/bert-base-uncased"
... )
```
## Loading an existing `SpeechEncoderDecoderModel` checkpoint and perform inference.
To load fine-tuned checkpoints of the `SpeechEncoderDecoderModel` class, [`SpeechEncoderDecoderModel`] provides the `from_pretrained(...)` method just like any other model architecture in Transformers.
To perform inference, one uses the [`generate`] method, which allows to autoregressively generate text. This method supports various forms of decoding, such as greedy, beam search and multinomial sampling.
```python
>>> from transformers import Wav2Vec2Processor, SpeechEncoderDecoderModel
>>> from datasets import load_dataset
>>> import torch
>>> # load a fine-tuned speech translation model and corresponding processor
>>> model = SpeechEncoderDecoderModel.from_pretrained("facebook/wav2vec2-xls-r-300m-en-to-15")
>>> processor = Wav2Vec2Processor.from_pretrained("facebook/wav2vec2-xls-r-300m-en-to-15")
>>> # let's perform inference on a piece of English speech (which we'll translate to German)
>>> ds = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
>>> input_values = processor(ds[0]["audio"]["array"], return_tensors="pt").input_values
>>> # autoregressively generate transcription (uses greedy decoding by default)
>>> generated_ids = model.generate(input_values)
>>> generated_text = processor.batch_decode(generated_ids, skip_special_tokens=True)[0]
>>> print(generated_text)
Mr. Quilter ist der Apostel der Mittelschicht und wir freuen uns, sein Evangelium willkommen heiรen zu kรถnnen.
```
## Training
Once the model is created, it can be fine-tuned similar to BART, T5 or any other encoder-decoder model on a dataset of (speech, text) pairs.
As you can see, only 2 inputs are required for the model in order to compute a loss: `input_values` (which are the
speech inputs) and `labels` (which are the `input_ids` of the encoded target sequence).
```python
>>> from transformers import AutoTokenizer, AutoFeatureExtractor, SpeechEncoderDecoderModel
>>> from datasets import load_dataset
>>> encoder_id = "facebook/wav2vec2-base-960h" # acoustic model encoder
>>> decoder_id = "google-bert/bert-base-uncased" # text decoder
>>> feature_extractor = AutoFeatureExtractor.from_pretrained(encoder_id)
>>> tokenizer = AutoTokenizer.from_pretrained(decoder_id)
>>> # Combine pre-trained encoder and pre-trained decoder to form a Seq2Seq model
>>> model = SpeechEncoderDecoderModel.from_encoder_decoder_pretrained(encoder_id, decoder_id)
>>> model.config.decoder_start_token_id = tokenizer.cls_token_id
>>> model.config.pad_token_id = tokenizer.pad_token_id
>>> # load an audio input and pre-process (normalise mean/std to 0/1)
>>> ds = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
>>> input_values = feature_extractor(ds[0]["audio"]["array"], return_tensors="pt").input_values
>>> # load its corresponding transcription and tokenize to generate labels
>>> labels = tokenizer(ds[0]["text"], return_tensors="pt").input_ids
>>> # the forward function automatically creates the correct decoder_input_ids
>>> loss = model(input_values=input_values, labels=labels).loss
>>> loss.backward()
```
## SpeechEncoderDecoderConfig
[[autodoc]] SpeechEncoderDecoderConfig
## SpeechEncoderDecoderModel
[[autodoc]] SpeechEncoderDecoderModel
- forward
- from_encoder_decoder_pretrained
## FlaxSpeechEncoderDecoderModel
[[autodoc]] FlaxSpeechEncoderDecoderModel
- __call__
- from_encoder_decoder_pretrained
| 0 |
mavonic_private_repos/transformers/docs/source/en | mavonic_private_repos/transformers/docs/source/en/model_doc/xlm-roberta.md | <!--Copyright 2020 The HuggingFace Team. All rights reserved.
Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
the License. You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
specific language governing permissions and limitations under the License.
โ ๏ธ Note that this file is in Markdown but contain specific syntax for our doc-builder (similar to MDX) that may not be
rendered properly in your Markdown viewer.
-->
# XLM-RoBERTa
<div class="flex flex-wrap space-x-1">
<a href="https://huggingface.co/models?filter=xlm-roberta">
<img alt="Models" src="https://img.shields.io/badge/All_model_pages-xlm--roberta-blueviolet">
</a>
<a href="https://huggingface.co/spaces/docs-demos/xlm-roberta-base">
<img alt="Spaces" src="https://img.shields.io/badge/%F0%9F%A4%97%20Hugging%20Face-Spaces-blue">
</a>
</div>
## Overview
The XLM-RoBERTa model was proposed in [Unsupervised Cross-lingual Representation Learning at Scale](https://arxiv.org/abs/1911.02116) by Alexis Conneau, Kartikay Khandelwal, Naman Goyal, Vishrav Chaudhary, Guillaume
Wenzek, Francisco Guzmรกn, Edouard Grave, Myle Ott, Luke Zettlemoyer and Veselin Stoyanov. It is based on Facebook's
RoBERTa model released in 2019. It is a large multi-lingual language model, trained on 2.5TB of filtered CommonCrawl
data.
The abstract from the paper is the following:
*This paper shows that pretraining multilingual language models at scale leads to significant performance gains for a
wide range of cross-lingual transfer tasks. We train a Transformer-based masked language model on one hundred
languages, using more than two terabytes of filtered CommonCrawl data. Our model, dubbed XLM-R, significantly
outperforms multilingual BERT (mBERT) on a variety of cross-lingual benchmarks, including +13.8% average accuracy on
XNLI, +12.3% average F1 score on MLQA, and +2.1% average F1 score on NER. XLM-R performs particularly well on
low-resource languages, improving 11.8% in XNLI accuracy for Swahili and 9.2% for Urdu over the previous XLM model. We
also present a detailed empirical evaluation of the key factors that are required to achieve these gains, including the
trade-offs between (1) positive transfer and capacity dilution and (2) the performance of high and low resource
languages at scale. Finally, we show, for the first time, the possibility of multilingual modeling without sacrificing
per-language performance; XLM-Ris very competitive with strong monolingual models on the GLUE and XNLI benchmarks. We
will make XLM-R code, data, and models publicly available.*
This model was contributed by [stefan-it](https://huggingface.co/stefan-it). The original code can be found [here](https://github.com/pytorch/fairseq/tree/master/examples/xlmr).
## Usage tips
- XLM-RoBERTa is a multilingual model trained on 100 different languages. Unlike some XLM multilingual models, it does
not require `lang` tensors to understand which language is used, and should be able to determine the correct
language from the input ids.
- Uses RoBERTa tricks on the XLM approach, but does not use the translation language modeling objective. It only uses masked language modeling on sentences coming from one language.
## Resources
A list of official Hugging Face and community (indicated by ๐) resources to help you get started with XLM-RoBERTa. If you're interested in submitting a resource to be included here, please feel free to open a Pull Request and we'll review it! The resource should ideally demonstrate something new instead of duplicating an existing resource.
<PipelineTag pipeline="text-classification"/>
- A blog post on how to [finetune XLM RoBERTa for multiclass classification with Habana Gaudi on AWS](https://www.philschmid.de/habana-distributed-training)
- [`XLMRobertaForSequenceClassification`] is supported by this [example script](https://github.com/huggingface/transformers/tree/main/examples/pytorch/text-classification) and [notebook](https://colab.research.google.com/github/huggingface/notebooks/blob/main/examples/text_classification.ipynb).
- [`TFXLMRobertaForSequenceClassification`] is supported by this [example script](https://github.com/huggingface/transformers/tree/main/examples/tensorflow/text-classification) and [notebook](https://colab.research.google.com/github/huggingface/notebooks/blob/main/examples/text_classification-tf.ipynb).
- [`FlaxXLMRobertaForSequenceClassification`] is supported by this [example script](https://github.com/huggingface/transformers/tree/main/examples/flax/text-classification) and [notebook](https://colab.research.google.com/github/huggingface/notebooks/blob/main/examples/text_classification_flax.ipynb).
- [Text classification](https://huggingface.co/docs/transformers/tasks/sequence_classification) chapter of the ๐ค Hugging Face Task Guides.
- [Text classification task guide](../tasks/sequence_classification)
<PipelineTag pipeline="token-classification"/>
- [`XLMRobertaForTokenClassification`] is supported by this [example script](https://github.com/huggingface/transformers/tree/main/examples/pytorch/token-classification) and [notebook](https://colab.research.google.com/github/huggingface/notebooks/blob/main/examples/token_classification.ipynb).
- [`TFXLMRobertaForTokenClassification`] is supported by this [example script](https://github.com/huggingface/transformers/tree/main/examples/tensorflow/token-classification) and [notebook](https://colab.research.google.com/github/huggingface/notebooks/blob/main/examples/token_classification-tf.ipynb).
- [`FlaxXLMRobertaForTokenClassification`] is supported by this [example script](https://github.com/huggingface/transformers/tree/main/examples/flax/token-classification).
- [Token classification](https://huggingface.co/course/chapter7/2?fw=pt) chapter of the ๐ค Hugging Face Course.
- [Token classification task guide](../tasks/token_classification)
<PipelineTag pipeline="text-generation"/>
- [`XLMRobertaForCausalLM`] is supported by this [example script](https://github.com/huggingface/transformers/tree/main/examples/pytorch/language-modeling) and [notebook](https://colab.research.google.com/github/huggingface/notebooks/blob/main/examples/language_modeling.ipynb).
- [Causal language modeling](https://huggingface.co/docs/transformers/tasks/language_modeling) chapter of the ๐ค Hugging Face Task Guides.
- [Causal language modeling task guide](../tasks/language_modeling)
<PipelineTag pipeline="fill-mask"/>
- [`XLMRobertaForMaskedLM`] is supported by this [example script](https://github.com/huggingface/transformers/tree/main/examples/pytorch/language-modeling#robertabertdistilbert-and-masked-language-modeling) and [notebook](https://colab.research.google.com/github/huggingface/notebooks/blob/main/examples/language_modeling.ipynb).
- [`TFXLMRobertaForMaskedLM`] is supported by this [example script](https://github.com/huggingface/transformers/tree/main/examples/tensorflow/language-modeling#run_mlmpy) and [notebook](https://colab.research.google.com/github/huggingface/notebooks/blob/main/examples/language_modeling-tf.ipynb).
- [`FlaxXLMRobertaForMaskedLM`] is supported by this [example script](https://github.com/huggingface/transformers/tree/main/examples/flax/language-modeling#masked-language-modeling) and [notebook](https://colab.research.google.com/github/huggingface/notebooks/blob/main/examples/masked_language_modeling_flax.ipynb).
- [Masked language modeling](https://huggingface.co/course/chapter7/3?fw=pt) chapter of the ๐ค Hugging Face Course.
- [Masked language modeling](../tasks/masked_language_modeling)
<PipelineTag pipeline="question-answering"/>
- [`XLMRobertaForQuestionAnswering`] is supported by this [example script](https://github.com/huggingface/transformers/tree/main/examples/pytorch/question-answering) and [notebook](https://colab.research.google.com/github/huggingface/notebooks/blob/main/examples/question_answering.ipynb).
- [`TFXLMRobertaForQuestionAnswering`] is supported by this [example script](https://github.com/huggingface/transformers/tree/main/examples/tensorflow/question-answering) and [notebook](https://colab.research.google.com/github/huggingface/notebooks/blob/main/examples/question_answering-tf.ipynb).
- [`FlaxXLMRobertaForQuestionAnswering`] is supported by this [example script](https://github.com/huggingface/transformers/tree/main/examples/flax/question-answering).
- [Question answering](https://huggingface.co/course/chapter7/7?fw=pt) chapter of the ๐ค Hugging Face Course.
- [Question answering task guide](../tasks/question_answering)
**Multiple choice**
- [`XLMRobertaForMultipleChoice`] is supported by this [example script](https://github.com/huggingface/transformers/tree/main/examples/pytorch/multiple-choice) and [notebook](https://colab.research.google.com/github/huggingface/notebooks/blob/main/examples/multiple_choice.ipynb).
- [`TFXLMRobertaForMultipleChoice`] is supported by this [example script](https://github.com/huggingface/transformers/tree/main/examples/tensorflow/multiple-choice) and [notebook](https://colab.research.google.com/github/huggingface/notebooks/blob/main/examples/multiple_choice-tf.ipynb).
- [Multiple choice task guide](../tasks/multiple_choice)
๐ Deploy
- A blog post on how to [Deploy Serverless XLM RoBERTa on AWS Lambda](https://www.philschmid.de/multilingual-serverless-xlm-roberta-with-huggingface).
<Tip>
This implementation is the same as RoBERTa. Refer to the [documentation of RoBERTa](roberta) for usage examples as well as the information relative to the inputs and outputs.
</Tip>
## XLMRobertaConfig
[[autodoc]] XLMRobertaConfig
## XLMRobertaTokenizer
[[autodoc]] XLMRobertaTokenizer
- build_inputs_with_special_tokens
- get_special_tokens_mask
- create_token_type_ids_from_sequences
- save_vocabulary
## XLMRobertaTokenizerFast
[[autodoc]] XLMRobertaTokenizerFast
<frameworkcontent>
<pt>
## XLMRobertaModel
[[autodoc]] XLMRobertaModel
- forward
## XLMRobertaForCausalLM
[[autodoc]] XLMRobertaForCausalLM
- forward
## XLMRobertaForMaskedLM
[[autodoc]] XLMRobertaForMaskedLM
- forward
## XLMRobertaForSequenceClassification
[[autodoc]] XLMRobertaForSequenceClassification
- forward
## XLMRobertaForMultipleChoice
[[autodoc]] XLMRobertaForMultipleChoice
- forward
## XLMRobertaForTokenClassification
[[autodoc]] XLMRobertaForTokenClassification
- forward
## XLMRobertaForQuestionAnswering
[[autodoc]] XLMRobertaForQuestionAnswering
- forward
</pt>
<tf>
## TFXLMRobertaModel
[[autodoc]] TFXLMRobertaModel
- call
## TFXLMRobertaForCausalLM
[[autodoc]] TFXLMRobertaForCausalLM
- call
## TFXLMRobertaForMaskedLM
[[autodoc]] TFXLMRobertaForMaskedLM
- call
## TFXLMRobertaForSequenceClassification
[[autodoc]] TFXLMRobertaForSequenceClassification
- call
## TFXLMRobertaForMultipleChoice
[[autodoc]] TFXLMRobertaForMultipleChoice
- call
## TFXLMRobertaForTokenClassification
[[autodoc]] TFXLMRobertaForTokenClassification
- call
## TFXLMRobertaForQuestionAnswering
[[autodoc]] TFXLMRobertaForQuestionAnswering
- call
</tf>
<jax>
## FlaxXLMRobertaModel
[[autodoc]] FlaxXLMRobertaModel
- __call__
## FlaxXLMRobertaForCausalLM
[[autodoc]] FlaxXLMRobertaForCausalLM
- __call__
## FlaxXLMRobertaForMaskedLM
[[autodoc]] FlaxXLMRobertaForMaskedLM
- __call__
## FlaxXLMRobertaForSequenceClassification
[[autodoc]] FlaxXLMRobertaForSequenceClassification
- __call__
## FlaxXLMRobertaForMultipleChoice
[[autodoc]] FlaxXLMRobertaForMultipleChoice
- __call__
## FlaxXLMRobertaForTokenClassification
[[autodoc]] FlaxXLMRobertaForTokenClassification
- __call__
## FlaxXLMRobertaForQuestionAnswering
[[autodoc]] FlaxXLMRobertaForQuestionAnswering
- __call__
</jax>
</frameworkcontent> | 0 |
mavonic_private_repos/transformers/docs/source/en | mavonic_private_repos/transformers/docs/source/en/model_doc/encodec.md | <!--Copyright 2023 The HuggingFace Team. All rights reserved.
Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
the License. You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
specific language governing permissions and limitations under the License.
โ ๏ธ Note that this file is in Markdown but contain specific syntax for our doc-builder (similar to MDX) that may not be
rendered properly in your Markdown viewer.
-->
# EnCodec
## Overview
The EnCodec neural codec model was proposed in [High Fidelity Neural Audio Compression](https://arxiv.org/abs/2210.13438) by Alexandre Dรฉfossez, Jade Copet, Gabriel Synnaeve, Yossi Adi.
The abstract from the paper is the following:
*We introduce a state-of-the-art real-time, high-fidelity, audio codec leveraging neural networks. It consists in a streaming encoder-decoder architecture with quantized latent space trained in an end-to-end fashion. We simplify and speed-up the training by using a single multiscale spectrogram adversary that efficiently reduces artifacts and produce high-quality samples. We introduce a novel loss balancer mechanism to stabilize training: the weight of a loss now defines the fraction of the overall gradient it should represent, thus decoupling the choice of this hyper-parameter from the typical scale of the loss. Finally, we study how lightweight Transformer models can be used to further compress the obtained representation by up to 40%, while staying faster than real time. We provide a detailed description of the key design choices of the proposed model including: training objective, architectural changes and a study of various perceptual loss functions. We present an extensive subjective evaluation (MUSHRA tests) together with an ablation study for a range of bandwidths and audio domains, including speech, noisy-reverberant speech, and music. Our approach is superior to the baselines methods across all evaluated settings, considering both 24 kHz monophonic and 48 kHz stereophonic audio.*
This model was contributed by [Matthijs](https://huggingface.co/Matthijs), [Patrick Von Platen](https://huggingface.co/patrickvonplaten) and [Arthur Zucker](https://huggingface.co/ArthurZ).
The original code can be found [here](https://github.com/facebookresearch/encodec).
## Usage example
Here is a quick example of how to encode and decode an audio using this model:
```python
>>> from datasets import load_dataset, Audio
>>> from transformers import EncodecModel, AutoProcessor
>>> librispeech_dummy = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
>>> model = EncodecModel.from_pretrained("facebook/encodec_24khz")
>>> processor = AutoProcessor.from_pretrained("facebook/encodec_24khz")
>>> librispeech_dummy = librispeech_dummy.cast_column("audio", Audio(sampling_rate=processor.sampling_rate))
>>> audio_sample = librispeech_dummy[-1]["audio"]["array"]
>>> inputs = processor(raw_audio=audio_sample, sampling_rate=processor.sampling_rate, return_tensors="pt")
>>> encoder_outputs = model.encode(inputs["input_values"], inputs["padding_mask"])
>>> audio_values = model.decode(encoder_outputs.audio_codes, encoder_outputs.audio_scales, inputs["padding_mask"])[0]
>>> # or the equivalent with a forward pass
>>> audio_values = model(inputs["input_values"], inputs["padding_mask"]).audio_values
```
## EncodecConfig
[[autodoc]] EncodecConfig
## EncodecFeatureExtractor
[[autodoc]] EncodecFeatureExtractor
- __call__
## EncodecModel
[[autodoc]] EncodecModel
- decode
- encode
- forward
| 0 |
mavonic_private_repos/transformers/docs/source/en | mavonic_private_repos/transformers/docs/source/en/model_doc/videomae.md | <!--Copyright 2022 The HuggingFace Team. All rights reserved.
Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
the License. You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
specific language governing permissions and limitations under the License.
โ ๏ธ Note that this file is in Markdown but contain specific syntax for our doc-builder (similar to MDX) that may not be
rendered properly in your Markdown viewer.
-->
# VideoMAE
## Overview
The VideoMAE model was proposed in [VideoMAE: Masked Autoencoders are Data-Efficient Learners for Self-Supervised Video Pre-Training](https://arxiv.org/abs/2203.12602) by Zhan Tong, Yibing Song, Jue Wang, Limin Wang.
VideoMAE extends masked auto encoders ([MAE](vit_mae)) to video, claiming state-of-the-art performance on several video classification benchmarks.
The abstract from the paper is the following:
*Pre-training video transformers on extra large-scale datasets is generally required to achieve premier performance on relatively small datasets. In this paper, we show that video masked autoencoders (VideoMAE) are data-efficient learners for self-supervised video pre-training (SSVP). We are inspired by the recent ImageMAE and propose customized video tube masking and reconstruction. These simple designs turn out to be effective for overcoming information leakage caused by the temporal correlation during video reconstruction. We obtain three important findings on SSVP: (1) An extremely high proportion of masking ratio (i.e., 90% to 95%) still yields favorable performance of VideoMAE. The temporally redundant video content enables higher masking ratio than that of images. (2) VideoMAE achieves impressive results on very small datasets (i.e., around 3k-4k videos) without using any extra data. This is partially ascribed to the challenging task of video reconstruction to enforce high-level structure learning. (3) VideoMAE shows that data quality is more important than data quantity for SSVP. Domain shift between pre-training and target datasets are important issues in SSVP. Notably, our VideoMAE with the vanilla ViT backbone can achieve 83.9% on Kinects-400, 75.3% on Something-Something V2, 90.8% on UCF101, and 61.1% on HMDB51 without using any extra data.*
<img src="https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/transformers/model_doc/videomae_architecture.jpeg"
alt="drawing" width="600"/>
<small> VideoMAE pre-training. Taken from the <a href="https://arxiv.org/abs/2203.12602">original paper</a>. </small>
This model was contributed by [nielsr](https://huggingface.co/nielsr).
The original code can be found [here](https://github.com/MCG-NJU/VideoMAE).
## Resources
A list of official Hugging Face and community (indicated by ๐) resources to help you get started with VideoMAE. If
you're interested in submitting a resource to be included here, please feel free to open a Pull Request and we'll
review it! The resource should ideally demonstrate something new instead of duplicating an existing resource.
**Video classification**
- [A notebook](https://github.com/huggingface/notebooks/blob/main/examples/video_classification.ipynb) that shows how
to fine-tune a VideoMAE model on a custom dataset.
- [Video classification task guide](../tasks/video_classification)
- [A ๐ค Space](https://huggingface.co/spaces/sayakpaul/video-classification-ucf101-subset) showing how to perform inference with a video classification model.
## VideoMAEConfig
[[autodoc]] VideoMAEConfig
## VideoMAEFeatureExtractor
[[autodoc]] VideoMAEFeatureExtractor
- __call__
## VideoMAEImageProcessor
[[autodoc]] VideoMAEImageProcessor
- preprocess
## VideoMAEModel
[[autodoc]] VideoMAEModel
- forward
## VideoMAEForPreTraining
`VideoMAEForPreTraining` includes the decoder on top for self-supervised pre-training.
[[autodoc]] transformers.VideoMAEForPreTraining
- forward
## VideoMAEForVideoClassification
[[autodoc]] transformers.VideoMAEForVideoClassification
- forward
| 0 |
mavonic_private_repos/transformers/docs/source/en | mavonic_private_repos/transformers/docs/source/en/model_doc/cpmant.md | <!--Copyright 2022 The HuggingFace Team and The OpenBMB Team. All rights reserved.
Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
the License. You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
specific language governing permissions and limitations under the License.
โ ๏ธ Note that this file is in Markdown but contain specific syntax for our doc-builder (similar to MDX) that may not be
rendered properly in your Markdown viewer.
-->
# CPMAnt
## Overview
CPM-Ant is an open-source Chinese pre-trained language model (PLM) with 10B parameters. It is also the first milestone of the live training process of CPM-Live. The training process is cost-effective and environment-friendly. CPM-Ant also achieves promising results with delta tuning on the CUGE benchmark. Besides the full model, we also provide various compressed versions to meet the requirements of different hardware configurations. [See more](https://github.com/OpenBMB/CPM-Live/tree/cpm-ant/cpm-live)
This model was contributed by [OpenBMB](https://huggingface.co/openbmb). The original code can be found [here](https://github.com/OpenBMB/CPM-Live/tree/cpm-ant/cpm-live).
## Resources
- A tutorial on [CPM-Live](https://github.com/OpenBMB/CPM-Live/tree/cpm-ant/cpm-live).
## CpmAntConfig
[[autodoc]] CpmAntConfig
- all
## CpmAntTokenizer
[[autodoc]] CpmAntTokenizer
- all
## CpmAntModel
[[autodoc]] CpmAntModel
- all
## CpmAntForCausalLM
[[autodoc]] CpmAntForCausalLM
- all | 0 |
mavonic_private_repos/transformers/docs/source/en | mavonic_private_repos/transformers/docs/source/en/model_doc/layoutxlm.md | <!--Copyright 2021 The HuggingFace Team. All rights reserved.
Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
the License. You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
specific language governing permissions and limitations under the License.
โ ๏ธ Note that this file is in Markdown but contain specific syntax for our doc-builder (similar to MDX) that may not be
rendered properly in your Markdown viewer.
-->
# LayoutXLM
## Overview
LayoutXLM was proposed in [LayoutXLM: Multimodal Pre-training for Multilingual Visually-rich Document Understanding](https://arxiv.org/abs/2104.08836) by Yiheng Xu, Tengchao Lv, Lei Cui, Guoxin Wang, Yijuan Lu, Dinei Florencio, Cha
Zhang, Furu Wei. It's a multilingual extension of the [LayoutLMv2 model](https://arxiv.org/abs/2012.14740) trained
on 53 languages.
The abstract from the paper is the following:
*Multimodal pre-training with text, layout, and image has achieved SOTA performance for visually-rich document
understanding tasks recently, which demonstrates the great potential for joint learning across different modalities. In
this paper, we present LayoutXLM, a multimodal pre-trained model for multilingual document understanding, which aims to
bridge the language barriers for visually-rich document understanding. To accurately evaluate LayoutXLM, we also
introduce a multilingual form understanding benchmark dataset named XFUN, which includes form understanding samples in
7 languages (Chinese, Japanese, Spanish, French, Italian, German, Portuguese), and key-value pairs are manually labeled
for each language. Experiment results show that the LayoutXLM model has significantly outperformed the existing SOTA
cross-lingual pre-trained models on the XFUN dataset.*
This model was contributed by [nielsr](https://huggingface.co/nielsr). The original code can be found [here](https://github.com/microsoft/unilm).
## Usage tips and examples
One can directly plug in the weights of LayoutXLM into a LayoutLMv2 model, like so:
```python
from transformers import LayoutLMv2Model
model = LayoutLMv2Model.from_pretrained("microsoft/layoutxlm-base")
```
Note that LayoutXLM has its own tokenizer, based on
[`LayoutXLMTokenizer`]/[`LayoutXLMTokenizerFast`]. You can initialize it as
follows:
```python
from transformers import LayoutXLMTokenizer
tokenizer = LayoutXLMTokenizer.from_pretrained("microsoft/layoutxlm-base")
```
Similar to LayoutLMv2, you can use [`LayoutXLMProcessor`] (which internally applies
[`LayoutLMv2ImageProcessor`] and
[`LayoutXLMTokenizer`]/[`LayoutXLMTokenizerFast`] in sequence) to prepare all
data for the model.
<Tip>
As LayoutXLM's architecture is equivalent to that of LayoutLMv2, one can refer to [LayoutLMv2's documentation page](layoutlmv2) for all tips, code examples and notebooks.
</Tip>
## LayoutXLMTokenizer
[[autodoc]] LayoutXLMTokenizer
- __call__
- build_inputs_with_special_tokens
- get_special_tokens_mask
- create_token_type_ids_from_sequences
- save_vocabulary
## LayoutXLMTokenizerFast
[[autodoc]] LayoutXLMTokenizerFast
- __call__
## LayoutXLMProcessor
[[autodoc]] LayoutXLMProcessor
- __call__
| 0 |
mavonic_private_repos/transformers/docs/source/en | mavonic_private_repos/transformers/docs/source/en/model_doc/persimmon.md | <!--Copyright 2023 The HuggingFace Team. All rights reserved.
Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
the License. You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
specific language governing permissions and limitations under the License.
โ ๏ธ Note that this file is in Markdown but contain specific syntax for our doc-builder (similar to MDX) that may not be
rendered properly in your Markdown viewer.
-->
# Persimmon
## Overview
The Persimmon model was created by [ADEPT](https://www.adept.ai/blog/persimmon-8b), and authored by Erich Elsen, Augustus Odena, Maxwell Nye, Saฤnak Taลฤฑrlar, Tri Dao, Curtis Hawthorne, Deepak Moparthi, Arushi Somani.
The authors introduced Persimmon-8B, a decoder model based on the classic transformers architecture, with query and key normalization. Persimmon-8B is a fully permissively-licensed model with approximately 8 billion parameters, released under the Apache license. Some of the key attributes of Persimmon-8B are long context size (16K), performance, and capabilities for multimodal extensions.
The authors showcase their approach to model evaluation, focusing on practical text generation, mirroring how users interact with language models. The work also includes a comparative analysis, pitting Persimmon-8B against other prominent models (MPT 7B Instruct and Llama 2 Base 7B 1-Shot), across various evaluation tasks. The results demonstrate Persimmon-8B's competitive performance, even with limited training data.
In terms of model details, the work outlines the architecture and training methodology of Persimmon-8B, providing insights into its design choices, sequence length, and dataset composition. The authors present a fast inference code that outperforms traditional implementations through operator fusion and CUDA graph utilization while maintaining code coherence. They express their anticipation of how the community will leverage this contribution to drive innovation, hinting at further upcoming releases as part of an ongoing series of developments.
This model was contributed by [ArthurZ](https://huggingface.co/ArthurZ).
The original code can be found [here](https://github.com/persimmon-ai-labs/adept-inference).
## Usage tips
<Tip warning={true}>
The `Persimmon` models were trained using `bfloat16`, but the original inference uses `float16` The checkpoints uploaded on the hub use `torch_dtype = 'float16'` which will be
used by the `AutoModel` API to cast the checkpoints from `torch.float32` to `torch.float16`.
The `dtype` of the online weights is mostly irrelevant, unless you are using `torch_dtype="auto"` when initializing a model using `model = AutoModelForCausalLM.from_pretrained("path", torch_dtype = "auto")`. The reason is that the model will first be downloaded ( using the `dtype` of the checkpoints online) then it will be cast to the default `dtype` of `torch` (becomes `torch.float32`). Users should specify the `torch_dtype` they want, and if they don't it will be `torch.float32`.
Finetuning the model in `float16` is not recommended and known to produce `nan`, as such the model should be fine-tuned in `bfloat16`.
</Tip>
Tips:
- To convert the model, you need to clone the original repository using `git clone https://github.com/persimmon-ai-labs/adept-inference`, then get the checkpoints:
```bash
git clone https://github.com/persimmon-ai-labs/adept-inference
wget https://axtkn4xl5cip.objectstorage.us-phoenix-1.oci.customer-oci.com/n/axtkn4xl5cip/b/adept-public-data/o/8b_base_model_release.tar
tar -xvf 8b_base_model_release.tar
python src/transformers/models/persimmon/convert_persimmon_weights_to_hf.py --input_dir /path/to/downloaded/persimmon/weights/ --output_dir /output/path \
--pt_model_path /path/to/8b_chat_model_release/iter_0001251/mp_rank_00/model_optim_rng.pt
--ada_lib_path /path/to/adept-inference
```
For the chat model:
```bash
wget https://axtkn4xl5cip.objectstorage.us-phoenix-1.oci.customer-oci.com/n/axtkn4xl5cip/b/adept-public-data/o/8b_chat_model_release.tar
tar -xvf 8b_base_model_release.tar
```
Thereafter, models can be loaded via:
```py
from transformers import PersimmonForCausalLM, PersimmonTokenizer
model = PersimmonForCausalLM.from_pretrained("/output/path")
tokenizer = PersimmonTokenizer.from_pretrained("/output/path")
```
- Perismmon uses a `sentencepiece` based tokenizer, with a `Unigram` model. It supports bytefallback, which is only available in `tokenizers==0.14.0` for the fast tokenizer.
The `LlamaTokenizer` is used as it is a standard wrapper around sentencepiece. The `chat` template will be updated with the templating functions in a follow up PR!
- The authors suggest to use the following prompt format for the chat mode: `f"human: {prompt}\n\nadept:"`
## PersimmonConfig
[[autodoc]] PersimmonConfig
## PersimmonModel
[[autodoc]] PersimmonModel
- forward
## PersimmonForCausalLM
[[autodoc]] PersimmonForCausalLM
- forward
## PersimmonForSequenceClassification
[[autodoc]] PersimmonForSequenceClassification
- forward
| 0 |
mavonic_private_repos/transformers/docs/source/en | mavonic_private_repos/transformers/docs/source/en/model_doc/gpt-sw3.md | <!--Copyright 2022 The HuggingFace Team. All rights reserved.
Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
the License. You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
specific language governing permissions and limitations under the License.
โ ๏ธ Note that this file is in Markdown but contain specific syntax for our doc-builder (similar to MDX) that may not be
rendered properly in your Markdown viewer.
-->
# GPT-Sw3
## Overview
The GPT-Sw3 model was first proposed in
[Lessons Learned from GPT-SW3: Building the First Large-Scale Generative Language Model for Swedish](http://www.lrec-conf.org/proceedings/lrec2022/pdf/2022.lrec-1.376.pdf)
by Ariel Ekgren, Amaru Cuba Gyllensten, Evangelia Gogoulou, Alice Heiman, Severine Verlinden, Joey รhman,
Fredrik Carlsson, Magnus Sahlgren.
Since that first paper the authors have extended their work and trained new models on their new 1.2TB corpora named The Nordic Pile.
GPT-Sw3 is a collection of large decoder-only pretrained transformer language models that were developed by AI Sweden
in collaboration with RISE and the WASP WARA for Media and Language. GPT-Sw3 has been trained on a dataset containing
320B tokens in Swedish, Norwegian, Danish, Icelandic, English, and programming code. The model was pretrained using a
causal language modeling (CLM) objective utilizing the NeMo Megatron GPT implementation.
This model was contributed by [AI Sweden Models](https://huggingface.co/AI-Sweden-Models).
## Usage example
```python
>>> from transformers import AutoTokenizer, AutoModelForCausalLM
>>> tokenizer = AutoTokenizer.from_pretrained("AI-Sweden-Models/gpt-sw3-356m")
>>> model = AutoModelForCausalLM.from_pretrained("AI-Sweden-Models/gpt-sw3-356m")
>>> input_ids = tokenizer("Trรคd รคr fina fรถr att", return_tensors="pt")["input_ids"]
>>> generated_token_ids = model.generate(inputs=input_ids, max_new_tokens=10, do_sample=True)[0]
>>> print(tokenizer.decode(generated_token_ids))
Trรคd รคr fina fรถr att de รคr fรคrgstarka. Men ibland รคr det fint
```
## Resources
- [Text classification task guide](../tasks/sequence_classification)
- [Token classification task guide](../tasks/token_classification)
- [Causal language modeling task guide](../tasks/language_modeling)
<Tip>
The implementation uses the `GPT2Model` coupled with our `GPTSw3Tokenizer`. Refer to [GPT2Model documentation](gpt2)
for API reference and examples.
Note that sentencepiece is required to use our tokenizer and can be installed with `pip install transformers[sentencepiece]` or `pip install sentencepiece`
</Tip>
## GPTSw3Tokenizer
[[autodoc]] GPTSw3Tokenizer
- save_vocabulary
| 0 |
mavonic_private_repos/transformers/docs/source/en | mavonic_private_repos/transformers/docs/source/en/model_doc/mixtral.md | <!--Copyright 2023 Mistral AI and The HuggingFace Team. All rights reserved.
Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
the License. You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
specific language governing permissions and limitations under the License.
โ ๏ธ Note that this file is in Markdown but contain specific syntax for our doc-builder (similar to MDX) that may not be
rendered properly in your Markdown viewer.
-->
# Mixtral
## Overview
Mixtral-8x7B was introduced in the [Mixtral of Experts blogpost](https://mistral.ai/news/mixtral-of-experts/) by Albert Jiang, Alexandre Sablayrolles, Arthur Mensch, Chris Bamford, Devendra Singh Chaplot, Diego de las Casas, Florian Bressand, Gianna Lengyel, Guillaume Lample, Lรฉlio Renard Lavaud, Lucile Saulnier, Marie-Anne Lachaux, Pierre Stock, Teven Le Scao, Thibaut Lavril, Thomas Wang, Timothรฉe Lacroix, William El Sayed.
The introduction of the blog post says:
*Today, the team is proud to release Mixtral 8x7B, a high-quality sparse mixture of experts models (SMoE) with open weights. Licensed under Apache 2.0. Mixtral outperforms Llama 2 70B on most benchmarks with 6x faster inference. It is the strongest open-weight model with a permissive license and the best model overall regarding cost/performance trade-offs. In particular, it matches or outperforms GPT3.5 on most standard benchmarks.*
Mixtral-8x7B is the second large language model (LLM) released by [mistral.ai](https://mistral.ai/), after [Mistral-7B](mistral).
### Architectural details
Mixtral-8x7B is a decoder-only Transformer with the following architectural choices:
- Mixtral is a Mixture of Experts (MoE) model with 8 experts per MLP, with a total of 45 billion parameters. To learn more about mixture-of-experts, refer to the [blog post](https://huggingface.co/blog/moe).
- Despite the model having 45 billion parameters,, the compute required for a single forward pass is the same as that of a 14 billion parameter model. This is because even though each of the experts have to be loaded in RAM (70B like ram requirement) each token from the hidden states are dispatched twice (top 2 routing) and thus the compute (the operation required at each forward computation) is just 2 X sequence_length.
The following implementation details are shared with Mistral AI's first model [Mistral-7B](mistral):
- Sliding Window Attention - Trained with 8k context length and fixed cache size, with a theoretical attention span of 128K tokens
- GQA (Grouped Query Attention) - allowing faster inference and lower cache size.
- Byte-fallback BPE tokenizer - ensures that characters are never mapped to out of vocabulary tokens.
For more details refer to the [release blog post](https://mistral.ai/news/mixtral-of-experts/).
### License
`Mixtral-8x7B` is released under the Apache 2.0 license.
## Usage tips
The Mistral team has released 2 checkpoints:
- a base model, [Mixtral-8x7B-v0.1](https://huggingface.co/mistralai/Mixtral-8x7B-v0.1), which has been pre-trained to predict the next token on internet-scale data.
- an instruction tuned model, [Mixtral-8x7B-Instruct-v0.1](https://huggingface.co/mistralai/Mixtral-8x7B-Instruct-v0.1), which is the base model optimized for chat purposes using supervised fine-tuning (SFT) and direct preference optimization (DPO).
The base model can be used as follows:
```python
>>> from transformers import AutoModelForCausalLM, AutoTokenizer
>>> model = AutoModelForCausalLM.from_pretrained("mistralai/Mixtral-8x7B-v0.1", device_map="auto")
>>> tokenizer = AutoTokenizer.from_pretrained("mistralai/Mixtral-8x7B-v0.1")
>>> prompt = "My favourite condiment is"
>>> model_inputs = tokenizer([prompt], return_tensors="pt").to("cuda")
>>> model.to(device)
>>> generated_ids = model.generate(**model_inputs, max_new_tokens=100, do_sample=True)
>>> tokenizer.batch_decode(generated_ids)[0]
"My favourite condiment is to ..."
```
The instruction tuned model can be used as follows:
```python
>>> from transformers import AutoModelForCausalLM, AutoTokenizer
>>> model = AutoModelForCausalLM.from_pretrained("mistralai/Mixtral-8x7B-Instruct-v0.1", device_map="auto")
>>> tokenizer = AutoTokenizer.from_pretrained("mistralai/Mixtral-8x7B-Instruct-v0.1")
>>> messages = [
... {"role": "user", "content": "What is your favourite condiment?"},
... {"role": "assistant", "content": "Well, I'm quite partial to a good squeeze of fresh lemon juice. It adds just the right amount of zesty flavour to whatever I'm cooking up in the kitchen!"},
... {"role": "user", "content": "Do you have mayonnaise recipes?"}
... ]
>>> model_inputs = tokenizer.apply_chat_template(messages, return_tensors="pt").to("cuda")
>>> generated_ids = model.generate(model_inputs, max_new_tokens=100, do_sample=True)
>>> tokenizer.batch_decode(generated_ids)[0]
"Mayonnaise can be made as follows: (...)"
```
As can be seen, the instruction-tuned model requires a [chat template](../chat_templating) to be applied to make sure the inputs are prepared in the right format.
## Speeding up Mixtral by using Flash Attention
The code snippets above showcase inference without any optimization tricks. However, one can drastically speed up the model by leveraging [Flash Attention](../perf_train_gpu_one.md#flash-attention-2), which is a faster implementation of the attention mechanism used inside the model.
First, make sure to install the latest version of Flash Attention 2 to include the sliding window attention feature.
```bash
pip install -U flash-attn --no-build-isolation
```
Make also sure that you have a hardware that is compatible with Flash-Attention 2. Read more about it in the official documentation of the [flash attention repository](https://github.com/Dao-AILab/flash-attention). Make also sure to load your model in half-precision (e.g. `torch.float16`)
To load and run a model using Flash Attention-2, refer to the snippet below:
```python
>>> import torch
>>> from transformers import AutoModelForCausalLM, AutoTokenizer
>>> model = AutoModelForCausalLM.from_pretrained("mistralai/Mixtral-8x7B-v0.1", torch_dtype=torch.float16, attn_implementation="flash_attention_2", device_map="auto")
>>> tokenizer = AutoTokenizer.from_pretrained("mistralai/Mixtral-8x7B-v0.1")
>>> prompt = "My favourite condiment is"
>>> model_inputs = tokenizer([prompt], return_tensors="pt").to("cuda")
>>> model.to(device)
>>> generated_ids = model.generate(**model_inputs, max_new_tokens=100, do_sample=True)
>>> tokenizer.batch_decode(generated_ids)[0]
"The expected output"
```
### Expected speedups
Below is a expected speedup diagram that compares pure inference time between the native implementation in transformers using `mistralai/Mixtral-8x7B-v0.1` checkpoint and the Flash Attention 2 version of the model.
<div style="text-align: center">
<img src="https://huggingface.co/datasets/ybelkada/documentation-images/resolve/main/mixtral-7b-inference-large-seqlen.png">
</div>
### Sliding window Attention
The current implementation supports the sliding window attention mechanism and memory efficient cache management.
To enable sliding window attention, just make sure to have a `flash-attn` version that is compatible with sliding window attention (`>=2.3.0`).
The Flash Attention-2 model uses also a more memory efficient cache slicing mechanism - as recommended per the official implementation of Mistral model that use rolling cache mechanism we keep the cache size fixed (`self.config.sliding_window`), support batched generation only for `padding_side="left"` and use the absolute position of the current token to compute the positional embedding.
## Shrinking down Mixtral using quantization
As the Mixtral model has 45 billion parameters, that would require about 90GB of GPU RAM in half precision (float16), since each parameter is stored in 2 bytes. However, one can shrink down the size of the model using [quantization](../quantization.md). If the model is quantized to 4 bits (or half a byte per parameter), a single A100 with 40GB of RAM is enough to fit the entire model, as in that case only about 27 GB of RAM is required.
Quantizing a model is as simple as passing a `quantization_config` to the model. Below, we'll leverage the BitsAndyBytes quantization (but refer to [this page](../quantization.md) for other quantization methods):
```python
>>> import torch
>>> from transformers import AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig
>>> # specify how to quantize the model
>>> quantization_config = BitsAndBytesConfig(
... load_in_4bit=True,
... bnb_4bit_quant_type="nf4",
... bnb_4bit_compute_dtype="torch.float16",
... )
>>> model = AutoModelForCausalLM.from_pretrained("mistralai/Mixtral-8x7B-Instruct-v0.1", quantization_config=True, device_map="auto")
>>> tokenizer = AutoTokenizer.from_pretrained("mistralai/Mixtral-8x7B-Instruct-v0.1")
>>> prompt = "My favourite condiment is"
>>> messages = [
... {"role": "user", "content": "What is your favourite condiment?"},
... {"role": "assistant", "content": "Well, I'm quite partial to a good squeeze of fresh lemon juice. It adds just the right amount of zesty flavour to whatever I'm cooking up in the kitchen!"},
... {"role": "user", "content": "Do you have mayonnaise recipes?"}
... ]
>>> model_inputs = tokenizer.apply_chat_template(messages, return_tensors="pt").to("cuda")
>>> generated_ids = model.generate(model_inputs, max_new_tokens=100, do_sample=True)
>>> tokenizer.batch_decode(generated_ids)[0]
"The expected output"
```
This model was contributed by [Younes Belkada](https://huggingface.co/ybelkada) and [Arthur Zucker](https://huggingface.co/ArthurZ) .
The original code can be found [here](https://github.com/mistralai/mistral-src).
## Resources
A list of official Hugging Face and community (indicated by ๐) resources to help you get started with Mixtral. If you're interested in submitting a resource to be included here, please feel free to open a Pull Request and we'll review it! The resource should ideally demonstrate something new instead of duplicating an existing resource.
<PipelineTag pipeline="text-generation"/>
- A demo notebook to perform supervised fine-tuning (SFT) of Mixtral-8x7B can be found [here](https://github.com/NielsRogge/Transformers-Tutorials/blob/master/Mistral/Supervised_fine_tuning_(SFT)_of_an_LLM_using_Hugging_Face_tooling.ipynb). ๐
- A [blog post](https://medium.com/@prakharsaxena11111/finetuning-mixtral-7bx8-6071b0ebf114) on fine-tuning Mixtral-8x7B using PEFT. ๐
- The [Alignment Handbook](https://github.com/huggingface/alignment-handbook) by Hugging Face includes scripts and recipes to perform supervised fine-tuning (SFT) and direct preference optimization with Mistral-7B. This includes scripts for full fine-tuning, QLoRa on a single GPU as well as multi-GPU fine-tuning.
- [Causal language modeling task guide](../tasks/language_modeling)
## MixtralConfig
[[autodoc]] MixtralConfig
## MixtralModel
[[autodoc]] MixtralModel
- forward
## MixtralForCausalLM
[[autodoc]] MixtralForCausalLM
- forward
## MixtralForSequenceClassification
[[autodoc]] MixtralForSequenceClassification
- forward
| 0 |
mavonic_private_repos/transformers/docs/source/en | mavonic_private_repos/transformers/docs/source/en/model_doc/deberta-v2.md | <!--Copyright 2020 The HuggingFace Team. All rights reserved.
Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
the License. You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
specific language governing permissions and limitations under the License.
โ ๏ธ Note that this file is in Markdown but contain specific syntax for our doc-builder (similar to MDX) that may not be
rendered properly in your Markdown viewer.
-->
# DeBERTa-v2
## Overview
The DeBERTa model was proposed in [DeBERTa: Decoding-enhanced BERT with Disentangled Attention](https://arxiv.org/abs/2006.03654) by Pengcheng He, Xiaodong Liu, Jianfeng Gao, Weizhu Chen It is based on Google's
BERT model released in 2018 and Facebook's RoBERTa model released in 2019.
It builds on RoBERTa with disentangled attention and enhanced mask decoder training with half of the data used in
RoBERTa.
The abstract from the paper is the following:
*Recent progress in pre-trained neural language models has significantly improved the performance of many natural
language processing (NLP) tasks. In this paper we propose a new model architecture DeBERTa (Decoding-enhanced BERT with
disentangled attention) that improves the BERT and RoBERTa models using two novel techniques. The first is the
disentangled attention mechanism, where each word is represented using two vectors that encode its content and
position, respectively, and the attention weights among words are computed using disentangled matrices on their
contents and relative positions. Second, an enhanced mask decoder is used to replace the output softmax layer to
predict the masked tokens for model pretraining. We show that these two techniques significantly improve the efficiency
of model pretraining and performance of downstream tasks. Compared to RoBERTa-Large, a DeBERTa model trained on half of
the training data performs consistently better on a wide range of NLP tasks, achieving improvements on MNLI by +0.9%
(90.2% vs. 91.1%), on SQuAD v2.0 by +2.3% (88.4% vs. 90.7%) and RACE by +3.6% (83.2% vs. 86.8%). The DeBERTa code and
pre-trained models will be made publicly available at https://github.com/microsoft/DeBERTa.*
The following information is visible directly on the [original implementation
repository](https://github.com/microsoft/DeBERTa). DeBERTa v2 is the second version of the DeBERTa model. It includes
the 1.5B model used for the SuperGLUE single-model submission and achieving 89.9, versus human baseline 89.8. You can
find more details about this submission in the authors'
[blog](https://www.microsoft.com/en-us/research/blog/microsoft-deberta-surpasses-human-performance-on-the-superglue-benchmark/)
New in v2:
- **Vocabulary** In v2 the tokenizer is changed to use a new vocabulary of size 128K built from the training data.
Instead of a GPT2-based tokenizer, the tokenizer is now
[sentencepiece-based](https://github.com/google/sentencepiece) tokenizer.
- **nGiE(nGram Induced Input Encoding)** The DeBERTa-v2 model uses an additional convolution layer aside with the first
transformer layer to better learn the local dependency of input tokens.
- **Sharing position projection matrix with content projection matrix in attention layer** Based on previous
experiments, this can save parameters without affecting the performance.
- **Apply bucket to encode relative positions** The DeBERTa-v2 model uses log bucket to encode relative positions
similar to T5.
- **900M model & 1.5B model** Two additional model sizes are available: 900M and 1.5B, which significantly improves the
performance of downstream tasks.
This model was contributed by [DeBERTa](https://huggingface.co/DeBERTa). This model TF 2.0 implementation was
contributed by [kamalkraj](https://huggingface.co/kamalkraj). The original code can be found [here](https://github.com/microsoft/DeBERTa).
## Resources
- [Text classification task guide](../tasks/sequence_classification)
- [Token classification task guide](../tasks/token_classification)
- [Question answering task guide](../tasks/question_answering)
- [Masked language modeling task guide](../tasks/masked_language_modeling)
- [Multiple choice task guide](../tasks/multiple_choice)
## DebertaV2Config
[[autodoc]] DebertaV2Config
## DebertaV2Tokenizer
[[autodoc]] DebertaV2Tokenizer
- build_inputs_with_special_tokens
- get_special_tokens_mask
- create_token_type_ids_from_sequences
- save_vocabulary
## DebertaV2TokenizerFast
[[autodoc]] DebertaV2TokenizerFast
- build_inputs_with_special_tokens
- create_token_type_ids_from_sequences
<frameworkcontent>
<pt>
## DebertaV2Model
[[autodoc]] DebertaV2Model
- forward
## DebertaV2PreTrainedModel
[[autodoc]] DebertaV2PreTrainedModel
- forward
## DebertaV2ForMaskedLM
[[autodoc]] DebertaV2ForMaskedLM
- forward
## DebertaV2ForSequenceClassification
[[autodoc]] DebertaV2ForSequenceClassification
- forward
## DebertaV2ForTokenClassification
[[autodoc]] DebertaV2ForTokenClassification
- forward
## DebertaV2ForQuestionAnswering
[[autodoc]] DebertaV2ForQuestionAnswering
- forward
## DebertaV2ForMultipleChoice
[[autodoc]] DebertaV2ForMultipleChoice
- forward
</pt>
<tf>
## TFDebertaV2Model
[[autodoc]] TFDebertaV2Model
- call
## TFDebertaV2PreTrainedModel
[[autodoc]] TFDebertaV2PreTrainedModel
- call
## TFDebertaV2ForMaskedLM
[[autodoc]] TFDebertaV2ForMaskedLM
- call
## TFDebertaV2ForSequenceClassification
[[autodoc]] TFDebertaV2ForSequenceClassification
- call
## TFDebertaV2ForTokenClassification
[[autodoc]] TFDebertaV2ForTokenClassification
- call
## TFDebertaV2ForQuestionAnswering
[[autodoc]] TFDebertaV2ForQuestionAnswering
- call
## TFDebertaV2ForMultipleChoice
[[autodoc]] TFDebertaV2ForMultipleChoice
- call
</tf>
</frameworkcontent>
| 0 |
mavonic_private_repos/transformers/docs/source/en | mavonic_private_repos/transformers/docs/source/en/model_doc/nllb.md | <!--Copyright 2020 The HuggingFace Team. All rights reserved.
Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
the License. You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
specific language governing permissions and limitations under the License.
โ ๏ธ Note that this file is in Markdown but contain specific syntax for our doc-builder (similar to MDX) that may not be
rendered properly in your Markdown viewer.
-->
# NLLB
## Updated tokenizer behavior
**DISCLAIMER:** The default behaviour for the tokenizer was fixed and thus changed in April 2023.
The previous version adds `[self.eos_token_id, self.cur_lang_code]` at the end of the token sequence for both target and source tokenization. This is wrong as the NLLB paper mentions (page 48, 6.1.1. Model Architecture) :
*Note that we prefix the source sequence with the source language, as opposed to the target
language as previously done in several works (Arivazhagan et al., 2019; Johnson et al.,
2017). This is primarily because we prioritize optimizing zero-shot performance of our
model on any pair of 200 languages at a minor cost to supervised performance.*
Previous behaviour:
```python
>>> from transformers import NllbTokenizer
>>> tokenizer = NllbTokenizer.from_pretrained("facebook/nllb-200-distilled-600M")
>>> tokenizer("How was your day?").input_ids
[13374, 1398, 4260, 4039, 248130, 2, 256047]
>>> # 2: '</s>'
>>> # 256047 : 'eng_Latn'
```
New behaviour
```python
>>> from transformers import NllbTokenizer
>>> tokenizer = NllbTokenizer.from_pretrained("facebook/nllb-200-distilled-600M")
>>> tokenizer("How was your day?").input_ids
[256047, 13374, 1398, 4260, 4039, 248130, 2]
```
Enabling the old behaviour can be done as follows:
```python
>>> from transformers import NllbTokenizer
>>> tokenizer = NllbTokenizer.from_pretrained("facebook/nllb-200-distilled-600M", legacy_behaviour=True)
```
For more details, feel free to check the linked [PR](https://github.com/huggingface/transformers/pull/22313) and [Issue](https://github.com/huggingface/transformers/issues/19943).
## Overview
The NLLB model was presented in [No Language Left Behind: Scaling Human-Centered Machine Translation](https://arxiv.org/abs/2207.04672) by Marta R. Costa-jussร , James Cross, Onur รelebi,
Maha Elbayad, Kenneth Heafield, Kevin Heffernan, Elahe Kalbassi, Janice Lam, Daniel Licht, Jean Maillard, Anna Sun, Skyler Wang, Guillaume Wenzek, Al Youngblood, Bapi Akula,
Loic Barrault, Gabriel Mejia Gonzalez, Prangthip Hansanti, John Hoffman, Semarley Jarrett, Kaushik Ram Sadagopan, Dirk Rowe, Shannon Spruit, Chau Tran, Pierre Andrews,
Necip Fazil Ayan, Shruti Bhosale, Sergey Edunov, Angela Fan, Cynthia Gao, Vedanuj Goswami, Francisco Guzmรกn, Philipp Koehn, Alexandre Mourachko, Christophe Ropers,
Safiyyah Saleem, Holger Schwenk, and Jeff Wang.
The abstract of the paper is the following:
*Driven by the goal of eradicating language barriers on a global scale, machine translation has solidified itself as a key focus of artificial intelligence research today.
However, such efforts have coalesced around a small subset of languages, leaving behind the vast majority of mostly low-resource languages. What does it take to break the
200 language barrier while ensuring safe, high quality results, all while keeping ethical considerations in mind? In No Language Left Behind, we took on this challenge by
first contextualizing the need for low-resource language translation support through exploratory interviews with native speakers. Then, we created datasets and models aimed
at narrowing the performance gap between low and high-resource languages. More specifically, we developed a conditional compute model based on Sparsely Gated Mixture of
Experts that is trained on data obtained with novel and effective data mining techniques tailored for low-resource languages. We propose multiple architectural and training
improvements to counteract overfitting while training on thousands of tasks. Critically, we evaluated the performance of over 40,000 different translation directions using
a human-translated benchmark, Flores-200, and combined human evaluation with a novel toxicity benchmark covering all languages in Flores-200 to assess translation safety.
Our model achieves an improvement of 44% BLEU relative to the previous state-of-the-art, laying important groundwork towards realizing a universal translation system.*
This implementation contains the dense models available on release.
**The sparse model NLLB-MoE (Mixture of Expert) is now available! More details [here](nllb-moe)**
This model was contributed by [Lysandre](https://huggingface.co/lysandre). The authors' code can be found [here](https://github.com/facebookresearch/fairseq/tree/nllb).
## Generating with NLLB
While generating the target text set the `forced_bos_token_id` to the target language id. The following
example shows how to translate English to French using the *facebook/nllb-200-distilled-600M* model.
Note that we're using the BCP-47 code for French `fra_Latn`. See [here](https://github.com/facebookresearch/flores/blob/main/flores200/README.md#languages-in-flores-200)
for the list of all BCP-47 in the Flores 200 dataset.
```python
>>> from transformers import AutoModelForSeq2SeqLM, AutoTokenizer
>>> tokenizer = AutoTokenizer.from_pretrained("facebook/nllb-200-distilled-600M")
>>> model = AutoModelForSeq2SeqLM.from_pretrained("facebook/nllb-200-distilled-600M")
>>> article = "UN Chief says there is no military solution in Syria"
>>> inputs = tokenizer(article, return_tensors="pt")
>>> translated_tokens = model.generate(
... **inputs, forced_bos_token_id=tokenizer.lang_code_to_id["fra_Latn"], max_length=30
... )
>>> tokenizer.batch_decode(translated_tokens, skip_special_tokens=True)[0]
Le chef de l'ONU dit qu'il n'y a pas de solution militaire en Syrie
```
### Generating from any other language than English
English (`eng_Latn`) is set as the default language from which to translate. In order to specify that you'd like to translate from a different language,
you should specify the BCP-47 code in the `src_lang` keyword argument of the tokenizer initialization.
See example below for a translation from romanian to german:
```py
>>> from transformers import AutoModelForSeq2SeqLM, AutoTokenizer
>>> tokenizer = AutoTokenizer.from_pretrained(
... "facebook/nllb-200-distilled-600M", token=True, src_lang="ron_Latn"
... )
>>> model = AutoModelForSeq2SeqLM.from_pretrained("facebook/nllb-200-distilled-600M", token=True)
>>> article = "ลeful ONU spune cฤ nu existฤ o soluลฃie militarฤ รฎn Siria"
>>> inputs = tokenizer(article, return_tensors="pt")
>>> translated_tokens = model.generate(
... **inputs, forced_bos_token_id=tokenizer.lang_code_to_id["deu_Latn"], max_length=30
... )
>>> tokenizer.batch_decode(translated_tokens, skip_special_tokens=True)[0]
UN-Chef sagt, es gibt keine militรคrische Lรถsung in Syrien
```
## Resources
- [Translation task guide](../tasks/translation)
- [Summarization task guide](../tasks/summarization)
## NllbTokenizer
[[autodoc]] NllbTokenizer
- build_inputs_with_special_tokens
## NllbTokenizerFast
[[autodoc]] NllbTokenizerFast
## Using Flash Attention 2
Flash Attention 2 is a faster, optimized version of the attention scores computation which relies on `cuda` kernels.
### Installation
First, check whether your hardware is compatible with Flash Attention 2. The latest list of compatible hardware can be found in the [official documentation](https://github.com/Dao-AILab/flash-attention#installation-and-features).
Next, [install](https://github.com/Dao-AILab/flash-attention#installation-and-features) the latest version of Flash Attention 2:
```bash
pip install -U flash-attn --no-build-isolation
```
### Usage
To load a model using Flash Attention 2, we can pass the argument `attn_implementation="flash_attention_2"` to [`.from_pretrained`](https://huggingface.co/docs/transformers/main/en/main_classes/model#transformers.PreTrainedModel.from_pretrained). You can use either `torch.float16` or `torch.bfloat16` precision.
```python
>>> import torch
>>> from transformers import AutoModelForSeq2SeqLM, AutoTokenizer
>>> model = AutoModelForSeq2SeqLM.from_pretrained("facebook/nllb-200-distilled-600M", torch_dtype=torch.float16, attn_implementation="flash_attention_2").to("cuda").eval()
>>> tokenizer = AutoTokenizer.from_pretrained("facebook/nllb-200-distilled-600M")
>>> article = "ลeful ONU spune cฤ nu existฤ o soluลฃie militarฤ รฎn Siria"
>>> inputs = tokenizer(article, return_tensors="pt").to("cuda")
>>> translated_tokens = model.generate(
... **inputs, forced_bos_token_id=tokenizer.lang_code_to_id["deu_Latn"], max_length=30
... )
>>> tokenizer.batch_decode(translated_tokens, skip_special_tokens=True)[0]
"UN-Chef sagt, es gibt keine militรคrische Lรถsung in Syrien"
```
### Expected speedups
Below is an expected speedup diagram that compares pure inference time between the native implementation and the Flash Attention 2.
<div style="text-align: center">
<img src="https://huggingface.co/datasets/visheratin/documentation-images/resolve/main/nllb-speedup.webp">
</div> | 0 |
mavonic_private_repos/transformers/docs/source/en | mavonic_private_repos/transformers/docs/source/en/model_doc/tvlt.md | <!--Copyright 2023 The HuggingFace Team. All rights reserved.
Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
the License. You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
specific language governing permissions and limitations under the License.
โ ๏ธ Note that this file is in Markdown but contain specific syntax for our doc-builder (similar to MDX) that may not be
rendered properly in your Markdown viewer.
-->
# TVLT
## Overview
The TVLT model was proposed in [TVLT: Textless Vision-Language Transformer](https://arxiv.org/abs/2209.14156)
by Zineng Tang, Jaemin Cho, Yixin Nie, Mohit Bansal (the first three authors contributed equally). The Textless Vision-Language Transformer (TVLT) is a model that uses raw visual and audio inputs for vision-and-language representation learning, without using text-specific modules such as tokenization or automatic speech recognition (ASR). It can perform various audiovisual and vision-language tasks like retrieval, question answering, etc.
The abstract from the paper is the following:
*In this work, we present the Textless Vision-Language Transformer (TVLT), where homogeneous transformer blocks take raw visual and audio inputs for vision-and-language representation learning with minimal modality-specific design, and do not use text-specific modules such as tokenization or automatic speech recognition (ASR). TVLT is trained by reconstructing masked patches of continuous video frames and audio spectrograms (masked autoencoding) and contrastive modeling to align video and audio. TVLT attains performance comparable to its text-based counterpart on various multimodal tasks, such as visual question answering, image retrieval, video retrieval, and multimodal sentiment analysis, with 28x faster inference speed and only 1/3 of the parameters. Our findings suggest the possibility of learning compact and efficient visual-linguistic representations from low-level visual and audio signals without assuming the prior existence of text.*
<p align="center">
<img src="https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/transformers/model_doc/tvlt_architecture.png"
alt="drawing" width="600"/>
</p>
<small> TVLT architecture. Taken from the <a href="[https://arxiv.org/abs/2102.03334](https://arxiv.org/abs/2209.14156)">original paper</a>. </small>
The original code can be found [here](https://github.com/zinengtang/TVLT). This model was contributed by [Zineng Tang](https://huggingface.co/ZinengTang).
## Usage tips
- TVLT is a model that takes both `pixel_values` and `audio_values` as input. One can use [`TvltProcessor`] to prepare data for the model.
This processor wraps an image processor (for the image/video modality) and an audio feature extractor (for the audio modality) into one.
- TVLT is trained with images/videos and audios of various sizes: the authors resize and crop the input images/videos to 224 and limit the length of audio spectrogram to 2048. To make batching of videos and audios possible, the authors use a `pixel_mask` that indicates which pixels are real/padding and `audio_mask` that indicates which audio values are real/padding.
- The design of TVLT is very similar to that of a standard Vision Transformer (ViT) and masked autoencoder (MAE) as in [ViTMAE](vitmae). The difference is that the model includes embedding layers for the audio modality.
- The PyTorch version of this model is only available in torch 1.10 and higher.
## TvltConfig
[[autodoc]] TvltConfig
## TvltProcessor
[[autodoc]] TvltProcessor
- __call__
## TvltImageProcessor
[[autodoc]] TvltImageProcessor
- preprocess
## TvltFeatureExtractor
[[autodoc]] TvltFeatureExtractor
- __call__
## TvltModel
[[autodoc]] TvltModel
- forward
## TvltForPreTraining
[[autodoc]] TvltForPreTraining
- forward
## TvltForAudioVisualClassification
[[autodoc]] TvltForAudioVisualClassification
- forward
| 0 |
mavonic_private_repos/transformers/docs/source/en | mavonic_private_repos/transformers/docs/source/en/model_doc/lilt.md | <!--Copyright 2022 The HuggingFace Team. All rights reserved.
Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
the License. You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
specific language governing permissions and limitations under the License.
โ ๏ธ Note that this file is in Markdown but contain specific syntax for our doc-builder (similar to MDX) that may not be
rendered properly in your Markdown viewer.
-->
# LiLT
## Overview
The LiLT model was proposed in [LiLT: A Simple yet Effective Language-Independent Layout Transformer for Structured Document Understanding](https://arxiv.org/abs/2202.13669) by Jiapeng Wang, Lianwen Jin, Kai Ding.
LiLT allows to combine any pre-trained RoBERTa text encoder with a lightweight Layout Transformer, to enable [LayoutLM](layoutlm)-like document understanding for many
languages.
The abstract from the paper is the following:
*Structured document understanding has attracted considerable attention and made significant progress recently, owing to its crucial role in intelligent document processing. However, most existing related models can only deal with the document data of specific language(s) (typically English) included in the pre-training collection, which is extremely limited. To address this issue, we propose a simple yet effective Language-independent Layout Transformer (LiLT) for structured document understanding. LiLT can be pre-trained on the structured documents of a single language and then directly fine-tuned on other languages with the corresponding off-the-shelf monolingual/multilingual pre-trained textual models. Experimental results on eight languages have shown that LiLT can achieve competitive or even superior performance on diverse widely-used downstream benchmarks, which enables language-independent benefit from the pre-training of document layout structure.*
<img src="https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/transformers/model_doc/lilt_architecture.jpg"
alt="drawing" width="600"/>
<small> LiLT architecture. Taken from the <a href="https://arxiv.org/abs/2202.13669">original paper</a>. </small>
This model was contributed by [nielsr](https://huggingface.co/nielsr).
The original code can be found [here](https://github.com/jpwang/lilt).
## Usage tips
- To combine the Language-Independent Layout Transformer with a new RoBERTa checkpoint from the [hub](https://huggingface.co/models?search=roberta), refer to [this guide](https://github.com/jpWang/LiLT#or-generate-your-own-checkpoint-optional).
The script will result in `config.json` and `pytorch_model.bin` files being stored locally. After doing this, one can do the following (assuming you're logged in with your HuggingFace account):
```python
from transformers import LiltModel
model = LiltModel.from_pretrained("path_to_your_files")
model.push_to_hub("name_of_repo_on_the_hub")
```
- When preparing data for the model, make sure to use the token vocabulary that corresponds to the RoBERTa checkpoint you combined with the Layout Transformer.
- As [lilt-roberta-en-base](https://huggingface.co/SCUT-DLVCLab/lilt-roberta-en-base) uses the same vocabulary as [LayoutLMv3](layoutlmv3), one can use [`LayoutLMv3TokenizerFast`] to prepare data for the model.
The same is true for [lilt-roberta-en-base](https://huggingface.co/SCUT-DLVCLab/lilt-infoxlm-base): one can use [`LayoutXLMTokenizerFast`] for that model.
## Resources
A list of official Hugging Face and community (indicated by ๐) resources to help you get started with LiLT.
- Demo notebooks for LiLT can be found [here](https://github.com/NielsRogge/Transformers-Tutorials/tree/master/LiLT).
**Documentation resources**
- [Text classification task guide](../tasks/sequence_classification)
- [Token classification task guide](../tasks/token_classification)
- [Question answering task guide](../tasks/question_answering)
If you're interested in submitting a resource to be included here, please feel free to open a Pull Request and we'll review it! The resource should ideally demonstrate something new instead of duplicating an existing resource.
## LiltConfig
[[autodoc]] LiltConfig
## LiltModel
[[autodoc]] LiltModel
- forward
## LiltForSequenceClassification
[[autodoc]] LiltForSequenceClassification
- forward
## LiltForTokenClassification
[[autodoc]] LiltForTokenClassification
- forward
## LiltForQuestionAnswering
[[autodoc]] LiltForQuestionAnswering
- forward
| 0 |
mavonic_private_repos/transformers/docs/source/en | mavonic_private_repos/transformers/docs/source/en/model_doc/vits.md | <!--Copyright 2023 The HuggingFace Team. All rights reserved.
Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
the License. You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
specific language governing permissions and limitations under the License.
-->
# VITS
## Overview
The VITS model was proposed in [Conditional Variational Autoencoder with Adversarial Learning for End-to-End Text-to-Speech](https://arxiv.org/abs/2106.06103) by Jaehyeon Kim, Jungil Kong, Juhee Son.
VITS (**V**ariational **I**nference with adversarial learning for end-to-end **T**ext-to-**S**peech) is an end-to-end
speech synthesis model that predicts a speech waveform conditional on an input text sequence. It is a conditional variational
autoencoder (VAE) comprised of a posterior encoder, decoder, and conditional prior.
A set of spectrogram-based acoustic features are predicted by the flow-based module, which is formed of a Transformer-based
text encoder and multiple coupling layers. The spectrogram is decoded using a stack of transposed convolutional layers,
much in the same style as the HiFi-GAN vocoder. Motivated by the one-to-many nature of the TTS problem, where the same text
input can be spoken in multiple ways, the model also includes a stochastic duration predictor, which allows the model to
synthesise speech with different rhythms from the same input text.
The model is trained end-to-end with a combination of losses derived from variational lower bound and adversarial training.
To improve the expressiveness of the model, normalizing flows are applied to the conditional prior distribution. During
inference, the text encodings are up-sampled based on the duration prediction module, and then mapped into the
waveform using a cascade of the flow module and HiFi-GAN decoder. Due to the stochastic nature of the duration predictor,
the model is non-deterministic, and thus requires a fixed seed to generate the same speech waveform.
The abstract from the paper is the following:
*Several recent end-to-end text-to-speech (TTS) models enabling single-stage training and parallel sampling have been proposed, but their sample quality does not match that of two-stage TTS systems. In this work, we present a parallel end-to-end TTS method that generates more natural sounding audio than current two-stage models. Our method adopts variational inference augmented with normalizing flows and an adversarial training process, which improves the expressive power of generative modeling. We also propose a stochastic duration predictor to synthesize speech with diverse rhythms from input text. With the uncertainty modeling over latent variables and the stochastic duration predictor, our method expresses the natural one-to-many relationship in which a text input can be spoken in multiple ways with different pitches and rhythms. A subjective human evaluation (mean opinion score, or MOS) on the LJ Speech, a single speaker dataset, shows that our method outperforms the best publicly available TTS systems and achieves a MOS comparable to ground truth.*
This model can also be used with TTS checkpoints from [Massively Multilingual Speech (MMS)](https://arxiv.org/abs/2305.13516)
as these checkpoints use the same architecture and a slightly modified tokenizer.
This model was contributed by [Matthijs](https://huggingface.co/Matthijs) and [sanchit-gandhi](https://huggingface.co/sanchit-gandhi). The original code can be found [here](https://github.com/jaywalnut310/vits).
## Usage examples
Both the VITS and MMS-TTS checkpoints can be used with the same API. Since the flow-based model is non-deterministic, it
is good practice to set a seed to ensure reproducibility of the outputs. For languages with a Roman alphabet,
such as English or French, the tokenizer can be used directly to pre-process the text inputs. The following code example
runs a forward pass using the MMS-TTS English checkpoint:
```python
import torch
from transformers import VitsTokenizer, VitsModel, set_seed
tokenizer = VitsTokenizer.from_pretrained("facebook/mms-tts-eng")
model = VitsModel.from_pretrained("facebook/mms-tts-eng")
inputs = tokenizer(text="Hello - my dog is cute", return_tensors="pt")
set_seed(555) # make deterministic
with torch.no_grad():
outputs = model(**inputs)
waveform = outputs.waveform[0]
```
The resulting waveform can be saved as a `.wav` file:
```python
import scipy
scipy.io.wavfile.write("techno.wav", rate=model.config.sampling_rate, data=waveform)
```
Or displayed in a Jupyter Notebook / Google Colab:
```python
from IPython.display import Audio
Audio(waveform, rate=model.config.sampling_rate)
```
For certain languages with a non-Roman alphabet, such as Arabic, Mandarin or Hindi, the [`uroman`](https://github.com/isi-nlp/uroman)
perl package is required to pre-process the text inputs to the Roman alphabet.
You can check whether you require the `uroman` package for your language by inspecting the `is_uroman` attribute of
the pre-trained `tokenizer`:
```python
from transformers import VitsTokenizer
tokenizer = VitsTokenizer.from_pretrained("facebook/mms-tts-eng")
print(tokenizer.is_uroman)
```
If required, you should apply the uroman package to your text inputs **prior** to passing them to the `VitsTokenizer`,
since currently the tokenizer does not support performing the pre-processing itself.
To do this, first clone the uroman repository to your local machine and set the bash variable `UROMAN` to the local path:
```bash
git clone https://github.com/isi-nlp/uroman.git
cd uroman
export UROMAN=$(pwd)
```
You can then pre-process the text input using the following code snippet. You can either rely on using the bash variable
`UROMAN` to point to the uroman repository, or you can pass the uroman directory as an argument to the `uromaize` function:
```python
import torch
from transformers import VitsTokenizer, VitsModel, set_seed
import os
import subprocess
tokenizer = VitsTokenizer.from_pretrained("facebook/mms-tts-kor")
model = VitsModel.from_pretrained("facebook/mms-tts-kor")
def uromanize(input_string, uroman_path):
"""Convert non-Roman strings to Roman using the `uroman` perl package."""
script_path = os.path.join(uroman_path, "bin", "uroman.pl")
command = ["perl", script_path]
process = subprocess.Popen(command, stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
# Execute the perl command
stdout, stderr = process.communicate(input=input_string.encode())
if process.returncode != 0:
raise ValueError(f"Error {process.returncode}: {stderr.decode()}")
# Return the output as a string and skip the new-line character at the end
return stdout.decode()[:-1]
text = "์ด๋ด ๋ฌด์จ ์ผ์ด์ผ"
uromaized_text = uromanize(text, uroman_path=os.environ["UROMAN"])
inputs = tokenizer(text=uromaized_text, return_tensors="pt")
set_seed(555) # make deterministic
with torch.no_grad():
outputs = model(inputs["input_ids"])
waveform = outputs.waveform[0]
```
## VitsConfig
[[autodoc]] VitsConfig
## VitsTokenizer
[[autodoc]] VitsTokenizer
- __call__
- save_vocabulary
## VitsModel
[[autodoc]] VitsModel
- forward
| 0 |
mavonic_private_repos/transformers/docs/source/en | mavonic_private_repos/transformers/docs/source/en/model_doc/jamba.md | <!--Copyright 2024 The HuggingFace Team. All rights reserved.
Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
the License. You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
specific language governing permissions and limitations under the License.
โ ๏ธ Note that this file is in Markdown but contain specific syntax for our doc-builder (similar to MDX) that may not be
rendered properly in your Markdown viewer.
-->
# Jamba
## Overview
Jamba is a state-of-the-art, hybrid SSM-Transformer LLM. It is the first production-scale Mamba implementation, which opens up interesting research and application opportunities. While this initial experimentation shows encouraging gains, we expect these to be further enhanced with future optimizations and explorations.
For full details of this model please read the [release blog post](https://www.ai21.com/blog/announcing-jamba).
### Model Details
Jamba is a pretrained, mixture-of-experts (MoE) generative text model, with 12B active parameters and an overall of 52B parameters across all experts. It supports a 256K context length, and can fit up to 140K tokens on a single 80GB GPU.
As depicted in the diagram below, Jamba's architecture features a blocks-and-layers approach that allows Jamba to successfully integrate Transformer and Mamba architectures altogether. Each Jamba block contains either an attention or a Mamba layer, followed by a multi-layer perceptron (MLP), producing an overall ratio of one Transformer layer out of every eight total layers.
<img src="https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/transformers/model_doc/jamba_architecture.png"
alt="drawing" width="600"/>
## Usage
### Presequities
Jamba requires you use `transformers` version 4.39.0 or higher:
```bash
pip install transformers>=4.39.0
```
In order to run optimized Mamba implementations, you first need to install `mamba-ssm` and `causal-conv1d`:
```bash
pip install mamba-ssm causal-conv1d>=1.2.0
```
You also have to have the model on a CUDA device.
You can run the model not using the optimized Mamba kernels, but it is **not** recommended as it will result in significantly lower latencies. In order to do that, you'll need to specify `use_mamba_kernels=False` when loading the model.
### Run the model
```python
from transformers import AutoModelForCausalLM, AutoTokenizer
model = AutoModelForCausalLM.from_pretrained("ai21labs/Jamba-v0.1")
tokenizer = AutoTokenizer.from_pretrained("ai21labs/Jamba-v0.1")
input_ids = tokenizer("In the recent Super Bowl LVIII,", return_tensors='pt').to(model.device)["input_ids"]
outputs = model.generate(input_ids, max_new_tokens=216)
print(tokenizer.batch_decode(outputs))
# ["<|startoftext|>In the recent Super Bowl LVIII, the Kansas City Chiefs emerged victorious, defeating the San Francisco 49ers in a thrilling overtime showdown. The game was a nail-biter, with both teams showcasing their skills and determination.\n\nThe Chiefs, led by their star quarterback Patrick Mahomes, displayed their offensive prowess, while the 49ers, led by their strong defense, put up a tough fight. The game went into overtime, with the Chiefs ultimately securing the win with a touchdown.\n\nThe victory marked the Chiefs' second Super Bowl win in four years, solidifying their status as one of the top teams in the NFL. The game was a testament to the skill and talent of both teams, and a thrilling end to the NFL season.\n\nThe Super Bowl is not just about the game itself, but also about the halftime show and the commercials. This year's halftime show featured a star-studded lineup, including Usher, Alicia Keys, and Lil Jon. The show was a spectacle of music and dance, with the performers delivering an energetic and entertaining performance.\n"]
```
<details>
<summary><strong>Loading the model in half precision</strong></summary>
The published checkpoint is saved in BF16. In order to load it into RAM in BF16/FP16, you need to specify `torch_dtype`:
```python
from transformers import AutoModelForCausalLM
import torch
model = AutoModelForCausalLM.from_pretrained("ai21labs/Jamba-v0.1", torch_dtype=torch.bfloat16)
# you can also use torch_dtype=torch.float16
```
When using half precision, you can enable the [FlashAttention2](https://github.com/Dao-AILab/flash-attention) implementation of the Attention blocks. In order to use it, you also need the model on a CUDA device. Since in this precision the model is to big to fit on a single 80GB GPU, you'll also need to parallelize it using [accelerate](https://huggingface.co/docs/accelerate/index):
```python
from transformers import AutoModelForCausalLM
import torch
model = AutoModelForCausalLM.from_pretrained("ai21labs/Jamba-v0.1",
torch_dtype=torch.bfloat16,
attn_implementation="flash_attention_2",
device_map="auto")
```
</details>
<details><summary><strong>Load the model in 8-bit</strong></summary>
**Using 8-bit precision, it is possible to fit up to 140K sequence lengths on a single 80GB GPU.** You can easily quantize the model to 8-bit using [bitsandbytes](https://huggingface.co/docs/bitsandbytes/index). In order to not degrade model quality, we recommend to exclude the Mamba blocks from the quantization:
```python
from transformers import AutoModelForCausalLM, BitsAndBytesConfig
quantization_config = BitsAndBytesConfig(load_in_8bit=True, llm_int8_skip_modules=["mamba"])
model = AutoModelForCausalLM.from_pretrained(
"ai21labs/Jamba-v0.1", torch_dtype=torch.bfloat16, attn_implementation="flash_attention_2", quantization_config=quantization_config
)
```
</details>
## JambaConfig
[[autodoc]] JambaConfig
## JambaModel
[[autodoc]] JambaModel
- forward
## JambaForCausalLM
[[autodoc]] JambaForCausalLM
- forward
## JambaForSequenceClassification
[[autodoc]] transformers.JambaForSequenceClassification
- forward
| 0 |
mavonic_private_repos/transformers/docs/source/en | mavonic_private_repos/transformers/docs/source/en/model_doc/glpn.md | <!--Copyright 2022 The HuggingFace Team. All rights reserved.
Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
the License. You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
specific language governing permissions and limitations under the License.
โ ๏ธ Note that this file is in Markdown but contain specific syntax for our doc-builder (similar to MDX) that may not be
rendered properly in your Markdown viewer.
-->
# GLPN
<Tip>
This is a recently introduced model so the API hasn't been tested extensively. There may be some bugs or slight
breaking changes to fix it in the future. If you see something strange, file a [Github Issue](https://github.com/huggingface/transformers/issues/new?assignees=&labels=&template=bug-report.md&title).
</Tip>
## Overview
The GLPN model was proposed in [Global-Local Path Networks for Monocular Depth Estimation with Vertical CutDepth](https://arxiv.org/abs/2201.07436) by Doyeon Kim, Woonghyun Ga, Pyungwhan Ahn, Donggyu Joo, Sehwan Chun, Junmo Kim.
GLPN combines [SegFormer](segformer)'s hierarchical mix-Transformer with a lightweight decoder for monocular depth estimation. The proposed decoder shows better performance than the previously proposed decoders, with considerably
less computational complexity.
The abstract from the paper is the following:
*Depth estimation from a single image is an important task that can be applied to various fields in computer vision, and has grown rapidly with the development of convolutional neural networks. In this paper, we propose a novel structure and training strategy for monocular depth estimation to further improve the prediction accuracy of the network. We deploy a hierarchical transformer encoder to capture and convey the global context, and design a lightweight yet powerful decoder to generate an estimated depth map while considering local connectivity. By constructing connected paths between multi-scale local features and the global decoding stream with our proposed selective feature fusion module, the network can integrate both representations and recover fine details. In addition, the proposed decoder shows better performance than the previously proposed decoders, with considerably less computational complexity. Furthermore, we improve the depth-specific augmentation method by utilizing an important observation in depth estimation to enhance the model. Our network achieves state-of-the-art performance over the challenging depth dataset NYU Depth V2. Extensive experiments have been conducted to validate and show the effectiveness of the proposed approach. Finally, our model shows better generalisation ability and robustness than other comparative models.*
<img src="https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/glpn_architecture.jpg"
alt="drawing" width="600"/>
<small> Summary of the approach. Taken from the <a href="https://arxiv.org/abs/2201.07436" target="_blank">original paper</a>. </small>
This model was contributed by [nielsr](https://huggingface.co/nielsr). The original code can be found [here](https://github.com/vinvino02/GLPDepth).
## Resources
A list of official Hugging Face and community (indicated by ๐) resources to help you get started with GLPN.
- Demo notebooks for [`GLPNForDepthEstimation`] can be found [here](https://github.com/NielsRogge/Transformers-Tutorials/tree/master/GLPN).
- [Monocular depth estimation task guide](../tasks/monocular_depth_estimation)
## GLPNConfig
[[autodoc]] GLPNConfig
## GLPNFeatureExtractor
[[autodoc]] GLPNFeatureExtractor
- __call__
## GLPNImageProcessor
[[autodoc]] GLPNImageProcessor
- preprocess
## GLPNModel
[[autodoc]] GLPNModel
- forward
## GLPNForDepthEstimation
[[autodoc]] GLPNForDepthEstimation
- forward
| 0 |
mavonic_private_repos/transformers/docs/source/en | mavonic_private_repos/transformers/docs/source/en/model_doc/wav2vec2.md | <!--Copyright 2021 The HuggingFace Team. All rights reserved.
Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
the License. You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
specific language governing permissions and limitations under the License.
โ ๏ธ Note that this file is in Markdown but contain specific syntax for our doc-builder (similar to MDX) that may not be
rendered properly in your Markdown viewer.
-->
# Wav2Vec2
## Overview
The Wav2Vec2 model was proposed in [wav2vec 2.0: A Framework for Self-Supervised Learning of Speech Representations](https://arxiv.org/abs/2006.11477) by Alexei Baevski, Henry Zhou, Abdelrahman Mohamed, Michael Auli.
The abstract from the paper is the following:
*We show for the first time that learning powerful representations from speech audio alone followed by fine-tuning on
transcribed speech can outperform the best semi-supervised methods while being conceptually simpler. wav2vec 2.0 masks
the speech input in the latent space and solves a contrastive task defined over a quantization of the latent
representations which are jointly learned. Experiments using all labeled data of Librispeech achieve 1.8/3.3 WER on the
clean/other test sets. When lowering the amount of labeled data to one hour, wav2vec 2.0 outperforms the previous state
of the art on the 100 hour subset while using 100 times less labeled data. Using just ten minutes of labeled data and
pre-training on 53k hours of unlabeled data still achieves 4.8/8.2 WER. This demonstrates the feasibility of speech
recognition with limited amounts of labeled data.*
This model was contributed by [patrickvonplaten](https://huggingface.co/patrickvonplaten).
## Usage tips
- Wav2Vec2 is a speech model that accepts a float array corresponding to the raw waveform of the speech signal.
- Wav2Vec2 model was trained using connectionist temporal classification (CTC) so the model output has to be decoded
using [`Wav2Vec2CTCTokenizer`].
## Using Flash Attention 2
Flash Attention 2 is an faster, optimized version of the model.
### Installation
First, check whether your hardware is compatible with Flash Attention 2. The latest list of compatible hardware can be found in the [official documentation](https://github.com/Dao-AILab/flash-attention#installation-and-features). If your hardware is not compatible with Flash Attention 2, you can still benefit from attention kernel optimisations through Better Transformer support covered [above](https://huggingface.co/docs/transformers/main/en/model_doc/bark#using-better-transformer).
Next, [install](https://github.com/Dao-AILab/flash-attention#installation-and-features) the latest version of Flash Attention 2:
```bash
pip install -U flash-attn --no-build-isolation
```
### Usage
To load a model using Flash Attention 2, we can pass the argument `attn_implementation="flash_attention_2"` to [`.from_pretrained`](https://huggingface.co/docs/transformers/main/en/main_classes/model#transformers.PreTrainedModel.from_pretrained). We'll also load the model in half-precision (e.g. `torch.float16`), since it results in almost no degradation to audio quality but significantly lower memory usage and faster inference:
```python
>>> from transformers import Wav2Vec2Model
model = Wav2Vec2Model.from_pretrained("facebook/wav2vec2-large-960h-lv60-self", torch_dtype=torch.float16, attn_implementation="flash_attention_2").to(device)
...
```
### Expected speedups
Below is an expected speedup diagram comparing the pure inference time between the native implementation in transformers of the `facebook/wav2vec2-large-960h-lv60-self` model and the flash-attention-2 and sdpa (scale-dot-product-attention) versions. . We show the average speedup obtained on the `librispeech_asr` `clean` validation split:
<div style="text-align: center">
<img src="https://huggingface.co/datasets/kamilakesbi/transformers_image_doc/resolve/main/data/Wav2Vec2_speedup.png">
</div>
## Resources
A list of official Hugging Face and community (indicated by ๐) resources to help you get started with Wav2Vec2. If you're interested in submitting a resource to be included here, please feel free to open a Pull Request and we'll review it! The resource should ideally demonstrate something new instead of duplicating an existing resource.
<PipelineTag pipeline="audio-classification"/>
- A notebook on how to [leverage a pretrained Wav2Vec2 model for emotion classification](https://colab.research.google.com/github/m3hrdadfi/soxan/blob/main/notebooks/Emotion_recognition_in_Greek_speech_using_Wav2Vec2.ipynb). ๐
- [`Wav2Vec2ForCTC`] is supported by this [example script](https://github.com/huggingface/transformers/tree/main/examples/pytorch/audio-classification) and [notebook](https://colab.research.google.com/github/huggingface/notebooks/blob/main/examples/audio_classification.ipynb).
- [Audio classification task guide](../tasks/audio_classification)
<PipelineTag pipeline="automatic-speech-recognition"/>
- A blog post on [boosting Wav2Vec2 with n-grams in ๐ค Transformers](https://huggingface.co/blog/wav2vec2-with-ngram).
- A blog post on how to [finetune Wav2Vec2 for English ASR with ๐ค Transformers](https://huggingface.co/blog/fine-tune-wav2vec2-english).
- A blog post on [finetuning XLS-R for Multi-Lingual ASR with ๐ค Transformers](https://huggingface.co/blog/fine-tune-xlsr-wav2vec2).
- A notebook on how to [create YouTube captions from any video by transcribing audio with Wav2Vec2](https://colab.research.google.com/github/Muennighoff/ytclipcc/blob/main/wav2vec_youtube_captions.ipynb). ๐
- [`Wav2Vec2ForCTC`] is supported by a notebook on [how to finetune a speech recognition model in English](https://colab.research.google.com/github/huggingface/notebooks/blob/main/examples/speech_recognition.ipynb), and [how to finetune a speech recognition model in any language](https://colab.research.google.com/github/huggingface/notebooks/blob/main/examples/multi_lingual_speech_recognition.ipynb).
- [Automatic speech recognition task guide](../tasks/asr)
๐ Deploy
- A blog post on how to deploy Wav2Vec2 for [Automatic Speech Recognition with Hugging Face's Transformers & Amazon SageMaker](https://www.philschmid.de/automatic-speech-recognition-sagemaker).
## Wav2Vec2Config
[[autodoc]] Wav2Vec2Config
## Wav2Vec2CTCTokenizer
[[autodoc]] Wav2Vec2CTCTokenizer
- __call__
- save_vocabulary
- decode
- batch_decode
- set_target_lang
## Wav2Vec2FeatureExtractor
[[autodoc]] Wav2Vec2FeatureExtractor
- __call__
## Wav2Vec2Processor
[[autodoc]] Wav2Vec2Processor
- __call__
- pad
- from_pretrained
- save_pretrained
- batch_decode
- decode
## Wav2Vec2ProcessorWithLM
[[autodoc]] Wav2Vec2ProcessorWithLM
- __call__
- pad
- from_pretrained
- save_pretrained
- batch_decode
- decode
### Decoding multiple audios
If you are planning to decode multiple batches of audios, you should consider using [`~Wav2Vec2ProcessorWithLM.batch_decode`] and passing an instantiated `multiprocessing.Pool`.
Otherwise, [`~Wav2Vec2ProcessorWithLM.batch_decode`] performance will be slower than calling [`~Wav2Vec2ProcessorWithLM.decode`] for each audio individually, as it internally instantiates a new `Pool` for every call. See the example below:
```python
>>> # Let's see how to use a user-managed pool for batch decoding multiple audios
>>> from multiprocessing import get_context
>>> from transformers import AutoTokenizer, AutoProcessor, AutoModelForCTC
>>> from datasets import load_dataset
>>> import datasets
>>> import torch
>>> # import model, feature extractor, tokenizer
>>> model = AutoModelForCTC.from_pretrained("patrickvonplaten/wav2vec2-base-100h-with-lm").to("cuda")
>>> processor = AutoProcessor.from_pretrained("patrickvonplaten/wav2vec2-base-100h-with-lm")
>>> # load example dataset
>>> dataset = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
>>> dataset = dataset.cast_column("audio", datasets.Audio(sampling_rate=16_000))
>>> def map_to_array(batch):
... batch["speech"] = batch["audio"]["array"]
... return batch
>>> # prepare speech data for batch inference
>>> dataset = dataset.map(map_to_array, remove_columns=["audio"])
>>> def map_to_pred(batch, pool):
... inputs = processor(batch["speech"], sampling_rate=16_000, padding=True, return_tensors="pt")
... inputs = {k: v.to("cuda") for k, v in inputs.items()}
... with torch.no_grad():
... logits = model(**inputs).logits
... transcription = processor.batch_decode(logits.cpu().numpy(), pool).text
... batch["transcription"] = transcription
... return batch
>>> # note: pool should be instantiated *after* `Wav2Vec2ProcessorWithLM`.
>>> # otherwise, the LM won't be available to the pool's sub-processes
>>> # select number of processes and batch_size based on number of CPU cores available and on dataset size
>>> with get_context("fork").Pool(processes=2) as pool:
... result = dataset.map(
... map_to_pred, batched=True, batch_size=2, fn_kwargs={"pool": pool}, remove_columns=["speech"]
... )
>>> result["transcription"][:2]
['MISTER QUILTER IS THE APOSTLE OF THE MIDDLE CLASSES AND WE ARE GLAD TO WELCOME HIS GOSPEL', "NOR IS MISTER COULTER'S MANNER LESS INTERESTING THAN HIS MATTER"]
```
## Wav2Vec2 specific outputs
[[autodoc]] models.wav2vec2_with_lm.processing_wav2vec2_with_lm.Wav2Vec2DecoderWithLMOutput
[[autodoc]] models.wav2vec2.modeling_wav2vec2.Wav2Vec2BaseModelOutput
[[autodoc]] models.wav2vec2.modeling_wav2vec2.Wav2Vec2ForPreTrainingOutput
[[autodoc]] models.wav2vec2.modeling_flax_wav2vec2.FlaxWav2Vec2BaseModelOutput
[[autodoc]] models.wav2vec2.modeling_flax_wav2vec2.FlaxWav2Vec2ForPreTrainingOutput
<frameworkcontent>
<pt>
## Wav2Vec2Model
[[autodoc]] Wav2Vec2Model
- forward
## Wav2Vec2ForCTC
[[autodoc]] Wav2Vec2ForCTC
- forward
- load_adapter
## Wav2Vec2ForSequenceClassification
[[autodoc]] Wav2Vec2ForSequenceClassification
- forward
## Wav2Vec2ForAudioFrameClassification
[[autodoc]] Wav2Vec2ForAudioFrameClassification
- forward
## Wav2Vec2ForXVector
[[autodoc]] Wav2Vec2ForXVector
- forward
## Wav2Vec2ForPreTraining
[[autodoc]] Wav2Vec2ForPreTraining
- forward
</pt>
<tf>
## TFWav2Vec2Model
[[autodoc]] TFWav2Vec2Model
- call
## TFWav2Vec2ForSequenceClassification
[[autodoc]] TFWav2Vec2ForSequenceClassification
- call
## TFWav2Vec2ForCTC
[[autodoc]] TFWav2Vec2ForCTC
- call
</tf>
<jax>
## FlaxWav2Vec2Model
[[autodoc]] FlaxWav2Vec2Model
- __call__
## FlaxWav2Vec2ForCTC
[[autodoc]] FlaxWav2Vec2ForCTC
- __call__
## FlaxWav2Vec2ForPreTraining
[[autodoc]] FlaxWav2Vec2ForPreTraining
- __call__
</jax>
</frameworkcontent>
| 0 |
mavonic_private_repos/transformers/docs/source | mavonic_private_repos/transformers/docs/source/fr/_config.py | # docstyle-ignore
INSTALL_CONTENT = """
# Installation de Transformers
! pip install transformers datasets evaluate accelerate
# Pour installer ร partir du code source au lieu de la derniรจre version, commentez la commande ci-dessus et dรฉcommentez la suivante.
# ! pip install git+https://github.com/huggingface/transformers.git
"""
notebook_first_cells = [{"type": "code", "content": INSTALL_CONTENT}]
black_avoid_patterns = {
"{processor_class}": "FakeProcessorClass",
"{model_class}": "FakeModelClass",
"{object_class}": "FakeObjectClass",
}
| 0 |
mavonic_private_repos/transformers/docs/source | mavonic_private_repos/transformers/docs/source/fr/autoclass_tutorial.md | <!--Copyright 2022 The HuggingFace Team. All rights reserved.
Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
the License. You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
specific language governing permissions and limitations under the License.
โ ๏ธ Note that this file is in Markdown but contain specific syntax for our doc-builder (similar to MDX) that may not be
rendered properly in your Markdown viewer.
-->
# Chargement d'instances prรฉ-entraรฎnรฉes avec une AutoClass
Avec autant d'architectures Transformer diffรฉrentes, il peut รชtre difficile d'en crรฉer une pour votre ensemble de poids (aussi appelรฉs "weights" ou "checkpoint" en anglais). Dans l'idรฉe de crรฉer une librairie facile, simple et flexible ร utiliser, ๐ค Transformers fournit une `AutoClass` qui infรจre et charge automatiquement l'architecture correcte ร partir d'un ensemble de poids donnรฉ. La fonction `from_pretrained()` vous permet de charger rapidement un modรจle prรฉ-entraรฎnรฉ pour n'importe quelle architecture afin que vous n'ayez pas ร consacrer du temps et des ressources ร l'entraรฎnement d'un modรจle ร partir de zรฉro. Produire un tel code indรฉpendant d'un ensemble de poids signifie que si votre code fonctionne pour un ensemble de poids, il fonctionnera avec un autre ensemble - tant qu'il a รฉtรฉ entraรฎnรฉ pour une tรขche similaire - mรชme si l'architecture est diffรฉrente.
<Tip>
Rappel, l'architecture fait rรฉfรฉrence au squelette du modรจle et l'ensemble de poids contient les poids pour une architecture donnรฉe. Par exemple, [BERT](https://huggingface.co/google-bert/bert-base-uncased) est une architecture, tandis que `google-bert/bert-base-uncased` est un ensemble de poids. Le terme modรจle est gรฉnรฉral et peut signifier soit architecture soit ensemble de poids.
</Tip>
Dans ce tutoriel, vous apprendrez ร :
* Charger un tokenizer prรฉ-entraรฎnรฉ.
* Charger un processeur d'image prรฉ-entraรฎnรฉ.
* Charger un extracteur de caractรฉristiques prรฉ-entraรฎnรฉ.
* Charger un processeur prรฉ-entraรฎnรฉ.
* Charger un modรจle prรฉ-entraรฎnรฉ.
## AutoTokenizer
Quasiment toutes les tรขches de traitement du langage (NLP) commencent avec un tokenizer. Un tokenizer convertit votre texte initial dans un format qui peut รชtre traitรฉ par le modรจle.
Chargez un tokenizer avec [`AutoTokenizer.from_pretrained`]:
```py
>>> from transformers import AutoTokenizer
>>> tokenizer = AutoTokenizer.from_pretrained("google-bert/bert-base-uncased")
```
Puis, transformez votre texte initial comme montrรฉ ci-dessous:
```py
>>> sequence = "In a hole in the ground there lived a hobbit."
>>> print(tokenizer(sequence))
{'input_ids': [101, 1999, 1037, 4920, 1999, 1996, 2598, 2045, 2973, 1037, 7570, 10322, 4183, 1012, 102],
'token_type_ids': [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
'attention_mask': [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]}
```
## AutoImageProcessor
Pour les tรขches de vision, un processeur d'image traite l'image pour la formater correctment.
```py
>>> from transformers import AutoImageProcessor
>>> image_processor = AutoImageProcessor.from_pretrained("google/vit-base-patch16-224")
```
## AutoFeatureExtractor
Pour les tรขches audio, un extracteur de caractรฉristiques (aussi appelรฉs "features" en anglais) traite le signal audio pour le formater correctement.
Chargez un extracteur de caractรฉristiques avec [`AutoFeatureExtractor.from_pretrained`]:
```py
>>> from transformers import AutoFeatureExtractor
>>> feature_extractor = AutoFeatureExtractor.from_pretrained(
... "ehcalabres/wav2vec2-lg-xlsr-en-speech-emotion-recognition"
... )
```
## AutoProcessor
Les tรขches multimodales nรฉcessitent un processeur qui combine deux types d'outils de prรฉtraitement. Par exemple, le modรจle [LayoutLMV2](model_doc/layoutlmv2) nรฉcessite un processeur d'image pour traiter les images et un tokenizer pour traiter le texte ; un processeur combine les deux.
Chargez un processeur avec [`AutoProcessor.from_pretrained`]:
```py
>>> from transformers import AutoProcessor
>>> processor = AutoProcessor.from_pretrained("microsoft/layoutlmv2-base-uncased")
```
## AutoModel
<frameworkcontent>
<pt>
Enfin, les classes `AutoModelFor` vous permettent de charger un modรจle prรฉ-entraรฎnรฉ pour une tรขche donnรฉe (voir [ici](model_doc/auto) pour une liste complรจte des tรขches disponibles). Par exemple, chargez un modรจle pour la classification de sรฉquence avec [`AutoModelForSequenceClassification.from_pretrained`]:
```py
>>> from transformers import AutoModelForSequenceClassification
>>> model = AutoModelForSequenceClassification.from_pretrained("distilbert/distilbert-base-uncased")
```
Rรฉutilisez facilement le mรชme ensemble de poids pour charger une architecture pour une tรขche diffรฉrente :
```py
>>> from transformers import AutoModelForTokenClassification
>>> model = AutoModelForTokenClassification.from_pretrained("distilbert/distilbert-base-uncased")
```
<Tip warning={true}>
Pour les modรจles PyTorch, la fonction `from_pretrained()` utilise `torch.load()` qui utilise `pickle` en interne et est connu pour รชtre non sรฉcurisรฉ. En gรฉnรฉral, ne chargez jamais un modรจle qui pourrait provenir d'une source non fiable, ou qui pourrait avoir รฉtรฉ altรฉrรฉ. Ce risque de sรฉcuritรฉ est partiellement attรฉnuรฉ pour les modรจles hรฉbergรฉs publiquement sur le Hugging Face Hub, qui sont [scannรฉs pour les logiciels malveillants](https://huggingface.co/docs/hub/security-malware) ร chaque modification. Consultez la [documentation du Hub](https://huggingface.co/docs/hub/security) pour connaรฎtre les meilleures pratiques comme la [vรฉrification des modifications signรฉes](https://huggingface.co/docs/hub/security-gpg#signing-commits-with-gpg) avec GPG.
Les points de contrรดle TensorFlow et Flax ne sont pas concernรฉs, et peuvent รชtre chargรฉs dans des architectures PyTorch en utilisant les arguments `from_tf` et `from_flax` de la fonction `from_pretrained` pour contourner ce problรจme.
</Tip>
En gรฉnรฉral, nous recommandons d'utiliser les classes `AutoTokenizer` et `AutoModelFor` pour charger des instances prรฉ-entraรฎnรฉes de tokenizers et modรจles respectivement. Cela vous permettra de charger la bonne architecture ร chaque fois. Dans le prochain [tutoriel](preprocessing), vous apprenez ร utiliser un tokenizer, processeur d'image, extracteur de caractรฉristiques et processeur pour prรฉ-traiter un jeu de donnรฉes pour le fine-tuning.
</pt>
<tf>
Enfin, les classes `TFAutoModelFor` vous permettent de charger un modรจle prรฉ-entraรฎnรฉ pour une tรขche donnรฉe (voir [ici](model_doc/auto) pour une liste complรจte des tรขches disponibles). Par exemple, chargez un modรจle pour la classification de sรฉquence avec [`TFAutoModelForSequenceClassification.from_pretrained`]:
```py
>>> from transformers import TFAutoModelForSequenceClassification
>>> model = TFAutoModelForSequenceClassification.from_pretrained("distilbert/distilbert-base-uncased")
```
Rรฉutilisez facilement le mรชme ensemble de poids pour charger une architecture pour une tรขche diffรฉrente :
```py
>>> from transformers import TFAutoModelForTokenClassification
>>> model = TFAutoModelForTokenClassification.from_pretrained("distilbert/distilbert-base-uncased")
```
En gรฉnรฉral, nous recommandons d'utiliser les classes `AutoTokenizer` et `TFAutoModelFor` pour charger des instances prรฉ-entraรฎnรฉes de tokenizers et modรจles respectivement. Cela vous permettra de charger la bonne architecture ร chaque fois. Dans le prochain [tutoriel](preprocessing), vous apprenez ร utiliser un tokenizer, processeur d'image, extracteur de caractรฉristiques et processeur pour prรฉ-traiter un jeu de donnรฉes pour le fine-tuning.
</tf>
</frameworkcontent>
| 0 |
mavonic_private_repos/transformers/docs/source | mavonic_private_repos/transformers/docs/source/fr/_toctree.yml | - sections:
- local: index
title: ๐ค Transformers
- local: quicktour
title: Visite rapide
- local: installation
title: Installation
title: Dรฉmarrer
- sections:
- local: in_translation
title: Pipelines pour l'infรฉrence
- local: autoclass_tutorial
title: Chargement d'instances prรฉ-entraรฎnรฉes avec une AutoClass
- local: in_translation
title: Prรฉparation des donnรฉes
- local: in_translation
title: Fine-tune un modรจle prรฉ-entraรฎnรฉ
- local: in_translation
title: Entraรฎnement avec un script
- local: in_translation
title: Entraรฎnement distribuรฉ avec ๐ค Accelerate
- local: in_translation
title: Chargement et entraรฎnement des adaptateurs avec ๐ค PEFT
- local: in_translation
title: Partager un modรจle
- local: in_translation
title: Agents
- local: in_translation
title: Gรฉnรฉration avec LLMs
title: Tutoriels
| 0 |
mavonic_private_repos/transformers/docs/source | mavonic_private_repos/transformers/docs/source/fr/index.md | <!--Copyright 2020 The HuggingFace Team. All rights reserved.
Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
the License. You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
specific language governing permissions and limitations under the License.
โ ๏ธ Note that this file is in Markdown but contain specific syntax for our doc-builder (similar to MDX) that may not be
rendered properly in your Markdown viewer.
-->
# ๐ค Transformers
Apprentissage automatique de pointe pour [PyTorch](https://pytorch.org/), [TensorFlow](https://www.tensorflow.org/), et [JAX](https://jax.readthedocs.io/en/latest/).
๐ค Transformers fournit des API et des outils pour tรฉlรฉcharger et entraรฎner facilement des modรจles prรฉ-entraรฎnรฉs de pointe. L'utilisation de modรจles prรฉ-entraรฎnรฉs peut rรฉduire vos coรปts de calcul, votre empreinte carbone, et vous faire รฉconomiser le temps et les ressources nรฉcessaires pour entraรฎner un modรจle ร partir de zรฉro. Ces modรจles prennent en charge des tรขches courantes dans diffรฉrentes modalitรฉs, telles que :
๐ **Traitement automatique des langues**: classification de texte, reconnaissance d'entitรฉs, systรจme de question-rรฉponse, modรจle de langage, gรฉnรฉration de rรฉsumรฉ, traduction, question ร choix multiples et gรฉnรฉration de texte.<br>
๐ผ๏ธ **Vision par ordinateur**: classification d'image, dรฉtection d'objet et segmentation.<br>
๐ฃ๏ธ **Audio**: reconnaissance automatique de la parole et classification audio.<br>
๐ **Multimodalitรฉ**: systรจme de question-rรฉponse avec des tableaux ou images, reconnaissance optique de caractรจres, extraction d'information depuis des documents scannรฉs et classification de vidรฉo.
๐ค Transformers prend en charge l'interopรฉrabilitรฉ entre PyTorch, TensorFlow et JAX. Cela permet d'utiliser un framework diffรฉrent ร chaque รฉtape de la vie d'un modรจle, par exemple entraรฎner un modรจle en trois lignes de code avec un framework, et le charger pour l'infรฉrence avec un autre. Les modรจles peuvent รฉgalement รชtre exportรฉs dans un format comme ONNX et TorchScript pour รชtre dรฉployรฉs dans des environnements de production.
Rejoignez la communautรฉ grandissante sur le [Hub](https://huggingface.co/models), le [forum](https://discuss.huggingface.co/) ou [Discord](https://discord.com/invite/JfAtkvEtRb) dรจs aujourd'hui !
## Si vous cherchez un support personnalisรฉ de l'รฉquipe Hugging Face
<a target="_blank" href="https://huggingface.co/support">
<img alt="HuggingFace Expert Acceleration Program" src="https://cdn-media.huggingface.co/marketing/transformers/new-support-improved.png" style="width: 100%; max-width: 600px; border: 1px solid #eee; border-radius: 4px; box-shadow: 0 1px 2px 0 rgba(0, 0, 0, 0.05);">
</a>
## Contents
La documentation est organisรฉe en 5 parties:
- **DEMARRER** propose une visite rapide de la bibliothรจque et des instructions d'installation pour รชtre opรฉrationnel.
- **TUTORIELS** excellent point de dรฉpart pour les dรฉbutants. Cette section vous aidera ร acquรฉrir les compรฉtences de base dont vous avez besoin pour commencer ร utiliser la bibliothรจque.
- **GUIDES D'UTILISATION** pour diffรฉrentes tรขches comme par exemple le finetuning d'un modรจle prรฉ-entraรฎnรฉ pour la classification de texte ou comment crรฉer et partager votre propre modรจle.
- **GUIDES CONCEPTUELS** pour plus de discussions et d'explications sur les concepts et les idรฉes sous-jacentes aux modรจles, aux tรขches et ร la philosophie de conception de ๐ค Transformers.
- **API** dรฉcrit toutes les classes et fonctions :
- **CLASSES PRINCIPALES** dรฉtaille les classes les plus importantes comme la configuration, le modรจle, le tokenizer et le pipeline..
- **MODELES** dรฉtaille les classes et les fonctions propres ร chaque modรจle de la bibliothรจque.
- **UTILITAIRES INTERNES** dรฉtaille les classes et fonctions utilitaires utilisรฉes en interne.
### Modรจles supportรฉs
<!--This list is updated automatically from the README with _make fix-copies_. Do not update manually! -->
1. **[ALBERT](model_doc/albert)** (from Google Research and the Toyota Technological Institute at Chicago) released with the paper [ALBERT: A Lite BERT for Self-supervised Learning of Language Representations](https://arxiv.org/abs/1909.11942), by Zhenzhong Lan, Mingda Chen, Sebastian Goodman, Kevin Gimpel, Piyush Sharma, Radu Soricut.
1. **[ALIGN](model_doc/align)** (from Google Research) released with the paper [Scaling Up Visual and Vision-Language Representation Learning With Noisy Text Supervision](https://arxiv.org/abs/2102.05918) by Chao Jia, Yinfei Yang, Ye Xia, Yi-Ting Chen, Zarana Parekh, Hieu Pham, Quoc V. Le, Yunhsuan Sung, Zhen Li, Tom Duerig.
1. **[AltCLIP](model_doc/altclip)** (from BAAI) released with the paper [AltCLIP: Altering the Language Encoder in CLIP for Extended Language Capabilities](https://arxiv.org/abs/2211.06679) by Chen, Zhongzhi and Liu, Guang and Zhang, Bo-Wen and Ye, Fulong and Yang, Qinghong and Wu, Ledell.
1. **[Audio Spectrogram Transformer](model_doc/audio-spectrogram-transformer)** (from MIT) released with the paper [AST: Audio Spectrogram Transformer](https://arxiv.org/abs/2104.01778) by Yuan Gong, Yu-An Chung, James Glass.
1. **[BART](model_doc/bart)** (from Facebook) released with the paper [BART: Denoising Sequence-to-Sequence Pre-training for Natural Language Generation, Translation, and Comprehension](https://arxiv.org/abs/1910.13461) by Mike Lewis, Yinhan Liu, Naman Goyal, Marjan Ghazvininejad, Abdelrahman Mohamed, Omer Levy, Ves Stoyanov and Luke Zettlemoyer.
1. **[BARThez](model_doc/barthez)** (from รcole polytechnique) released with the paper [BARThez: a Skilled Pretrained French Sequence-to-Sequence Model](https://arxiv.org/abs/2010.12321) by Moussa Kamal Eddine, Antoine J.-P. Tixier, Michalis Vazirgiannis.
1. **[BARTpho](model_doc/bartpho)** (from VinAI Research) released with the paper [BARTpho: Pre-trained Sequence-to-Sequence Models for Vietnamese](https://arxiv.org/abs/2109.09701) by Nguyen Luong Tran, Duong Minh Le and Dat Quoc Nguyen.
1. **[BEiT](model_doc/beit)** (from Microsoft) released with the paper [BEiT: BERT Pre-Training of Image Transformers](https://arxiv.org/abs/2106.08254) by Hangbo Bao, Li Dong, Furu Wei.
1. **[BERT](model_doc/bert)** (from Google) released with the paper [BERT: Pre-training of Deep Bidirectional Transformers for Language Understanding](https://arxiv.org/abs/1810.04805) by Jacob Devlin, Ming-Wei Chang, Kenton Lee and Kristina Toutanova.
1. **[BERT For Sequence Generation](model_doc/bert-generation)** (from Google) released with the paper [Leveraging Pre-trained Checkpoints for Sequence Generation Tasks](https://arxiv.org/abs/1907.12461) by Sascha Rothe, Shashi Narayan, Aliaksei Severyn.
1. **[BERTweet](model_doc/bertweet)** (from VinAI Research) released with the paper [BERTweet: A pre-trained language model for English Tweets](https://aclanthology.org/2020.emnlp-demos.2/) by Dat Quoc Nguyen, Thanh Vu and Anh Tuan Nguyen.
1. **[BigBird-Pegasus](model_doc/bigbird_pegasus)** (from Google Research) released with the paper [Big Bird: Transformers for Longer Sequences](https://arxiv.org/abs/2007.14062) by Manzil Zaheer, Guru Guruganesh, Avinava Dubey, Joshua Ainslie, Chris Alberti, Santiago Ontanon, Philip Pham, Anirudh Ravula, Qifan Wang, Li Yang, Amr Ahmed.
1. **[BigBird-RoBERTa](model_doc/big_bird)** (from Google Research) released with the paper [Big Bird: Transformers for Longer Sequences](https://arxiv.org/abs/2007.14062) by Manzil Zaheer, Guru Guruganesh, Avinava Dubey, Joshua Ainslie, Chris Alberti, Santiago Ontanon, Philip Pham, Anirudh Ravula, Qifan Wang, Li Yang, Amr Ahmed.
1. **[BioGpt](model_doc/biogpt)** (from Microsoft Research AI4Science) released with the paper [BioGPT: generative pre-trained transformer for biomedical text generation and mining](https://academic.oup.com/bib/advance-article/doi/10.1093/bib/bbac409/6713511?guestAccessKey=a66d9b5d-4f83-4017-bb52-405815c907b9) by Renqian Luo, Liai Sun, Yingce Xia, Tao Qin, Sheng Zhang, Hoifung Poon and Tie-Yan Liu.
1. **[BiT](model_doc/bit)** (from Google AI) released with the paper [Big Transfer (BiT): General Visual Representation Learning](https://arxiv.org/abs/1912.11370) by Alexander Kolesnikov, Lucas Beyer, Xiaohua Zhai, Joan Puigcerver, Jessica Yung, Sylvain Gelly, Neil Houlsby.
1. **[Blenderbot](model_doc/blenderbot)** (from Facebook) released with the paper [Recipes for building an open-domain chatbot](https://arxiv.org/abs/2004.13637) by Stephen Roller, Emily Dinan, Naman Goyal, Da Ju, Mary Williamson, Yinhan Liu, Jing Xu, Myle Ott, Kurt Shuster, Eric M. Smith, Y-Lan Boureau, Jason Weston.
1. **[BlenderbotSmall](model_doc/blenderbot-small)** (from Facebook) released with the paper [Recipes for building an open-domain chatbot](https://arxiv.org/abs/2004.13637) by Stephen Roller, Emily Dinan, Naman Goyal, Da Ju, Mary Williamson, Yinhan Liu, Jing Xu, Myle Ott, Kurt Shuster, Eric M. Smith, Y-Lan Boureau, Jason Weston.
1. **[BLIP](model_doc/blip)** (from Salesforce) released with the paper [BLIP: Bootstrapping Language-Image Pre-training for Unified Vision-Language Understanding and Generation](https://arxiv.org/abs/2201.12086) by Junnan Li, Dongxu Li, Caiming Xiong, Steven Hoi.
1. **[BLOOM](model_doc/bloom)** (from BigScience workshop) released by the [BigScience Workshop](https://bigscience.huggingface.co/).
1. **[BORT](model_doc/bort)** (from Alexa) released with the paper [Optimal Subarchitecture Extraction For BERT](https://arxiv.org/abs/2010.10499) by Adrian de Wynter and Daniel J. Perry.
1. **[BridgeTower](model_doc/bridgetower)** (from Harbin Institute of Technology/Microsoft Research Asia/Intel Labs) released with the paper [BridgeTower: Building Bridges Between Encoders in Vision-Language Representation Learning](https://arxiv.org/abs/2206.08657) by Xiao Xu, Chenfei Wu, Shachar Rosenman, Vasudev Lal, Wanxiang Che, Nan Duan.
1. **[ByT5](model_doc/byt5)** (from Google Research) released with the paper [ByT5: Towards a token-free future with pre-trained byte-to-byte models](https://arxiv.org/abs/2105.13626) by Linting Xue, Aditya Barua, Noah Constant, Rami Al-Rfou, Sharan Narang, Mihir Kale, Adam Roberts, Colin Raffel.
1. **[CamemBERT](model_doc/camembert)** (from Inria/Facebook/Sorbonne) released with the paper [CamemBERT: a Tasty French Language Model](https://arxiv.org/abs/1911.03894) by Louis Martin*, Benjamin Muller*, Pedro Javier Ortiz Suรกrez*, Yoann Dupont, Laurent Romary, รric Villemonte de la Clergerie, Djamรฉ Seddah and Benoรฎt Sagot.
1. **[CANINE](model_doc/canine)** (from Google Research) released with the paper [CANINE: Pre-training an Efficient Tokenization-Free Encoder for Language Representation](https://arxiv.org/abs/2103.06874) by Jonathan H. Clark, Dan Garrette, Iulia Turc, John Wieting.
1. **[Chinese-CLIP](model_doc/chinese_clip)** (from OFA-Sys) released with the paper [Chinese CLIP: Contrastive Vision-Language Pretraining in Chinese](https://arxiv.org/abs/2211.01335) by An Yang, Junshu Pan, Junyang Lin, Rui Men, Yichang Zhang, Jingren Zhou, Chang Zhou.
1. **[CLIP](model_doc/clip)** (from OpenAI) released with the paper [Learning Transferable Visual Models From Natural Language Supervision](https://arxiv.org/abs/2103.00020) by Alec Radford, Jong Wook Kim, Chris Hallacy, Aditya Ramesh, Gabriel Goh, Sandhini Agarwal, Girish Sastry, Amanda Askell, Pamela Mishkin, Jack Clark, Gretchen Krueger, Ilya Sutskever.
1. **[CLIPSeg](model_doc/clipseg)** (from University of Gรถttingen) released with the paper [Image Segmentation Using Text and Image Prompts](https://arxiv.org/abs/2112.10003) by Timo Lรผddecke and Alexander Ecker.
1. **[CodeGen](model_doc/codegen)** (from Salesforce) released with the paper [A Conversational Paradigm for Program Synthesis](https://arxiv.org/abs/2203.13474) by Erik Nijkamp, Bo Pang, Hiroaki Hayashi, Lifu Tu, Huan Wang, Yingbo Zhou, Silvio Savarese, Caiming Xiong.
1. **[Conditional DETR](model_doc/conditional_detr)** (from Microsoft Research Asia) released with the paper [Conditional DETR for Fast Training Convergence](https://arxiv.org/abs/2108.06152) by Depu Meng, Xiaokang Chen, Zejia Fan, Gang Zeng, Houqiang Li, Yuhui Yuan, Lei Sun, Jingdong Wang.
1. **[ConvBERT](model_doc/convbert)** (from YituTech) released with the paper [ConvBERT: Improving BERT with Span-based Dynamic Convolution](https://arxiv.org/abs/2008.02496) by Zihang Jiang, Weihao Yu, Daquan Zhou, Yunpeng Chen, Jiashi Feng, Shuicheng Yan.
1. **[ConvNeXT](model_doc/convnext)** (from Facebook AI) released with the paper [A ConvNet for the 2020s](https://arxiv.org/abs/2201.03545) by Zhuang Liu, Hanzi Mao, Chao-Yuan Wu, Christoph Feichtenhofer, Trevor Darrell, Saining Xie.
1. **[ConvNeXTV2](model_doc/convnextv2)** (from Facebook AI) released with the paper [ConvNeXt V2: Co-designing and Scaling ConvNets with Masked Autoencoders](https://arxiv.org/abs/2301.00808) by Sanghyun Woo, Shoubhik Debnath, Ronghang Hu, Xinlei Chen, Zhuang Liu, In So Kweon, Saining Xie.
1. **[CPM](model_doc/cpm)** (from Tsinghua University) released with the paper [CPM: A Large-scale Generative Chinese Pre-trained Language Model](https://arxiv.org/abs/2012.00413) by Zhengyan Zhang, Xu Han, Hao Zhou, Pei Ke, Yuxian Gu, Deming Ye, Yujia Qin, Yusheng Su, Haozhe Ji, Jian Guan, Fanchao Qi, Xiaozhi Wang, Yanan Zheng, Guoyang Zeng, Huanqi Cao, Shengqi Chen, Daixuan Li, Zhenbo Sun, Zhiyuan Liu, Minlie Huang, Wentao Han, Jie Tang, Juanzi Li, Xiaoyan Zhu, Maosong Sun.
1. **[CTRL](model_doc/ctrl)** (from Salesforce) released with the paper [CTRL: A Conditional Transformer Language Model for Controllable Generation](https://arxiv.org/abs/1909.05858) by Nitish Shirish Keskar*, Bryan McCann*, Lav R. Varshney, Caiming Xiong and Richard Socher.
1. **[CvT](model_doc/cvt)** (from Microsoft) released with the paper [CvT: Introducing Convolutions to Vision Transformers](https://arxiv.org/abs/2103.15808) by Haiping Wu, Bin Xiao, Noel Codella, Mengchen Liu, Xiyang Dai, Lu Yuan, Lei Zhang.
1. **[Data2Vec](model_doc/data2vec)** (from Facebook) released with the paper [Data2Vec: A General Framework for Self-supervised Learning in Speech, Vision and Language](https://arxiv.org/abs/2202.03555) by Alexei Baevski, Wei-Ning Hsu, Qiantong Xu, Arun Babu, Jiatao Gu, Michael Auli.
1. **[DeBERTa](model_doc/deberta)** (from Microsoft) released with the paper [DeBERTa: Decoding-enhanced BERT with Disentangled Attention](https://arxiv.org/abs/2006.03654) by Pengcheng He, Xiaodong Liu, Jianfeng Gao, Weizhu Chen.
1. **[DeBERTa-v2](model_doc/deberta-v2)** (from Microsoft) released with the paper [DeBERTa: Decoding-enhanced BERT with Disentangled Attention](https://arxiv.org/abs/2006.03654) by Pengcheng He, Xiaodong Liu, Jianfeng Gao, Weizhu Chen.
1. **[Decision Transformer](model_doc/decision_transformer)** (from Berkeley/Facebook/Google) released with the paper [Decision Transformer: Reinforcement Learning via Sequence Modeling](https://arxiv.org/abs/2106.01345) by Lili Chen, Kevin Lu, Aravind Rajeswaran, Kimin Lee, Aditya Grover, Michael Laskin, Pieter Abbeel, Aravind Srinivas, Igor Mordatch.
1. **[Deformable DETR](model_doc/deformable_detr)** (from SenseTime Research) released with the paper [Deformable DETR: Deformable Transformers for End-to-End Object Detection](https://arxiv.org/abs/2010.04159) by Xizhou Zhu, Weijie Su, Lewei Lu, Bin Li, Xiaogang Wang, Jifeng Dai.
1. **[DeiT](model_doc/deit)** (from Facebook) released with the paper [Training data-efficient image transformers & distillation through attention](https://arxiv.org/abs/2012.12877) by Hugo Touvron, Matthieu Cord, Matthijs Douze, Francisco Massa, Alexandre Sablayrolles, Hervรฉ Jรฉgou.
1. **[DETA](model_doc/deta)** (from The University of Texas at Austin) released with the paper [NMS Strikes Back](https://arxiv.org/abs/2212.06137) by Jeffrey Ouyang-Zhang, Jang Hyun Cho, Xingyi Zhou, Philipp Krรคhenbรผhl.
1. **[DETR](model_doc/detr)** (from Facebook) released with the paper [End-to-End Object Detection with Transformers](https://arxiv.org/abs/2005.12872) by Nicolas Carion, Francisco Massa, Gabriel Synnaeve, Nicolas Usunier, Alexander Kirillov, Sergey Zagoruyko.
1. **[DialoGPT](model_doc/dialogpt)** (from Microsoft Research) released with the paper [DialoGPT: Large-Scale Generative Pre-training for Conversational Response Generation](https://arxiv.org/abs/1911.00536) by Yizhe Zhang, Siqi Sun, Michel Galley, Yen-Chun Chen, Chris Brockett, Xiang Gao, Jianfeng Gao, Jingjing Liu, Bill Dolan.
1. **[DiNAT](model_doc/dinat)** (from SHI Labs) released with the paper [Dilated Neighborhood Attention Transformer](https://arxiv.org/abs/2209.15001) by Ali Hassani and Humphrey Shi.
1. **[DistilBERT](model_doc/distilbert)** (from HuggingFace), released together with the paper [DistilBERT, a distilled version of BERT: smaller, faster, cheaper and lighter](https://arxiv.org/abs/1910.01108) by Victor Sanh, Lysandre Debut and Thomas Wolf. The same method has been applied to compress GPT2 into [DistilGPT2](https://github.com/huggingface/transformers/tree/main/examples/research_projects/distillation), RoBERTa into [DistilRoBERTa](https://github.com/huggingface/transformers/tree/main/examples/research_projects/distillation), Multilingual BERT into [DistilmBERT](https://github.com/huggingface/transformers/tree/main/examples/research_projects/distillation) and a German version of DistilBERT.
1. **[DiT](model_doc/dit)** (from Microsoft Research) released with the paper [DiT: Self-supervised Pre-training for Document Image Transformer](https://arxiv.org/abs/2203.02378) by Junlong Li, Yiheng Xu, Tengchao Lv, Lei Cui, Cha Zhang, Furu Wei.
1. **[Donut](model_doc/donut)** (from NAVER), released together with the paper [OCR-free Document Understanding Transformer](https://arxiv.org/abs/2111.15664) by Geewook Kim, Teakgyu Hong, Moonbin Yim, Jeongyeon Nam, Jinyoung Park, Jinyeong Yim, Wonseok Hwang, Sangdoo Yun, Dongyoon Han, Seunghyun Park.
1. **[DPR](model_doc/dpr)** (from Facebook) released with the paper [Dense Passage Retrieval for Open-Domain Question Answering](https://arxiv.org/abs/2004.04906) by Vladimir Karpukhin, Barlas Oฤuz, Sewon Min, Patrick Lewis, Ledell Wu, Sergey Edunov, Danqi Chen, and Wen-tau Yih.
1. **[DPT](master/model_doc/dpt)** (from Intel Labs) released with the paper [Vision Transformers for Dense Prediction](https://arxiv.org/abs/2103.13413) by Renรฉ Ranftl, Alexey Bochkovskiy, Vladlen Koltun.
1. **[EfficientFormer](model_doc/efficientformer)** (from Snap Research) released with the paper [EfficientFormer: Vision Transformers at MobileNetSpeed](https://arxiv.org/abs/2206.01191) by Yanyu Li, Geng Yuan, Yang Wen, Ju Hu, Georgios Evangelidis, Sergey Tulyakov, Yanzhi Wang, Jian Ren.
1. **[ELECTRA](model_doc/electra)** (from Google Research/Stanford University) released with the paper [ELECTRA: Pre-training text encoders as discriminators rather than generators](https://arxiv.org/abs/2003.10555) by Kevin Clark, Minh-Thang Luong, Quoc V. Le, Christopher D. Manning.
1. **[EncoderDecoder](model_doc/encoder-decoder)** (from Google Research) released with the paper [Leveraging Pre-trained Checkpoints for Sequence Generation Tasks](https://arxiv.org/abs/1907.12461) by Sascha Rothe, Shashi Narayan, Aliaksei Severyn.
1. **[ERNIE](model_doc/ernie)** (from Baidu) released with the paper [ERNIE: Enhanced Representation through Knowledge Integration](https://arxiv.org/abs/1904.09223) by Yu Sun, Shuohuan Wang, Yukun Li, Shikun Feng, Xuyi Chen, Han Zhang, Xin Tian, Danxiang Zhu, Hao Tian, Hua Wu.
1. **[ESM](model_doc/esm)** (from Meta AI) are transformer protein language models. **ESM-1b** was released with the paper [Biological structure and function emerge from scaling unsupervised learning to 250 million protein sequences](https://www.pnas.org/content/118/15/e2016239118) by Alexander Rives, Joshua Meier, Tom Sercu, Siddharth Goyal, Zeming Lin, Jason Liu, Demi Guo, Myle Ott, C. Lawrence Zitnick, Jerry Ma, and Rob Fergus. **ESM-1v** was released with the paper [Language models enable zero-shot prediction of the effects of mutations on protein function](https://doi.org/10.1101/2021.07.09.450648) by Joshua Meier, Roshan Rao, Robert Verkuil, Jason Liu, Tom Sercu and Alexander Rives. **ESM-2 and ESMFold** were released with the paper [Language models of protein sequences at the scale of evolution enable accurate structure prediction](https://doi.org/10.1101/2022.07.20.500902) by Zeming Lin, Halil Akin, Roshan Rao, Brian Hie, Zhongkai Zhu, Wenting Lu, Allan dos Santos Costa, Maryam Fazel-Zarandi, Tom Sercu, Sal Candido, Alexander Rives.
1. **[FastSpeech2Conformer](model_doc/fastspeech2_conformer)** (from ESPnet) released with the paper [Recent Developments On Espnet Toolkit Boosted By Conformer](https://arxiv.org/abs/2010.13956) by Pengcheng Guo, Florian Boyer, Xuankai Chang, Tomoki Hayashi, Yosuke Higuchi, Hirofumi Inaguma, Naoyuki Kamo, Chenda Li, Daniel Garcia-Romero, Jiatong Shi, Jing Shi, Shinji Watanabe, Kun Wei, Wangyou Zhang, and Yuekai Zhang.
1. **[FLAN-T5](model_doc/flan-t5)** (from Google AI) released in the repository [google-research/t5x](https://github.com/google-research/t5x/blob/main/docs/models.md#flan-t5-checkpoints) by Hyung Won Chung, Le Hou, Shayne Longpre, Barret Zoph, Yi Tay, William Fedus, Eric Li, Xuezhi Wang, Mostafa Dehghani, Siddhartha Brahma, Albert Webson, Shixiang Shane Gu, Zhuyun Dai, Mirac Suzgun, Xinyun Chen, Aakanksha Chowdhery, Sharan Narang, Gaurav Mishra, Adams Yu, Vincent Zhao, Yanping Huang, Andrew Dai, Hongkun Yu, Slav Petrov, Ed H. Chi, Jeff Dean, Jacob Devlin, Adam Roberts, Denny Zhou, Quoc V. Le, and Jason Wei
1. **[FlauBERT](model_doc/flaubert)** (from CNRS) released with the paper [FlauBERT: Unsupervised Language Model Pre-training for French](https://arxiv.org/abs/1912.05372) by Hang Le, Loรฏc Vial, Jibril Frej, Vincent Segonne, Maximin Coavoux, Benjamin Lecouteux, Alexandre Allauzen, Benoรฎt Crabbรฉ, Laurent Besacier, Didier Schwab.
1. **[FLAVA](model_doc/flava)** (from Facebook AI) released with the paper [FLAVA: A Foundational Language And Vision Alignment Model](https://arxiv.org/abs/2112.04482) by Amanpreet Singh, Ronghang Hu, Vedanuj Goswami, Guillaume Couairon, Wojciech Galuba, Marcus Rohrbach, and Douwe Kiela.
1. **[FNet](model_doc/fnet)** (from Google Research) released with the paper [FNet: Mixing Tokens with Fourier Transforms](https://arxiv.org/abs/2105.03824) by James Lee-Thorp, Joshua Ainslie, Ilya Eckstein, Santiago Ontanon.
1. **[Funnel Transformer](model_doc/funnel)** (from CMU/Google Brain) released with the paper [Funnel-Transformer: Filtering out Sequential Redundancy for Efficient Language Processing](https://arxiv.org/abs/2006.03236) by Zihang Dai, Guokun Lai, Yiming Yang, Quoc V. Le.
1. **[GIT](model_doc/git)** (from Microsoft Research) released with the paper [GIT: A Generative Image-to-text Transformer for Vision and Language](https://arxiv.org/abs/2205.14100) by Jianfeng Wang, Zhengyuan Yang, Xiaowei Hu, Linjie Li, Kevin Lin, Zhe Gan, Zicheng Liu, Ce Liu, Lijuan Wang.
1. **[GLPN](model_doc/glpn)** (from KAIST) released with the paper [Global-Local Path Networks for Monocular Depth Estimation with Vertical CutDepth](https://arxiv.org/abs/2201.07436) by Doyeon Kim, Woonghyun Ga, Pyungwhan Ahn, Donggyu Joo, Sehwan Chun, Junmo Kim.
1. **[GPT](model_doc/openai-gpt)** (from OpenAI) released with the paper [Improving Language Understanding by Generative Pre-Training](https://openai.com/research/language-unsupervised/) by Alec Radford, Karthik Narasimhan, Tim Salimans and Ilya Sutskever.
1. **[GPT Neo](model_doc/gpt_neo)** (from EleutherAI) released in the repository [EleutherAI/gpt-neo](https://github.com/EleutherAI/gpt-neo) by Sid Black, Stella Biderman, Leo Gao, Phil Wang and Connor Leahy.
1. **[GPT NeoX](model_doc/gpt_neox)** (from EleutherAI) released with the paper [GPT-NeoX-20B: An Open-Source Autoregressive Language Model](https://arxiv.org/abs/2204.06745) by Sid Black, Stella Biderman, Eric Hallahan, Quentin Anthony, Leo Gao, Laurence Golding, Horace He, Connor Leahy, Kyle McDonell, Jason Phang, Michael Pieler, USVSN Sai Prashanth, Shivanshu Purohit, Laria Reynolds, Jonathan Tow, Ben Wang, Samuel Weinbach
1. **[GPT NeoX Japanese](model_doc/gpt_neox_japanese)** (from ABEJA) released by Shinya Otani, Takayoshi Makabe, Anuj Arora, and Kyo Hattori.
1. **[GPT-2](model_doc/gpt2)** (from OpenAI) released with the paper [Language Models are Unsupervised Multitask Learners](https://openai.com/research/better-language-models/) by Alec Radford, Jeffrey Wu, Rewon Child, David Luan, Dario Amodei and Ilya Sutskever.
1. **[GPT-J](model_doc/gptj)** (from EleutherAI) released in the repository [kingoflolz/mesh-transformer-jax](https://github.com/kingoflolz/mesh-transformer-jax/) by Ben Wang and Aran Komatsuzaki.
1. **[GPT-Sw3](model_doc/gpt-sw3)** (from AI-Sweden) released with the paper [Lessons Learned from GPT-SW3: Building the First Large-Scale Generative Language Model for Swedish](http://www.lrec-conf.org/proceedings/lrec2022/pdf/2022.lrec-1.376.pdf) by Ariel Ekgren, Amaru Cuba Gyllensten, Evangelia Gogoulou, Alice Heiman, Severine Verlinden, Joey รhman, Fredrik Carlsson, Magnus Sahlgren.
1. **[Graphormer](model_doc/graphormer)** (from Microsoft) released with the paper [Do Transformers Really Perform Bad for Graph Representation?](https://arxiv.org/abs/2106.05234) by Chengxuan Ying, Tianle Cai, Shengjie Luo, Shuxin Zheng, Guolin Ke, Di He, Yanming Shen, Tie-Yan Liu.
1. **[GroupViT](model_doc/groupvit)** (from UCSD, NVIDIA) released with the paper [GroupViT: Semantic Segmentation Emerges from Text Supervision](https://arxiv.org/abs/2202.11094) by Jiarui Xu, Shalini De Mello, Sifei Liu, Wonmin Byeon, Thomas Breuel, Jan Kautz, Xiaolong Wang.
1. **[Hubert](model_doc/hubert)** (from Facebook) released with the paper [HuBERT: Self-Supervised Speech Representation Learning by Masked Prediction of Hidden Units](https://arxiv.org/abs/2106.07447) by Wei-Ning Hsu, Benjamin Bolte, Yao-Hung Hubert Tsai, Kushal Lakhotia, Ruslan Salakhutdinov, Abdelrahman Mohamed.
1. **[I-BERT](model_doc/ibert)** (from Berkeley) released with the paper [I-BERT: Integer-only BERT Quantization](https://arxiv.org/abs/2101.01321) by Sehoon Kim, Amir Gholami, Zhewei Yao, Michael W. Mahoney, Kurt Keutzer.
1. **[ImageGPT](model_doc/imagegpt)** (from OpenAI) released with the paper [Generative Pretraining from Pixels](https://openai.com/blog/image-gpt/) by Mark Chen, Alec Radford, Rewon Child, Jeffrey Wu, Heewoo Jun, David Luan, Ilya Sutskever.
1. **[Jukebox](model_doc/jukebox)** (from OpenAI) released with the paper [Jukebox: A Generative Model for Music](https://arxiv.org/pdf/2005.00341.pdf) by Prafulla Dhariwal, Heewoo Jun, Christine Payne, Jong Wook Kim, Alec Radford, Ilya Sutskever.
1. **[LayoutLM](model_doc/layoutlm)** (from Microsoft Research Asia) released with the paper [LayoutLM: Pre-training of Text and Layout for Document Image Understanding](https://arxiv.org/abs/1912.13318) by Yiheng Xu, Minghao Li, Lei Cui, Shaohan Huang, Furu Wei, Ming Zhou.
1. **[LayoutLMv2](model_doc/layoutlmv2)** (from Microsoft Research Asia) released with the paper [LayoutLMv2: Multi-modal Pre-training for Visually-Rich Document Understanding](https://arxiv.org/abs/2012.14740) by Yang Xu, Yiheng Xu, Tengchao Lv, Lei Cui, Furu Wei, Guoxin Wang, Yijuan Lu, Dinei Florencio, Cha Zhang, Wanxiang Che, Min Zhang, Lidong Zhou.
1. **[LayoutLMv3](model_doc/layoutlmv3)** (from Microsoft Research Asia) released with the paper [LayoutLMv3: Pre-training for Document AI with Unified Text and Image Masking](https://arxiv.org/abs/2204.08387) by Yupan Huang, Tengchao Lv, Lei Cui, Yutong Lu, Furu Wei.
1. **[LayoutXLM](model_doc/layoutxlm)** (from Microsoft Research Asia) released with the paper [LayoutXLM: Multimodal Pre-training for Multilingual Visually-rich Document Understanding](https://arxiv.org/abs/2104.08836) by Yiheng Xu, Tengchao Lv, Lei Cui, Guoxin Wang, Yijuan Lu, Dinei Florencio, Cha Zhang, Furu Wei.
1. **[LED](model_doc/led)** (from AllenAI) released with the paper [Longformer: The Long-Document Transformer](https://arxiv.org/abs/2004.05150) by Iz Beltagy, Matthew E. Peters, Arman Cohan.
1. **[LeViT](model_doc/levit)** (from Meta AI) released with the paper [LeViT: A Vision Transformer in ConvNet's Clothing for Faster Inference](https://arxiv.org/abs/2104.01136) by Ben Graham, Alaaeldin El-Nouby, Hugo Touvron, Pierre Stock, Armand Joulin, Hervรฉ Jรฉgou, Matthijs Douze.
1. **[LiLT](model_doc/lilt)** (from South China University of Technology) released with the paper [LiLT: A Simple yet Effective Language-Independent Layout Transformer for Structured Document Understanding](https://arxiv.org/abs/2202.13669) by Jiapeng Wang, Lianwen Jin, Kai Ding.
1. **[Longformer](model_doc/longformer)** (from AllenAI) released with the paper [Longformer: The Long-Document Transformer](https://arxiv.org/abs/2004.05150) by Iz Beltagy, Matthew E. Peters, Arman Cohan.
1. **[LongT5](model_doc/longt5)** (from Google AI) released with the paper [LongT5: Efficient Text-To-Text Transformer for Long Sequences](https://arxiv.org/abs/2112.07916) by Mandy Guo, Joshua Ainslie, David Uthus, Santiago Ontanon, Jianmo Ni, Yun-Hsuan Sung, Yinfei Yang.
1. **[LUKE](model_doc/luke)** (from Studio Ousia) released with the paper [LUKE: Deep Contextualized Entity Representations with Entity-aware Self-attention](https://arxiv.org/abs/2010.01057) by Ikuya Yamada, Akari Asai, Hiroyuki Shindo, Hideaki Takeda, Yuji Matsumoto.
1. **[LXMERT](model_doc/lxmert)** (from UNC Chapel Hill) released with the paper [LXMERT: Learning Cross-Modality Encoder Representations from Transformers for Open-Domain Question Answering](https://arxiv.org/abs/1908.07490) by Hao Tan and Mohit Bansal.
1. **[M-CTC-T](model_doc/mctct)** (from Facebook) released with the paper [Pseudo-Labeling For Massively Multilingual Speech Recognition](https://arxiv.org/abs/2111.00161) by Loren Lugosch, Tatiana Likhomanenko, Gabriel Synnaeve, and Ronan Collobert.
1. **[M2M100](model_doc/m2m_100)** (from Facebook) released with the paper [Beyond English-Centric Multilingual Machine Translation](https://arxiv.org/abs/2010.11125) by Angela Fan, Shruti Bhosale, Holger Schwenk, Zhiyi Ma, Ahmed El-Kishky, Siddharth Goyal, Mandeep Baines, Onur Celebi, Guillaume Wenzek, Vishrav Chaudhary, Naman Goyal, Tom Birch, Vitaliy Liptchinsky, Sergey Edunov, Edouard Grave, Michael Auli, Armand Joulin.
1. **[MarianMT](model_doc/marian)** Machine translation models trained using [OPUS](http://opus.nlpl.eu/) data by Jรถrg Tiedemann. The [Marian Framework](https://marian-nmt.github.io/) is being developed by the Microsoft Translator Team.
1. **[MarkupLM](model_doc/markuplm)** (from Microsoft Research Asia) released with the paper [MarkupLM: Pre-training of Text and Markup Language for Visually-rich Document Understanding](https://arxiv.org/abs/2110.08518) by Junlong Li, Yiheng Xu, Lei Cui, Furu Wei.
1. **[Mask2Former](model_doc/mask2former)** (from FAIR and UIUC) released with the paper [Masked-attention Mask Transformer for Universal Image Segmentation](https://arxiv.org/abs/2112.01527) by Bowen Cheng, Ishan Misra, Alexander G. Schwing, Alexander Kirillov, Rohit Girdhar.
1. **[MaskFormer](model_doc/maskformer)** (from Meta and UIUC) released with the paper [Per-Pixel Classification is Not All You Need for Semantic Segmentation](https://arxiv.org/abs/2107.06278) by Bowen Cheng, Alexander G. Schwing, Alexander Kirillov.
1. **[mBART](model_doc/mbart)** (from Facebook) released with the paper [Multilingual Denoising Pre-training for Neural Machine Translation](https://arxiv.org/abs/2001.08210) by Yinhan Liu, Jiatao Gu, Naman Goyal, Xian Li, Sergey Edunov, Marjan Ghazvininejad, Mike Lewis, Luke Zettlemoyer.
1. **[mBART-50](model_doc/mbart)** (from Facebook) released with the paper [Multilingual Translation with Extensible Multilingual Pretraining and Finetuning](https://arxiv.org/abs/2008.00401) by Yuqing Tang, Chau Tran, Xian Li, Peng-Jen Chen, Naman Goyal, Vishrav Chaudhary, Jiatao Gu, Angela Fan.
1. **[Megatron-BERT](model_doc/megatron-bert)** (from NVIDIA) released with the paper [Megatron-LM: Training Multi-Billion Parameter Language Models Using Model Parallelism](https://arxiv.org/abs/1909.08053) by Mohammad Shoeybi, Mostofa Patwary, Raul Puri, Patrick LeGresley, Jared Casper and Bryan Catanzaro.
1. **[Megatron-GPT2](model_doc/megatron_gpt2)** (from NVIDIA) released with the paper [Megatron-LM: Training Multi-Billion Parameter Language Models Using Model Parallelism](https://arxiv.org/abs/1909.08053) by Mohammad Shoeybi, Mostofa Patwary, Raul Puri, Patrick LeGresley, Jared Casper and Bryan Catanzaro.
1. **[mLUKE](model_doc/mluke)** (from Studio Ousia) released with the paper [mLUKE: The Power of Entity Representations in Multilingual Pretrained Language Models](https://arxiv.org/abs/2110.08151) by Ryokan Ri, Ikuya Yamada, and Yoshimasa Tsuruoka.
1. **[MobileBERT](model_doc/mobilebert)** (from CMU/Google Brain) released with the paper [MobileBERT: a Compact Task-Agnostic BERT for Resource-Limited Devices](https://arxiv.org/abs/2004.02984) by Zhiqing Sun, Hongkun Yu, Xiaodan Song, Renjie Liu, Yiming Yang, and Denny Zhou.
1. **[MobileNetV1](model_doc/mobilenet_v1)** (from Google Inc.) released with the paper [MobileNets: Efficient Convolutional Neural Networks for Mobile Vision Applications](https://arxiv.org/abs/1704.04861) by Andrew G. Howard, Menglong Zhu, Bo Chen, Dmitry Kalenichenko, Weijun Wang, Tobias Weyand, Marco Andreetto, Hartwig Adam.
1. **[MobileNetV2](model_doc/mobilenet_v2)** (from Google Inc.) released with the paper [MobileNetV2: Inverted Residuals and Linear Bottlenecks](https://arxiv.org/abs/1801.04381) by Mark Sandler, Andrew Howard, Menglong Zhu, Andrey Zhmoginov, Liang-Chieh Chen.
1. **[MobileViT](model_doc/mobilevit)** (from Apple) released with the paper [MobileViT: Light-weight, General-purpose, and Mobile-friendly Vision Transformer](https://arxiv.org/abs/2110.02178) by Sachin Mehta and Mohammad Rastegari.
1. **[MPNet](model_doc/mpnet)** (from Microsoft Research) released with the paper [MPNet: Masked and Permuted Pre-training for Language Understanding](https://arxiv.org/abs/2004.09297) by Kaitao Song, Xu Tan, Tao Qin, Jianfeng Lu, Tie-Yan Liu.
1. **[MT5](model_doc/mt5)** (from Google AI) released with the paper [mT5: A massively multilingual pre-trained text-to-text transformer](https://arxiv.org/abs/2010.11934) by Linting Xue, Noah Constant, Adam Roberts, Mihir Kale, Rami Al-Rfou, Aditya Siddhant, Aditya Barua, Colin Raffel.
1. **[MVP](model_doc/mvp)** (from RUC AI Box) released with the paper [MVP: Multi-task Supervised Pre-training for Natural Language Generation](https://arxiv.org/abs/2206.12131) by Tianyi Tang, Junyi Li, Wayne Xin Zhao and Ji-Rong Wen.
1. **[NAT](model_doc/nat)** (from SHI Labs) released with the paper [Neighborhood Attention Transformer](https://arxiv.org/abs/2204.07143) by Ali Hassani, Steven Walton, Jiachen Li, Shen Li, and Humphrey Shi.
1. **[Nezha](model_doc/nezha)** (from Huawei Noahโs Ark Lab) released with the paper [NEZHA: Neural Contextualized Representation for Chinese Language Understanding](https://arxiv.org/abs/1909.00204) by Junqiu Wei, Xiaozhe Ren, Xiaoguang Li, Wenyong Huang, Yi Liao, Yasheng Wang, Jiashu Lin, Xin Jiang, Xiao Chen and Qun Liu.
1. **[NLLB](model_doc/nllb)** (from Meta) released with the paper [No Language Left Behind: Scaling Human-Centered Machine Translation](https://arxiv.org/abs/2207.04672) by the NLLB team.
1. **[Nystrรถmformer](model_doc/nystromformer)** (from the University of Wisconsin - Madison) released with the paper [Nystrรถmformer: A Nystrรถm-Based Algorithm for Approximating Self-Attention](https://arxiv.org/abs/2102.03902) by Yunyang Xiong, Zhanpeng Zeng, Rudrasis Chakraborty, Mingxing Tan, Glenn Fung, Yin Li, Vikas Singh.
1. **[OneFormer](model_doc/oneformer)** (from SHI Labs) released with the paper [OneFormer: One Transformer to Rule Universal Image Segmentation](https://arxiv.org/abs/2211.06220) by Jitesh Jain, Jiachen Li, MangTik Chiu, Ali Hassani, Nikita Orlov, Humphrey Shi.
1. **[OPT](master/model_doc/opt)** (from Meta AI) released with the paper [OPT: Open Pre-trained Transformer Language Models](https://arxiv.org/abs/2205.01068) by Susan Zhang, Stephen Roller, Naman Goyal, Mikel Artetxe, Moya Chen, Shuohui Chen et al.
1. **[OWL-ViT](model_doc/owlvit)** (from Google AI) released with the paper [Simple Open-Vocabulary Object Detection with Vision Transformers](https://arxiv.org/abs/2205.06230) by Matthias Minderer, Alexey Gritsenko, Austin Stone, Maxim Neumann, Dirk Weissenborn, Alexey Dosovitskiy, Aravindh Mahendran, Anurag Arnab, Mostafa Dehghani, Zhuoran Shen, Xiao Wang, Xiaohua Zhai, Thomas Kipf, and Neil Houlsby.
1. **[Pegasus](model_doc/pegasus)** (from Google) released with the paper [PEGASUS: Pre-training with Extracted Gap-sentences for Abstractive Summarization](https://arxiv.org/abs/1912.08777) by Jingqing Zhang, Yao Zhao, Mohammad Saleh and Peter J. Liu.
1. **[PEGASUS-X](model_doc/pegasus_x)** (from Google) released with the paper [Investigating Efficiently Extending Transformers for Long Input Summarization](https://arxiv.org/abs/2208.04347) by Jason Phang, Yao Zhao, and Peter J. Liu.
1. **[Perceiver IO](model_doc/perceiver)** (from Deepmind) released with the paper [Perceiver IO: A General Architecture for Structured Inputs & Outputs](https://arxiv.org/abs/2107.14795) by Andrew Jaegle, Sebastian Borgeaud, Jean-Baptiste Alayrac, Carl Doersch, Catalin Ionescu, David Ding, Skanda Koppula, Daniel Zoran, Andrew Brock, Evan Shelhamer, Olivier Hรฉnaff, Matthew M. Botvinick, Andrew Zisserman, Oriol Vinyals, Joรฃo Carreira.
1. **[PhoBERT](model_doc/phobert)** (from VinAI Research) released with the paper [PhoBERT: Pre-trained language models for Vietnamese](https://www.aclweb.org/anthology/2020.findings-emnlp.92/) by Dat Quoc Nguyen and Anh Tuan Nguyen.
1. **[PLBart](model_doc/plbart)** (from UCLA NLP) released with the paper [Unified Pre-training for Program Understanding and Generation](https://arxiv.org/abs/2103.06333) by Wasi Uddin Ahmad, Saikat Chakraborty, Baishakhi Ray, Kai-Wei Chang.
1. **[PoolFormer](model_doc/poolformer)** (from Sea AI Labs) released with the paper [MetaFormer is Actually What You Need for Vision](https://arxiv.org/abs/2111.11418) by Yu, Weihao and Luo, Mi and Zhou, Pan and Si, Chenyang and Zhou, Yichen and Wang, Xinchao and Feng, Jiashi and Yan, Shuicheng.
1. **[ProphetNet](model_doc/prophetnet)** (from Microsoft Research) released with the paper [ProphetNet: Predicting Future N-gram for Sequence-to-Sequence Pre-training](https://arxiv.org/abs/2001.04063) by Yu Yan, Weizhen Qi, Yeyun Gong, Dayiheng Liu, Nan Duan, Jiusheng Chen, Ruofei Zhang and Ming Zhou.
1. **[QDQBert](model_doc/qdqbert)** (from NVIDIA) released with the paper [Integer Quantization for Deep Learning Inference: Principles and Empirical Evaluation](https://arxiv.org/abs/2004.09602) by Hao Wu, Patrick Judd, Xiaojie Zhang, Mikhail Isaev and Paulius Micikevicius.
1. **[RAG](model_doc/rag)** (from Facebook) released with the paper [Retrieval-Augmented Generation for Knowledge-Intensive NLP Tasks](https://arxiv.org/abs/2005.11401) by Patrick Lewis, Ethan Perez, Aleksandara Piktus, Fabio Petroni, Vladimir Karpukhin, Naman Goyal, Heinrich Kรผttler, Mike Lewis, Wen-tau Yih, Tim Rocktรคschel, Sebastian Riedel, Douwe Kiela.
1. **[REALM](model_doc/realm.html)** (from Google Research) released with the paper [REALM: Retrieval-Augmented Language Model Pre-Training](https://arxiv.org/abs/2002.08909) by Kelvin Guu, Kenton Lee, Zora Tung, Panupong Pasupat and Ming-Wei Chang.
1. **[Reformer](model_doc/reformer)** (from Google Research) released with the paper [Reformer: The Efficient Transformer](https://arxiv.org/abs/2001.04451) by Nikita Kitaev, ลukasz Kaiser, Anselm Levskaya.
1. **[RegNet](model_doc/regnet)** (from META Platforms) released with the paper [Designing Network Design Space](https://arxiv.org/abs/2003.13678) by Ilija Radosavovic, Raj Prateek Kosaraju, Ross Girshick, Kaiming He, Piotr Dollรกr.
1. **[RemBERT](model_doc/rembert)** (from Google Research) released with the paper [Rethinking embedding coupling in pre-trained language models](https://arxiv.org/abs/2010.12821) by Hyung Won Chung, Thibault Fรฉvry, Henry Tsai, M. Johnson, Sebastian Ruder.
1. **[ResNet](model_doc/resnet)** (from Microsoft Research) released with the paper [Deep Residual Learning for Image Recognition](https://arxiv.org/abs/1512.03385) by Kaiming He, Xiangyu Zhang, Shaoqing Ren, Jian Sun.
1. **[RoBERTa](model_doc/roberta)** (from Facebook), released together with the paper [RoBERTa: A Robustly Optimized BERT Pretraining Approach](https://arxiv.org/abs/1907.11692) by Yinhan Liu, Myle Ott, Naman Goyal, Jingfei Du, Mandar Joshi, Danqi Chen, Omer Levy, Mike Lewis, Luke Zettlemoyer, Veselin Stoyanov.
1. **[RoBERTa-PreLayerNorm](model_doc/roberta-prelayernorm)** (from Facebook) released with the paper [fairseq: A Fast, Extensible Toolkit for Sequence Modeling](https://arxiv.org/abs/1904.01038) by Myle Ott, Sergey Edunov, Alexei Baevski, Angela Fan, Sam Gross, Nathan Ng, David Grangier, Michael Auli.
1. **[RoCBert](model_doc/roc_bert)** (from WeChatAI) released with the paper [RoCBert: Robust Chinese Bert with Multimodal Contrastive Pretraining](https://aclanthology.org/2022.acl-long.65.pdf) by HuiSu, WeiweiShi, XiaoyuShen, XiaoZhou, TuoJi, JiaruiFang, JieZhou.
1. **[RoFormer](model_doc/roformer)** (from ZhuiyiTechnology), released together with the paper [RoFormer: Enhanced Transformer with Rotary Position Embedding](https://arxiv.org/abs/2104.09864) by Jianlin Su and Yu Lu and Shengfeng Pan and Bo Wen and Yunfeng Liu.
1. **[SegFormer](model_doc/segformer)** (from NVIDIA) released with the paper [SegFormer: Simple and Efficient Design for Semantic Segmentation with Transformers](https://arxiv.org/abs/2105.15203) by Enze Xie, Wenhai Wang, Zhiding Yu, Anima Anandkumar, Jose M. Alvarez, Ping Luo.
1. **[SEW](model_doc/sew)** (from ASAPP) released with the paper [Performance-Efficiency Trade-offs in Unsupervised Pre-training for Speech Recognition](https://arxiv.org/abs/2109.06870) by Felix Wu, Kwangyoun Kim, Jing Pan, Kyu Han, Kilian Q. Weinberger, Yoav Artzi.
1. **[SEW-D](model_doc/sew_d)** (from ASAPP) released with the paper [Performance-Efficiency Trade-offs in Unsupervised Pre-training for Speech Recognition](https://arxiv.org/abs/2109.06870) by Felix Wu, Kwangyoun Kim, Jing Pan, Kyu Han, Kilian Q. Weinberger, Yoav Artzi.
1. **[SpeechT5](model_doc/speecht5)** (from Microsoft Research) released with the paper [SpeechT5: Unified-Modal Encoder-Decoder Pre-Training for Spoken Language Processing](https://arxiv.org/abs/2110.07205) by Junyi Ao, Rui Wang, Long Zhou, Chengyi Wang, Shuo Ren, Yu Wu, Shujie Liu, Tom Ko, Qing Li, Yu Zhang, Zhihua Wei, Yao Qian, Jinyu Li, Furu Wei.
1. **[SpeechToTextTransformer](model_doc/speech_to_text)** (from Facebook), released together with the paper [fairseq S2T: Fast Speech-to-Text Modeling with fairseq](https://arxiv.org/abs/2010.05171) by Changhan Wang, Yun Tang, Xutai Ma, Anne Wu, Dmytro Okhonko, Juan Pino.
1. **[SpeechToTextTransformer2](model_doc/speech_to_text_2)** (from Facebook), released together with the paper [Large-Scale Self- and Semi-Supervised Learning for Speech Translation](https://arxiv.org/abs/2104.06678) by Changhan Wang, Anne Wu, Juan Pino, Alexei Baevski, Michael Auli, Alexis Conneau.
1. **[Splinter](model_doc/splinter)** (from Tel Aviv University), released together with the paper [Few-Shot Question Answering by Pretraining Span Selection](https://arxiv.org/abs/2101.00438) by Ori Ram, Yuval Kirstain, Jonathan Berant, Amir Globerson, Omer Levy.
1. **[SqueezeBERT](model_doc/squeezebert)** (from Berkeley) released with the paper [SqueezeBERT: What can computer vision teach NLP about efficient neural networks?](https://arxiv.org/abs/2006.11316) by Forrest N. Iandola, Albert E. Shaw, Ravi Krishna, and Kurt W. Keutzer.
1. **[Swin Transformer](model_doc/swin)** (from Microsoft) released with the paper [Swin Transformer: Hierarchical Vision Transformer using Shifted Windows](https://arxiv.org/abs/2103.14030) by Ze Liu, Yutong Lin, Yue Cao, Han Hu, Yixuan Wei, Zheng Zhang, Stephen Lin, Baining Guo.
1. **[Swin Transformer V2](model_doc/swinv2)** (from Microsoft) released with the paper [Swin Transformer V2: Scaling Up Capacity and Resolution](https://arxiv.org/abs/2111.09883) by Ze Liu, Han Hu, Yutong Lin, Zhuliang Yao, Zhenda Xie, Yixuan Wei, Jia Ning, Yue Cao, Zheng Zhang, Li Dong, Furu Wei, Baining Guo.
1. **[Swin2SR](model_doc/swin2sr)** (from University of Wรผrzburg) released with the paper [Swin2SR: SwinV2 Transformer for Compressed Image Super-Resolution and Restoration](https://arxiv.org/abs/2209.11345) by Marcos V. Conde, Ui-Jin Choi, Maxime Burchi, Radu Timofte.
1. **[SwitchTransformers](model_doc/switch_transformers)** (from Google) released with the paper [Switch Transformers: Scaling to Trillion Parameter Models with Simple and Efficient Sparsity](https://arxiv.org/abs/2101.03961) by William Fedus, Barret Zoph, Noam Shazeer.
1. **[T5](model_doc/t5)** (from Google AI) released with the paper [Exploring the Limits of Transfer Learning with a Unified Text-to-Text Transformer](https://arxiv.org/abs/1910.10683) by Colin Raffel and Noam Shazeer and Adam Roberts and Katherine Lee and Sharan Narang and Michael Matena and Yanqi Zhou and Wei Li and Peter J. Liu.
1. **[T5v1.1](model_doc/t5v1.1)** (from Google AI) released in the repository [google-research/text-to-text-transfer-transformer](https://github.com/google-research/text-to-text-transfer-transformer/blob/main/released_checkpoints.md#t511) by Colin Raffel and Noam Shazeer and Adam Roberts and Katherine Lee and Sharan Narang and Michael Matena and Yanqi Zhou and Wei Li and Peter J. Liu.
1. **[Table Transformer](model_doc/table-transformer)** (from Microsoft Research) released with the paper [PubTables-1M: Towards Comprehensive Table Extraction From Unstructured Documents](https://arxiv.org/abs/2110.00061) by Brandon Smock, Rohith Pesala, Robin Abraham.
1. **[TAPAS](model_doc/tapas)** (from Google AI) released with the paper [TAPAS: Weakly Supervised Table Parsing via Pre-training](https://arxiv.org/abs/2004.02349) by Jonathan Herzig, Paweล Krzysztof Nowak, Thomas Mรผller, Francesco Piccinno and Julian Martin Eisenschlos.
1. **[TAPEX](model_doc/tapex)** (from Microsoft Research) released with the paper [TAPEX: Table Pre-training via Learning a Neural SQL Executor](https://arxiv.org/abs/2107.07653) by Qian Liu, Bei Chen, Jiaqi Guo, Morteza Ziyadi, Zeqi Lin, Weizhu Chen, Jian-Guang Lou.
1. **[Time Series Transformer](model_doc/time_series_transformer)** (from HuggingFace).
1. **[TimeSformer](model_doc/timesformer)** (from Facebook) released with the paper [Is Space-Time Attention All You Need for Video Understanding?](https://arxiv.org/abs/2102.05095) by Gedas Bertasius, Heng Wang, Lorenzo Torresani.
1. **[Trajectory Transformer](model_doc/trajectory_transformers)** (from the University of California at Berkeley) released with the paper [Offline Reinforcement Learning as One Big Sequence Modeling Problem](https://arxiv.org/abs/2106.02039) by Michael Janner, Qiyang Li, Sergey Levine
1. **[Transformer-XL](model_doc/transfo-xl)** (from Google/CMU) released with the paper [Transformer-XL: Attentive Language Models Beyond a Fixed-Length Context](https://arxiv.org/abs/1901.02860) by Zihang Dai*, Zhilin Yang*, Yiming Yang, Jaime Carbonell, Quoc V. Le, Ruslan Salakhutdinov.
1. **[TrOCR](model_doc/trocr)** (from Microsoft), released together with the paper [TrOCR: Transformer-based Optical Character Recognition with Pre-trained Models](https://arxiv.org/abs/2109.10282) by Minghao Li, Tengchao Lv, Lei Cui, Yijuan Lu, Dinei Florencio, Cha Zhang, Zhoujun Li, Furu Wei.
1. **[UL2](model_doc/ul2)** (from Google Research) released with the paper [Unifying Language Learning Paradigms](https://arxiv.org/abs/2205.05131v1) by Yi Tay, Mostafa Dehghani, Vinh Q. Tran, Xavier Garcia, Dara Bahri, Tal Schuster, Huaixiu Steven Zheng, Neil Houlsby, Donald Metzler
1. **[UniSpeech](model_doc/unispeech)** (from Microsoft Research) released with the paper [UniSpeech: Unified Speech Representation Learning with Labeled and Unlabeled Data](https://arxiv.org/abs/2101.07597) by Chengyi Wang, Yu Wu, Yao Qian, Kenichi Kumatani, Shujie Liu, Furu Wei, Michael Zeng, Xuedong Huang.
1. **[UniSpeechSat](model_doc/unispeech-sat)** (from Microsoft Research) released with the paper [UNISPEECH-SAT: UNIVERSAL SPEECH REPRESENTATION LEARNING WITH SPEAKER AWARE PRE-TRAINING](https://arxiv.org/abs/2110.05752) by Sanyuan Chen, Yu Wu, Chengyi Wang, Zhengyang Chen, Zhuo Chen, Shujie Liu, Jian Wu, Yao Qian, Furu Wei, Jinyu Li, Xiangzhan Yu.
1. **[UPerNet](model_doc/upernet)** (from Peking University) released with the paper [Unified Perceptual Parsing for Scene Understanding](https://arxiv.org/abs/1807.10221) by Tete Xiao, Yingcheng Liu, Bolei Zhou, Yuning Jiang, Jian Sun.
1. **[VAN](model_doc/van)** (from Tsinghua University and Nankai University) released with the paper [Visual Attention Network](https://arxiv.org/abs/2202.09741) by Meng-Hao Guo, Cheng-Ze Lu, Zheng-Ning Liu, Ming-Ming Cheng, Shi-Min Hu.
1. **[VideoMAE](model_doc/videomae)** (from Multimedia Computing Group, Nanjing University) released with the paper [VideoMAE: Masked Autoencoders are Data-Efficient Learners for Self-Supervised Video Pre-Training](https://arxiv.org/abs/2203.12602) by Zhan Tong, Yibing Song, Jue Wang, Limin Wang.
1. **[ViLT](model_doc/vilt)** (from NAVER AI Lab/Kakao Enterprise/Kakao Brain) released with the paper [ViLT: Vision-and-Language Transformer Without Convolution or Region Supervision](https://arxiv.org/abs/2102.03334) by Wonjae Kim, Bokyung Son, Ildoo Kim.
1. **[Vision Transformer (ViT)](model_doc/vit)** (from Google AI) released with the paper [An Image is Worth 16x16 Words: Transformers for Image Recognition at Scale](https://arxiv.org/abs/2010.11929) by Alexey Dosovitskiy, Lucas Beyer, Alexander Kolesnikov, Dirk Weissenborn, Xiaohua Zhai, Thomas Unterthiner, Mostafa Dehghani, Matthias Minderer, Georg Heigold, Sylvain Gelly, Jakob Uszkoreit, Neil Houlsby.
1. **[VisualBERT](model_doc/visual_bert)** (from UCLA NLP) released with the paper [VisualBERT: A Simple and Performant Baseline for Vision and Language](https://arxiv.org/pdf/1908.03557) by Liunian Harold Li, Mark Yatskar, Da Yin, Cho-Jui Hsieh, Kai-Wei Chang.
1. **[ViT Hybrid](model_doc/vit_hybrid)** (from Google AI) released with the paper [An Image is Worth 16x16 Words: Transformers for Image Recognition at Scale](https://arxiv.org/abs/2010.11929) by Alexey Dosovitskiy, Lucas Beyer, Alexander Kolesnikov, Dirk Weissenborn, Xiaohua Zhai, Thomas Unterthiner, Mostafa Dehghani, Matthias Minderer, Georg Heigold, Sylvain Gelly, Jakob Uszkoreit, Neil Houlsby.
1. **[ViTMAE](model_doc/vit_mae)** (from Meta AI) released with the paper [Masked Autoencoders Are Scalable Vision Learners](https://arxiv.org/abs/2111.06377) by Kaiming He, Xinlei Chen, Saining Xie, Yanghao Li, Piotr Dollรกr, Ross Girshick.
1. **[ViTMSN](model_doc/vit_msn)** (from Meta AI) released with the paper [Masked Siamese Networks for Label-Efficient Learning](https://arxiv.org/abs/2204.07141) by Mahmoud Assran, Mathilde Caron, Ishan Misra, Piotr Bojanowski, Florian Bordes, Pascal Vincent, Armand Joulin, Michael Rabbat, Nicolas Ballas.
1. **[Wav2Vec2](model_doc/wav2vec2)** (from Facebook AI) released with the paper [wav2vec 2.0: A Framework for Self-Supervised Learning of Speech Representations](https://arxiv.org/abs/2006.11477) by Alexei Baevski, Henry Zhou, Abdelrahman Mohamed, Michael Auli.
1. **[Wav2Vec2-Conformer](model_doc/wav2vec2-conformer)** (from Facebook AI) released with the paper [FAIRSEQ S2T: Fast Speech-to-Text Modeling with FAIRSEQ](https://arxiv.org/abs/2010.05171) by Changhan Wang, Yun Tang, Xutai Ma, Anne Wu, Sravya Popuri, Dmytro Okhonko, Juan Pino.
1. **[Wav2Vec2Phoneme](model_doc/wav2vec2_phoneme)** (from Facebook AI) released with the paper [Simple and Effective Zero-shot Cross-lingual Phoneme Recognition](https://arxiv.org/abs/2109.11680) by Qiantong Xu, Alexei Baevski, Michael Auli.
1. **[WavLM](model_doc/wavlm)** (from Microsoft Research) released with the paper [WavLM: Large-Scale Self-Supervised Pre-Training for Full Stack Speech Processing](https://arxiv.org/abs/2110.13900) by Sanyuan Chen, Chengyi Wang, Zhengyang Chen, Yu Wu, Shujie Liu, Zhuo Chen, Jinyu Li, Naoyuki Kanda, Takuya Yoshioka, Xiong Xiao, Jian Wu, Long Zhou, Shuo Ren, Yanmin Qian, Yao Qian, Jian Wu, Michael Zeng, Furu Wei.
1. **[Whisper](model_doc/whisper)** (from OpenAI) released with the paper [Robust Speech Recognition via Large-Scale Weak Supervision](https://cdn.openai.com/papers/whisper.pdf) by Alec Radford, Jong Wook Kim, Tao Xu, Greg Brockman, Christine McLeavey, Ilya Sutskever.
1. **[X-CLIP](model_doc/xclip)** (from Microsoft Research) released with the paper [Expanding Language-Image Pretrained Models for General Video Recognition](https://arxiv.org/abs/2208.02816) by Bolin Ni, Houwen Peng, Minghao Chen, Songyang Zhang, Gaofeng Meng, Jianlong Fu, Shiming Xiang, Haibin Ling.
1. **[XGLM](model_doc/xglm)** (From Facebook AI) released with the paper [Few-shot Learning with Multilingual Language Models](https://arxiv.org/abs/2112.10668) by Xi Victoria Lin, Todor Mihaylov, Mikel Artetxe, Tianlu Wang, Shuohui Chen, Daniel Simig, Myle Ott, Naman Goyal, Shruti Bhosale, Jingfei Du, Ramakanth Pasunuru, Sam Shleifer, Punit Singh Koura, Vishrav Chaudhary, Brian O'Horo, Jeff Wang, Luke Zettlemoyer, Zornitsa Kozareva, Mona Diab, Veselin Stoyanov, Xian Li.
1. **[XLM](model_doc/xlm)** (from Facebook) released together with the paper [Cross-lingual Language Model Pretraining](https://arxiv.org/abs/1901.07291) by Guillaume Lample and Alexis Conneau.
1. **[XLM-ProphetNet](model_doc/xlm-prophetnet)** (from Microsoft Research) released with the paper [ProphetNet: Predicting Future N-gram for Sequence-to-Sequence Pre-training](https://arxiv.org/abs/2001.04063) by Yu Yan, Weizhen Qi, Yeyun Gong, Dayiheng Liu, Nan Duan, Jiusheng Chen, Ruofei Zhang and Ming Zhou.
1. **[XLM-RoBERTa](model_doc/xlm-roberta)** (from Facebook AI), released together with the paper [Unsupervised Cross-lingual Representation Learning at Scale](https://arxiv.org/abs/1911.02116) by Alexis Conneau*, Kartikay Khandelwal*, Naman Goyal, Vishrav Chaudhary, Guillaume Wenzek, Francisco Guzmรกn, Edouard Grave, Myle Ott, Luke Zettlemoyer and Veselin Stoyanov.
1. **[XLM-RoBERTa-XL](model_doc/xlm-roberta-xl)** (from Facebook AI), released together with the paper [Larger-Scale Transformers for Multilingual Masked Language Modeling](https://arxiv.org/abs/2105.00572) by Naman Goyal, Jingfei Du, Myle Ott, Giri Anantharaman, Alexis Conneau.
1. **[XLNet](model_doc/xlnet)** (from Google/CMU) released with the paper [โXLNet: Generalized Autoregressive Pretraining for Language Understanding](https://arxiv.org/abs/1906.08237) by Zhilin Yang*, Zihang Dai*, Yiming Yang, Jaime Carbonell, Ruslan Salakhutdinov, Quoc V. Le.
1. **[XLS-R](model_doc/xls_r)** (from Facebook AI) released with the paper [XLS-R: Self-supervised Cross-lingual Speech Representation Learning at Scale](https://arxiv.org/abs/2111.09296) by Arun Babu, Changhan Wang, Andros Tjandra, Kushal Lakhotia, Qiantong Xu, Naman Goyal, Kritika Singh, Patrick von Platen, Yatharth Saraf, Juan Pino, Alexei Baevski, Alexis Conneau, Michael Auli.
1. **[XLSR-Wav2Vec2](model_doc/xlsr_wav2vec2)** (from Facebook AI) released with the paper [Unsupervised Cross-Lingual Representation Learning For Speech Recognition](https://arxiv.org/abs/2006.13979) by Alexis Conneau, Alexei Baevski, Ronan Collobert, Abdelrahman Mohamed, Michael Auli.
1. **[YOLOS](model_doc/yolos)** (from Huazhong University of Science & Technology) released with the paper [You Only Look at One Sequence: Rethinking Transformer in Vision through Object Detection](https://arxiv.org/abs/2106.00666) by Yuxin Fang, Bencheng Liao, Xinggang Wang, Jiemin Fang, Jiyang Qi, Rui Wu, Jianwei Niu, Wenyu Liu.
1. **[YOSO](model_doc/yoso)** (from the University of Wisconsin - Madison) released with the paper [You Only Sample (Almost) Once: Linear Cost Self-Attention Via Bernoulli Sampling](https://arxiv.org/abs/2111.09714) by Zhanpeng Zeng, Yunyang Xiong, Sathya N. Ravi, Shailesh Acharya, Glenn Fung, Vikas Singh.
### Frameworks compatibles
Le tableau ci-dessous reprรฉsente la prise en charge actuelle dans la bibliothรจque pour chacun de ces modรจles, qu'ils aient ou non un tokenizer Python (appelรฉ "slow"). Un tokenizer rapide ("fast") soutenu par la bibliothรจque ๐ค Tokenizers, qu'ils aient un support en Jax (via Flax), PyTorch, et/ou TensorFlow.
<!--This table is updated automatically from the auto modules with _make fix-copies_. Do not update manually!-->
| Modรจle | Tokenizer slow | Tokenizer fast | PyTorch support | TensorFlow support | Flax Support |
|:-----------------------------:|:--------------:|:--------------:|:---------------:|:------------------:|:------------:|
| ALBERT | โ
| โ
| โ
| โ
| โ
|
| AltCLIP | โ | โ | โ
| โ | โ |
| Audio Spectrogram Transformer | โ | โ | โ
| โ | โ |
| BART | โ
| โ
| โ
| โ
| โ
|
| BEiT | โ | โ | โ
| โ | โ
|
| BERT | โ
| โ
| โ
| โ
| โ
|
| Bert Generation | โ
| โ | โ
| โ | โ |
| BigBird | โ
| โ
| โ
| โ | โ
|
| BigBird-Pegasus | โ | โ | โ
| โ | โ |
| BioGpt | โ
| โ | โ
| โ | โ |
| BiT | โ | โ | โ
| โ | โ |
| Blenderbot | โ
| โ
| โ
| โ
| โ
|
| BlenderbotSmall | โ
| โ
| โ
| โ
| โ
|
| BLIP | โ | โ | โ
| โ | โ |
| BLOOM | โ | โ
| โ
| โ | โ |
| BridgeTower | โ | โ | โ
| โ | โ |
| CamemBERT | โ
| โ
| โ
| โ
| โ |
| CANINE | โ
| โ | โ
| โ | โ |
| Chinese-CLIP | โ | โ | โ
| โ | โ |
| CLIP | โ
| โ
| โ
| โ
| โ
|
| CLIPSeg | โ | โ | โ
| โ | โ |
| CodeGen | โ
| โ
| โ
| โ | โ |
| Conditional DETR | โ | โ | โ
| โ | โ |
| ConvBERT | โ
| โ
| โ
| โ
| โ |
| ConvNeXT | โ | โ | โ
| โ
| โ |
| CTRL | โ
| โ | โ
| โ
| โ |
| CvT | โ | โ | โ
| โ
| โ |
| Data2VecAudio | โ | โ | โ
| โ | โ |
| Data2VecText | โ | โ | โ
| โ | โ |
| Data2VecVision | โ | โ | โ
| โ
| โ |
| DeBERTa | โ
| โ
| โ
| โ
| โ |
| DeBERTa-v2 | โ
| โ
| โ
| โ
| โ |
| Decision Transformer | โ | โ | โ
| โ | โ |
| Deformable DETR | โ | โ | โ
| โ | โ |
| DeiT | โ | โ | โ
| โ
| โ |
| DETA | โ | โ | โ
| โ | โ |
| DETR | โ | โ | โ
| โ | โ |
| DiNAT | โ | โ | โ
| โ | โ |
| DistilBERT | โ
| โ
| โ
| โ
| โ
|
| DonutSwin | โ | โ | โ
| โ | โ |
| DPR | โ
| โ
| โ
| โ
| โ |
| DPT | โ | โ | โ
| โ | โ |
| EfficientFormer | โ | โ | โ
| โ | โ |
| ELECTRA | โ
| โ
| โ
| โ
| โ
|
| Encoder decoder | โ | โ | โ
| โ
| โ
|
| ERNIE | โ | โ | โ
| โ | โ |
| ESM | โ
| โ | โ
| โ
| โ |
| FairSeq Machine-Translation | โ
| โ | โ
| โ | โ |
| FastSpeech2Conformer | โ
| โ | โ
| โ | โ |
| FlauBERT | โ
| โ | โ
| โ
| โ |
| FLAVA | โ | โ | โ
| โ | โ |
| FNet | โ
| โ
| โ
| โ | โ |
| Funnel Transformer | โ
| โ
| โ
| โ
| โ |
| GIT | โ | โ | โ
| โ | โ |
| GLPN | โ | โ | โ
| โ | โ |
| GPT Neo | โ | โ | โ
| โ | โ
|
| GPT NeoX | โ | โ
| โ
| โ | โ |
| GPT NeoX Japanese | โ
| โ | โ
| โ | โ |
| GPT-J | โ | โ | โ
| โ
| โ
|
| GPT-Sw3 | โ
| โ
| โ
| โ
| โ
|
| Graphormer | โ | โ | โ
| โ | โ |
| GroupViT | โ | โ | โ
| โ
| โ |
| Hubert | โ | โ | โ
| โ
| โ |
| I-BERT | โ | โ | โ
| โ | โ |
| ImageGPT | โ | โ | โ
| โ | โ |
| Jukebox | โ
| โ | โ
| โ | โ |
| LayoutLM | โ
| โ
| โ
| โ
| โ |
| LayoutLMv2 | โ
| โ
| โ
| โ | โ |
| LayoutLMv3 | โ
| โ
| โ
| โ
| โ |
| LED | โ
| โ
| โ
| โ
| โ |
| LeViT | โ | โ | โ
| โ | โ |
| LiLT | โ | โ | โ
| โ | โ |
| Longformer | โ
| โ
| โ
| โ
| โ |
| LongT5 | โ | โ | โ
| โ | โ
|
| LUKE | โ
| โ | โ
| โ | โ |
| LXMERT | โ
| โ
| โ
| โ
| โ |
| M-CTC-T | โ | โ | โ
| โ | โ |
| M2M100 | โ
| โ | โ
| โ | โ |
| Marian | โ
| โ | โ
| โ
| โ
|
| MarkupLM | โ
| โ
| โ
| โ | โ |
| Mask2Former | โ | โ | โ
| โ | โ |
| MaskFormer | โ | โ | โ
| โ | โ |
| MaskFormerSwin | โ | โ | โ | โ | โ |
| mBART | โ
| โ
| โ
| โ
| โ
|
| Megatron-BERT | โ | โ | โ
| โ | โ |
| MobileBERT | โ
| โ
| โ
| โ
| โ |
| MobileNetV1 | โ | โ | โ
| โ | โ |
| MobileNetV2 | โ | โ | โ
| โ | โ |
| MobileViT | โ | โ | โ
| โ
| โ |
| MPNet | โ
| โ
| โ
| โ
| โ |
| MT5 | โ
| โ
| โ
| โ
| โ
|
| MVP | โ
| โ
| โ
| โ | โ |
| NAT | โ | โ | โ
| โ | โ |
| Nezha | โ | โ | โ
| โ | โ |
| Nystrรถmformer | โ | โ | โ
| โ | โ |
| OneFormer | โ | โ | โ
| โ | โ |
| OpenAI GPT | โ
| โ
| โ
| โ
| โ |
| OpenAI GPT-2 | โ
| โ
| โ
| โ
| โ
|
| OPT | โ | โ | โ
| โ
| โ
|
| OWL-ViT | โ | โ | โ
| โ | โ |
| Pegasus | โ
| โ
| โ
| โ
| โ
|
| PEGASUS-X | โ | โ | โ
| โ | โ |
| Perceiver | โ
| โ | โ
| โ | โ |
| PLBart | โ
| โ | โ
| โ | โ |
| PoolFormer | โ | โ | โ
| โ | โ |
| ProphetNet | โ
| โ | โ
| โ | โ |
| QDQBert | โ | โ | โ
| โ | โ |
| RAG | โ
| โ | โ
| โ
| โ |
| REALM | โ
| โ
| โ
| โ | โ |
| Reformer | โ
| โ
| โ
| โ | โ |
| RegNet | โ | โ | โ
| โ
| โ
|
| RemBERT | โ
| โ
| โ
| โ
| โ |
| ResNet | โ | โ | โ
| โ
| โ |
| RetriBERT | โ
| โ
| โ
| โ | โ |
| RoBERTa | โ
| โ
| โ
| โ
| โ
|
| RoBERTa-PreLayerNorm | โ | โ | โ
| โ
| โ
|
| RoCBert | โ
| โ | โ
| โ | โ |
| RoFormer | โ
| โ
| โ
| โ
| โ
|
| SegFormer | โ | โ | โ
| โ
| โ |
| SEW | โ | โ | โ
| โ | โ |
| SEW-D | โ | โ | โ
| โ | โ |
| Speech Encoder decoder | โ | โ | โ
| โ | โ
|
| Speech2Text | โ
| โ | โ
| โ
| โ |
| Speech2Text2 | โ
| โ | โ | โ | โ |
| SpeechT5 | โ
| โ | โ
| โ | โ |
| Splinter | โ
| โ
| โ
| โ | โ |
| SqueezeBERT | โ
| โ
| โ
| โ | โ |
| Swin Transformer | โ | โ | โ
| โ
| โ |
| Swin Transformer V2 | โ | โ | โ
| โ | โ |
| Swin2SR | โ | โ | โ
| โ | โ |
| SwitchTransformers | โ | โ | โ
| โ | โ |
| T5 | โ
| โ
| โ
| โ
| โ
|
| Table Transformer | โ | โ | โ
| โ | โ |
| TAPAS | โ
| โ | โ
| โ
| โ |
| Time Series Transformer | โ | โ | โ
| โ | โ |
| TimeSformer | โ | โ | โ
| โ | โ |
| Trajectory Transformer | โ | โ | โ
| โ | โ |
| Transformer-XL | โ
| โ | โ
| โ
| โ |
| TrOCR | โ | โ | โ
| โ | โ |
| UniSpeech | โ | โ | โ
| โ | โ |
| UniSpeechSat | โ | โ | โ
| โ | โ |
| UPerNet | โ | โ | โ
| โ | โ |
| VAN | โ | โ | โ
| โ | โ |
| VideoMAE | โ | โ | โ
| โ | โ |
| ViLT | โ | โ | โ
| โ | โ |
| Vision Encoder decoder | โ | โ | โ
| โ
| โ
|
| VisionTextDualEncoder | โ | โ | โ
| โ | โ
|
| VisualBERT | โ | โ | โ
| โ | โ |
| ViT | โ | โ | โ
| โ
| โ
|
| ViT Hybrid | โ | โ | โ
| โ | โ |
| ViTMAE | โ | โ | โ
| โ
| โ |
| ViTMSN | โ | โ | โ
| โ | โ |
| Wav2Vec2 | โ
| โ | โ
| โ
| โ
|
| Wav2Vec2-Conformer | โ | โ | โ
| โ | โ |
| WavLM | โ | โ | โ
| โ | โ |
| Whisper | โ
| โ | โ
| โ
| โ |
| X-CLIP | โ | โ | โ
| โ | โ |
| XGLM | โ
| โ
| โ
| โ
| โ
|
| XLM | โ
| โ | โ
| โ
| โ |
| XLM-ProphetNet | โ
| โ | โ
| โ | โ |
| XLM-RoBERTa | โ
| โ
| โ
| โ
| โ
|
| XLM-RoBERTa-XL | โ | โ | โ
| โ | โ |
| XLNet | โ
| โ
| โ
| โ
| โ |
| YOLOS | โ | โ | โ
| โ | โ |
| YOSO | โ | โ | โ
| โ | โ |
<!-- End table-->
| 0 |
mavonic_private_repos/transformers/docs/source | mavonic_private_repos/transformers/docs/source/fr/in_translation.md | <!--โ ๏ธ Note that this file is in Markdown but contain specific syntax for our doc-builder (similar to MDX) that may not be
rendered properly in your Markdown viewer.
-->
# Traduction en cours. | 0 |
mavonic_private_repos/transformers/docs/source | mavonic_private_repos/transformers/docs/source/fr/installation.md | <!---
Copyright 2022 The HuggingFace Team. All rights reserved.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
-->
# Installation
Installez ๐ค Transformers pour n'importe quelle librairie d'apprentissage profond avec laquelle vous avez l'habitude de travaillez, configurez votre cache et configurez ๐ค Transformers pour un usage hors ligne (facultatif).
๐ค Transformers est testรฉ avec Python 3.6+, PyTorch 1.1.0+, TensorFlow 2.0+ et Flax.
Consulter les instructions d'installation ci-dessous pour la librairie d'apprentissage profond que vous utilisez:
* Instructions d'installation pour [PyTorch](https://pytorch.org/get-started/locally/).
* Instructions d'installation pour [TensorFlow 2.0](https://www.tensorflow.org/install/pip).
* Instructions d'installation pour [Flax](https://flax.readthedocs.io/en/latest/).
## Installation avec pip
Vous devriez installer ๐ค Transformers dans un [environnement virtuel](https://docs.python.org/3/library/venv.html).
Si vous n'รชtes pas ร l'aise avec les environnements virtuels, consultez ce [guide](https://packaging.python.org/guides/installing-using-pip-and-virtual-environments/).
Utiliser un environnement virtuel permet de facilement gรฉrer diffรฉrents projets et d'รฉviter des erreurs de compatibilitรฉ entre les diffรฉrentes dรฉpendances.
Commencez par crรฉer un environnement virtuel dans l'espace de travail de votre projet :
```bash
python -m venv .env
```
Activez l'environnement virtuel. Sur Linux ou MacOs :
```bash
source .env/bin/activate
```
Activez l'environnement virtuel sur Windows :
```bash
.env/Scripts/activate
```
Maintenant, ๐ค Transformers peut รชtre installรฉ avec la commande suivante :
```bash
pip install transformers
```
Pour une utilisation avec CPU seulement, ๐ค Transformers et la librairie d'apprentissage profond de votre choix peuvent รชtre installรฉs en une seule ligne.
Par exemple, installez ๐ค Transformers et PyTorch avec la commande suivante :
```bash
pip install 'transformers[torch]'
```
๐ค Transformers et TensorFlow 2.0 :
```bash
pip install 'transformers[tf-cpu]'
```
<Tip warning={true}>
Pour les architectures mac M1 / ARM
Vous devez installer les outils suivants avant d'installer TensorFLow 2.0
```bash
brew install cmake
brew install pkg-config
```
</Tip>
๐ค Transformers et Flax :
```bash
pip install 'transformers[flax]'
```
Vรฉrifiez que ๐ค Transformers a bien รฉtรฉ installรฉ avec la commande suivante. La commande va tรฉlรฉcharger un modรจle prรฉ-entraรฎnรฉ :
```bash
python -c "from transformers import pipeline; print(pipeline('sentiment-analysis')('we love you'))"
```
Le label et score sont ensuite affichรฉs :
```bash
[{'label': 'POSITIVE', 'score': 0.9998704791069031}]
```
## Installation depuis le code source
Installez ๐ค Transformers depuis le code source avec la commande suivante :
```bash
pip install git+https://github.com/huggingface/transformers
```
Cette commande installe la version depuis la branche `main` au lieu de la derniรจre version stable. La version de la branche `main` est utile pour avoir les derniers dรฉveloppements. Par exemple, si un bug a รฉtรฉ rรฉsolu depuis la derniรจre version stable mais n'a pas encore รฉtรฉ publiรฉ officiellement. Cependant, cela veut aussi dire que la version de la branche `main` n'est pas toujours stable. Nous nous efforรงons de maintenir la version de la branche `main` opรฉrationnelle, et la plupart des problรจmes sont gรฉnรฉralement rรฉsolus en l'espace de quelques heures ou d'un jour. Si vous recontrez un problรจme, n'hรฉsitez pas ร crรฉer une [Issue](https://github.com/huggingface/transformers/issues) pour que l'on puisse trouver une solution au plus vite !
Vรฉrifiez que ๐ค Transformers a bien รฉtรฉ installรฉ avec la commande suivante :
```bash
python -c "from transformers import pipeline; print(pipeline('sentiment-analysis')('I love you'))"
```
## Installation modifiable
Vous aurez besoin d'une installation modifiable si vous le souhaitez :
* Utiliser la version de la branche `main` du code source.
* Contribuer ร ๐ค Transformers et vouler tester vos modifications du code source.
Clonez le projet et installez ๐ค Transformers avec les commandes suivantes :
```bash
git clone https://github.com/huggingface/transformers.git
cd transformers
pip install -e .
```
Ces commandes crรฉent des liens entre le dossier oรน le projet a รฉtรฉ clonรฉ et les chemins de vos librairies Python. Python regardera maintenant dans le dossier que vous avez clonรฉ en plus des dossiers oรน sont installรฉes vos autres librairies. Par exemple, si vos librairies Python sont installรฉes dans `~/anaconda3/envs/main/lib/python3.7/site-packages/`, Python cherchera aussi dans le dossier oรน vous avez clonรฉ : `~/transformers/`.
<Tip warning={true}>
Vous devez garder le dossier `transformers` si vous voulez continuer d'utiliser la librairie.
</Tip>
Maintenant, vous pouvez facilement mettre ร jour votre clone avec la derniรจre version de ๐ค Transformers en utilisant la commande suivante :
```bash
cd ~/transformers/
git pull
```
Votre environnement Python utilisera la version de la branche `main` lors de la prochaine exรฉcution.
## Installation avec conda
Installation via le canal `conda-forge` de conda :
```bash
conda install conda-forge::transformers
```
## Configuration du cache
Les modรจles prรฉ-entraรฎnรฉs sont tรฉlรฉchargรฉs et mis en cache localement dans le dossier suivant : `~/.cache/huggingface/hub`. C'est le dossier par dรฉfaut donnรฉ par la variable d'environnement `TRANSFORMERS_CACHE`. Sur Windows, le dossier par dรฉfaut est `C:\Users\nom_utilisateur\.cache\huggingface\hub`. Vous pouvez modifier les variables d'environnement indiquรฉes ci-dessous - par ordre de prioritรฉ - pour spรฉcifier un dossier de cache diffรฉrent :
1. Variable d'environnement (par dรฉfaut) : `HUGGINGFACE_HUB_CACHE` ou `TRANSFORMERS_CACHE`.
2. Variable d'environnement : `HF_HOME`.
3. Variable d'environnement : `XDG_CACHE_HOME` + `/huggingface`.
<Tip>
๐ค Transformers utilisera les variables d'environnement `PYTORCH_TRANSFORMERS_CACHE` ou `PYTORCH_PRETRAINED_BERT_CACHE` si vous utilisez une version prรฉcรฉdente de cette librairie et avez dรฉfini ces variables d'environnement, sauf si vous spรฉcifiez la variable d'environnement `TRANSFORMERS_CACHE`.
</Tip>
## Mode hors ligne
๐ค Transformers peut fonctionner dans un environnement cloisonnรฉ ou hors ligne en n'utilisant que des fichiers locaux. Dรฉfinissez la variable d'environnement `TRANSFORMERS_OFFLINE=1` pour activer ce mode.
<Tip>
Ajoutez [๐ค Datasets](https://huggingface.co/docs/datasets/) ร votre processus d'entraรฎnement hors ligne en dรฉfinissant la variable d'environnement `HF_DATASETS_OFFLINE=1`.
</Tip>
```bash
HF_DATASETS_OFFLINE=1 TRANSFORMERS_OFFLINE=1 \
python examples/pytorch/translation/run_translation.py --model_name_or_path google-t5/t5-small --dataset_name wmt16 --dataset_config ro-en ...
```
Le script devrait maintenant s'exรฉcuter sans rester en attente ou attendre une expiration, car il n'essaiera pas de tรฉlรฉcharger des modรจle sur le Hub.
Vous pouvez aussi รฉviter de tรฉlรฉcharger un modรจle ร chaque appel de la fonction [`~PreTrainedModel.from_pretrained`] en utilisant le paramรจtre [local_files_only]. Seuls les fichiers locaux sont chargรฉs lorsque ce paramรจtre est activรฉ (c.-ร -d. `local_files_only=True`) :
```py
from transformers import T5Model
model = T5Model.from_pretrained("./path/to/local/directory", local_files_only=True)
```
### Rรฉcupรฉrer des modรจles et des tokenizers pour une utilisation hors ligne
Une autre option pour utiliser ๐ค Transformers hors ligne est de tรฉlรฉcharger les fichiers ร l'avance, puis d'utiliser les chemins locaux lorsque vous en avez besoin en mode hors ligne. Il existe trois faรงons de faire cela :
* Tรฉlรฉchargez un fichier via l'interface utilisateur sur le [Model Hub](https://huggingface.co/models) en cliquant sur l'icรดne โ.
* Utilisez les fonctions [`PreTrainedModel.from_pretrained`] et [`PreTrainedModel.save_pretrained`] :
1. Tรฉlรฉchargez vos fichiers ร l'avance avec [`PreTrainedModel.from_pretrained`]:
```py
>>> from transformers import AutoTokenizer, AutoModelForSeq2SeqLM
>>> tokenizer = AutoTokenizer.from_pretrained("bigscience/T0_3B")
>>> model = AutoModelForSeq2SeqLM.from_pretrained("bigscience/T0_3B")
```
2. Sauvegardez les fichiers dans un dossier de votre choix avec [`PreTrainedModel.save_pretrained`]:
```py
>>> tokenizer.save_pretrained("./your/path/bigscience_t0")
>>> model.save_pretrained("./your/path/bigscience_t0")
```
3. Maintenant, lorsque vous รชtes hors ligne, rechargez vos fichiers avec [`PreTrainedModel.from_pretrained`] depuis le dossier oรน vous les avez sauvegardรฉs :
```py
>>> tokenizer = AutoTokenizer.from_pretrained("./your/path/bigscience_t0")
>>> model = AutoModel.from_pretrained("./your/path/bigscience_t0")
```
* Tรฉlรฉchargez des fichiers de maniรจre automatique avec la librairie [huggingface_hub](https://github.com/huggingface/huggingface_hub/tree/main/src/huggingface_hub) :
1. Installez la librairie `huggingface_hub` dans votre environnement virtuel :
```bash
python -m pip install huggingface_hub
```
2. Utilisez la fonction [`hf_hub_download`](https://huggingface.co/docs/hub/adding-a-library#download-files-from-the-hub) pour tรฉlรฉcharger un fichier vers un chemin de votre choix. Par exemple, la commande suivante tรฉlรฉcharge le fichier `config.json` du modรจle [T0](https://huggingface.co/bigscience/T0_3B) vers le chemin de votre choix :
```py
>>> from huggingface_hub import hf_hub_download
>>> hf_hub_download(repo_id="bigscience/T0_3B", filename="config.json", cache_dir="./your/path/bigscience_t0")
```
Une fois que votre fichier est tรฉlรฉchargรฉ et cachรฉ localement, spรฉcifiez son chemin local pour le charger et l'utiliser :
```py
>>> from transformers import AutoConfig
>>> config = AutoConfig.from_pretrained("./your/path/bigscience_t0/config.json")
```
<Tip>
Consultez la section [How to download files from the Hub (Comment tรฉlรฉcharger des fichiers depuis le Hub)](https://huggingface.co/docs/hub/how-to-downstream) pour plus de dรฉtails sur le tรฉlรฉchargement de fichiers stockรฉs sur le Hub.
</Tip>
| 0 |
mavonic_private_repos/transformers/docs/source | mavonic_private_repos/transformers/docs/source/fr/quicktour.md | <!--Copyright 2022 The HuggingFace Team. All rights reserved.
Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
the License. You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
specific language governing permissions and limitations under the License.
โ ๏ธ Note that this file is in Markdown but contain specific syntax for our doc-builder (similar to MDX) that may not be
rendered properly in your Markdown viewer.
-->
# Visite rapide
[[open-in-colab]]
Soyez opรฉrationnel avec ๐ค Transformers ! Que vous soyez un dรฉveloppeur ou un utilisateur lambda, cette visite rapide vous aidera ร dรฉmarrer et vous montrera comment utiliser le [`pipeline`] pour l'infรฉrence, charger un modรจle prรฉ-entraรฎnรฉ et un prรฉprocesseur avec une [AutoClass](./model_doc/auto), et entraรฎner rapidement un modรจle avec PyTorch ou TensorFlow. Si vous รชtes un dรฉbutant, nous vous recommandons de consulter nos tutoriels ou notre [cours](https://huggingface.co/course/chapter1/1) suivant pour des explications plus approfondies des concepts prรฉsentรฉs ici.
Avant de commencer, assurez-vous que vous avez installรฉ toutes les bibliothรจques nรฉcessaires :
```bash
!pip install transformers datasets evaluate accelerate
```
Vous aurez aussi besoin d'installer votre bibliothรจque d'apprentissage profond favorite :
<frameworkcontent>
<pt>
```bash
pip install torch
```
</pt>
<tf>
```bash
pip install tensorflow
```
</tf>
</frameworkcontent>
## Pipeline
<Youtube id="tiZFewofSLM"/>
Le [`pipeline`] est le moyen le plus simple d'utiliser un modรจle prรฉ-entraรฎnรฉ pour l'infรฉrence. Vous pouvez utiliser le [`pipeline`] prรชt ร l'emploi pour de nombreuses tรขches dans diffรฉrentes modalitรฉs. Consultez le tableau ci-dessous pour connaรฎtre les tรขches prises en charge :
| **Tรขche** | **Description** | **Modalitรฉ** | **Identifiant du pipeline** |
|------------------------------|--------------------------------------------------------------------------------------------------------------|----------------------|-----------------------------------------------|
| Classification de texte | Attribue une catรฉgorie ร une sรฉquence de texte donnรฉe | Texte | pipeline(task="sentiment-analysis") |
| Gรฉnรฉration de texte | Gรฉnรจre du texte ร partir d'une consigne donnรฉe | Texte | pipeline(task="text-generation") |
| Reconnaissance de token nommรฉ | Attribue une catรฉgorie ร chaque token dans une sรฉquence (personnes, organisation, localisation, etc.) | Texte | pipeline(task="ner") |
| Question rรฉponse | Extrait une rรฉponse du texte en fonction du contexte et d'une question | Texte | pipeline(task="question-answering") |
| Prรฉdiction de token masquรฉ | Prรฉdit correctement le token masquรฉ dans une sรฉquence | Texte | pipeline(task="fill-mask") |
| Gรฉnรฉration de rรฉsumรฉ | Gรฉnรจre un rรฉsumรฉ d'une sรฉquence de texte donnรฉe ou d'un document | Texte | pipeline(task="summarization") |
| Traduction | Traduit du texte d'un langage ร un autre | Texte | pipeline(task="translation") |
| Classification d'image | Attribue une catรฉgorie ร une image | Image | pipeline(task="image-classification") |
| Segmentation d'image | Attribue une catรฉgorie ร chaque pixel d'une image (supporte la segmentation sรฉmantique, panoptique et d'instance) | Image | pipeline(task="image-segmentation") |
| Dรฉtection d'objets | Prรฉdit les dรฉlimitations et catรฉgories d'objets dans une image | Image | pipeline(task="object-detection") |
| Classification d'audio | Attribue une catรฉgorie ร un fichier audio | Audio | pipeline(task="audio-classification") |
| Reconnaissance automatique de la parole | Extrait le discours d'un fichier audio en texte | Audio | pipeline(task="automatic-speech-recognition") |
| Question rรฉponse visuels | Etant donnรฉes une image et une question, rรฉpond correctement ร une question sur l'image | Modalitรฉs multiples | pipeline(task="vqa") |
Commencez par crรฉer une instance de [`pipeline`] et spรฉcifiez la tรขche pour laquelle vous souhaitez l'utiliser. Vous pouvez utiliser le [`pipeline`] pour n'importe laquelle des tรขches mentionnรฉes dans le tableau prรฉcรฉdent. Pour obtenir une liste complรจte des tรขches prises en charge, consultez la documentation de l'[API pipeline](./main_classes/pipelines). Dans ce guide, nous utiliserons le [`pipeline`] pour l'analyse des sentiments ร titre d'exemple :
```py
>>> from transformers import pipeline
>>> classifier = pipeline("sentiment-analysis")
```
Le [`pipeline`] tรฉlรฉcharge et stocke en cache un [modรจle prรฉ-entraรฎnรฉ](https://huggingface.co/distilbert/distilbert-base-uncased-finetuned-sst-2-english) et un tokenizer par dรฉfaut pour l'analyse des sentiments. Vous pouvez maintenant utiliser le `classifier` sur le texte de votre choix :
```py
>>> classifier("We are very happy to show you the ๐ค Transformers library.")
[{'label': 'POSITIVE', 'score': 0.9998}]
```
Si vous voulez classifier plus qu'un texte, donnez une liste de textes au [`pipeline`] pour obtenir une liste de dictionnaires en retour :
```py
>>> results = classifier(["We are very happy to show you the ๐ค Transformers library.", "We hope you don't hate it."])
>>> for result in results:
... print(f"label: {result['label']}, avec le score de: {round(result['score'], 4)}")
label: POSITIVE, avec le score de: 0.9998
label: NEGATIVE, avec le score de: 0.5309
```
Le [`pipeline`] peut aussi itรฉrer sur un jeu de donnรฉes entier pour n'importe quelle tรขche. Prenons par exemple la reconnaissance automatique de la parole :
```py
>>> import torch
>>> from transformers import pipeline
>>> speech_recognizer = pipeline("automatic-speech-recognition", model="facebook/wav2vec2-base-960h")
```
Chargez un jeu de donnรฉes audio (voir le ๐ค Datasets [Quick Start](https://huggingface.co/docs/datasets/quickstart#audio) pour plus de dรฉtails) sur lequel vous souhaitez itรฉrer. Pour cet exemple, nous chargeons le jeu de donnรฉes [MInDS-14](https://huggingface.co/datasets/PolyAI/minds14) :
```py
>>> from datasets import load_dataset, Audio
>>> dataset = load_dataset("PolyAI/minds14", name="en-US", split="train") # doctest: +IGNORE_RESULT
```
Vous devez vous assurer que le taux d'รฉchantillonnage de l'ensemble de donnรฉes correspond au taux d'รฉchantillonnage sur lequel [`facebook/wav2vec2-base-960h`](https://huggingface.co/facebook/wav2vec2-base-960h) a รฉtรฉ entraรฎnรฉ :
```py
>>> dataset = dataset.cast_column("audio", Audio(sampling_rate=speech_recognizer.feature_extractor.sampling_rate))
```
Les fichiers audio sont automatiquement chargรฉs et rรฉรฉchantillonnรฉs lors de l'appel de la colonne `"audio"`.
Extrayez les tableaux de formes d'ondes brutes des quatre premiers รฉchantillons et passez-les comme une liste au pipeline :
```py
>>> result = speech_recognizer(dataset[:4]["audio"])
>>> print([d["text"] for d in result])
['I WOULD LIKE TO SET UP A JOINT ACCOUNT WITH MY PARTNER HOW DO I PROCEED WITH DOING THAT', "FODING HOW I'D SET UP A JOIN TO HET WITH MY WIFE AND WHERE THE AP MIGHT BE", "I I'D LIKE TOY SET UP A JOINT ACCOUNT WITH MY PARTNER I'M NOT SEEING THE OPTION TO DO IT ON THE AP SO I CALLED IN TO GET SOME HELP CAN I JUST DO IT OVER THE PHONE WITH YOU AND GIVE YOU THE INFORMATION OR SHOULD I DO IT IN THE AP AND I'M MISSING SOMETHING UQUETTE HAD PREFERRED TO JUST DO IT OVER THE PHONE OF POSSIBLE THINGS", 'HOW DO I THURN A JOIN A COUNT']
```
Pour les ensembles de donnรฉes plus importants oรน les entrรฉes sont volumineuses (comme dans les domaines de la parole ou de la vision), utilisez plutรดt un gรฉnรฉrateur au lieu d'une liste pour charger toutes les entrรฉes en mรฉmoire. Pour plus d'informations, consultez la documentation de l'[API pipeline](./main_classes/pipelines).
### Utiliser une autre modรจle et tokenizer dans le pipeline
Le [`pipeline`] peut รชtre utilisรฉ avec n'importe quel modรจle du [Hub](https://huggingface.co/models), ce qui permet d'adapter facilement le [`pipeline`] ร d'autres cas d'utilisation. Par exemple, si vous souhaitez un modรจle capable de traiter du texte franรงais, utilisez les filtres du Hub pour trouver un modรจle appropriรฉ. Le premier rรฉsultat renvoie un [modรจle BERT](https://huggingface.co/nlptown/bert-base-multilingual-uncased-sentiment) multilingue finetunรฉ pour l'analyse des sentiments que vous pouvez utiliser pour le texte franรงais :
```py
>>> model_name = "nlptown/bert-base-multilingual-uncased-sentiment"
```
<frameworkcontent>
<pt>
Utilisez [`AutoModelForSequenceClassification`] et [`AutoTokenizer`] pour charger le modรจle prรฉ-entraรฎnรฉ et le tokenizer adaptรฉ (plus de dรฉtails sur une `AutoClass` dans la section suivante) :
```py
>>> from transformers import AutoTokenizer, AutoModelForSequenceClassification
>>> model = AutoModelForSequenceClassification.from_pretrained(model_name)
>>> tokenizer = AutoTokenizer.from_pretrained(model_name)
```
</pt>
<tf>
Utilisez [`TFAutoModelForSequenceClassification`] et [`AutoTokenizer`] pour charger le modรจle prรฉ-entraรฎnรฉ et le tokenizer adaptรฉ (plus de dรฉtails sur une `TFAutoClass` dans la section suivante) :
```py
>>> from transformers import AutoTokenizer, TFAutoModelForSequenceClassification
>>> model = TFAutoModelForSequenceClassification.from_pretrained(model_name)
>>> tokenizer = AutoTokenizer.from_pretrained(model_name)
```
</tf>
</frameworkcontent>
Spรฉcifiez le modรจle et le tokenizer dans le [`pipeline`], et utilisez le `classifier` sur le texte en franรงais :
```py
>>> classifier = pipeline("sentiment-analysis", model=model, tokenizer=tokenizer)
>>> classifier("Nous sommes trรจs heureux de vous prรฉsenter la bibliothรจque ๐ค Transformers.")
[{'label': '5 stars', 'score': 0.7273}]
```
Si vous ne parvenez pas ร trouver un modรจle adaptรฉ ร votre cas d'utilisation, vous devrez finetuner un modรจle prรฉ-entraรฎnรฉ sur vos donnรฉes. Jetez un coup d'ลil ร notre [tutoriel sur le finetuning](./training) pour apprendre comment faire. Enfin, aprรจs avoir finetunรฉ votre modรจle prรฉ-entraรฎnรฉ, pensez ร [partager](./model_sharing) le modรจle avec la communautรฉ sur le Hub afin de dรฉmocratiser l'apprentissage automatique pour tous ! ๐ค
## AutoClass
<Youtube id="AhChOFRegn4"/>
Les classes [`AutoModelForSequenceClassification`] et [`AutoTokenizer`] fonctionnent ensemble pour crรฉer un [`pipeline`] comme celui que vous avez utilisรฉ ci-dessus. Une [AutoClass](./model_doc/auto) est un raccourci qui rรฉcupรจre automatiquement l'architecture d'un modรจle prรฉ-entraรฎnรฉ ร partir de son nom ou de son emplacement. Il vous suffit de sรฉlectionner l'`AutoClass` appropriรฉe ร votre tรขche et la classe de prรฉtraitement qui lui est associรฉe.
Reprenons l'exemple de la section prรฉcรฉdente et voyons comment vous pouvez utiliser l'`AutoClass` pour reproduire les rรฉsultats du [`pipeline`].
### AutoTokenizer
Un tokenizer est chargรฉ de prรฉtraiter le texte pour en faire un tableau de chiffres qui servira d'entrรฉe ร un modรจle. De nombreuses rรจgles rรฉgissent le processus de tokenisation, notamment la maniรจre de diviser un mot et le niveau auquel les mots doivent รชtre divisรฉs (pour en savoir plus sur la tokenisation, consultez le [rรฉsumรฉ](./tokenizer_summary)). La chose la plus importante ร retenir est que vous devez instancier un tokenizer avec le mรชme nom de modรจle pour vous assurer que vous utilisez les mรชmes rรจgles de tokenisation que celles avec lesquelles un modรจle a รฉtรฉ prรฉ-entraรฎnรฉ.
Chargez un tokenizer avec [`AutoTokenizer`] :
```py
>>> from transformers import AutoTokenizer
>>> model_name = "nlptown/bert-base-multilingual-uncased-sentiment"
>>> tokenizer = AutoTokenizer.from_pretrained(model_name)
```
Passez votre texte au tokenizer :
```py
>>> encoding = tokenizer("We are very happy to show you the ๐ค Transformers library.")
>>> print(encoding)
{'input_ids': [101, 11312, 10320, 12495, 19308, 10114, 11391, 10855, 10103, 100, 58263, 13299, 119, 102],
'token_type_ids': [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
'attention_mask': [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]}
```
Le tokenizer retourne un dictionnaire contenant :
* [input_ids](./glossary#input-ids): la reprรฉsentation numรฉrique des tokens.
* [attention_mask](.glossary#attention-mask): indique quels tokens doivent faire l'objet d'une attention particuliรจre (plus particuliรจrement les tokens de remplissage).
Un tokenizer peut รฉgalement accepter une liste de textes, et remplir et tronquer le texte pour retourner un รฉchantillon de longueur uniforme :
<frameworkcontent>
<pt>
```py
>>> pt_batch = tokenizer(
... ["We are very happy to show you the ๐ค Transformers library.", "We hope you don't hate it."],
... padding=True,
... truncation=True,
... max_length=512,
... return_tensors="pt",
... )
```
</pt>
<tf>
```py
>>> tf_batch = tokenizer(
... ["We are very happy to show you the ๐ค Transformers library.", "We hope you don't hate it."],
... padding=True,
... truncation=True,
... max_length=512,
... return_tensors="tf",
... )
```
</tf>
</frameworkcontent>
<Tip>
Consultez le tutoriel [prรฉtraitement](./preprocessing) pour plus de dรฉtails sur la tokenisation, et sur la maniรจre d'utiliser un [`AutoImageProcessor`], un [`AutoFeatureExtractor`] et un [`AutoProcessor`] pour prรฉtraiter les images, l'audio et les contenus multimodaux.
</Tip>
### AutoModel
<frameworkcontent>
<pt>
๐ค Transformers fournit un moyen simple et unifiรฉ de charger des instances prรฉ-entraรฎnรฉes. Cela signifie que vous pouvez charger un [`AutoModel`] comme vous chargeriez un [`AutoTokenizer`]. La seule diffรฉrence est de sรฉlectionner l'[`AutoModel`] appropriรฉ pour la tรขche. Pour une classification de texte (ou de sรฉquence de textes), vous devez charger [`AutoModelForSequenceClassification`] :
```py
>>> from transformers import AutoModelForSequenceClassification
>>> model_name = "nlptown/bert-base-multilingual-uncased-sentiment"
>>> pt_model = AutoModelForSequenceClassification.from_pretrained(model_name)
```
<Tip>
Voir le [rรฉsumรฉ de la tรขche](./task_summary) pour vรฉrifier si elle est prise en charge par une classe [`AutoModel`].
</Tip>
Maintenant, passez votre รฉchantillon d'entrรฉes prรฉtraitรฉes directement au modรจle. Il vous suffit de dรฉcompresser le dictionnaire en ajoutant `**` :
```py
>>> pt_outputs = pt_model(**pt_batch)
```
Le modรจle produit les activations finales dans l'attribut `logits`. Appliquez la fonction softmax aux `logits` pour rรฉcupรฉrer les probabilitรฉs :
```py
>>> from torch import nn
>>> pt_predictions = nn.functional.softmax(pt_outputs.logits, dim=-1)
>>> print(pt_predictions)
tensor([[0.0021, 0.0018, 0.0115, 0.2121, 0.7725],
[0.2084, 0.1826, 0.1969, 0.1755, 0.2365]], grad_fn=<SoftmaxBackward0>)
```
</pt>
<tf>
๐ค Transformers fournit un moyen simple et unifiรฉ de charger des instances prรฉ-entraรฎnรฉs. Cela signifie que vous pouvez charger un [`TFAutoModel`] comme vous chargeriez un [`AutoTokenizer`]. La seule diffรฉrence est de sรฉlectionner le [`TFAutoModel`] appropriรฉ pour la tรขche. Pour une classification de texte (ou de sรฉquence de textes), vous devez charger [`TFAutoModelForSequenceClassification`] :
```py
>>> from transformers import TFAutoModelForSequenceClassification
>>> model_name = "nlptown/bert-base-multilingual-uncased-sentiment"
>>> tf_model = TFAutoModelForSequenceClassification.from_pretrained(model_name)
```
<Tip>
Voir le [rรฉsumรฉ de la tรขche](./task_summary) pour vรฉrifier si elle est prise en charge par une classe [`AutoModel`].
</Tip>
Passez maintenant votre รฉchantillon d'entrรฉes prรฉtraitรฉes directement au modรจle en passant les clรฉs du dictionnaire directement aux tensors :
```py
>>> tf_outputs = tf_model(tf_batch)
```
Le modรจle produit les activations finales dans l'attribut `logits`. Appliquez la fonction softmax aux `logits` pour rรฉcupรฉrer les probabilitรฉs :
```py
>>> import tensorflow as tf
>>> tf_predictions = tf.nn.softmax(tf_outputs.logits, axis=-1)
>>> tf_predictions # doctest: +IGNORE_RESULT
```
</tf>
</frameworkcontent>
<Tip>
Tous les modรจles ๐ค Transformers (PyTorch ou TensorFlow) produisent les tensors *avant* la fonction d'activation finale (comme softmax) car la fonction d'activation finale est souvent fusionnรฉe avec le calcul de la perte. Les structures produites par le modรจle sont des classes de donnรฉes spรฉciales, de sorte que leurs attributs sont autocomplรฉtรฉs dans un environnement de dรฉveloppement. Les structures produites par le modรจle se comportent comme un tuple ou un dictionnaire (vous pouvez les indexer avec un entier, une tranche ou une chaรฎne), auquel cas les attributs qui sont None sont ignorรฉs.
</Tip>
### Sauvegarder un modรจle
<frameworkcontent>
<pt>
Une fois que votre modรจle est finetunรฉ, vous pouvez le sauvegarder avec son tokenizer en utilisant [`PreTrainedModel.save_pretrained`] :
```py
>>> pt_save_directory = "./pt_save_pretrained"
>>> tokenizer.save_pretrained(pt_save_directory) # doctest: +IGNORE_RESULT
>>> pt_model.save_pretrained(pt_save_directory)
```
Lorsque vous voulez rรฉutiliser le modรจle, rechargez-le avec [`PreTrainedModel.from_pretrained`] :
```py
>>> pt_model = AutoModelForSequenceClassification.from_pretrained("./pt_save_pretrained")
```
</pt>
<tf>
Une fois que votre modรจle est finetunรฉ, vous pouvez le sauvegarder avec son tokenizer en utilisant [`TFPreTrainedModel.save_pretrained`] :
```py
>>> tf_save_directory = "./tf_save_pretrained"
>>> tokenizer.save_pretrained(tf_save_directory) # doctest: +IGNORE_RESULT
>>> tf_model.save_pretrained(tf_save_directory)
```
Lorsque vous voulez rรฉutiliser le modรจle, rechargez-le avec [`TFPreTrainedModel.from_pretrained`] :
```py
>>> tf_model = TFAutoModelForSequenceClassification.from_pretrained("./tf_save_pretrained")
```
</tf>
</frameworkcontent>
Une fonctionnalitรฉ particuliรจrement cool ๐ค Transformers est la possibilitรฉ d'enregistrer un modรจle et de le recharger en tant que modรจle PyTorch ou TensorFlow. Le paramรจtre `from_pt` ou `from_tf` permet de convertir le modรจle d'un framework ร l'autre :
<frameworkcontent>
<pt>
```py
>>> from transformers import AutoModel
>>> tokenizer = AutoTokenizer.from_pretrained(tf_save_directory)
>>> pt_model = AutoModelForSequenceClassification.from_pretrained(tf_save_directory, from_tf=True)
```
</pt>
<tf>
```py
>>> from transformers import TFAutoModel
>>> tokenizer = AutoTokenizer.from_pretrained(pt_save_directory)
>>> tf_model = TFAutoModelForSequenceClassification.from_pretrained(pt_save_directory, from_pt=True)
```
</tf>
</frameworkcontent>
## Constructions de modรจles personnalisรฉs
Vous pouvez modifier la configuration du modรจle pour changer la faรงon dont un modรจle est construit. La configuration spรฉcifie les attributs d'un modรจle, tels que le nombre de couches ou de tรชtes d'attention. Vous partez de zรฉro lorsque vous initialisez un modรจle ร partir d'une configuration personnalisรฉe. Les attributs du modรจle sont initialisรฉs de maniรจre alรฉatoire et vous devrez entraรฎner le modรจle avant de pouvoir l'utiliser pour obtenir des rรฉsultats significatifs.
Commencez par importer [`AutoConfig`], puis chargez le modรจle prรฉ-entraรฎnรฉ que vous voulez modifier. Dans [`AutoConfig.from_pretrained`], vous pouvez spรฉcifier l'attribut que vous souhaitez modifier, tel que le nombre de tรชtes d'attention :
```py
>>> from transformers import AutoConfig
>>> my_config = AutoConfig.from_pretrained("distilbert/distilbert-base-uncased", n_heads=12)
```
<frameworkcontent>
<pt>
Crรฉez un modรจle personnalisรฉ ร partir de votre configuration avec [`AutoModel.from_config`] :
```py
>>> from transformers import AutoModel
>>> my_model = AutoModel.from_config(my_config)
```
</pt>
<tf>
Crรฉez un modรจle personnalisรฉ ร partir de votre configuration avec [`TFAutoModel.from_config`] :
```py
>>> from transformers import TFAutoModel
>>> my_model = TFAutoModel.from_config(my_config)
```
</tf>
</frameworkcontent>
Consultez le guide [Crรฉer une architecture personnalisรฉe](./create_a_model) pour plus d'informations sur la crรฉation de configurations personnalisรฉes.
## Trainer - une boucle d'entraรฎnement optimisรฉe par PyTorch
Tous les modรจles sont des [`torch.nn.Module`](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) standard, vous pouvez donc les utiliser dans n'importe quelle boucle d'entraรฎnement typique. Bien que vous puissiez รฉcrire votre propre boucle d'entraรฎnement, ๐ค Transformers fournit une classe [`Trainer`] pour PyTorch, qui contient la boucle d'entraรฎnement de base et ajoute des fonctionnalitรฉs supplรฉmentaires comme l'entraรฎnement distribuรฉ, la prรฉcision mixte, et plus encore.
En fonction de votre tรขche, vous passerez gรฉnรฉralement les paramรจtres suivants ร [`Trainer`] :
1. Un [`PreTrainedModel`] ou un [`torch.nn.Module`](https://pytorch.org/docs/stable/nn.html#torch.nn.Module):
```py
>>> from transformers import AutoModelForSequenceClassification
>>> model = AutoModelForSequenceClassification.from_pretrained("distilbert/distilbert-base-uncased")
```
2. [`TrainingArguments`] contient les hyperparamรจtres du modรจle que vous pouvez changer comme le taux d'apprentissage, la taille de l'รฉchantillon, et le nombre d'รฉpoques pour s'entraรฎner. Les valeurs par dรฉfaut sont utilisรฉes si vous ne spรฉcifiez pas d'hyperparamรจtres d'apprentissage :
```py
>>> from transformers import TrainingArguments
>>> training_args = TrainingArguments(
... output_dir="path/to/save/folder/",
... learning_rate=2e-5,
... per_device_train_batch_size=8,
... per_device_eval_batch_size=8,
... num_train_epochs=2,
... )
```
3. Une classe de prรฉtraitement comme un tokenizer, un processeur d'images ou un extracteur de caractรฉristiques :
```py
>>> from transformers import AutoTokenizer
>>> tokenizer = AutoTokenizer.from_pretrained("distilbert/distilbert-base-uncased")
```
4. Chargez un jeu de donnรฉes :
```py
>>> from datasets import load_dataset
>>> dataset = load_dataset("rotten_tomatoes") # doctest: +IGNORE_RESULT
```
5. Crรฉez une fonction qui transforme le texte du jeu de donnรฉes en token :
```py
>>> def tokenize_dataset(dataset):
... return tokenizer(dataset["text"])
```
Puis appliquez-la ร l'intรฉgralitรฉ du jeu de donnรฉes avec [`~datasets.Dataset.map`]:
```py
>>> dataset = dataset.map(tokenize_dataset, batched=True)
```
6. Un [`DataCollatorWithPadding`] pour crรฉer un รฉchantillon d'exemples ร partir de votre jeu de donnรฉes :
```py
>>> from transformers import DataCollatorWithPadding
>>> data_collator = DataCollatorWithPadding(tokenizer=tokenizer)
```
Maintenant, rassemblez tous ces รฉlรฉments dans un [`Trainer`] :
```py
>>> from transformers import Trainer
>>> trainer = Trainer(
... model=model,
... args=training_args,
... train_dataset=dataset["train"],
... eval_dataset=dataset["test"],
... tokenizer=tokenizer,
... data_collator=data_collator,
... ) # doctest: +SKIP
```
Une fois que vous รชtes prรชt, appelez la fonction [`~Trainer.train`] pour commencer l'entraรฎnement :
```py
>>> trainer.train() # doctest: +SKIP
```
<Tip>
Pour les tรขches - comme la traduction ou la gรฉnรฉration de rรฉsumรฉ - qui utilisent un modรจle sรฉquence ร sรฉquence, utilisez plutรดt les classes [`Seq2SeqTrainer`] et [`Seq2SeqTrainingArguments`].
</Tip>
Vous pouvez personnaliser le comportement de la boucle d'apprentissage en redรฉfinissant les mรฉthodes ร l'intรฉrieur de [`Trainer`]. Cela vous permet de personnaliser des caractรฉristiques telles que la fonction de perte, l'optimiseur et le planificateur. Consultez la documentation de [`Trainer`] pour savoir quelles mรฉthodes peuvent รชtre redรฉfinies.
L'autre moyen de personnaliser la boucle d'apprentissage est d'utiliser les [Callbacks](./main_classes/callbacks). Vous pouvez utiliser les callbacks pour intรฉgrer d'autres bibliothรจques et inspecter la boucle d'apprentissage afin de suivre la progression ou d'arrรชter l'apprentissage plus tรดt. Les callbacks ne modifient rien dans la boucle d'apprentissage elle-mรชme. Pour personnaliser quelque chose comme la fonction de perte, vous devez redรฉfinir le [`Trainer`] ร la place.
## Entraรฎnement avec TensorFlow
Tous les modรจles sont des modรจles standard [`tf.keras.Model`](https://www.tensorflow.org/api_docs/python/tf/keras/Model) afin qu'ils puissent รชtre entraรฎnรฉs avec TensorFlow avec l'API [Keras](https://keras.io/). ๐ค Transformers fournit la fonction [`~TFPreTrainedModel.prepare_tf_dataset`] pour charger facilement votre jeu de donnรฉes comme un `tf.data.Dataset` afin que vous puissiez commencer l'entraรฎnement immรฉdiatement avec les fonctions [`compile`](https://keras.io/api/models/model_training_apis/#compile-method) et [`fit`](https://keras.io/api/models/model_training_apis/#fit-method) de Keras.
1. Vous commencez avec un modรจle [`TFPreTrainedModel`] ou [`tf.keras.Model`](https://www.tensorflow.org/api_docs/python/tf/keras/Model) :
```py
>>> from transformers import TFAutoModelForSequenceClassification
>>> model = TFAutoModelForSequenceClassification.from_pretrained("distilbert/distilbert-base-uncased")
```
2. Une classe de prรฉtraitement comme un tokenizer, un processeur d'images ou un extracteur de caractรฉristiques :
```py
>>> from transformers import AutoTokenizer
>>> tokenizer = AutoTokenizer.from_pretrained("distilbert/distilbert-base-uncased")
```
3. Crรฉez une fonction qui transforme le texte du jeu de donnรฉes en token :
```py
>>> def tokenize_dataset(dataset):
... return tokenizer(dataset["text"]) # doctest: +SKIP
```
4. Appliquez le tokenizer ร l'ensemble du jeu de donnรฉes avec [`~datasets.Dataset.map`] et passez ensuite le jeu de donnรฉes et le tokenizer ร [`~TFPreTrainedModel.prepare_tf_dataset`]. Vous pouvez รฉgalement modifier la taille de l'รฉchantillon et mรฉlanger le jeu de donnรฉes ici si vous le souhaitez :
```py
>>> dataset = dataset.map(tokenize_dataset) # doctest: +SKIP
>>> tf_dataset = model.prepare_tf_dataset(
... dataset, batch_size=16, shuffle=True, tokenizer=tokenizer
... ) # doctest: +SKIP
```
5. Une fois que vous รชtes prรชt, appelez les fonctions `compile` et `fit` pour commencer l'entraรฎnement :
```py
>>> from tensorflow.keras.optimizers import Adam
>>> model.compile(optimizer=Adam(3e-5))
>>> model.fit(dataset) # doctest: +SKIP
```
## Et aprรจs ?
Maintenant que vous avez terminรฉ la visite rapide de ๐ค Transformers, consultez nos guides et apprenez ร faire des choses plus spรฉcifiques comme crรฉer un modรจle personnalisรฉ, finetuner un modรจle pour une tรขche, et comment entraรฎner un modรจle avec un script. Si vous souhaitez en savoir plus sur les concepts fondamentaux de ๐ค Transformers, jetez un ลil ร nos guides conceptuels !
| 0 |
mavonic_private_repos/transformers/docs/source | mavonic_private_repos/transformers/docs/source/te/_toctree.yml | - sections:
- local: index
title: ๐ค Transformers
- local: quicktour
title: เฐคเฑเฐตเฐฐเฐฟเฐค เฐชเฐฐเฑเฐฏเฐเฐจ
title: เฐชเฑเฐฐเฐพเฐฐเฐเฐญเฐฟเฐเฐเฐกเฐพเฐจเฐฟเฐเฐฟ
| 0 |
mavonic_private_repos/transformers/docs/source | mavonic_private_repos/transformers/docs/source/te/index.md | <!--Copyright 2020 The HuggingFace Team. All rights reserved.
Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
the License. You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
specific language governing permissions and limitations under the License.
โ ๏ธ Note that this file is in Markdown but contain specific syntax for our doc-builder (similar to MDX) that may not be
rendered properly in your Markdown viewer.
-->
[เฐชเฑเฐเฑเฐฐเฑเฐเฑ](https://pytorch.org/), [เฐเฑเฐจเฑเฐธเฐฐเฑโเฐซเฑเฐฒเฑ](https://www.tensorflow.org/), เฐฎเฐฐเฐฟเฐฏเฑ [เฐเฐพเฐเฑเฐธเฑ](https://jax.readthedocs.io/en/latest/) เฐเฑเฐธเฐ เฐธเฑเฐฅเฐฟเฐคเฐฟ-เฐเฐฒเฐพเฐจ เฐฏเฐเฐคเฑเฐฐ เฐ
เฐญเฑเฐฏเฐพเฐธเฐ.
๐ค เฐเฑเฐฐเฐพเฐจเฑเฐธเฑเฐซเฐพเฐฐเฑเฐฎเฐฐเฑเฐธเฑ เฐ
เฐญเฐฟเฐตเฑเฐฆเฑเฐงเฐฟเฐธเฑเฐคเฑเฐจเฑเฐจเฐฆเฐฟ API เฐฎเฐฐเฐฟเฐฏเฑ เฐเฐชเฐเฐฐเฐฃเฐพเฐฒเฑ, เฐชเฑเฐฐเฑเฐต-เฐเฑเฐคเฐจ เฐฎเฑเฐกเฐฒเฑเฐฒเฐจเฑ เฐธเฑเฐฒเฐญเฐเฐเฐพ เฐกเฑเฐจเฑเฐฒเฑเฐกเฑ เฐฎเฐฐเฐฟเฐฏเฑ เฐถเฐฟเฐเฑเฐทเฐฃ เฐเฑเฐฏเฐกเฐพเฐจเฐฟเฐเฐฟ เฐ
เฐตเฐธเฐฐเฐฎเฑเฐจ เฐธเฐฎเฐฏเฐ, เฐตเฐจเฐฐเฑเฐฒเฑ, เฐฎเฐฐเฐฟเฐฏเฑ เฐตเฐธเฑเฐคเฑเฐตเฑเฐฒเฐจเฑ เฐจเฑเฐเฐเฐฟ เฐฎเฑเฐกเฐฒเฑเฐจเฑ เฐถเฑเฐฐเฑเฐทเฐฟเฐเฐ เฐจเฑเฐเฐเฐฟ เฐชเฑเฐฐเฐถเฐฟเฐเฑเฐทเฐฟเฐเฐเฐกเฐ เฐตเฐฐเฐเฑ เฐฆเฑเฐตเฐพเฐฏเฐจเฐ เฐเฑเฐธเฑเฐคเฑเฐเฐฆเฐฟ. เฐ เฐฎเฑเฐกเฐฒเฑเฐฒเฑ เฐตเฐฟเฐญเฐฟเฐจเฑเฐจ เฐฎเฑเฐกเฐพเฐฒเฐฟเฐเฑเฐฒเฐฒเฑ เฐธเฐพเฐงเฐพเฐฐเฐฃ เฐชเฐจเฑเฐฒเฐเฑ เฐฎเฐฆเฑเฐฆเฐคเฑ เฐเฑเฐธเฑเฐคเฐพเฐฏเฐฟ, เฐตเฐเฐเฐฟเฐตเฐฟ:
๐ **เฐชเฑเฐฐเฐพเฐเฑเฐคเฐฟเฐ เฐญเฐพเฐท เฐชเฑเฐฐเฐเฑเฐฐเฐฟเฐฏ**: เฐตเฐเฐจ เฐตเฐฐเฑเฐเฑเฐเฐฐเฐฃ, เฐชเฑเฐฐเฑเฐฒ เฐฏเฑเฐเฑเฐ เฐฏเฑเฐเฐเฐฟเฐเฑ เฐเฑเฐฐเฑเฐคเฑเฐตเฑ, เฐชเฑเฐฐเฐถเฑเฐจ เฐธเฐเฐตเฐพเฐฆ, เฐญเฐพเฐทเฐพ เฐฐเฐเฐจ, เฐธเฐเฐเฑเฐทเฑเฐชเฐฃ, เฐ
เฐจเฑเฐตเฐพเฐฆเฐ, เฐ
เฐจเฑเฐ เฐชเฑเฐฐเฐเฐพเฐฐเฐพเฐฒเฑ, เฐฎเฐฐเฐฟเฐฏเฑ เฐตเฐเฐจ เฐธเฑเฐทเฑเฐเฐฟ.<br>
๐ผ๏ธ **เฐเฐเฐชเฑเฐฏเฑเฐเฐฐเฑ เฐตเฐฟเฐทเฐฏเฐ**: เฐเฐฟเฐคเฑเฐฐเฐ เฐตเฐฐเฑเฐเฑเฐเฐฐเฐฃ, เฐตเฐธเฑเฐคเฑเฐฐเฐ เฐเฑเฐฐเฑเฐคเฑเฐตเฑ, เฐฎเฐฐเฐฟเฐฏเฑ เฐตเฐฟเฐญเฐเฐจ.<br>
๐ฃ๏ธ **เฐเฐกเฐฟเฐฏเฑ**: เฐธเฑเฐตเฐฏเฐเฐเฐฒเฐจ เฐชเฑเฐฐเฐธเฐเฐเฐพเฐจเฑเฐจเฐฟ เฐเฑเฐฐเฑเฐคเฑเฐเฑเฐธเฑเฐเฐฆเฑเฐเฑ, เฐเฐกเฐฟเฐฏเฑ เฐตเฐฐเฑเฐเฑเฐเฐฐเฐฃ.<br>
๐ **เฐฌเฐนเฑเฐฎเฑเฐฒเฐฟเฐ**: เฐชเฐเฑเฐเฐฟ เฐชเฑเฐฐเฐถเฑเฐจ เฐธเฐเฐตเฐพเฐฆ, เฐเฐชเฑเฐเฐฟเฐเฐฒเฑ เฐธเฐฟเฐซเฐฐเฑ เฐเฑเฐฐเฑเฐคเฑเฐตเฑ, เฐกเฐพเฐเฑเฐฏเฑเฐฎเฑเฐเฐเฑเฐฒเฑ เฐธเฑเฐเฑเฐฏเฐพเฐจเฑ เฐเฑเฐธเฐฟเฐจเฐเฐคเฐเฐพ เฐธเฐฎเฐพเฐเฐพเฐฐ เฐชเฑเฐเฐฆเฐกเฐ, เฐตเฑเฐกเฐฟเฐฏเฑ เฐตเฐฐเฑเฐเฑเฐเฐฐเฐฃ, เฐฎเฐฐเฐฟเฐฏเฑ เฐฆเฑเฐถเฑเฐฏ เฐชเฑเฐฐเฐถเฑเฐจ เฐธเฐเฐตเฐพเฐฆ.
๐ค เฐเฑเฐฐเฐพเฐจเฑเฐธเฑเฐซเฐพเฐฐเฑเฐฎเฐฐเฑเฐธเฑ เฐชเฑเฐจ เฐฎเฐฆเฑเฐฆเฐคเฑ เฐเฑเฐธเฑเฐคเฑเฐเฐฆเฐฟ เฐชเฑเฐจ เฐคเฑเฐฒเฐเฐฟเฐเฐเฐกเฐพเฐจเฐฟเฐเฐฟ เฐชเฑเฐจ เฐชเฑเฐจ เฐชเฑเฐจ เฐชเฑเฐฐเฑเฐเฑเฐฐเฐพเฐฎเฑเฐฒเฑ เฐฎเฑเฐกเฐฒเฑเฐจเฑ เฐถเฐฟเฐเฑเฐทเฐฟเฐเฐเฐเฐกเฐฟ, เฐฎเฐฐเฐฟเฐฏเฑ เฐ
เฐจเฑเฐจเฐฟ เฐชเฑเฐฐเฐพเฐฅเฐฎเฐฟเฐ เฐฏเฑเฐเฑเฐเฐกเฐพ เฐเฐจเฑโเฐซเฐฐเฑเฐจเฑเฐธเฑ เฐเฑเฐธเฐ เฐฒเฑเฐกเฑ เฐเฑเฐฏเฐเฐกเฐฟ. เฐฎเฑ
เฐกเฐฒเฑเฐฒเฑ เฐเฑเฐกเฐพ เฐชเฑเฐฐเฑเฐกเฐเฑเฐทเฐจเฑ เฐตเฐพเฐคเฐพเฐตเฐฐเฐฃเฐพเฐฒเฐฒเฑ เฐตเฐพเฐกเฑเฐเฑเฐตเฐกเฐพเฐจเฐฟเฐเฐฟ ONNX เฐฎเฐฐเฐฟเฐฏเฑ TorchScript เฐตเฐเฐเฐฟ เฐเฐเฑเฐคเฑเฐฒเฐเฑ เฐเฐเฑเฐฎเฐคเฐฟ เฐเฑเฐฏเฐตเฐเฑเฐเฑ.
เฐเฐฐเฑเฐตเฑเฐฒเฐเฑ [เฐนเฐฌเฑ](https://huggingface.co/models), [เฐซเฑเฐฐเฐ](https://discuss.huggingface.co/), เฐฒเฑเฐฆเฐพ [เฐกเฐฟเฐธเฑเฐเฐพเฐฐเฑเฐกเฑ](https://discord.com/invite/JfAtkvEtRb) เฐฒเฑ เฐ เฐชเฑเฐฆเฑเฐฆ เฐธเฐฎเฑเฐฆเฐพเฐฏเฐเฐฒเฑ เฐเฑเฐฐเฐเฐกเฐฟ!
## เฐฎเฑเฐฐเฑ เฐนเฐเฑเฐเฐฟเฐเฐเฑ เฐซเฑเฐธเฑ เฐเฑเฐฎเฑ เฐจเฑเฐเฐกเฐฟ เฐ
เฐจเฑเฐเฑเฐฒ เฐฎเฐฆเฑเฐฆเฐคเฑ เฐเฑเฐธเฐ เฐเฑเฐธเฑเฐคเฑเฐจเฑเฐจเฐเฑเฐฒเฐฏเฐฟเฐคเฑ
<a target="_blank" href="https://huggingface.co/support">
<img alt="HuggingFace Expert Acceleration Program" src="https://cdn-media.huggingface.co/marketing/transformers/new-support-improved.png" style="width: 100%; max-width: 600px; border: 1px solid #eee; border-radius: 4px; box-shadow: 0 1px 2px 0 rgba(0, 0, 0, 0.05);">
</a>
## เฐตเฐฟเฐทเฐฏเฐพเฐฒเฑ
เฐกเฐพเฐเฑเฐฏเฑเฐฎเฑเฐเฐเฑเฐทเฐจเฑ เฐเฐฆเฑ เฐตเฐฟเฐญเฐพเฐเฐพเฐฒเฑเฐเฐพ เฐจเฐฟเฐฐเฑเฐตเฐนเฐฟเฐเฐเฐฌเฐกเฐฟเฐเฐฆเฐฟ:
- **เฐชเฑเฐฐเฐพเฐฐเฐเฐญเฐฟเฐเฐเฐเฐกเฐฟ** เฐฒเฑเฐฌเฑเฐฐเฐฐเฑ เฐฏเฑเฐเฑเฐ เฐถเฑเฐเฑเฐฐ เฐชเฐฐเฑเฐฏเฐเฐจ เฐฎเฐฐเฐฟเฐฏเฑ เฐฐเฐจเฑเฐจเฐฟเฐเฐเฑ เฐเฑเฐธเฐ เฐเฐจเฑโเฐธเฑเฐเฐพเฐฒเฑเฐทเฐจเฑ เฐธเฑเฐเฐจเฐฒเฐจเฑ เฐ
เฐเฐฆเฐฟเฐธเฑเฐคเฑเฐเฐฆเฐฟ.
- **เฐเฑเฐฏเฑเฐเฑเฐฐเฐฟเฐฏเฐฒเฑเฐธเฑ** เฐฎเฑเฐฐเฑ เฐ
เฐจเฑเฐญเฐตเฐถเฑเฐจเฑเฐฏเฑเฐกเฑ เฐ
เฐฏเฐฟเฐคเฑ เฐชเฑเฐฐเฐพเฐฐเฐเฐญเฐฟเฐเฐเฐกเฐพเฐจเฐฟเฐเฐฟ เฐเฑเฐชเฑเฐช เฐชเฑเฐฐเฐฆเฑเฐถเฐ. เฐฎเฑเฐฐเฑ เฐฒเฑเฐฌเฑเฐฐเฐฐเฑเฐจเฐฟ เฐเฐชเฐฏเฑเฐเฐฟเฐเฐเฐกเฐ เฐชเฑเฐฐเฐพเฐฐเฐเฐญเฐฟเฐเฐเฐกเฐพเฐจเฐฟเฐเฐฟ เฐ
เฐตเฐธเฐฐเฐฎเฑเฐจ เฐชเฑเฐฐเฐพเฐฅเฐฎเฐฟเฐ เฐจเฑเฐชเฑเฐฃเฑเฐฏเฐพเฐฒเฐจเฑ เฐชเฑเฐเฐฆเฐกเฐพเฐจเฐฟเฐเฐฟ เฐ เฐตเฐฟเฐญเฐพเฐเฐ เฐฎเฑเฐเฑ เฐธเฐนเฐพเฐฏเฐ เฐเฑเฐธเฑเฐคเฑเฐเฐฆเฐฟ.
- **เฐนเฑ-เฐเฑ-เฐเฑเฐกเฑโเฐฒเฑ** เฐฒเฐพเฐเฐเฑเฐตเฑเฐเฑ เฐฎเฑเฐกเฐฒเฐฟเฐเฐเฑ เฐเฑเฐธเฐ เฐชเฑเฐฐเฐฟเฐเฑเฐฐเฑเฐจเฑเฐกเฑ เฐฎเฑเฐกเฐฒเฑโเฐจเฐฟ เฐซเฑเฐจเฑโเฐเฑเฐฏเฑเฐจเฑ เฐเฑเฐฏเฐกเฐ เฐฒเฑเฐฆเฐพ เฐเฐธเฑเฐเฐฎเฑ เฐฎเฑเฐกเฐฒเฑโเฐจเฑ เฐเฐฒเฐพ เฐตเฑเฐฐเฐพเฐฏเฐพเฐฒเฐฟ เฐฎเฐฐเฐฟเฐฏเฑ เฐทเฑเฐฐเฑ เฐเฑเฐฏเฐพเฐฒเฐฟ เฐตเฐเฐเฐฟ เฐจเฐฟเฐฐเฑเฐฆเฐฟเฐทเฑเฐ เฐฒเฐเฑเฐทเฑเฐฏเฐพเฐจเฑเฐจเฐฟ เฐเฐฒเฐพ เฐธเฐพเฐงเฐฟเฐเฐเฐพเฐฒเฑ เฐฎเฑเฐเฑ เฐเฑเฐชเฑเฐคเฐพเฐฏเฐฟ.
- **เฐเฐพเฐจเฑเฐธเฑเฐชเฑเฐเฑเฐตเฐฒเฑ เฐเฑเฐกเฑเฐธเฑ** เฐฎเฑเฐกเฐฒเฑโเฐฒเฑ, เฐเฐพเฐธเฑเฐเฑโเฐฒเฑ เฐฎเฐฐเฐฟเฐฏเฑ ๐ค เฐเฑเฐฐเฐพเฐจเฑเฐธเฑโเฐซเฐพเฐฐเฑเฐฎเฐฐเฑเฐฒ เฐกเฐฟเฐเฑเฐจเฑ เฐซเฐฟเฐฒเฐพเฐธเฐซเฑ เฐตเฑเฐจเฑเฐ เฐเฐจเฑเฐจ เฐ
เฐเฐคเฐฐเฑเฐฒเฑเฐจ เฐญเฐพเฐตเฐจเฐฒเฑ เฐฎเฐฐเฐฟเฐฏเฑ เฐเฐฒเฑเฐเฐจเฐฒ เฐเฑเฐฐเฐฟเฐเฐเฐฟ เฐฎเฐฐเฐฟเฐเฐค เฐเฐฐเฑเฐ เฐฎเฐฐเฐฟเฐฏเฑ เฐตเฐฟเฐตเฐฐเฐฃเฐจเฑ เฐ
เฐเฐฆเฐฟเฐธเฑเฐคเฑเฐเฐฆเฐฟ.
- **API** เฐ
เฐจเฑเฐจเฐฟ เฐคเฐฐเฐเฐคเฑเฐฒเฑ เฐฎเฐฐเฐฟเฐฏเฑ เฐตเฐฟเฐงเฑเฐฒเฐจเฑ เฐตเฐฟเฐตเฐฐเฐฟเฐธเฑเฐคเฑเฐเฐฆเฐฟ:
- **เฐชเฑเฐฐเฐงเฐพเฐจ เฐคเฐฐเฐเฐคเฑเฐฒเฑ** เฐเฐพเฐจเฑเฐซเฐฟเฐเฐฐเฑเฐทเฐจเฑ, เฐฎเฑเฐกเฐฒเฑ, เฐเฑเฐเฑเฐจเฑเฐเฐฐเฑ เฐฎเฐฐเฐฟเฐฏเฑ เฐชเฑเฐชเฑโเฐฒเฑเฐจเฑ เฐตเฐเฐเฐฟ เฐ
เฐคเฑเฐฏเฐเฐค เฐฎเฑเฐเฑเฐฏเฐฎเฑเฐจ เฐคเฐฐเฐเฐคเฑเฐฒเฐจเฑ เฐตเฐฟเฐตเฐฐเฐฟเฐธเฑเฐคเฑเฐเฐฆเฐฟ.
- **เฐฎเฑเฐกเฐฒเฑเฐธเฑ** เฐฒเฑเฐฌเฑเฐฐเฐฐเฑเฐฒเฑ เฐ
เฐฎเฐฒเฑ เฐเฑเฐฏเฐฌเฐกเฐฟเฐจ เฐชเฑเฐฐเฐคเฐฟ เฐฎเฑเฐกเฐฒเฑโเฐเฑ เฐธเฐเฐฌเฐเฐงเฐฟเฐเฐเฐฟเฐจ เฐคเฐฐเฐเฐคเฑเฐฒเฑ เฐฎเฐฐเฐฟเฐฏเฑ เฐตเฐฟเฐงเฑเฐฒเฐจเฑ เฐตเฐฟเฐตเฐฐเฐฟเฐธเฑเฐคเฑเฐเฐฆเฐฟ.
- **เฐ
เฐเฐคเฐฐเฑเฐเฐค เฐธเฐนเฐพเฐฏเฐเฑเฐฒเฑ** เฐ
เฐเฐคเฐฐเฑเฐเฐคเฐเฐเฐพ เฐเฐชเฐฏเฑเฐเฐฟเฐเฐเฑ เฐฏเฑเฐเฐฟเฐฒเฐฟเฐเฑ เฐเฑเฐฒเฐพเฐธเฑโเฐฒเฑ เฐฎเฐฐเฐฟเฐฏเฑ เฐซเฐเฐเฑเฐทเฐจเฑโเฐฒ เฐตเฐฟเฐตเฐฐเฐพเฐฒเฑ.
## เฐฎเฐฆเฑเฐฆเฐคเฑ เฐเฐจเฑเฐจ เฐจเฐฎเฑเฐจเฐพเฐฒเฑ เฐฎเฐฐเฐฟเฐฏเฑ เฐซเฑเฐฐเฑเฐฎเฑโเฐตเฐฐเฑเฐเฑโเฐฒเฑ
เฐฆเฐฟเฐเฑเฐตเฐจ เฐเฐจเฑเฐจ เฐชเฐเฑเฐเฐฟเฐ เฐ เฐชเฑเฐฐเฐคเฐฟ เฐฎเฑเฐกเฐฒเฑโเฐเฑ เฐชเฑเฐฅเฐพเฐจเฑ เฐเฐฒเฐฟเฐเฐฟ เฐเฐจเฑเฐจเฐพ เฐฒเฑเฐฌเฑเฐฐเฐฐเฑเฐฒเฑ เฐชเฑเฐฐเฐธเฑเฐคเฑเฐค เฐฎเฐฆเฑเฐฆเฐคเฑเฐจเฑ เฐธเฑเฐเฐฟเฐธเฑเฐคเฑเฐเฐฆเฐฟ
เฐเฑเฐเฑเฐจเฑเฐเฐฐเฑ ("เฐจเฑเฐฎเฑเฐฎเฐฆเฐฟเฐเฐพ" เฐ
เฐจเฐฟ เฐชเฐฟเฐฒเฑเฐธเฑเฐคเฐพเฐฐเฑ). Jax (เฐฆเฑเฐตเฐพเฐฐเฐพ
เฐซเฑเฐฒเฐพเฐเฑเฐธเฑ), เฐชเฑเฐเฐพเฐฐเฑเฐเฑ เฐฎเฐฐเฐฟเฐฏเฑ/เฐฒเฑเฐฆเฐพ เฐเฑเฐจเฑเฐธเฐฐเฑโเฐซเฑเฐฒเฑ.
<!--This table is updated automatically from the auto modules with _make fix-copies_. Do not update manually!-->
| Model | PyTorch support | TensorFlow support | Flax Support |
|:------------------------------------------------------------------------:|:---------------:|:------------------:|:------------:|
| [ALBERT](model_doc/albert) | โ
| โ
| โ
|
| [ALIGN](model_doc/align) | โ
| โ | โ |
| [AltCLIP](model_doc/altclip) | โ
| โ | โ |
| [Audio Spectrogram Transformer](model_doc/audio-spectrogram-transformer) | โ
| โ | โ |
| [Autoformer](model_doc/autoformer) | โ
| โ | โ |
| [Bark](model_doc/bark) | โ
| โ | โ |
| [BART](model_doc/bart) | โ
| โ
| โ
|
| [BARThez](model_doc/barthez) | โ
| โ
| โ
|
| [BARTpho](model_doc/bartpho) | โ
| โ
| โ
|
| [BEiT](model_doc/beit) | โ
| โ | โ
|
| [BERT](model_doc/bert) | โ
| โ
| โ
|
| [Bert Generation](model_doc/bert-generation) | โ
| โ | โ |
| [BertJapanese](model_doc/bert-japanese) | โ
| โ
| โ
|
| [BERTweet](model_doc/bertweet) | โ
| โ
| โ
|
| [BigBird](model_doc/big_bird) | โ
| โ | โ
|
| [BigBird-Pegasus](model_doc/bigbird_pegasus) | โ
| โ | โ |
| [BioGpt](model_doc/biogpt) | โ
| โ | โ |
| [BiT](model_doc/bit) | โ
| โ | โ |
| [Blenderbot](model_doc/blenderbot) | โ
| โ
| โ
|
| [BlenderbotSmall](model_doc/blenderbot-small) | โ
| โ
| โ
|
| [BLIP](model_doc/blip) | โ
| โ
| โ |
| [BLIP-2](model_doc/blip-2) | โ
| โ | โ |
| [BLOOM](model_doc/bloom) | โ
| โ | โ
|
| [BORT](model_doc/bort) | โ
| โ
| โ
|
| [BridgeTower](model_doc/bridgetower) | โ
| โ | โ |
| [BROS](model_doc/bros) | โ
| โ | โ |
| [ByT5](model_doc/byt5) | โ
| โ
| โ
|
| [CamemBERT](model_doc/camembert) | โ
| โ
| โ |
| [CANINE](model_doc/canine) | โ
| โ | โ |
| [Chinese-CLIP](model_doc/chinese_clip) | โ
| โ | โ |
| [CLAP](model_doc/clap) | โ
| โ | โ |
| [CLIP](model_doc/clip) | โ
| โ
| โ
|
| [CLIPSeg](model_doc/clipseg) | โ
| โ | โ |
| [CodeGen](model_doc/codegen) | โ
| โ | โ |
| [CodeLlama](model_doc/code_llama) | โ
| โ | โ |
| [Conditional DETR](model_doc/conditional_detr) | โ
| โ | โ |
| [ConvBERT](model_doc/convbert) | โ
| โ
| โ |
| [ConvNeXT](model_doc/convnext) | โ
| โ
| โ |
| [ConvNeXTV2](model_doc/convnextv2) | โ
| โ | โ |
| [CPM](model_doc/cpm) | โ
| โ
| โ
|
| [CPM-Ant](model_doc/cpmant) | โ
| โ | โ |
| [CTRL](model_doc/ctrl) | โ
| โ
| โ |
| [CvT](model_doc/cvt) | โ
| โ
| โ |
| [Data2VecAudio](model_doc/data2vec) | โ
| โ | โ |
| [Data2VecText](model_doc/data2vec) | โ
| โ | โ |
| [Data2VecVision](model_doc/data2vec) | โ
| โ
| โ |
| [DeBERTa](model_doc/deberta) | โ
| โ
| โ |
| [DeBERTa-v2](model_doc/deberta-v2) | โ
| โ
| โ |
| [Decision Transformer](model_doc/decision_transformer) | โ
| โ | โ |
| [Deformable DETR](model_doc/deformable_detr) | โ
| โ | โ |
| [DeiT](model_doc/deit) | โ
| โ
| โ |
| [DePlot](model_doc/deplot) | โ
| โ | โ |
| [DETA](model_doc/deta) | โ
| โ | โ |
| [DETR](model_doc/detr) | โ
| โ | โ |
| [DialoGPT](model_doc/dialogpt) | โ
| โ
| โ
|
| [DiNAT](model_doc/dinat) | โ
| โ | โ |
| [DINOv2](model_doc/dinov2) | โ
| โ | โ |
| [DistilBERT](model_doc/distilbert) | โ
| โ
| โ
|
| [DiT](model_doc/dit) | โ
| โ | โ
|
| [DonutSwin](model_doc/donut) | โ
| โ | โ |
| [DPR](model_doc/dpr) | โ
| โ
| โ |
| [DPT](model_doc/dpt) | โ
| โ | โ |
| [EfficientFormer](model_doc/efficientformer) | โ
| โ
| โ |
| [EfficientNet](model_doc/efficientnet) | โ
| โ | โ |
| [ELECTRA](model_doc/electra) | โ
| โ
| โ
|
| [EnCodec](model_doc/encodec) | โ
| โ | โ |
| [Encoder decoder](model_doc/encoder-decoder) | โ
| โ
| โ
|
| [ERNIE](model_doc/ernie) | โ
| โ | โ |
| [ErnieM](model_doc/ernie_m) | โ
| โ | โ |
| [ESM](model_doc/esm) | โ
| โ
| โ |
| [FairSeq Machine-Translation](model_doc/fsmt) | โ
| โ | โ |
| [Falcon](model_doc/falcon) | โ
| โ | โ |
| [FLAN-T5](model_doc/flan-t5) | โ
| โ
| โ
|
| [FLAN-UL2](model_doc/flan-ul2) | โ
| โ
| โ
|
| [FlauBERT](model_doc/flaubert) | โ
| โ
| โ |
| [FLAVA](model_doc/flava) | โ
| โ | โ |
| [FNet](model_doc/fnet) | โ
| โ | โ |
| [FocalNet](model_doc/focalnet) | โ
| โ | โ |
| [Funnel Transformer](model_doc/funnel) | โ
| โ
| โ |
| [GIT](model_doc/git) | โ
| โ | โ |
| [GLPN](model_doc/glpn) | โ
| โ | โ |
| [GPT Neo](model_doc/gpt_neo) | โ
| โ | โ
|
| [GPT NeoX](model_doc/gpt_neox) | โ
| โ | โ |
| [GPT NeoX Japanese](model_doc/gpt_neox_japanese) | โ
| โ | โ |
| [GPT-J](model_doc/gptj) | โ
| โ
| โ
|
| [GPT-Sw3](model_doc/gpt-sw3) | โ
| โ
| โ
|
| [GPTBigCode](model_doc/gpt_bigcode) | โ
| โ | โ |
| [GPTSAN-japanese](model_doc/gptsan-japanese) | โ
| โ | โ |
| [Graphormer](model_doc/graphormer) | โ
| โ | โ |
| [GroupViT](model_doc/groupvit) | โ
| โ
| โ |
| [HerBERT](model_doc/herbert) | โ
| โ
| โ
|
| [Hubert](model_doc/hubert) | โ
| โ
| โ |
| [I-BERT](model_doc/ibert) | โ
| โ | โ |
| [IDEFICS](model_doc/idefics) | โ
| โ | โ |
| [ImageGPT](model_doc/imagegpt) | โ
| โ | โ |
| [Informer](model_doc/informer) | โ
| โ | โ |
| [InstructBLIP](model_doc/instructblip) | โ
| โ | โ |
| [Jukebox](model_doc/jukebox) | โ
| โ | โ |
| [LayoutLM](model_doc/layoutlm) | โ
| โ
| โ |
| [LayoutLMv2](model_doc/layoutlmv2) | โ
| โ | โ |
| [LayoutLMv3](model_doc/layoutlmv3) | โ
| โ
| โ |
| [LayoutXLM](model_doc/layoutxlm) | โ
| โ | โ |
| [LED](model_doc/led) | โ
| โ
| โ |
| [LeViT](model_doc/levit) | โ
| โ | โ |
| [LiLT](model_doc/lilt) | โ
| โ | โ |
| [LLaMA](model_doc/llama) | โ
| โ | โ |
| [Llama2](model_doc/llama2) | โ
| โ | โ |
| [Longformer](model_doc/longformer) | โ
| โ
| โ |
| [LongT5](model_doc/longt5) | โ
| โ | โ
|
| [LUKE](model_doc/luke) | โ
| โ | โ |
| [LXMERT](model_doc/lxmert) | โ
| โ
| โ |
| [M-CTC-T](model_doc/mctct) | โ
| โ | โ |
| [M2M100](model_doc/m2m_100) | โ
| โ | โ |
| [Marian](model_doc/marian) | โ
| โ
| โ
|
| [MarkupLM](model_doc/markuplm) | โ
| โ | โ |
| [Mask2Former](model_doc/mask2former) | โ
| โ | โ |
| [MaskFormer](model_doc/maskformer) | โ
| โ | โ |
| [MatCha](model_doc/matcha) | โ
| โ | โ |
| [mBART](model_doc/mbart) | โ
| โ
| โ
|
| [mBART-50](model_doc/mbart50) | โ
| โ
| โ
|
| [MEGA](model_doc/mega) | โ
| โ | โ |
| [Megatron-BERT](model_doc/megatron-bert) | โ
| โ | โ |
| [Megatron-GPT2](model_doc/megatron_gpt2) | โ
| โ
| โ
|
| [MGP-STR](model_doc/mgp-str) | โ
| โ | โ |
| [Mistral](model_doc/mistral) | โ
| โ | โ |
| [mLUKE](model_doc/mluke) | โ
| โ | โ |
| [MMS](model_doc/mms) | โ
| โ
| โ
|
| [MobileBERT](model_doc/mobilebert) | โ
| โ
| โ |
| [MobileNetV1](model_doc/mobilenet_v1) | โ
| โ | โ |
| [MobileNetV2](model_doc/mobilenet_v2) | โ
| โ | โ |
| [MobileViT](model_doc/mobilevit) | โ
| โ
| โ |
| [MobileViTV2](model_doc/mobilevitv2) | โ
| โ | โ |
| [MPNet](model_doc/mpnet) | โ
| โ
| โ |
| [MPT](model_doc/mpt) | โ
| โ | โ |
| [MRA](model_doc/mra) | โ
| โ | โ |
| [MT5](model_doc/mt5) | โ
| โ
| โ
|
| [MusicGen](model_doc/musicgen) | โ
| โ | โ |
| [MVP](model_doc/mvp) | โ
| โ | โ |
| [NAT](model_doc/nat) | โ
| โ | โ |
| [Nezha](model_doc/nezha) | โ
| โ | โ |
| [NLLB](model_doc/nllb) | โ
| โ | โ |
| [NLLB-MOE](model_doc/nllb-moe) | โ
| โ | โ |
| [Nougat](model_doc/nougat) | โ
| โ
| โ
|
| [Nystrรถmformer](model_doc/nystromformer) | โ
| โ | โ |
| [OneFormer](model_doc/oneformer) | โ
| โ | โ |
| [OpenAI GPT](model_doc/openai-gpt) | โ
| โ
| โ |
| [OpenAI GPT-2](model_doc/gpt2) | โ
| โ
| โ
|
| [OpenLlama](model_doc/open-llama) | โ
| โ | โ |
| [OPT](model_doc/opt) | โ
| โ
| โ
|
| [OWL-ViT](model_doc/owlvit) | โ
| โ | โ |
| [Pegasus](model_doc/pegasus) | โ
| โ
| โ
|
| [PEGASUS-X](model_doc/pegasus_x) | โ
| โ | โ |
| [Perceiver](model_doc/perceiver) | โ
| โ | โ |
| [Persimmon](model_doc/persimmon) | โ
| โ | โ |
| [PhoBERT](model_doc/phobert) | โ
| โ
| โ
|
| [Pix2Struct](model_doc/pix2struct) | โ
| โ | โ |
| [PLBart](model_doc/plbart) | โ
| โ | โ |
| [PoolFormer](model_doc/poolformer) | โ
| โ | โ |
| [Pop2Piano](model_doc/pop2piano) | โ
| โ | โ |
| [ProphetNet](model_doc/prophetnet) | โ
| โ | โ |
| [PVT](model_doc/pvt) | โ
| โ | โ |
| [QDQBert](model_doc/qdqbert) | โ
| โ | โ |
| [RAG](model_doc/rag) | โ
| โ
| โ |
| [REALM](model_doc/realm) | โ
| โ | โ |
| [Reformer](model_doc/reformer) | โ
| โ | โ |
| [RegNet](model_doc/regnet) | โ
| โ
| โ
|
| [RemBERT](model_doc/rembert) | โ
| โ
| โ |
| [ResNet](model_doc/resnet) | โ
| โ
| โ
|
| [RetriBERT](model_doc/retribert) | โ
| โ | โ |
| [RoBERTa](model_doc/roberta) | โ
| โ
| โ
|
| [RoBERTa-PreLayerNorm](model_doc/roberta-prelayernorm) | โ
| โ
| โ
|
| [RoCBert](model_doc/roc_bert) | โ
| โ | โ |
| [RoFormer](model_doc/roformer) | โ
| โ
| โ
|
| [RWKV](model_doc/rwkv) | โ
| โ | โ |
| [SAM](model_doc/sam) | โ
| โ
| โ |
| [SegFormer](model_doc/segformer) | โ
| โ
| โ |
| [SEW](model_doc/sew) | โ
| โ | โ |
| [SEW-D](model_doc/sew-d) | โ
| โ | โ |
| [Speech Encoder decoder](model_doc/speech-encoder-decoder) | โ
| โ | โ
|
| [Speech2Text](model_doc/speech_to_text) | โ
| โ
| โ |
| [SpeechT5](model_doc/speecht5) | โ
| โ | โ |
| [Splinter](model_doc/splinter) | โ
| โ | โ |
| [SqueezeBERT](model_doc/squeezebert) | โ
| โ | โ |
| [SwiftFormer](model_doc/swiftformer) | โ
| โ | โ |
| [Swin Transformer](model_doc/swin) | โ
| โ
| โ |
| [Swin Transformer V2](model_doc/swinv2) | โ
| โ | โ |
| [Swin2SR](model_doc/swin2sr) | โ
| โ | โ |
| [SwitchTransformers](model_doc/switch_transformers) | โ
| โ | โ |
| [T5](model_doc/t5) | โ
| โ
| โ
|
| [T5v1.1](model_doc/t5v1.1) | โ
| โ
| โ
|
| [Table Transformer](model_doc/table-transformer) | โ
| โ | โ |
| [TAPAS](model_doc/tapas) | โ
| โ
| โ |
| [TAPEX](model_doc/tapex) | โ
| โ
| โ
|
| [Time Series Transformer](model_doc/time_series_transformer) | โ
| โ | โ |
| [TimeSformer](model_doc/timesformer) | โ
| โ | โ |
| [Trajectory Transformer](model_doc/trajectory_transformer) | โ
| โ | โ |
| [Transformer-XL](model_doc/transfo-xl) | โ
| โ
| โ |
| [TrOCR](model_doc/trocr) | โ
| โ | โ |
| [TVLT](model_doc/tvlt) | โ
| โ | โ |
| [UL2](model_doc/ul2) | โ
| โ
| โ
|
| [UMT5](model_doc/umt5) | โ
| โ | โ |
| [UniSpeech](model_doc/unispeech) | โ
| โ | โ |
| [UniSpeechSat](model_doc/unispeech-sat) | โ
| โ | โ |
| [UPerNet](model_doc/upernet) | โ
| โ | โ |
| [VAN](model_doc/van) | โ
| โ | โ |
| [VideoMAE](model_doc/videomae) | โ
| โ | โ |
| [ViLT](model_doc/vilt) | โ
| โ | โ |
| [Vision Encoder decoder](model_doc/vision-encoder-decoder) | โ
| โ
| โ
|
| [VisionTextDualEncoder](model_doc/vision-text-dual-encoder) | โ
| โ
| โ
|
| [VisualBERT](model_doc/visual_bert) | โ
| โ | โ |
| [ViT](model_doc/vit) | โ
| โ
| โ
|
| [ViT Hybrid](model_doc/vit_hybrid) | โ
| โ | โ |
| [VitDet](model_doc/vitdet) | โ
| โ | โ |
| [ViTMAE](model_doc/vit_mae) | โ
| โ
| โ |
| [ViTMatte](model_doc/vitmatte) | โ
| โ | โ |
| [ViTMSN](model_doc/vit_msn) | โ
| โ | โ |
| [VITS](model_doc/vits) | โ
| โ | โ |
| [ViViT](model_doc/vivit) | โ
| โ | โ |
| [Wav2Vec2](model_doc/wav2vec2) | โ
| โ
| โ
|
| [Wav2Vec2-Conformer](model_doc/wav2vec2-conformer) | โ
| โ | โ |
| [Wav2Vec2Phoneme](model_doc/wav2vec2_phoneme) | โ
| โ
| โ
|
| [WavLM](model_doc/wavlm) | โ
| โ | โ |
| [Whisper](model_doc/whisper) | โ
| โ
| โ
|
| [X-CLIP](model_doc/xclip) | โ
| โ | โ |
| [X-MOD](model_doc/xmod) | โ
| โ | โ |
| [XGLM](model_doc/xglm) | โ
| โ
| โ
|
| [XLM](model_doc/xlm) | โ
| โ
| โ |
| [XLM-ProphetNet](model_doc/xlm-prophetnet) | โ
| โ | โ |
| [XLM-RoBERTa](model_doc/xlm-roberta) | โ
| โ
| โ
|
| [XLM-RoBERTa-XL](model_doc/xlm-roberta-xl) | โ
| โ | โ |
| [XLM-V](model_doc/xlm-v) | โ
| โ
| โ
|
| [XLNet](model_doc/xlnet) | โ
| โ
| โ |
| [XLS-R](model_doc/xls_r) | โ
| โ
| โ
|
| [XLSR-Wav2Vec2](model_doc/xlsr_wav2vec2) | โ
| โ
| โ
|
| [YOLOS](model_doc/yolos) | โ
| โ | โ |
| [YOSO](model_doc/yoso) | โ
| โ | โ |
<!-- End table-->
| 0 |
mavonic_private_repos/transformers/docs/source | mavonic_private_repos/transformers/docs/source/te/quicktour.md | <!--Copyright 2022 The HuggingFace Team. All rights reserved.
Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
the License. You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
specific language governing permissions and limitations under the License.
โ ๏ธ Note that this file is in Markdown but contain specific syntax for our doc-builder (similar to MDX) that may not be
rendered properly in your Markdown viewer.
-->
# เฐถเฑเฐเฑเฐฐ เฐชเฐฐเฑเฐฏเฐเฐจ
[[เฐเฐชเฑเฐจเฑ-เฐเฐจเฑ-เฐเฑเฐฒเฐพเฐฌเฑ]]
๐ค เฐเฑเฐฐเฐพเฐจเฑเฐธเฑโเฐซเฐพเฐฐเฑเฐฎเฐฐเฑโเฐฒเฐคเฑ เฐฒเฑเฐเฐฟ เฐชเฐฐเฑเฐเฑเฐคเฑเฐคเฐเฐกเฐฟ! เฐฎเฑเฐฐเฑ เฐกเฑเฐตเฐฒเฐชเฐฐเฑ เฐ
เฐฏเฐฟเฐจเฐพ เฐฒเฑเฐฆเฐพ เฐฐเฑเฐเฑเฐตเฐพเฐฐเฑ เฐตเฐฟเฐจเฐฟเฐฏเฑเฐเฐฆเฐพเฐฐเฑ เฐ
เฐฏเฐฟเฐจเฐพ, เฐ เฐถเฑเฐเฑเฐฐ เฐชเฐฐเฑเฐฏเฐเฐจ เฐฎเฑเฐเฑ เฐชเฑเฐฐเฐพเฐฐเฐเฐญเฐฟเฐเฐเฐกเฐพเฐจเฐฟเฐเฐฟ เฐธเฐนเฐพเฐฏเฐ เฐเฑเฐธเฑเฐคเฑเฐเฐฆเฐฟ เฐฎเฐฐเฐฟเฐฏเฑ [`pipeline`] เฐ
เฐจเฑเฐฎเฐฟเฐคเฐฟ เฐเฑเฐธเฐ เฐเฐฒเฐพ เฐเฐชเฐฏเฑเฐเฐฟเฐเฐเฐพเฐฒเฑ เฐฎเฑเฐเฑ เฐเฑเฐชเฑเฐคเฑเฐเฐฆเฐฟ, [AutoClass](./model_doc/auto) เฐคเฑ เฐชเฑเฐฐเฑเฐเฑเฐฐเฑเฐจเฑเฐกเฑ เฐฎเฑเฐกเฐฒเฑ เฐฎเฐฐเฐฟเฐฏเฑ เฐชเฑเฐฐเฐฟเฐชเฑเฐฐเฐพเฐธเฑเฐธเฐฐเฑ/ เฐเฐเฑ, เฐฎเฐฐเฐฟเฐฏเฑ PyTorch เฐฒเฑเฐฆเฐพ TensorFlowเฐคเฑ เฐฎเฑเฐกเฐฒเฑโเฐเฑ เฐคเฑเฐตเฐฐเฐเฐพ เฐถเฐฟเฐเฑเฐทเฐฃ เฐเฐตเฑเฐตเฐเฐกเฐฟ. เฐฎเฑเฐฐเฑ เฐเฐ เฐ
เฐจเฑเฐญเฐตเฐถเฑเฐจเฑเฐฏเฑเฐกเฑ เฐ
เฐฏเฐฟเฐคเฑ, เฐเฐเฑเฐเฐก เฐชเฐฐเฐฟเฐเฐฏเฐ เฐเฑเฐฏเฐฌเฐกเฐฟเฐจ เฐญเฐพเฐตเฐจเฐฒ เฐเฑเฐฐเฐฟเฐเฐเฐฟ เฐฎเฐฐเฐฟเฐเฐค เฐฒเฑเฐคเฑเฐจ เฐตเฐฟเฐตเฐฐเฐฃเฐฒ เฐเฑเฐธเฐ เฐฎเฐพ เฐเฑเฐฏเฑเฐเฑเฐฐเฐฟเฐฏเฐฒเฑเฐธเฑ เฐฒเฑเฐฆเฐพ [course](https://huggingface.co/course/chapter1/1)เฐจเฐฟ เฐคเฐจเฐฟเฐเฑ เฐเฑเฐฏเฐฎเฐจเฐฟ เฐฎเฑเฐฎเฑ เฐธเฐฟเฐซเฐพเฐฐเฑเฐธเฑ เฐเฑเฐธเฑเฐคเฑเฐจเฑเฐจเฐพเฐฎเฑ.
เฐฎเฑเฐฐเฑ เฐชเฑเฐฐเฐพเฐฐเฐเฐญเฐฟเฐเฐเฐกเฐพเฐจเฐฟเฐเฐฟ เฐฎเฑเฐเฐฆเฑ, เฐฎเฑเฐฐเฑ เฐ
เฐตเฐธเฐฐเฐฎเฑเฐจ เฐ
เฐจเฑเฐจเฐฟ เฐฒเฑเฐฌเฑเฐฐเฐฐเฑเฐฒเฐจเฑ เฐเฐจเฑโเฐธเฑเฐเฐพเฐฒเฑ เฐเฑเฐถเฐพเฐฐเฐจเฐฟ เฐจเฐฟเฐฐเฑเฐงเฐพเฐฐเฐฟเฐเฐเฑเฐเฑเฐเฐกเฐฟ:
```bash
!pip install transformers datasets evaluate accelerate
```
เฐฎเฑเฐฐเฑ เฐฎเฑ เฐชเฑเฐฐเฐพเฐงเฐพเฐจเฑเฐฏ เฐฏเฐเฐคเฑเฐฐ เฐ
เฐญเฑเฐฏเฐพเฐธ เฐซเฑเฐฐเฑเฐฎเฑโเฐตเฐฐเฑเฐเฑโเฐจเฑ เฐเฑเฐกเฐพ เฐเฐจเฑโเฐธเฑเฐเฐพเฐฒเฑ เฐเฑเฐฏเฐพเฐฒเฐฟ:
<frameworkcontent>
<pt>
```bash
pip install torch
```
</pt>
<tf>
```bash
pip install tensorflow
```
</tf>
</frameworkcontent>
## เฐชเฑเฐชเฑโเฐฒเฑเฐจเฑ
<Youtube id="tiZFewofSLM"/>
[`pipeline`] เฐ
เฐจเฑเฐฎเฐฟเฐคเฐฟ เฐเฑเฐธเฐ เฐฎเฑเฐเฐฆเฑเฐเฐพ เฐถเฐฟเฐเฑเฐทเฐฃ เฐชเฑเฐเฐฆเฐฟเฐจ เฐจเฐฎเฑเฐจเฐพเฐจเฑ เฐเฐชเฐฏเฑเฐเฐฟเฐเฐเฐกเฐพเฐจเฐฟเฐเฐฟ เฐธเฑเฐฒเฐญเฐฎเฑเฐจ เฐฎเฐฐเฐฟเฐฏเฑ เฐตเฑเฐเฐตเฐเฐคเฐฎเฑเฐจ เฐฎเฐพเฐฐเฑเฐเฐ. เฐฎเฑเฐฐเฑ เฐตเฐฟเฐตเฐฟเฐง เฐชเฐฆเฑเฐงเฐคเฑเฐฒเฐฒเฑ เฐ
เฐจเฑเฐ เฐชเฐจเฑเฐฒ เฐเฑเฐธเฐ [`pipeline`] เฐตเฑเฐฒเฑเฐชเฐฒ เฐเฐชเฐฏเฑเฐเฐฟเฐเฐเฐตเฐเฑเฐเฑ, เฐตเฐพเฐเฐฟเฐฒเฑ เฐเฑเฐจเฑเฐจเฐฟ เฐเฑเฐฐเฐฟเฐเฐฆเฐฟ เฐชเฐเฑเฐเฐฟเฐเฐฒเฑ เฐเฑเฐชเฐฌเฐกเฑเฐกเฐพเฐฏเฐฟ:
<Tip>
เฐ
เฐเฐฆเฑเฐฌเฐพเฐเฑเฐฒเฑ เฐเฐจเฑเฐจ เฐชเฐจเฑเฐฒ เฐชเฑเฐฐเฑเฐคเฐฟ เฐเฐพเฐฌเฐฟเฐคเฐพ เฐเฑเฐธเฐ, [เฐชเฑเฐชเฑโเฐฒเฑเฐจเฑ API เฐธเฑเฐเฐจ](./main_classes/pipelines)เฐจเฐฟ เฐคเฐจเฐฟเฐเฑ เฐเฑเฐฏเฐเฐกเฐฟ.
</Tip>
Here is the translation in Telugu:
| **เฐชเฐจเฐฟ** | **เฐตเฐฟเฐตเฐฐเฐฃ** | **เฐฎเฑเฐกเฐพเฐฒเฐฟเฐเฑ** | **เฐชเฑเฐชเฑโเฐฒเฑเฑเฐจเฑ เฐเฐกเฑเฐเฐเฐฟเฐซเฑเฐฏเฐฐเฑ** |
|------------------------------|--------------------------------------------------------------------------------------------------------|-----------------|------------------------------------------|
| เฐตเฐเฐจ เฐตเฐฐเฑเฐเฑเฐเฐฐเฐฃเฑ | เฐเฑเฐจเฑเฐจเฐฟ เฐตเฐเฐจเฐพเฐฒ เฐ
เฐเฐคเฐพ เฐเฐ เฐฒเฑเฐฌเฑเฐฒเฑโเฐจเฑ เฐเฑเฐกเฐฟ | NLP | pipeline(task=โsentiment-analysisโ) |
| เฐตเฐเฐจ เฐธเฑเฐทเฑเฐเฐฟ | เฐชเฑเฐฐเฐฎเฑเฐชเฑเฐเฐ เฐเฐฒเฐฟเฐเฐฟเฐจเฐเฐค เฐตเฐเฐจเฐ เฐธเฑเฐทเฑเฐเฐฟเฐเฐเฐเฐกเฐฟ | NLP | pipeline(task=โtext-generationโ) |
| เฐธเฐเฐเฑเฐทเฑเฐชเฐฃ | เฐตเฐเฐจเฐ เฐฒเฑเฐฆเฐพ เฐชเฐคเฑเฐฐเฐ เฐเฑเฐฐเฐเฑ เฐธเฐเฐเฑเฐทเฑเฐชเฐฃ เฐคเฐฏเฐพเฐฐเฑเฐเฑเฐธเฐเฐกเฐฟ | NLP | pipeline(task=โsummarizationโ) |
| เฐเฐฟเฐคเฑเฐฐเฐ เฐตเฐฐเฑเฐเฑเฐเฐฐเฐฃเฑ | เฐเฐฟเฐคเฑเฐฐเฐเฐฒเฑ เฐเฐ เฐฒเฑเฐฌเฑเฐฒเฑโเฐจเฑ เฐเฑเฐกเฐฟ | เฐเฐเฐชเฑเฐฏเฑเฐเฐฐเฑ เฐตเฐฟเฐทเฐฏเฐ | pipeline(task=โimage-classificationโ) |
| เฐเฐฟเฐคเฑเฐฐเฐ เฐตเฐฟเฐญเฐเฐจ | เฐเฐ เฐเฐฟเฐคเฑเฐฐเฐเฐฒเฑ เฐชเฑเฐฐเฐคเฐฟ เฐตเฑเฐฏเฐเฑเฐคเฐฟเฐเฐค เฐชเฐฟเฐเฑเฐธเฐฒเฑโเฐจเฑ เฐเฐ เฐฒเฑเฐฌเฑเฐฒเฑโเฐเฐพ เฐจเฐฎเฑเฐฆเฑ เฐเฑเฐฏเฐเฐกเฐฟ (เฐธเฑเฐฎเฐพเฐเฐเฐฟเฐเฑ, เฐชเฐพเฐจเฑเฐชเฑเฐเฐฟเฐเฑ, เฐฎเฐฐเฐฟเฐฏเฑ เฐเฐจเฑเฐธเฑเฐเฐจเฑเฐธเฑ เฐตเฐฟเฐญเฐเฐจเฐฒเฐจเฑ เฐฎเฐฆเฑเฐฆเฐคเฑ เฐเฑเฐธเฑเฐคเฑเฐเฐฆเฐฟ) | เฐเฐเฐชเฑเฐฏเฑเฐเฐฐเฑ เฐตเฐฟเฐทเฐฏเฐ | pipeline(task=โimage-segmentationโ) |
| เฐตเฐธเฑเฐคเฑเฐฐเฐ เฐเฑเฐฐเฑเฐคเฑเฐตเฑ | เฐเฐ เฐเฐฟเฐคเฑเฐฐเฐเฐฒเฑ เฐชเฐฆเฐพเฐฒ เฐฏเฑเฐเฑเฐ เฐฌเฑเฐเฐกเฐฟเฐเฐเฑ เฐฌเฐพเฐเฑเฐธเฑโเฐฒเฐจเฑ เฐฎเฐฐเฐฟเฐฏเฑ เฐตเฐธเฑเฐคเฑเฐฐเฐพเฐฒ เฐตเฐฐเฑเฐเฐพเฐฒเฐจเฑ เฐ
เฐเฐเฐจเฐพ เฐเฑเฐฏเฐเฐกเฐฟ | เฐเฐเฐชเฑเฐฏเฑเฐเฐฐเฑ เฐตเฐฟเฐทเฐฏเฐ | pipeline(task=โobject-detectionโ) |
| เฐเฐกเฐฟเฐฏเฑ เฐเฑเฐฐเฑเฐคเฑเฐตเฑ | เฐเฑเฐจเฑเฐจเฐฟ เฐเฐกเฐฟเฐฏเฑ เฐกเฑเฐเฐพเฐจเฐฟเฐเฐฟ เฐเฐ เฐฒเฑเฐฌเฑเฐฒเฑโเฐจเฑ เฐเฑเฐกเฐฟ | เฐเฐกเฐฟเฐฏเฑ | pipeline(task=โaudio-classificationโ) |
| เฐธเฑเฐตเฐฏเฐเฐเฐฒเฐจ เฐชเฑเฐฐเฐธเฐเฐ เฐเฑเฐฐเฑเฐคเฑเฐตเฑ | เฐชเฑเฐฐเฐธเฐเฐเฐพเฐจเฑเฐจเฐฟ เฐตเฐเฐจเฐเฐเฐพ เฐตเฐฐเฑเฐฃเฐฟเฐเฐเฐเฐกเฐฟ | เฐเฐกเฐฟเฐฏเฑ | pipeline(task=โautomatic-speech-recognitionโ) |
| เฐฆเฑเฐถเฑเฐฏ เฐชเฑเฐฐเฐถเฑเฐจ เฐธเฐเฐตเฐพเฐฆเฐ | เฐตเฐเฐจเฐ เฐฎเฐฐเฐฟเฐฏเฑ เฐชเฑเฐฐเฐถเฑเฐจเฐจเฑ เฐจเฐฎเฑเฐฆเฑ เฐเฑเฐธเฐฟเฐจ เฐเฐฟเฐคเฑเฐฐเฐเฐคเฑ เฐชเฑเฐฐเฐถเฑเฐจเฐเฑ เฐธเฐฎเฐพเฐงเฐพเฐจเฐ เฐเฐตเฑเฐตเฐเฐกเฐฟ | เฐฌเฐนเฑเฐฎเฑเฐฒเฐฟเฐ | pipeline(task=โvqaโ) |
| เฐชเฐคเฑเฐฐเฐ เฐชเฑเฐฐเฐถเฑเฐจ เฐธเฐเฐตเฐพเฐฆเฐ | เฐชเฑเฐฐเฐถเฑเฐจเฐจเฑ เฐชเฐคเฑเฐฐเฐ เฐฒเฑเฐฆเฐพ เฐกเฐพเฐเฑเฐฏเฑเฐฎเฑเฐเฐเฑโเฐคเฑ เฐธเฐฎเฐพเฐงเฐพเฐจเฐ เฐเฐตเฑเฐตเฐเฐกเฐฟ | เฐฌเฐนเฑเฐฎเฑเฐฒเฐฟเฐ | pipeline(task="document-question-answering") |
| เฐเฐฟเฐคเฑเฐฐเฐ เฐตเฑเฐฐเฐพเฐธเฐพเฐฏเฐฟเฐเฐเฑ | เฐเฑเฐจเฑเฐจเฐฟ เฐเฐฟเฐคเฑเฐฐเฐพเฐจเฐฟเฐเฐฟ เฐชเฐฟเฐเฐฟเฐฏเฐพเฐฐเฑเฐฒเฐจเฑ เฐธเฑเฐทเฑเฐเฐฟเฐเฐเฐเฐกเฐฟ | เฐฌเฐนเฑเฐฎเฑเฐฒเฐฟเฐ | pipeline(task="image-to-text") |
[`pipeline`] เฐฏเฑเฐเฑเฐ เฐเฐฆเฐพเฐนเฐฐเฐฃเฐจเฑ เฐธเฑเฐทเฑเฐเฐฟเฐเฐเฐกเฐ เฐฆเฑเฐตเฐพเฐฐเฐพ เฐฎเฐฐเฐฟเฐฏเฑ เฐฎเฑเฐฐเฑ เฐฆเฐพเฐจเฐฟเฐจเฐฟ เฐเฐชเฐฏเฑเฐเฐฟเฐเฐเฐพเฐฒเฐจเฑเฐเฑเฐเฐเฑเฐจเฑเฐจ เฐชเฐจเฐฟเฐจเฐฟ เฐชเฑเฐฐเฑเฐเฑเฐจเฐกเฐ เฐฆเฑเฐตเฐพเฐฐเฐพ เฐชเฑเฐฐเฐพเฐฐเฐเฐญเฐฟเฐเฐเฐเฐกเฐฟ. เฐ เฐเฑเฐกเฑโเฐฒเฑ, เฐฎเฑเฐฐเฑ เฐธเฑเฐเฐเฐฟเฐฎเฑเฐเฐเฑ เฐตเฐฟเฐถเฑเฐฒเฑเฐทเฐฃ เฐเฑเฐธเฐ [`pipeline`]เฐจเฐฟ เฐเฐฆเฐพเฐนเฐฐเฐฃเฐเฐพ เฐเฐชเฐฏเฑเฐเฐฟเฐธเฑเฐคเฐพเฐฐเฑ:
```py
>>> from transformers import pipeline
>>> classifier = pipeline("sentiment-analysis")
```
เฐธเฑเฐเฐเฐฟเฐฎเฑเฐเฐเฑ เฐตเฐฟเฐถเฑเฐฒเฑเฐทเฐฃ เฐเฑเฐธเฐ [`pipeline`] เฐกเฐฟเฐซเฐพเฐฒเฑเฐเฑ [เฐชเฑเฐฐเฑเฐเฑเฐฐเฑเฐจเฑเฐกเฑ เฐฎเฑเฐกเฐฒเฑ](https://huggingface.co/distilbert/distilbert-base-uncased-finetuned-sst-2-english) เฐฎเฐฐเฐฟเฐฏเฑ เฐเฑเฐเฑเฐจเฑเฐเฐฐเฑโเฐจเฐฟ เฐกเฑเฐจเฑโเฐฒเฑเฐกเฑ เฐเฑเฐธเฑเฐคเฑเฐเฐฆเฐฟ เฐฎเฐฐเฐฟเฐฏเฑ เฐเฐพเฐทเฑ เฐเฑเฐธเฑเฐคเฑเฐเฐฆเฐฟ. เฐเฐชเฑเฐชเฑเฐกเฑ เฐฎเฑเฐฐเฑ เฐฎเฑ เฐฒเฐเฑเฐทเฑเฐฏ เฐตเฐเฐจเฐเฐฒเฑ `classifier`เฐจเฐฟ เฐเฐชเฐฏเฑเฐเฐฟเฐเฐเฐตเฐเฑเฐเฑ:
```py
>>> classifier("We are very happy to show you the ๐ค Transformers library.")
[{'label': 'POSITIVE', 'score': 0.9998}]
```
เฐฎเฑเฐฐเฑ เฐเฐเฐเฐฟ เฐเฐเฐเฑ เฐเฐเฑเฐเฑเฐต เฐเฐจเฑโเฐชเฑเฐเฑโเฐฒเฐจเฑ เฐเฐฒเฐฟเฐเฐฟ เฐเฐเฐเฑ, เฐจเฐฟเฐเฐเฐเฑเฐตเฑเฐฒ เฐเฐพเฐฌเฐฟเฐคเฐพเฐจเฑ เฐ
เฐเฐฆเฐฟเฐเฐเฐกเฐพเฐจเฐฟเฐเฐฟ เฐฎเฑ เฐเฐจเฑโเฐชเฑเฐเฑโเฐฒเฐจเฑ เฐเฐพเฐฌเฐฟเฐคเฐพเฐเฐพ [`pipeline`]เฐเฐฟ เฐชเฐเฐชเฐเฐกเฐฟ:
```py
>>> results = classifier(["We are very happy to show you the ๐ค Transformers library.", "We hope you don't hate it."])
>>> for result in results:
... print(f"label: {result['label']}, with score: {round(result['score'], 4)}")
label: POSITIVE, with score: 0.9998
label: NEGATIVE, with score: 0.5309
```
[`pipeline`] เฐฎเฑเฐเฑ เฐจเฐเฑเฐเฐฟเฐจ เฐเฐฆเฑเฐจเฐพ เฐชเฐจเฐฟ เฐเฑเฐธเฐ เฐฎเฑเฐคเฑเฐคเฐ เฐกเฑเฐเฐพเฐธเฑเฐเฑโเฐจเฑ เฐเฑเฐกเฐพ เฐชเฑเฐจเฐฐเฐพเฐตเฑเฐคเฐ เฐเฑเฐฏเฐเฐฒเฐฆเฑ. เฐ เฐเฐฆเฐพเฐนเฐฐเฐฃ เฐเฑเฐธเฐ, เฐธเฑเฐตเฐฏเฐเฐเฐพเฐฒเฐ เฐชเฑเฐฐเฐธเฐเฐ เฐเฑเฐฐเฑเฐคเฐฟเฐเฐชเฑเฐจเฑ เฐฎเฐจ เฐชเฐจเฐฟเฐเฐพ เฐเฐเฐเฑเฐเฑเฐเฐฆเฐพเฐ:
```py
>>> import torch
>>> from transformers import pipeline
>>> speech_recognizer = pipeline("automatic-speech-recognition", model="facebook/wav2vec2-base-960h")
```
เฐฎเฑเฐฐเฑ เฐฎเฐณเฑเฐฒเฑ เฐฎเฐณเฑเฐฒเฑ เฐเฑเฐชเฑเฐชเฐพเฐฒเฐจเฑเฐเฑเฐเฐเฑเฐจเฑเฐจ เฐเฐกเฐฟเฐฏเฑ เฐกเฑเฐเฐพเฐธเฑเฐเฑโเฐจเฑ เฐฒเฑเฐกเฑ เฐเฑเฐฏเฐเฐกเฐฟ (เฐฎเฐฐเฐฟเฐจเฑเฐจเฐฟ เฐตเฐฟเฐตเฐฐเฐพเฐฒ เฐเฑเฐธเฐ ๐ค เฐกเฑเฐเฐพเฐธเฑเฐเฑโเฐฒเฑ [เฐคเฑเฐตเฐฐเฐฟเฐค เฐชเฑเฐฐเฐพเฐฐเฐเฐญเฐ](https://huggingface.co/docs/datasets/quickstart#audio) เฐเฑเฐกเฐเฐกเฐฟ. เฐเฐฆเฐพเฐนเฐฐเฐฃเฐเฑ, [MInDS-14](https://huggingface.co/datasets/PolyAI/minds14) เฐกเฑเฐเฐพเฐธเฑเฐเฑโเฐจเฑ เฐฒเฑเฐกเฑ เฐเฑเฐฏเฐเฐกเฐฟ:
```py
>>> from datasets import load_dataset, Audio
>>> dataset = load_dataset("PolyAI/minds14", name="en-US", split="train") # doctest: +IGNORE_RESULT
```
เฐกเฑเฐเฐพเฐธเฑเฐเฑ เฐฏเฑเฐเฑเฐ เฐจเฐฎเฑเฐจเฐพ เฐฐเฑเฐเฑ เฐจเฐฎเฑเฐจเฐพเฐคเฑ เฐธเฐฐเฐฟเฐชเฑเฐฒเฑเฐคเฑเฐเฐฆเฐจเฐฟ เฐฎเฑเฐฐเฑ เฐจเฐฟเฐฐเฑเฐงเฐพเฐฐเฐฟเฐเฐเฑเฐเฑเฐตเฐพเฐฒเฐฟ
เฐฐเฑเฐเฑ [`facebook/wav2vec2-base-960h`](https://huggingface.co/facebook/wav2vec2-base-960h) เฐฆเฑเฐจเฐฟเฐชเฑ เฐถเฐฟเฐเฑเฐทเฐฃ เฐชเฑเฐเฐฆเฐฟเฐเฐฆเฐฟ:
```py
>>> dataset = dataset.cast_column("audio", Audio(sampling_rate=speech_recognizer.feature_extractor.sampling_rate))
```
`"เฐเฐกเฐฟเฐฏเฑ"` เฐเฐพเฐฒเฐฎเฑโเฐเฐฟ เฐเฐพเฐฒเฑ เฐเฑเฐธเฑเฐคเฑเฐจเฑเฐจเฐชเฑเฐชเฑเฐกเฑ เฐเฐกเฐฟเฐฏเฑ เฐซเฑเฐฒเฑโเฐฒเฑ เฐธเฑเฐตเฐฏเฐเฐเฐพเฐฒเฐเฐเฐเฐพ เฐฒเฑเฐกเฑ เฐเฑเฐฏเฐฌเฐกเฐคเฐพเฐฏเฐฟ เฐฎเฐฐเฐฟเฐฏเฑ เฐฎเฐณเฑเฐฒเฑ เฐจเฐฎเฑเฐจเฐพ เฐเฑเฐฏเฐฌเฐกเฐคเฐพเฐฏเฐฟ.
เฐฎเฑเฐฆเฐเฐฟ 4 เฐจเฐฎเฑเฐจเฐพเฐฒ เฐจเฑเฐเฐกเฐฟ เฐฎเฑเฐกเฐฟ เฐตเฑเฐตเฑโเฐซเฐพเฐฐเฑเฐฎเฑ เฐถเฑเฐฐเฑเฐฃเฑเฐฒเฐจเฑ เฐธเฐเฐเฑเฐฐเฐนเฐฟเฐเฐเฐฟ, เฐชเฑเฐชเฑโเฐฒเฑเฐจเฑโเฐเฑ เฐเฐพเฐฌเฐฟเฐคเฐพเฐเฐพ เฐชเฐพเฐธเฑ เฐเฑเฐฏเฐเฐกเฐฟ:
```py
>>> result = speech_recognizer(dataset[:4]["audio"])
>>> print([d["text"] for d in result])
['I WOULD LIKE TO SET UP A JOINT ACCOUNT WITH MY PARTNER HOW DO I PROCEED WITH DOING THAT', "FONDERING HOW I'D SET UP A JOIN TO HELL T WITH MY WIFE AND WHERE THE AP MIGHT BE", "I I'D LIKE TOY SET UP A JOINT ACCOUNT WITH MY PARTNER I'M NOT SEEING THE OPTION TO DO IT ON THE APSO I CALLED IN TO GET SOME HELP CAN I JUST DO IT OVER THE PHONE WITH YOU AND GIVE YOU THE INFORMATION OR SHOULD I DO IT IN THE AP AN I'M MISSING SOMETHING UQUETTE HAD PREFERRED TO JUST DO IT OVER THE PHONE OF POSSIBLE THINGS", 'HOW DO I FURN A JOINA COUT']
```
เฐเฐจเฑโเฐชเฑเฐเฑโเฐฒเฑ เฐชเฑเฐฆเฑเฐฆเฐเฐพ เฐเฐจเฑเฐจ เฐชเฑเฐฆเฑเฐฆ เฐกเฑเฐเฐพเฐธเฑเฐเฑโเฐฒ เฐเฑเฐธเฐ (เฐธเฑเฐชเฑเฐเฑ เฐฒเฑเฐฆเฐพ เฐตเฐฟเฐเฐจเฑ เฐตเฐเฐเฐฟเฐตเฐฟ), เฐฎเฑเฐฎเฐฐเฑเฐฒเฑเฐจเฐฟ เฐ
เฐจเฑเฐจเฐฟ เฐเฐจเฑโเฐชเฑเฐเฑโเฐฒเฐจเฑ เฐฒเฑเฐกเฑ เฐเฑเฐฏเฐกเฐพเฐจเฐฟเฐเฐฟ เฐฎเฑเฐฐเฑ เฐเฐพเฐฌเฐฟเฐคเฐพเฐเฑ เฐฌเฐฆเฑเฐฒเฑเฐเฐพ เฐเฑเฐจเฐฐเฑเฐเฐฐเฑโเฐจเฑ เฐชเฐพเฐธเฑ เฐเฑเฐฏเฐพเฐฒเฐจเฑเฐเฑเฐเฐเฑเฐจเฑเฐจเฐพเฐฐเฑ. เฐฎเฐฐเฐฟเฐเฐค เฐธเฐฎเฐพเฐเฐพเฐฐเฐ เฐเฑเฐธเฐ [เฐชเฑเฐชเฑโเฐฒเฑเฐจเฑ API เฐธเฑเฐเฐจ](./main_classes/pipelines)เฐจเฐฟ เฐเฑเฐกเฐเฐกเฐฟ.
### เฐชเฑเฐชเฑโเฐฒเฑเฐจเฑโเฐฒเฑ เฐฎเฐฐเฑเฐ เฐฎเฑเฐกเฐฒเฑ เฐฎเฐฐเฐฟเฐฏเฑ เฐเฑเฐเฑเฐจเฑเฐเฐฐเฑโเฐจเฐฟ เฐเฐชเฐฏเฑเฐเฐฟเฐเฐเฐเฐกเฐฟ
[`pipeline`] [Hub](https://huggingface.co/models) เฐจเฑเฐเฐกเฐฟ เฐเฐฆเฑเฐจเฐพ เฐฎเฑเฐกเฐฒเฑโเฐจเฑ เฐเฐฒเฐฟเฐเฐฟ เฐเฐเฐเฑเฐเฐฆเฐฟ, เฐฆเฑเฐจเฐฟ เฐตเฐฒเฐจ เฐเฐคเฐฐ เฐตเฐฟเฐจเฐฟเฐฏเฑเฐ-เฐเฑเฐธเฑเฐฒ เฐเฑเฐธเฐ [`pipeline`]เฐจเฐฟ เฐธเฑเฐฒเฐญเฐเฐเฐพ เฐธเฑเฐตเฑเฐเฐฐเฐฟเฐเฐเฐตเฐเฑเฐเฑ. เฐเฐฆเฐพเฐนเฐฐเฐฃเฐเฑ, เฐฎเฑเฐฐเฑ เฐซเฑเฐฐเฑเฐเฐเฑ เฐเฑเฐเฑเฐธเฑเฐเฑโเฐจเฑ เฐนเฑเฐฏเฐพเฐเฐกเฐฟเฐฒเฑ เฐเฑเฐฏเฐเฐฒ เฐฎเฑเฐกเฐฒเฑ เฐเฐพเฐตเฐพเฐฒเฐจเฑเฐเฑเฐเฐเฑ, เฐคเฐเฐฟเฐจ เฐฎเฑเฐกเฐฒเฑ เฐเฑเฐธเฐ เฐซเฐฟเฐฒเฑเฐเฐฐเฑ เฐเฑเฐฏเฐกเฐพเฐจเฐฟเฐเฐฟ เฐนเฐฌเฑโเฐฒเฑเฐจเฐฟ เฐเฑเฐฏเฐพเฐเฑโเฐฒเฐจเฑ เฐเฐชเฐฏเฑเฐเฐฟเฐเฐเฐเฐกเฐฟ. เฐ
เฐเฑเฐฐ เฐซเฐฟเฐฒเฑเฐเฐฐเฑ เฐเฑเฐธเฐฟเฐจ เฐซเฐฒเฐฟเฐคเฐ เฐฎเฑเฐฐเฑ เฐซเฑเฐฐเฑเฐเฐเฑ เฐเฑเฐเฑเฐธเฑเฐเฑ เฐเฑเฐธเฐ เฐเฐชเฐฏเฑเฐเฐฟเฐเฐเฐเฐฒ เฐธเฑเฐเฐเฐฟเฐฎเฑเฐเฐเฑ เฐตเฐฟเฐถเฑเฐฒเฑเฐทเฐฃ เฐเฑเฐธเฐ เฐซเฑเฐจเฑโเฐเฑเฐฏเฑเฐจเฑ เฐเฑเฐฏเฐฌเฐกเฐฟเฐจ เฐฌเฐนเฑเฐญเฐพเฐทเฐพ [BERT เฐฎเฑเฐกเฐฒเฑ](https://huggingface.co/nlptown/bert-base-multilingual-uncased-sentiment)เฐจเฐฟ เฐ
เฐเฐฆเฐฟเฐธเฑเฐคเฑเฐเฐฆเฐฟ:
```py
>>> model_name = "nlptown/bert-base-multilingual-uncased-sentiment"
```
<frameworkcontent>
<pt>
เฐฎเฑเฐเฐฆเฑเฐเฐพ เฐถเฐฟเฐเฑเฐทเฐฃ เฐชเฑเฐเฐฆเฐฟเฐจ เฐฎเฑเฐกเฐฒเฑโเฐจเฑ เฐฒเฑเฐกเฑ เฐเฑเฐฏเฐกเฐพเฐจเฐฟเฐเฐฟ [`AutoModelForSequenceClassification`] เฐฎเฐฐเฐฟเฐฏเฑ [`AutoTokenizer`]เฐจเฐฟ เฐเฐชเฐฏเฑเฐเฐฟเฐเฐเฐเฐกเฐฟ เฐฎเฐฐเฐฟเฐฏเฑ เฐฆเฐพเฐจเฐฟ เฐ
เฐจเฑเฐฌเฐเฐงเฐฟเฐค เฐเฑเฐเฑเฐจเฑเฐเฐฐเฑ (เฐคเฐฆเฑเฐชเฐฐเฐฟ เฐตเฐฟเฐญเฐพเฐเฐเฐฒเฑ `AutoClass`เฐชเฑ เฐฎเฐฐเฐฟเฐจเฑเฐจเฐฟ):
```py
>>> from transformers import AutoTokenizer, AutoModelForSequenceClassification
>>> model = AutoModelForSequenceClassification.from_pretrained(model_name)
>>> tokenizer = AutoTokenizer.from_pretrained(model_name)
```
</pt>
<tf>
เฐฎเฑเฐเฐฆเฑเฐเฐพ เฐถเฐฟเฐเฑเฐทเฐฃ เฐชเฑเฐเฐฆเฐฟเฐจ เฐฎเฑเฐกเฐฒเฑโเฐจเฑ เฐฒเฑเฐกเฑ เฐเฑเฐฏเฐกเฐพเฐจเฐฟเฐเฐฟ [`TFAutoModelForSequenceClassification`] เฐฎเฐฐเฐฟเฐฏเฑ [`AutoTokenizer`]เฐจเฐฟ เฐเฐชเฐฏเฑเฐเฐฟเฐเฐเฐเฐกเฐฟ เฐฎเฐฐเฐฟเฐฏเฑ เฐฆเฐพเฐจเฐฟ เฐ
เฐจเฑเฐฌเฐเฐงเฐฟเฐค เฐเฑเฐเฑเฐจเฑเฐเฐฐเฑ (เฐคเฐฆเฑเฐชเฐฐเฐฟ เฐตเฐฟเฐญเฐพเฐเฐเฐฒเฑ `TFAutoClass`เฐชเฑ เฐฎเฐฐเฐฟเฐจเฑเฐจเฐฟ):
```py
>>> from transformers import AutoTokenizer, TFAutoModelForSequenceClassification
>>> model = TFAutoModelForSequenceClassification.from_pretrained(model_name)
>>> tokenizer = AutoTokenizer.from_pretrained(model_name)
```
</tf>
</frameworkcontent>
[`pipeline`]เฐฒเฑ เฐฎเฑเฐกเฐฒเฑ เฐฎเฐฐเฐฟเฐฏเฑ เฐเฑเฐเฑเฐจเฑเฐเฐฐเฑโเฐจเฑ เฐชเฑเฐฐเฑเฐเฑเฐจเฐเฐกเฐฟ เฐฎเฐฐเฐฟเฐฏเฑ เฐเฐชเฑเฐชเฑเฐกเฑ เฐฎเฑเฐฐเฑ เฐซเฑเฐฐเฑเฐเฐเฑ เฐเฑเฐเฑเฐธเฑเฐเฑโเฐชเฑ `เฐเฑเฐฒเฐพเฐธเฐฟเฐซเฑเฐฏเฐฐเฑ`เฐจเฐฟ เฐตเฐฐเฑเฐคเฐฟเฐเฐชเฐเฑเฐฏเฐตเฐเฑเฐเฑ:
```py
>>> classifier = pipeline("sentiment-analysis", model=model, tokenizer=tokenizer)
>>> classifier("Nous sommes trรจs heureux de vous prรฉsenter la bibliothรจque ๐ค Transformers.")
[{'label': '5 stars', 'score': 0.7273}]
```
เฐฎเฑเฐฐเฑ เฐฎเฑ เฐตเฐฟเฐจเฐฟเฐฏเฑเฐ-เฐเฑเฐธเฑ เฐเฑเฐธเฐ เฐฎเฑเฐกเฐฒเฑโเฐจเฑ เฐเฐจเฑเฐเฑเฐจเฐฒเฑเฐเฐชเฑเฐคเฑ, เฐฎเฑเฐฐเฑ เฐฎเฑ เฐกเฑเฐเฐพเฐชเฑ เฐฎเฑเฐเฐฆเฑเฐเฐพ เฐถเฐฟเฐเฑเฐทเฐฃ เฐชเฑเฐเฐฆเฐฟเฐจ เฐฎเฑเฐกเฐฒเฑโเฐจเฑ เฐเฐเฑเฐเฐเฐพ เฐฎเฐพเฐฐเฑเฐเฐพเฐฒเฐฟ. เฐเฐฒเฐพเฐเฑ เฐคเฑเฐฒเฑเฐธเฑเฐเฑเฐตเฐกเฐพเฐจเฐฟเฐเฐฟ เฐฎเฐพ [เฐซเฑเฐจเฑโเฐเฑเฐฏเฑเฐจเฐฟเฐเฐเฑ เฐเฑเฐฏเฑเฐเฑเฐฐเฐฟเฐฏเฐฒเฑ](./training)เฐจเฐฟ เฐเฑเฐกเฐเฐกเฐฟ. เฐเฐฟเฐตเฐฐเฐเฐพ, เฐฎเฑเฐฐเฑ เฐฎเฑ เฐชเฑเฐฐเฑเฐเฑเฐฐเฑเฐจเฑเฐกเฑ เฐฎเฑเฐกเฐฒเฑโเฐจเฐฟ เฐซเฑเฐจเฑโเฐเฑเฐฏเฑเฐจเฑ เฐเฑเฐธเฐฟเฐจ เฐคเฐฐเฑเฐตเฐพเฐค, เฐฆเฐฏเฐเฑเฐธเฐฟ เฐ
เฐเฐฆเฐฐเฐฟ เฐเฑเฐธเฐ เฐฎเฑเฐทเฐฟเฐจเฑ เฐฒเฑเฐฐเฑเฐจเฐฟเฐเฐเฑโเฐจเฐฟ เฐกเฑเฐฎเฑเฐเฑเฐฐเฐเฑเฐเฑ เฐเฑเฐฏเฐกเฐพเฐจเฐฟเฐเฐฟ เฐนเฐฌเฑโเฐฒเฑเฐจเฐฟ เฐธเฐเฐเฐเฐคเฑ เฐฎเฑเฐกเฐฒเฑโเฐจเฑ [เฐทเฑเฐฐเฐฟเฐเฐเฑ](./model_sharing) เฐชเฐฐเฐฟเฐเฐฃเฐฟเฐเฐเฐเฐกเฐฟ! ๐ค
## AutoClass
<Youtube id="AhChOFRegn4"/>
เฐนเฑเฐกเฑ เฐเฐฟเฐเฐฆ, เฐฎเฑเฐฐเฑ เฐชเฑเฐจ เฐเฐชเฐฏเฑเฐเฐฟเฐเฐเฐฟเฐจ [`pipeline`]เฐเฐฟ เฐถเฐเฑเฐคเฐฟเฐจเฐฟ เฐ
เฐเฐฆเฐฟเฐเฐเฐกเฐพเฐจเฐฟเฐเฐฟ [`AutoModelForSequenceClassification`] เฐฎเฐฐเฐฟเฐฏเฑ [`AutoTokenizer`] เฐคเฐฐเฐเฐคเฑเฐฒเฑ เฐเฐฒเฐฟเฐธเฐฟ เฐชเฐจเฐฟ เฐเฑเฐธเฑเฐคเฐพเฐฏเฐฟ. เฐเฐ [AutoClass](./model_doc/auto) เฐ
เฐจเฑเฐฆเฐฟ เฐฎเฑเฐเฐฆเฑเฐเฐพ เฐถเฐฟเฐเฑเฐทเฐฃ เฐชเฑเฐเฐฆเฐฟเฐจ เฐฎเฑเฐกเฐฒเฑ เฐฏเฑเฐเฑเฐ เฐเฐฐเฑเฐเฐฟเฐเฑเฐเฑเฐเฐฐเฑโเฐจเฑ เฐฆเฐพเฐจเฐฟ เฐชเฑเฐฐเฑ เฐฒเฑเฐฆเฐพ เฐฎเฐพเฐฐเฑเฐเฐ เฐจเฑเฐเฐกเฐฟ เฐธเฑเฐตเฐฏเฐเฐเฐพเฐฒเฐเฐเฐเฐพ เฐคเฐฟเฐฐเฐฟเฐเฐฟ เฐชเฑเฐเฐฆเฑ เฐธเฐคเฑเฐตเฐฐเฐฎเฐพเฐฐเฑเฐเฐ. เฐฎเฑเฐฐเฑ เฐฎเฑ เฐเฐพเฐธเฑเฐเฑ เฐเฑเฐธเฐ เฐคเฐเฐฟเฐจ `เฐเฐเฑเฐเฑเฐฒเฐพเฐธเฑ`เฐจเฐฟ เฐฎเฐพเฐคเฑเฐฐเฐฎเฑ เฐเฐเฐเฑเฐเฑเฐตเฐพเฐฒเฐฟ เฐฎเฐฐเฐฟเฐฏเฑ เฐเฐฆเฐฟ เฐ
เฐจเฑเฐฌเฐเฐงเฐฟเฐค เฐชเฑเฐฐเฑเฐชเฑเฐฐเฐพเฐธเฑเฐธเฐฟเฐเฐเฑ เฐเฑเฐฒเฐพเฐธเฑ.
เฐฎเฑเฐจเฑเฐชเฐเฐฟ เฐตเฐฟเฐญเฐพเฐเฐ เฐจเฑเฐเฐกเฐฟ เฐเฐฆเฐพเฐนเฐฐเฐฃเฐเฐฟ เฐคเฐฟเฐฐเฐฟเฐเฐฟ เฐตเฑเฐณเฑเฐฒเฐฟ, [`pipeline`] เฐซเฐฒเฐฟเฐคเฐพเฐฒเฐจเฑ เฐชเฑเฐฐเฐคเฐฟเฐฌเฐฟเฐเฐฌเฐฟเฐเฐเฐกเฐพเฐจเฐฟเฐเฐฟ เฐฎเฑเฐฐเฑ `เฐเฐเฑเฐเฑเฐฒเฐพเฐธเฑ`เฐจเฐฟ เฐเฐฒเฐพ เฐเฐชเฐฏเฑเฐเฐฟเฐเฐเฐตเฐเฑเฐเฑ เฐเฑเฐฆเฑเฐฆเฐพเฐ.
### AutoTokenizer
เฐเฐ เฐฎเฑเฐกเฐฒเฑโเฐเฑ เฐเฐจเฑโเฐชเฑเฐเฑโเฐฒเฑเฐเฐพ เฐธเฐเฐเฑเฐฏเฐฒ เฐถเฑเฐฐเฑเฐฃเฐฟเฐฒเฑ เฐตเฐเฐจเฐพเฐจเฑเฐจเฐฟ เฐชเฑเฐฐเฑเฐชเฑเฐฐเฐพเฐธเฑเฐธเฐฟเฐเฐเฑ เฐเฑเฐฏเฐกเฐพเฐจเฐฟเฐเฐฟ เฐเฑเฐเฑเฐจเฑเฐเฐฐเฑ เฐฌเฐพเฐงเฑเฐฏเฐค เฐตเฐนเฐฟเฐธเฑเฐคเฑเฐเฐฆเฐฟ. เฐชเฐฆเฐพเฐจเฑเฐจเฐฟ เฐเฐฒเฐพ เฐตเฐฟเฐญเฐเฐฟเฐเฐเฐพเฐฒเฐฟ เฐฎเฐฐเฐฟเฐฏเฑ เฐ เฐธเฑเฐฅเฐพเฐฏเฐฟเฐฒเฑ เฐชเฐฆเฐพเฐฒเฐจเฑ เฐตเฐฟเฐญเฐเฐฟเฐเฐเฐพเฐฒเฐฟ ([tokenizer เฐธเฐพเฐฐเฐพเฐเฐถเฐ](./tokenizer_summary)เฐฒเฑ เฐเฑเฐเฐจเฑเฐเฑเฐทเฐจเฑ เฐเฑเฐฐเฐฟเฐเฐเฐฟ เฐฎเฐฐเฐฟเฐเฐค เฐคเฑเฐฒเฑเฐธเฑเฐเฑเฐเฐกเฐฟ) เฐธเฐนเฐพ เฐเฑเฐเฐจเฑเฐเฑเฐทเฐจเฑ เฐชเฑเฐฐเฐเฑเฐฐเฐฟเฐฏเฐจเฑ เฐจเฐฟเฐฏเฐเฐคเฑเฐฐเฐฟเฐเฐเฑ เฐ
เฐจเฑเฐ เฐจเฐฟเฐฏเฐฎเฐพเฐฒเฑ เฐเฐจเฑเฐจเฐพเฐฏเฐฟ. เฐเฑเฐฐเฑเฐคเฑเฐเฐเฑเฐเฑเฐตเฐฒเฐธเฐฟเฐจ เฐฎเฑเฐเฑเฐฏเฐฎเฑเฐจ เฐตเฐฟเฐทเฐฏเฐ เฐเฐฎเฐฟเฐเฐเฐเฑ, เฐฎเฑเฐฐเฑ เฐฎเฑเฐกเฐฒเฑโเฐเฑ เฐฎเฑเฐเฐฆเฑ เฐถเฐฟเฐเฑเฐทเฐฃ เฐชเฑเฐเฐฆเฐฟเฐจ เฐ
เฐฆเฑ เฐเฑเฐเฐจเฑเฐเฑเฐทเฐจเฑ เฐจเฐฟเฐฏเฐฎเฐพเฐฒเฐจเฑ เฐเฐชเฐฏเฑเฐเฐฟเฐธเฑเฐคเฑเฐจเฑเฐจเฐพเฐฐเฐจเฐฟ เฐจเฐฟเฐฐเฑเฐงเฐพเฐฐเฐฟเฐเฐเฑเฐเฑเฐตเฐกเฐพเฐจเฐฟเฐเฐฟ เฐฎเฑเฐฐเฑ เฐ
เฐฆเฑ เฐฎเฑเฐกเฐฒเฑ เฐชเฑเฐฐเฑเฐคเฑ เฐเฑเฐเฑเฐจเฑเฐเฐฐเฑโเฐจเฑ เฐคเฐเฑเฐทเฐฃเฐ เฐเฑเฐฏเฐพเฐฒเฐฟ.
[`AutoTokenizer`]เฐคเฑ เฐเฑเฐเฑเฐจเฑเฐเฐฐเฑโเฐจเฑ เฐฒเฑเฐกเฑ เฐเฑเฐฏเฐเฐกเฐฟ:
```py
>>> from transformers import AutoTokenizer
>>> model_name = "nlptown/bert-base-multilingual-uncased-sentiment"
>>> tokenizer = AutoTokenizer.from_pretrained(model_name)
```
เฐฎเฑ เฐตเฐเฐจเฐพเฐจเฑเฐจเฐฟ เฐเฑเฐเฑเฐจเฑเฐเฐฐเฑโเฐเฑ เฐชเฐเฐชเฐเฐกเฐฟ:
```py
>>> encoding = tokenizer("We are very happy to show you the ๐ค Transformers library.")
>>> print(encoding)
{'input_ids': [101, 11312, 10320, 12495, 19308, 10114, 11391, 10855, 10103, 100, 58263, 13299, 119, 102],
'token_type_ids': [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
'attention_mask': [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]}
```
เฐเฑเฐเฑเฐจเฑเฐเฐฐเฑ เฐตเฑเฐเฐฟเฐจเฐฟ เฐเฐฒเฐฟเฐเฐฟ เฐเฐจเฑเฐจ เฐจเฐฟเฐเฐเฐเฑเฐตเฑเฐจเฐฟ เฐ
เฐเฐฆเฐฟเฐธเฑเฐคเฑเฐเฐฆเฐฟ:
* [input_ids](./glossary#input-ids): เฐฎเฑ เฐเฑเฐเฑเฐจเฑโเฐฒ เฐธเฐเฐเฑเฐฏเฐพเฐชเฐฐเฐฎเฑเฐจ เฐชเฑเฐฐเฐพเฐคเฐฟเฐจเฐฟเฐงเฑเฐฏเฐ.
* [เฐ
เฐเฑเฐจเฑเฐทเฐจเฑ_เฐฎเฐพเฐธเฑเฐเฑ](./glossary#attention-mask): เฐ เฐเฑเฐเฑเฐจเฑโเฐฒเฐเฑ เฐนเฐพเฐเฐฐเฑ เฐเฐพเฐตเฐพเฐฒเฑ เฐธเฑเฐเฐฟเฐธเฑเฐคเฑเฐเฐฆเฐฟ.
เฐเฐ เฐเฑเฐเฑเฐจเฑเฐเฐฐเฑ เฐเฐจเฑโเฐชเฑเฐเฑโเฐฒ เฐเฐพเฐฌเฐฟเฐคเฐพเฐจเฑ เฐเฑเฐกเฐพ เฐเฐฎเฑเฐฆเฐฟเฐเฐเฐเฐฒเฐฆเฑ เฐฎเฐฐเฐฟเฐฏเฑ เฐเฐเฐฐเฑเฐคเฐฟ เฐชเฑเฐกเฐตเฑเฐคเฑ เฐฌเฑเฐฏเฐพเฐเฑโเฐจเฑ เฐคเฐฟเฐฐเฐฟเฐเฐฟ เฐเฐตเฑเฐตเฐกเฐพเฐจเฐฟเฐเฐฟ เฐเฑเฐเฑเฐธเฑเฐเฑโเฐจเฑ เฐชเฑเฐฏเฐพเฐกเฑ เฐเฑเฐธเฐฟ เฐเฐคเฑเฐคเฐฟเฐฐเฐฟเฐเฐเฐตเฐเฑเฐเฑ:
<frameworkcontent>
<pt>
```py
>>> pt_batch = tokenizer(
... ["We are very happy to show you the ๐ค Transformers library.", "We hope you don't hate it."],
... padding=True,
... truncation=True,
... max_length=512,
... return_tensors="pt",
... )
```
</pt>
<tf>
```py
>>> tf_batch = tokenizer(
... ["We are very happy to show you the ๐ค Transformers library.", "We hope you don't hate it."],
... padding=True,
... truncation=True,
... max_length=512,
... return_tensors="tf",
... )
```
</tf>
</frameworkcontent>
<Tip>
เฐเฑเฐเฐจเฑเฐเฑเฐทเฐจเฑ เฐเฑเฐฐเฐฟเฐเฐเฐฟ เฐฎเฐฐเฐฟเฐจเฑเฐจเฐฟ เฐตเฐฟเฐตเฐฐเฐพเฐฒ เฐเฑเฐธเฐ [เฐชเฑเฐฐเฑเฐชเฑเฐฐเฐพเฐธเฑเฐธเฑ](./preprocessing) เฐเฑเฐฏเฑเฐเฑเฐฐเฐฟเฐฏเฐฒเฑโเฐจเฐฟ เฐเฑเฐกเฐเฐกเฐฟ เฐฎเฐฐเฐฟเฐฏเฑ เฐเฐฎเฑเฐเฑ, เฐเฐกเฐฟเฐฏเฑ เฐฎเฐฐเฐฟเฐฏเฑ เฐฎเฐฒเฑเฐเฑเฐฎเฑเฐกเฐฒเฑ เฐเฐจเฑโเฐชเฑเฐเฑโเฐฒเฐจเฑ เฐชเฑเฐฐเฑเฐชเฑเฐฐเฐพเฐธเฑเฐธเฑ เฐเฑเฐฏเฐกเฐพเฐจเฐฟเฐเฐฟ [`AutoImageProcessor`], [`AutoFeatureExtractor`] เฐฎเฐฐเฐฟเฐฏเฑ [`AutoProcessor`] เฐเฐฒเฐพ เฐเฐชเฐฏเฑเฐเฐฟเฐเฐเฐพเฐฒเฐฟ.
</Tip>
### AutoModel
<frameworkcontent>
<pt>
๐ค เฐเฑเฐฐเฐพเฐจเฑเฐธเฑโเฐซเฐพเฐฐเฑเฐฎเฐฐเฑเฐฒเฑ เฐชเฑเฐฐเฑเฐเฑเฐฐเฑเฐจเฑเฐกเฑ เฐเฐจเฑโเฐธเฑเฐเฐพเฐจเฑเฐธเฑโเฐฒเฐจเฑ เฐฒเฑเฐกเฑ เฐเฑเฐฏเฐกเฐพเฐจเฐฟเฐเฐฟ เฐธเฑเฐฒเฐญเฐฎเฑเฐจ เฐฎเฐฐเฐฟเฐฏเฑ เฐเฐเฑเฐเฑเฐค เฐฎเฐพเฐฐเฑเฐเฐพเฐจเฑเฐจเฐฟ เฐ
เฐเฐฆเฐฟเฐธเฑเฐคเฐพเฐฏเฐฟ. เฐฆเฑเฐจเฐฟ เฐ
เฐฐเฑเฐฅเฐ เฐฎเฑเฐฐเฑ [`AutoTokenizer`]เฐจเฐฟ เฐฒเฑเฐกเฑ เฐเฑเฐธเฐฟเฐจเฐเฑเฐฒเฑเฐเฐพ [`AutoModel`]เฐจเฐฟ เฐฒเฑเฐกเฑ เฐเฑเฐฏเฐตเฐเฑเฐเฑ. เฐเฐพเฐธเฑเฐเฑ เฐเฑเฐธเฐ เฐธเฐฐเฑเฐจ [`AutoModel`]เฐจเฐฟ เฐเฐเฐเฑเฐเฑเฐตเฐกเฐ เฐฎเฐพเฐคเฑเฐฐเฐฎเฑ เฐคเฑเฐกเฐพ. เฐเฑเฐเฑเฐธเฑเฐเฑ (เฐฒเฑเฐฆเฐพ เฐธเฑเฐเฑเฐตเฑเฐจเฑเฐธเฑ) เฐตเฐฐเฑเฐเฑเฐเฐฐเฐฃ เฐเฑเฐธเฐ, เฐฎเฑเฐฐเฑ [`AutoModelForSequenceClassification`]เฐจเฐฟ เฐฒเฑเฐกเฑ เฐเฑเฐฏเฐพเฐฒเฐฟ:
```py
>>> from transformers import AutoModelForSequenceClassification
>>> model_name = "nlptown/bert-base-multilingual-uncased-sentiment"
>>> pt_model = AutoModelForSequenceClassification.from_pretrained(model_name)
```
<Tip>
[`AutoModel`] เฐเฑเฐฒเฐพเฐธเฑ เฐฆเฑเฐตเฐพเฐฐเฐพ เฐธเฐชเฑเฐฐเฑเฐเฑ เฐเฑเฐธเฑ เฐเฐพเฐธเฑเฐเฑโเฐฒ เฐเฑเฐธเฐ [เฐเฐพเฐธเฑเฐเฑ เฐธเฐพเฐฐเฐพเฐเฐถเฐ](./task_summary)เฐจเฐฟ เฐเฑเฐกเฐเฐกเฐฟ.
</Tip>
เฐเฐชเฑเฐชเฑเฐกเฑ เฐฎเฑ เฐชเฑเฐฐเฑเฐชเฑเฐฐเฐพเฐธเฑเฐธเฑ เฐเฑเฐฏเฐฌเฐกเฐฟเฐจ เฐฌเฑเฐฏเฐพเฐเฑ เฐเฐจเฑโเฐชเฑเฐเฑโเฐฒเฐจเฑ เฐจเฑเฐฐเฑเฐเฐพ เฐฎเฑเฐกเฐฒเฑโเฐเฐฟ เฐชเฐเฐชเฐเฐกเฐฟ. เฐฎเฑเฐฐเฑ `**`เฐจเฐฟ เฐเฑเฐกเฐฟเฐเฐเฐกเฐ เฐฆเฑเฐตเฐพเฐฐเฐพ เฐจเฐฟเฐเฐเฐเฑเฐตเฑเฐจเฐฟ เฐ
เฐจเฑโเฐชเฑเฐฏเฐพเฐเฑ เฐเฑเฐฏเฐพเฐฒเฐฟ:
```py
>>> pt_outputs = pt_model(**pt_batch)
```
เฐฎเฑเฐกเฐฒเฑ เฐคเฑเฐฆเฐฟ เฐฏเฐพเฐเฑเฐเฐฟเฐตเฑเฐทเฐจเฑโเฐฒเฐจเฑ `logits` เฐฒเฐเฑเฐทเฐฃเฐเฐฒเฑ เฐ
เฐตเฑเฐเฑโเฐชเฑเฐเฑ เฐเฑเฐธเฑเฐคเฑเฐเฐฆเฐฟ. เฐธเฐเฐญเฐพเฐตเฑเฐฏเฐคเฐฒเฐจเฑ เฐคเฐฟเฐฐเฐฟเฐเฐฟ เฐชเฑเฐเฐฆเฐกเฐพเฐจเฐฟเฐเฐฟ เฐธเฐพเฐซเฑเฐเฑโเฐฎเฐพเฐเฑเฐธเฑ เฐซเฐเฐเฑเฐทเฐจเฑโเฐจเฑ `logits` เฐเฑ เฐตเฐฐเฑเฐคเฐฟเฐเฐชเฐเฑเฐฏเฐเฐกเฐฟ:
```py
>>> from torch import nn
>>> pt_predictions = nn.functional.softmax(pt_outputs.logits, dim=-1)
>>> print(pt_predictions)
tensor([[0.0021, 0.0018, 0.0115, 0.2121, 0.7725],
[0.2084, 0.1826, 0.1969, 0.1755, 0.2365]], grad_fn=<SoftmaxBackward0>)
```
</pt>
<tf>
๐ค เฐเฑเฐฐเฐพเฐจเฑเฐธเฑโเฐซเฐพเฐฐเฑเฐฎเฐฐเฑเฐฒเฑ เฐชเฑเฐฐเฑเฐเฑเฐฐเฑเฐจเฑเฐกเฑ เฐเฐจเฑโเฐธเฑเฐเฐพเฐจเฑเฐธเฑโเฐฒเฐจเฑ เฐฒเฑเฐกเฑ เฐเฑเฐฏเฐกเฐพเฐจเฐฟเฐเฐฟ เฐธเฑเฐฒเฐญเฐฎเฑเฐจ เฐฎเฐฐเฐฟเฐฏเฑ เฐเฐเฑเฐเฑเฐค เฐฎเฐพเฐฐเฑเฐเฐพเฐจเฑเฐจเฐฟ เฐ
เฐเฐฆเฐฟเฐธเฑเฐคเฐพเฐฏเฐฟ. เฐฎเฑเฐฐเฑ [`AutoTokenizer`]เฐจเฐฟ เฐฒเฑเฐกเฑ เฐเฑเฐธเฐฟเฐจเฐเฑเฐฒเฑเฐเฐพ เฐฎเฑเฐฐเฑ [`TFAutoModel`]เฐจเฐฟ เฐฒเฑเฐกเฑ เฐเฑเฐฏเฐตเฐเฑเฐเฐจเฐฟ เฐฆเฑเฐจเฐฟ เฐ
เฐฐเฑเฐฅเฐ. เฐเฐพเฐธเฑเฐเฑ เฐเฑเฐธเฐ เฐธเฐฐเฑเฐจ [`TFAutoModel`]เฐจเฐฟ เฐเฐเฐเฑเฐเฑเฐตเฐกเฐ เฐฎเฐพเฐคเฑเฐฐเฐฎเฑ เฐคเฑเฐกเฐพ. เฐเฑเฐเฑเฐธเฑเฐเฑ (เฐฒเฑเฐฆเฐพ เฐธเฑเฐเฑเฐตเฑเฐจเฑเฐธเฑ) เฐตเฐฐเฑเฐเฑเฐเฐฐเฐฃ เฐเฑเฐธเฐ, เฐฎเฑเฐฐเฑ [`TFAutoModelForSequenceClassification`]เฐจเฐฟ เฐฒเฑเฐกเฑ เฐเฑเฐฏเฐพเฐฒเฐฟ:
```py
>>> from transformers import TFAutoModelForSequenceClassification
>>> model_name = "nlptown/bert-base-multilingual-uncased-sentiment"
>>> tf_model = TFAutoModelForSequenceClassification.from_pretrained(model_name)
```
<Tip>
[`AutoModel`] เฐเฑเฐฒเฐพเฐธเฑ เฐฆเฑเฐตเฐพเฐฐเฐพ เฐธเฐชเฑเฐฐเฑเฐเฑ เฐเฑเฐธเฑ เฐเฐพเฐธเฑเฐเฑโเฐฒ เฐเฑเฐธเฐ [เฐเฐพเฐธเฑเฐเฑ เฐธเฐพเฐฐเฐพเฐเฐถเฐ](./task_summary)เฐจเฐฟ เฐเฑเฐกเฐเฐกเฐฟ.
</Tip>
เฐเฐชเฑเฐชเฑเฐกเฑ เฐฎเฑ เฐชเฑเฐฐเฑเฐชเฑเฐฐเฐพเฐธเฑเฐธเฑ เฐเฑเฐฏเฐฌเฐกเฐฟเฐจ เฐฌเฑเฐฏเฐพเฐเฑ เฐเฐจเฑโเฐชเฑเฐเฑโเฐฒเฐจเฑ เฐจเฑเฐฐเฑเฐเฐพ เฐฎเฑเฐกเฐฒเฑโเฐเฐฟ เฐชเฐเฐชเฐเฐกเฐฟ. เฐฎเฑเฐฐเฑ เฐเฑเฐจเฑเฐธเฐฐเฑโเฐฒเฐจเฑ เฐเฐฒเฐพ เฐชเฐพเฐธเฑ เฐเฑเฐฏเฐตเฐเฑเฐเฑ:
```py
>>> tf_outputs = tf_model(tf_batch)
```
เฐฎเฑเฐกเฐฒเฑ เฐคเฑเฐฆเฐฟ เฐฏเฐพเฐเฑเฐเฐฟเฐตเฑเฐทเฐจเฑโเฐฒเฐจเฑ `logits` เฐฒเฐเฑเฐทเฐฃเฐเฐฒเฑ เฐ
เฐตเฑเฐเฑโเฐชเฑเฐเฑ เฐเฑเฐธเฑเฐคเฑเฐเฐฆเฐฟ. เฐธเฐเฐญเฐพเฐตเฑเฐฏเฐคเฐฒเฐจเฑ เฐคเฐฟเฐฐเฐฟเฐเฐฟ เฐชเฑเฐเฐฆเฐกเฐพเฐจเฐฟเฐเฐฟ เฐธเฐพเฐซเฑเฐเฑโเฐฎเฐพเฐเฑเฐธเฑ เฐซเฐเฐเฑเฐทเฐจเฑโเฐจเฑ `logits`เฐเฑ เฐตเฐฐเฑเฐคเฐฟเฐเฐชเฐเฑเฐฏเฐเฐกเฐฟ:
```py
>>> import tensorflow as tf
>>> tf_predictions = tf.nn.softmax(tf_outputs.logits, axis=-1)
>>> tf_predictions # doctest: +IGNORE_RESULT
```
</tf>
</frameworkcontent>
<Tip>
เฐ
เฐจเฑเฐจเฐฟ ๐ค เฐเฑเฐฐเฐพเฐจเฑเฐธเฑโเฐซเฐพเฐฐเฑเฐฎเฐฐเฑเฐธเฑ เฐฎเฑเฐกเฐฒเฑโเฐฒเฑ (PyTorch เฐฒเฑเฐฆเฐพ TensorFlow) เฐคเฑเฐฆเฐฟ เฐฏเฐพเฐเฑเฐเฐฟเฐตเฑเฐทเฐจเฑโเฐเฑ *เฐฎเฑเฐเฐฆเฑ* เฐเฑเฐจเฑเฐธเฐฐเฑโเฐฒเฐจเฑ เฐ
เฐตเฑเฐเฑโเฐชเฑเฐเฑ เฐเฑเฐธเฑเฐคเฐพเฐฏเฐฟ
เฐซเฐเฐเฑเฐทเฐจเฑ (softmax เฐตเฐเฐเฐฟเฐฆเฐฟ) เฐเฐเฐฆเฑเฐเฐเฐเฑ เฐเฐฟเฐตเฐฐเฐฟ เฐฏเฐพเฐเฑเฐเฐฟเฐตเฑเฐทเฐจเฑ เฐซเฐเฐเฑเฐทเฐจเฑ เฐคเฐฐเฐเฑเฐเฐพ เฐจเฐทเฑเฐเฐเฐคเฑ เฐเฐฒเฐฟเฐธเฐฟเฐชเฑเฐคเฑเฐเฐฆเฐฟ. เฐฎเฑเฐกเฐฒเฑ เฐ
เฐตเฑเฐเฑโเฐชเฑเฐเฑโเฐฒเฑ เฐชเฑเฐฐเฐคเฑเฐฏเฑเฐ เฐกเฑเฐเฐพเฐเฑเฐฒเฐพเฐธเฑโเฐฒเฑ เฐเฐพเฐฌเฐเฑเฐเฐฟ เฐตเฐพเฐเฐฟ เฐฒเฐเฑเฐทเฐฃเฐพเฐฒเฑ IDEเฐฒเฑ เฐธเฑเฐตเฐฏเฐเฐเฐพเฐฒเฐเฐเฐเฐพ เฐชเฑเฐฐเฑเฐคเฐฟ เฐเฑเฐฏเฐฌเฐกเฐคเฐพเฐฏเฐฟ. เฐฎเฑเฐกเฐฒเฑ เฐ
เฐตเฑเฐเฑโเฐชเฑเฐเฑโเฐฒเฑ เฐเฑเฐชเฑเฐฒเฑ เฐฒเฑเฐฆเฐพ เฐกเฐฟเฐเฑเฐทเฐจเฐฐเฑ เฐฒเฐพเฐเฐพ เฐชเฑเฐฐเฐตเฐฐเฑเฐคเฐฟเฐธเฑเฐคเฐพเฐฏเฐฟ (เฐฎเฑเฐฐเฑ เฐชเฑเฐฐเฑเฐฃเฐพเฐเฐเฐ, เฐธเฑเฐฒเฑเฐธเฑ เฐฒเฑเฐฆเฐพ เฐธเฑเฐเฑเฐฐเฐฟเฐเฐเฑโเฐคเฑ เฐเฐเฐกเฑเฐเฑเฐธเฑ เฐเฑเฐฏเฐตเฐเฑเฐเฑ) เฐ เฐธเฐเฐฆเฐฐเฑเฐญเฐเฐฒเฑ, เฐเฐฆเฑ เฐฒเฑเฐจเฐฟ เฐเฑเฐฃเฐพเฐฒเฑ เฐตเฐฟเฐธเฑเฐฎเฐฐเฐฟเฐเฐเฐฌเฐกเฐคเฐพเฐฏเฐฟ.
</Tip>
### เฐฎเฑเฐกเฐฒเฑโเฐจเฑ เฐธเฑเฐตเฑ เฐเฑเฐฏเฐเฐกเฐฟ
<frameworkcontent>
<pt>
เฐฎเฑ เฐฎเฑเฐกเฐฒเฑ เฐเฐเฑเฐเฐเฐพ เฐเฑเฐฏเฑเฐจเฑ เฐเฑเฐฏเฐฌเฐกเฐฟเฐจ เฐคเฐฐเฑเฐตเฐพเฐค, เฐฎเฑเฐฐเฑ เฐฆเฐพเฐจเฐฟเฐจเฐฟ [`PreTrainedModel.save_pretrained`]เฐจเฐฟ เฐเฐชเฐฏเฑเฐเฐฟเฐเฐเฐฟ เฐฆเฐพเฐจเฐฟ เฐเฑเฐเฑเฐจเฑเฐเฐฐเฑโเฐคเฑ เฐธเฑเฐตเฑ เฐเฑเฐฏเฐตเฐเฑเฐเฑ:
```py
>>> pt_save_directory = "./pt_save_pretrained"
>>> tokenizer.save_pretrained(pt_save_directory) # doctest: +IGNORE_RESULT
>>> pt_model.save_pretrained(pt_save_directory)
```
เฐฎเฑเฐฐเฑ เฐฎเฑเฐกเฐฒเฑโเฐจเฐฟ เฐฎเฐณเฑเฐฒเฑ เฐเฐชเฐฏเฑเฐเฐฟเฐเฐเฐกเฐพเฐจเฐฟเฐเฐฟ เฐธเฐฟเฐฆเฑเฐงเฐเฐเฐพ เฐเฐจเฑเฐจเฐชเฑเฐชเฑเฐกเฑ, เฐฆเฐพเฐจเฑเฐจเฐฟ [`PreTrainedModel.from_pretrained`]เฐคเฑ เฐฐเฑเฐฒเฑเฐกเฑ เฐเฑเฐฏเฐเฐกเฐฟ:
```py
>>> pt_model = AutoModelForSequenceClassification.from_pretrained("./pt_save_pretrained")
```
</pt>
<tf>
เฐฎเฑ เฐฎเฑเฐกเฐฒเฑ เฐเฐเฑเฐเฐเฐพ เฐเฑเฐฏเฑเฐจเฑ เฐเฑเฐฏเฐฌเฐกเฐฟเฐจ เฐคเฐฐเฑเฐตเฐพเฐค, เฐฎเฑเฐฐเฑ เฐฆเฐพเฐจเฐฟเฐจเฐฟ [`TFPreTrainedModel.save_pretrained`]เฐจเฐฟ เฐเฐชเฐฏเฑเฐเฐฟเฐเฐเฐฟ เฐฆเฐพเฐจเฐฟ เฐเฑเฐเฑเฐจเฑเฐเฐฐเฑโเฐคเฑ เฐธเฑเฐตเฑ เฐเฑเฐฏเฐตเฐเฑเฐเฑ:
```py
>>> tf_save_directory = "./tf_save_pretrained"
>>> tokenizer.save_pretrained(tf_save_directory) # doctest: +IGNORE_RESULT
>>> tf_model.save_pretrained(tf_save_directory)
```
เฐฎเฑเฐฐเฑ เฐฎเฑเฐกเฐฒเฑโเฐจเฐฟ เฐฎเฐณเฑเฐฒเฑ เฐเฐชเฐฏเฑเฐเฐฟเฐเฐเฐกเฐพเฐจเฐฟเฐเฐฟ เฐธเฐฟเฐฆเฑเฐงเฐเฐเฐพ เฐเฐจเฑเฐจเฐชเฑเฐชเฑเฐกเฑ, เฐฆเฐพเฐจเฑเฐจเฐฟ [`TFPreTrainedModel.from_pretrained`]เฐคเฑ เฐฐเฑเฐฒเฑเฐกเฑ เฐเฑเฐฏเฐเฐกเฐฟ:
```py
>>> tf_model = TFAutoModelForSequenceClassification.from_pretrained("./tf_save_pretrained")
```
</tf>
</frameworkcontent>
เฐเฐ เฐชเฑเฐฐเฐคเฑเฐฏเฑเฐเฐฟเฐเฐเฐฟ เฐ
เฐฆเฑเฐญเฑเฐคเฐฎเฑเฐจ ๐ค เฐเฑเฐฐเฐพเฐจเฑเฐธเฑโเฐซเฐพเฐฐเฑเฐฎเฐฐเฑเฐธเฑ เฐซเฑเฐเฐฐเฑ เฐฎเฑเฐกเฐฒเฑโเฐจเฑ เฐธเฑเฐตเฑ เฐเฑเฐฏเฐเฐฒ เฐธเฐพเฐฎเฐฐเฑเฐฅเฑเฐฏเฐ เฐฎเฐฐเฐฟเฐฏเฑ เฐฆเฐพเฐจเฐฟเฐจเฐฟ PyTorch เฐฒเฑเฐฆเฐพ TensorFlow เฐฎเฑเฐกเฐฒเฑโเฐเฐพ เฐฐเฑเฐฒเฑเฐกเฑ เฐเฑเฐฏเฐเฐฒเฐฆเฑ. `from_pt` เฐฒเฑเฐฆเฐพ `from_tf` เฐชเฐฐเฐพเฐฎเฐฟเฐคเฐฟ เฐฎเฑเฐกเฐฒเฑโเฐจเฑ เฐเฐ เฐซเฑเฐฐเฑเฐฎเฑโเฐตเฐฐเฑเฐเฑ เฐจเฑเฐเฐกเฐฟ เฐฎเฐฐเฑเฐ เฐซเฑเฐฐเฑเฐฎเฑโเฐตเฐฐเฑเฐเฑโเฐเฐฟ เฐฎเฐพเฐฐเฑเฐเฐเฐฒเฐฆเฑ:
<frameworkcontent>
<pt>
```py
>>> from transformers import AutoModel
>>> tokenizer = AutoTokenizer.from_pretrained(tf_save_directory)
>>> pt_model = AutoModelForSequenceClassification.from_pretrained(tf_save_directory, from_tf=True)
```
</pt>
<tf>
```py
>>> from transformers import TFAutoModel
>>> tokenizer = AutoTokenizer.from_pretrained(pt_save_directory)
>>> tf_model = TFAutoModelForSequenceClassification.from_pretrained(pt_save_directory, from_pt=True)
```
</tf>
</frameworkcontent>
## เฐเฐธเฑเฐเฐฎเฑ เฐฎเฑเฐกเฐฒเฑ เฐฌเฐฟเฐฒเฑเฐกเฑเฐธเฑ
เฐฎเฑเฐกเฐฒเฑ เฐเฐฒเฐพ เฐจเฐฟเฐฐเฑเฐฎเฐฟเฐเฐเฐฌเฐกเฑเฐคเฑเฐเฐฆเฑ เฐฎเฐพเฐฐเฑเฐเฐกเฐพเฐจเฐฟเฐเฐฟ เฐฎเฑเฐฐเฑ เฐฎเฑเฐกเฐฒเฑ เฐเฐพเฐจเฑเฐซเฐฟเฐเฐฐเฑเฐทเฐจเฑ เฐเฑเฐฒเฐพเฐธเฑโเฐจเฐฟ เฐธเฐตเฐฐเฐฟเฐเฐเฐตเฐเฑเฐเฑ. เฐฆเฐพเฐเฐฟเฐจ เฐฒเฑเฐฏเฐฐเฑโเฐฒเฑ เฐฒเฑเฐฆเฐพ เฐ
เฐเฑเฐจเฑเฐทเฐจเฑ เฐนเฑเฐกเฑโเฐฒ เฐธเฐเฐเฑเฐฏ เฐตเฐเฐเฐฟ เฐฎเฑเฐกเฐฒเฑ เฐฒเฐเฑเฐทเฐฃเฐพเฐฒเฐจเฑ เฐเฐพเฐจเฑเฐซเฐฟเฐเฐฐเฑเฐทเฐจเฑ เฐจเฐฟเฐฐเฑเฐฆเฑเฐถเฐฟเฐธเฑเฐคเฑเฐเฐฆเฐฟ. เฐฎเฑเฐฐเฑ เฐเฐธเฑเฐเฐฎเฑ เฐเฐพเฐจเฑเฐซเฐฟเฐเฐฐเฑเฐทเฐจเฑ เฐเฑเฐฒเฐพเฐธเฑ เฐจเฑเฐเฐกเฐฟ เฐฎเฑเฐกเฐฒเฑโเฐจเฑ เฐชเฑเฐฐเฐพเฐฐเฐเฐญเฐฟเฐเฐเฐฟเฐจเฐชเฑเฐชเฑเฐกเฑ เฐฎเฑเฐฐเฑ เฐฎเฑเฐฆเฐเฐฟ เฐจเฑเฐเฐกเฐฟ เฐชเฑเฐฐเฐพเฐฐเฐเฐญเฐฟเฐธเฑเฐคเฐพเฐฐเฑ. เฐฎเฑเฐกเฐฒเฑ เฐ
เฐเฑเฐฐเฐฟเฐฌเฑเฐฏเฑเฐเฑโเฐฒเฑ เฐฏเฐพเฐฆเฑเฐเฑเฐเฐฟเฐเฐเฐเฐพ เฐชเฑเฐฐเฐพเฐฐเฐเฐญเฐฟเฐเฐเฐฌเฐกเฑเฐกเฐพเฐฏเฐฟ เฐฎเฐฐเฐฟเฐฏเฑ เฐ
เฐฐเฑเฐฅเฐตเฐเฐคเฐฎเฑเฐจ เฐซเฐฒเฐฟเฐคเฐพเฐฒเฐจเฑ เฐชเฑเฐเฐฆเฐกเฐพเฐจเฐฟเฐเฐฟ เฐฎเฑเฐฐเฑ เฐฎเฑเฐกเฐฒเฑโเฐจเฑ เฐเฐชเฐฏเฑเฐเฐฟเฐเฐเฑ เฐฎเฑเฐเฐฆเฑ เฐฆเฐพเฐจเฐฟเฐเฐฟ เฐถเฐฟเฐเฑเฐทเฐฃ เฐเฐตเฑเฐตเฐพเฐฒเฐฟ.
[`AutoConfig`]เฐจเฐฟ เฐฆเฐฟเฐเฑเฐฎเฐคเฐฟ เฐเฑเฐฏเฐกเฐ เฐฆเฑเฐตเฐพเฐฐเฐพ เฐชเฑเฐฐเฐพเฐฐเฐเฐญเฐฟเฐเฐเฐเฐกเฐฟ, เฐเฐชเฑ เฐฎเฑเฐฐเฑ เฐธเฐตเฐฐเฐฟเฐเฐเฐพเฐฒเฐจเฑเฐเฑเฐเฐเฑเฐจเฑเฐจ เฐชเฑเฐฐเฑเฐเฑเฐฐเฑเฐจเฑเฐกเฑ เฐฎเฑเฐกเฐฒเฑโเฐจเฑ เฐฒเฑเฐกเฑ เฐเฑเฐฏเฐเฐกเฐฟ. [`AutoConfig.from_pretrained`]เฐฒเฑ, เฐฎเฑเฐฐเฑ เฐ
เฐเฑเฐจเฑเฐทเฐจเฑ เฐนเฑเฐกเฑโเฐฒ เฐธเฐเฐเฑเฐฏ เฐตเฐเฐเฐฟ เฐฎเฑเฐฐเฑ เฐฎเฐพเฐฐเฑเฐเฐพเฐฒเฐจเฑเฐเฑเฐเฐเฑเฐจเฑเฐจ เฐฒเฐเฑเฐทเฐฃเฐพเฐจเฑเฐจเฐฟ เฐชเฑเฐฐเฑเฐเฑเฐจเฐตเฐเฑเฐเฑ:
```py
>>> from transformers import AutoConfig
>>> my_config = AutoConfig.from_pretrained("distilbert/distilbert-base-uncased", n_heads=12)
```
<frameworkcontent>
<pt>
[`AutoModel.from_config`]เฐคเฑ เฐฎเฑ เฐ
เฐจเฑเฐเฑเฐฒ เฐเฐพเฐจเฑเฐซเฐฟเฐเฐฐเฑเฐทเฐจเฑ เฐจเฑเฐเฐกเฐฟ เฐฎเฑเฐกเฐฒเฑโเฐจเฑ เฐธเฑเฐทเฑเฐเฐฟเฐเฐเฐเฐกเฐฟ:
```py
>>> from transformers import AutoModel
>>> my_model = AutoModel.from_config(my_config)
```
</pt>
<tf>
[`TFAutoModel.from_config`]เฐคเฑ เฐฎเฑ เฐ
เฐจเฑเฐเฑเฐฒ เฐเฐพเฐจเฑเฐซเฐฟเฐเฐฐเฑเฐทเฐจเฑ เฐจเฑเฐเฐกเฐฟ เฐฎเฑเฐกเฐฒเฑโเฐจเฑ เฐธเฑเฐทเฑเฐเฐฟเฐเฐเฐเฐกเฐฟ:
```py
>>> from transformers import TFAutoModel
>>> my_model = TFAutoModel.from_config(my_config)
```
</tf>
</frameworkcontent>
เฐ
เฐจเฑเฐเฑเฐฒ เฐเฐพเฐจเฑเฐซเฐฟเฐเฐฐเฑเฐทเฐจเฑโเฐฒเฐจเฑ เฐฐเฑเฐชเฑเฐเฐฆเฐฟเฐเฐเฐกเฐ เฐเฑเฐฐเฐฟเฐเฐเฐฟ เฐฎเฐฐเฐฟเฐเฐค เฐธเฐฎเฐพเฐเฐพเฐฐเฐ เฐเฑเฐธเฐ [เฐเฐธเฑเฐเฐฎเฑ เฐเฐฐเฑเฐเฐฟเฐเฑเฐเฑเฐเฐฐเฑโเฐจเฐฟ เฐธเฑเฐทเฑเฐเฐฟเฐเฐเฐเฐกเฐฟ](./create_a_model) เฐเฑเฐกเฑโเฐจเฑ เฐเฑเฐกเฐเฐกเฐฟ.
## เฐถเฐฟเฐเฑเฐทเฐเฑเฐกเฑ - เฐชเฑเฐเฐพเฐฐเฑเฐเฑ เฐเฐชเฑเฐเฐฟเฐฎเฑเฐเฑ เฐเฑเฐธเฐฟเฐจ เฐถเฐฟเฐเฑเฐทเฐฃ เฐฒเฑเฐชเฑ
เฐ
เฐจเฑเฐจเฐฟ เฐฎเฑเฐกเฐฒเฑโเฐฒเฑ เฐชเฑเฐฐเฐพเฐฎเฐพเฐฃเฐฟเฐเฐฎเฑเฐจ [`torch.nn.Module`](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) เฐเฐพเฐฌเฐเฑเฐเฐฟ เฐฎเฑเฐฐเฑ เฐตเฐพเฐเฐฟเฐจเฐฟ เฐเฐฆเฑเฐจเฐพ เฐธเฐพเฐงเฐพเฐฐเฐฃ เฐถเฐฟเฐเฑเฐทเฐฃ เฐฒเฑเฐชเฑโเฐฒเฑ เฐเฐชเฐฏเฑเฐเฐฟเฐเฐเฐตเฐเฑเฐเฑ. เฐฎเฑเฐฐเฑ เฐฎเฑ เฐธเฑเฐตเฐเฐค เฐถเฐฟเฐเฑเฐทเฐฃ เฐฒเฑเฐชเฑโเฐจเฑ เฐตเฑเฐฐเฐพเฐฏเฐเฐฒเฐฟเฐเฐฟเฐจเฐชเฑเฐชเฐเฐฟเฐเฑ, ๐ค เฐเฑเฐฐเฐพเฐจเฑเฐธเฑโเฐซเฐพเฐฐเฑเฐฎเฐฐเฑเฐฒเฑ PyTorch เฐเฑเฐธเฐ [`เฐเฑเฐฐเฑเฐจเฐฐเฑ`] เฐคเฐฐเฐเฐคเฐฟเฐจเฐฟ เฐ
เฐเฐฆเฐเฑเฐธเฑเฐคเฐพเฐฏเฐฟ, เฐเฐเฐฆเฑเฐฒเฑ เฐชเฑเฐฐเฐพเฐฅเฐฎเฐฟเฐ เฐถเฐฟเฐเฑเฐทเฐฃ เฐฒเฑเฐชเฑ เฐเฐเฐเฑเฐเฐฆเฐฟ เฐฎเฐฐเฐฟเฐฏเฑ เฐชเฐเฐชเฐฟเฐฃเฑ เฐเฑเฐฏเฐฌเฐกเฐฟเฐจ เฐถเฐฟเฐเฑเฐทเฐฃ, เฐฎเฐฟเฐถเฑเฐฐเฐฎ เฐเฐเฑเฐเฐฟเฐคเฐคเฑเฐตเฐ เฐฎเฐฐเฐฟเฐฏเฑ เฐฎเฐฐเฐฟเฐจเฑเฐจเฐฟ เฐตเฐเฐเฐฟ เฐซเฑเฐเฐฐเฑโเฐฒ เฐเฑเฐธเฐ เฐ
เฐฆเฐจเฐชเฑ เฐเฐพเฐฐเฑเฐฏเฐพเฐเฐฐเฐฃเฐจเฑ เฐเฑเฐกเฐฟเฐธเฑเฐคเฑเฐเฐฆเฐฟ.
เฐฎเฑ เฐตเฐฟเฐงเฐฟเฐจเฐฟ เฐฌเฐเฑเฐเฐฟ, เฐฎเฑเฐฐเฑ เฐธเฐพเฐงเฐพเฐฐเฐฃเฐเฐเฐพ เฐเฐฟเฐเฐฆเฐฟ เฐชเฐพเฐฐเฐพเฐฎเฐฟเฐคเฑเฐฒเฐจเฑ [`เฐเฑเฐฐเฑเฐจเฐฐเฑ`]เฐเฐฟ เฐชเฐเฐชเฑเฐคเฐพเฐฐเฑ:
1. เฐฎเฑเฐฐเฑ [`PreTrainedModel`] เฐฒเฑเฐฆเฐพ [`torch.nn.Module`](https://pytorch.org/docs/stable/nn.html#torch.nn.Module)เฐคเฑ เฐชเฑเฐฐเฐพเฐฐเฐเฐญเฐฟเฐธเฑเฐคเฐพเฐฐเฑ:
```py
>>> from transformers import AutoModelForSequenceClassification
>>> model = AutoModelForSequenceClassification.from_pretrained("distilbert/distilbert-base-uncased")
```
2. [`TrainingArguments`] เฐฎเฑเฐฐเฑ เฐจเฑเฐฐเฑเฐเฑเฐเฑเฐจเฑ เฐฐเฑเฐเฑ, เฐฌเฑเฐฏเฐพเฐเฑ เฐชเฐฐเฐฟเฐฎเฐพเฐฃเฐ เฐฎเฐฐเฐฟเฐฏเฑ เฐถเฐฟเฐเฑเฐทเฐฃ เฐชเฑเฐเฐฆเฐตเฐฒเฐธเฐฟเฐจ เฐฏเฑเฐเฐพเฐฒ เฐธเฐเฐเฑเฐฏ เฐตเฐเฐเฐฟ เฐฎเฐพเฐฐเฑเฐเฐเฐฒ เฐฎเฑเฐกเฐฒเฑ เฐนเฑเฐชเฐฐเฑโเฐชเฐพเฐฐเฐพเฐฎเฑเฐเฐฐเฑโเฐฒเฐจเฑ เฐเฐฒเฐฟเฐเฐฟ เฐเฐเฐฆเฐฟ. เฐฎเฑเฐฐเฑ เฐเฐฒเฐพเฐเฐเฐฟ เฐถเฐฟเฐเฑเฐทเฐฃเฐพ เฐตเฐพเฐฆเฐจเฐฒเฐจเฑ เฐชเฑเฐฐเฑเฐเฑเฐจเฐเฑเฐเฐเฑ เฐกเฐฟเฐซเฐพเฐฒเฑเฐเฑ เฐตเฐฟเฐฒเฑเฐตเฐฒเฑ เฐเฐชเฐฏเฑเฐเฐฟเฐเฐเฐฌเฐกเฐคเฐพเฐฏเฐฟ:
```py
>>> from transformers import TrainingArguments
>>> training_args = TrainingArguments(
... output_dir="path/to/save/folder/",
... learning_rate=2e-5,
... per_device_train_batch_size=8,
... per_device_eval_batch_size=8,
... num_train_epochs=2,
... )
```
3. เฐเฑเฐเฑเฐจเฑเฐเฐฐเฑ, เฐเฐฎเฑเฐเฑ เฐชเฑเฐฐเฐพเฐธเฑเฐธเฐฐเฑ, เฐซเฑเฐเฐฐเฑ เฐเฐเฑเฐธเฑโเฐเฑเฐฐเฐพเฐเฑเฐเฐฐเฑ เฐฒเฑเฐฆเฐพ เฐชเฑเฐฐเฐพเฐธเฑเฐธเฐฐเฑ เฐตเฐเฐเฐฟ เฐชเฑเฐฐเฑเฐชเฑเฐฐเฐพเฐธเฑเฐธเฐฟเฐเฐเฑ เฐเฑเฐฒเฐพเฐธเฑโเฐจเฐฟ เฐฒเฑเฐกเฑ เฐเฑเฐฏเฐเฐกเฐฟ:
```py
>>> from transformers import AutoTokenizer
>>> tokenizer = AutoTokenizer.from_pretrained("distilbert/distilbert-base-uncased")
```
4. เฐกเฑเฐเฐพเฐธเฑเฐเฑโเฐจเฑ เฐฒเฑเฐกเฑ เฐเฑเฐฏเฐเฐกเฐฟ:
```py
>>> from datasets import load_dataset
>>> dataset = load_dataset("rotten_tomatoes") # doctest: +IGNORE_RESULT
```
5. เฐกเฑเฐเฐพเฐธเฑเฐเฑโเฐจเฑ เฐเฑเฐเฐจเฑเฐเฑ เฐเฑเฐฏเฐกเฐพเฐจเฐฟเฐเฐฟ เฐเฐ เฐซเฐเฐเฑเฐทเฐจเฑโเฐจเฑ เฐธเฑเฐทเฑเฐเฐฟเฐเฐเฐเฐกเฐฟ:
```py
>>> def tokenize_dataset(dataset):
... return tokenizer(dataset["text"])
```
เฐเฐชเฑ เฐฆเฐพเฐจเฐฟเฐจเฐฟ [`~datasets.Dataset.map`]เฐคเฑ เฐฎเฑเฐคเฑเฐคเฐ เฐกเฑเฐเฐพเฐธเฑเฐเฑโเฐฒเฑ เฐตเฐฐเฑเฐคเฐฟเฐเฐชเฐเฑเฐฏเฐเฐกเฐฟ:
```py
>>> dataset = dataset.map(tokenize_dataset, batched=True)
```
6. เฐฎเฑ เฐกเฑเฐเฐพเฐธเฑเฐเฑ เฐจเฑเฐเฐกเฐฟ เฐเฐฆเฐพเฐนเฐฐเฐฃเฐฒ เฐธเฐฎเฑเฐนเฐพเฐจเฑเฐจเฐฟ เฐธเฑเฐทเฑเฐเฐฟเฐเฐเฐกเฐพเฐจเฐฟเฐเฐฟ [`DataCollatorWithPadding`]:
```py
>>> from transformers import DataCollatorWithPadding
>>> data_collator = DataCollatorWithPadding(tokenizer=tokenizer)
```
เฐเฐชเฑเฐชเฑเฐกเฑ เฐ เฐคเฐฐเฐเฐคเฑเฐฒเฐจเฑเฐจเฐฟเฐเฐเฐฟเฐจเฑ [`Trainer`]เฐฒเฑ เฐธเฑเฐเฐฐเฐฟเฐเฐเฐเฐกเฐฟ:
```py
>>> from transformers import Trainer
>>> trainer = Trainer(
... model=model,
... args=training_args,
... train_dataset=dataset["train"],
... eval_dataset=dataset["test"],
... tokenizer=tokenizer,
... data_collator=data_collator,
... ) # doctest: +SKIP
```
เฐฎเฑเฐฐเฑ เฐธเฐฟเฐฆเฑเฐงเฐเฐเฐพ เฐเฐจเฑเฐจเฐชเฑเฐชเฑเฐกเฑ, เฐถเฐฟเฐเฑเฐทเฐฃเฐจเฑ เฐชเฑเฐฐเฐพเฐฐเฐเฐญเฐฟเฐเฐเฐกเฐพเฐจเฐฟเฐเฐฟ [`~Trainer.train`]เฐเฐฟ เฐเฐพเฐฒเฑ เฐเฑเฐฏเฐเฐกเฐฟ:
```py
>>> trainer.train() # doctest: +SKIP
```
<Tip>
เฐธเฑเฐเฑเฐตเฑเฐจเฑเฐธเฑ-เฐเฑ-เฐธเฑเฐเฑเฐตเฑเฐจเฑเฐธเฑ เฐฎเฑเฐกเฐฒเฑโเฐจเฐฟ เฐเฐชเฐฏเฑเฐเฐฟเฐเฐเฑ - เฐ
เฐจเฑเฐตเฐพเฐฆเฐ เฐฒเฑเฐฆเฐพ เฐธเฐพเฐฐเฐพเฐเฐถเฐ เฐตเฐเฐเฐฟ เฐชเฐจเฑเฐฒ เฐเฑเฐธเฐ, เฐฌเฐฆเฑเฐฒเฑเฐเฐพ [`Seq2SeqTrainer`] เฐฎเฐฐเฐฟเฐฏเฑ [`Seq2SeqTrainingArguments`] เฐคเฐฐเฐเฐคเฑเฐฒเฐจเฑ เฐเฐชเฐฏเฑเฐเฐฟเฐเฐเฐเฐกเฐฟ.
</Tip>
เฐฎเฑเฐฐเฑ [`Trainer`] เฐฒเฑเฐชเฐฒ เฐเฐจเฑเฐจ เฐชเฐฆเฑเฐงเฐคเฑเฐฒเฐจเฑ เฐเฐชเฐตเฐฐเฑเฐเฑเฐเฐฐเฐฟเฐเฐเฐกเฐ เฐฆเฑเฐตเฐพเฐฐเฐพ เฐถเฐฟเฐเฑเฐทเฐฃ เฐฒเฑเฐชเฑ เฐชเฑเฐฐเฐตเฐฐเฑเฐคเฐจเฐจเฑ เฐ
เฐจเฑเฐเฑเฐฒเฑเฐเฐฐเฐฟเฐเฐเฐตเฐเฑเฐเฑ. เฐเฐฆเฐฟ เฐฒเฐพเฐธเฑ เฐซเฐเฐเฑเฐทเฐจเฑ, เฐเฐชเฑเฐเฐฟเฐฎเฑเฐเฐฐเฑ เฐฎเฐฐเฐฟเฐฏเฑ เฐทเฑเฐกเฑเฐฏเฑเฐฒเฐฐเฑ เฐตเฐเฐเฐฟ เฐฒเฐเฑเฐทเฐฃเฐพเฐฒเฐจเฑ เฐ
เฐจเฑเฐเฑเฐฒเฑเฐเฐฐเฐฟเฐเฐเฐกเฐพเฐจเฐฟเฐเฐฟ เฐฎเฐฟเฐฎเฑเฐฎเฐฒเฑเฐจเฐฟ เฐ
เฐจเฑเฐฎเฐคเฐฟเฐธเฑเฐคเฑเฐเฐฆเฐฟ. เฐเฐชเฐตเฐฐเฑเฐเฑเฐเฐฐเฐฟเฐเฐเฐฌเฐกเฑ เฐชเฐฆเฑเฐงเฐคเฑเฐฒ เฐเฑเฐธเฐ [`Trainer`] เฐธเฑเฐเฐจเฐจเฑ เฐชเฐฐเฐฟเฐถเฑเฐฒเฐฟเฐเฐเฐเฐกเฐฟ.
เฐถเฐฟเฐเฑเฐทเฐฃ เฐฒเฑเฐชเฑโเฐจเฑ เฐ
เฐจเฑเฐเฑเฐฒเฑเฐเฐฐเฐฟเฐเฐเฐกเฐพเฐจเฐฟเฐเฐฟ เฐฎเฐฐเฑเฐ เฐฎเฐพเฐฐเฑเฐเฐ [เฐเฐพเฐฒเฑโเฐฌเฑเฐฏเฐพเฐเฑโเฐฒเฑ](./main_classes/callbacks). เฐฎเฑเฐฐเฑ เฐเฐคเฐฐ เฐฒเฑเฐฌเฑเฐฐเฐฐเฑเฐฒเฐคเฑ เฐ
เฐจเฑเฐธเฐเฐงเฐพเฐจเฐ เฐเฑเฐฏเฐกเฐพเฐจเฐฟเฐเฐฟ เฐเฐพเฐฒเฑโเฐฌเฑเฐฏเฐพเฐเฑโเฐฒเฐจเฑ เฐเฐชเฐฏเฑเฐเฐฟเฐเฐเฐตเฐเฑเฐเฑ เฐฎเฐฐเฐฟเฐฏเฑ เฐชเฑเฐฐเฑเฐเฐคเฐฟเฐชเฑ เฐจเฐฟเฐตเฑเฐฆเฐฟเฐเฐเฐกเฐพเฐจเฐฟเฐเฐฟ เฐถเฐฟเฐเฑเฐทเฐฃ เฐฒเฑเฐชเฑโเฐจเฑ เฐคเฐจเฐฟเฐเฑ เฐเฑเฐฏเฐตเฐเฑเฐเฑ เฐฒเฑเฐฆเฐพ เฐถเฐฟเฐเฑเฐทเฐฃเฐจเฑ เฐฎเฑเฐเฐฆเฑเฐเฐพเฐจเฑ เฐเฐชเฐตเฐเฑเฐเฑ. เฐถเฐฟเฐเฑเฐทเฐฃ เฐฒเฑเฐชเฑโเฐฒเฑเฐจเฑ เฐเฐพเฐฒเฑโเฐฌเฑเฐฏเฐพเฐเฑโเฐฒเฑ เฐฆเฑเฐจเฐฟเฐจเฑ เฐธเฐตเฐฐเฐฟเฐเฐเฐตเฑ. เฐฒเฐพเฐธเฑ เฐซเฐเฐเฑเฐทเฐจเฑ เฐตเฐเฐเฐฟเฐตเฐพเฐเฐฟเฐจเฐฟ เฐ
เฐจเฑเฐเฑเฐฒเฑเฐเฐฐเฐฟเฐเฐเฐกเฐพเฐจเฐฟเฐเฐฟ, เฐฎเฑเฐฐเฑ เฐฌเฐฆเฑเฐฒเฑเฐเฐพ [`Trainer`]เฐจเฐฟ เฐเฐชเฐตเฐฐเฑเฐเฐ เฐเฑเฐฏเฐพเฐฒเฐฟ.
## TensorFlowเฐคเฑ เฐถเฐฟเฐเฑเฐทเฐฃ เฐชเฑเฐเฐฆเฐเฐกเฐฟ
เฐ
เฐจเฑเฐจเฐฟ เฐฎเฑเฐกเฐฒเฑโเฐฒเฑ เฐชเฑเฐฐเฐพเฐฎเฐพเฐฃเฐฟเฐเฐฎเฑเฐจ [`tf.keras.Model`](https://www.tensorflow.org/api_docs/python/tf/keras/Model) เฐเฐพเฐฌเฐเฑเฐเฐฟ เฐตเฐพเฐเฐฟเฐจเฐฟ [Keras]เฐคเฑ TensorFlowเฐฒเฑ เฐถเฐฟเฐเฑเฐทเฐฃ เฐชเฑเฐเฐฆเฐตเฐเฑเฐเฑ(https: //keras.io/) API. ๐ค เฐเฑเฐฐเฐพเฐจเฑเฐธเฑโเฐซเฐพเฐฐเฑเฐฎเฐฐเฑโเฐฒเฑ เฐฎเฑ เฐกเฑเฐเฐพเฐธเฑเฐเฑโเฐจเฐฟ เฐธเฑเฐฒเฐญเฐเฐเฐพ `tf.data.Dataset`เฐเฐพ เฐฒเฑเฐกเฑ เฐเฑเฐฏเฐกเฐพเฐจเฐฟเฐเฐฟ [`~TFPreTrainedModel.prepare_tf_dataset`] เฐชเฐฆเฑเฐงเฐคเฐฟเฐจเฐฟ เฐ
เฐเฐฆเฐเฑเฐธเฑเฐคเฑเฐเฐฆเฐฟ เฐเฐพเฐฌเฐเฑเฐเฐฟ เฐฎเฑเฐฐเฑ เฐตเฑเฐเฐเฐจเฑ Keras' [`compile`](https://keras.io/api/models/model_training_apis/#compile-method) เฐฎเฐฐเฐฟเฐฏเฑ [`fit`](https://keras.io/api/models/model_training_apis/#fit-method) เฐชเฐฆเฑเฐงเฐคเฑเฐฒเฑ.
1. เฐฎเฑเฐฐเฑ [`TFPreTrainedModel`] เฐฒเฑเฐฆเฐพ [`tf.keras.Model`](https://www.tensorflow.org/api_docs/python/tf/keras/Model)เฐคเฑ เฐชเฑเฐฐเฐพเฐฐเฐเฐญเฐฟเฐธเฑเฐคเฐพเฐฐเฑ:
```py
>>> from transformers import TFAutoModelForSequenceClassification
>>> model = TFAutoModelForSequenceClassification.from_pretrained("distilbert/distilbert-base-uncased")
```
2. เฐเฑเฐเฑเฐจเฑเฐเฐฐเฑ, เฐเฐฎเฑเฐเฑ เฐชเฑเฐฐเฐพเฐธเฑเฐธเฐฐเฑ, เฐซเฑเฐเฐฐเฑ เฐเฐเฑเฐธเฑโเฐเฑเฐฐเฐพเฐเฑเฐเฐฐเฑ เฐฒเฑเฐฆเฐพ เฐชเฑเฐฐเฐพเฐธเฑเฐธเฐฐเฑ เฐตเฐเฐเฐฟ เฐชเฑเฐฐเฑเฐชเฑเฐฐเฐพเฐธเฑเฐธเฐฟเฐเฐเฑ เฐเฑเฐฒเฐพเฐธเฑโเฐจเฐฟ เฐฒเฑเฐกเฑ เฐเฑเฐฏเฐเฐกเฐฟ:
```py
>>> from transformers import AutoTokenizer
>>> tokenizer = AutoTokenizer.from_pretrained("distilbert/distilbert-base-uncased")
```
3. เฐกเฑเฐเฐพเฐธเฑเฐเฑโเฐจเฑ เฐเฑเฐเฐจเฑเฐเฑ เฐเฑเฐฏเฐกเฐพเฐจเฐฟเฐเฐฟ เฐเฐ เฐซเฐเฐเฑเฐทเฐจเฑโเฐจเฑ เฐธเฑเฐทเฑเฐเฐฟเฐเฐเฐเฐกเฐฟ:
```py
>>> def tokenize_dataset(dataset):
... return tokenizer(dataset["text"]) # doctest: +SKIP
```
4. [`~datasets.Dataset.map`]เฐคเฑ เฐฎเฑเฐคเฑเฐคเฐ เฐกเฑเฐเฐพเฐธเฑเฐเฑโเฐชเฑ เฐเฑเฐเฑเฐจเฑเฐเฐฐเฑโเฐจเฐฟ เฐตเฐฐเฑเฐคเฐฟเฐเฐชเฐเฑเฐฏเฐฟ, เฐเฐชเฑ เฐกเฑเฐเฐพเฐธเฑเฐเฑ เฐฎเฐฐเฐฟเฐฏเฑ เฐเฑเฐเฑเฐจเฑเฐเฐฐเฑโเฐจเฑ [`~TFPreTrainedModel.prepare_tf_dataset`]เฐเฐฟ เฐชเฐเฐชเฐเฐกเฐฟ. เฐฎเฑเฐฐเฑ เฐเฐพเฐตเฐพเฐฒเฐจเฑเฐเฑเฐเฐเฑ เฐฌเฑเฐฏเฐพเฐเฑ เฐชเฐฐเฐฟเฐฎเฐพเฐฃเฐพเฐจเฑเฐจเฐฟ เฐเฑเฐกเฐพ เฐฎเฐพเฐฐเฑเฐเฐตเฐเฑเฐเฑ เฐฎเฐฐเฐฟเฐฏเฑ เฐกเฑเฐเฐพเฐธเฑเฐเฑโเฐจเฑ เฐเฐเฑเฐเฐก เฐทเฐซเฑเฐฒเฑ เฐเฑเฐฏเฐตเฐเฑเฐเฑ:
```py
>>> dataset = dataset.map(tokenize_dataset) # doctest: +SKIP
>>> tf_dataset = model.prepare_tf_dataset(
... dataset["train"], batch_size=16, shuffle=True, tokenizer=tokenizer
... ) # doctest: +SKIP
```
5. เฐฎเฑเฐฐเฑ เฐธเฐฟเฐฆเฑเฐงเฐเฐเฐพ เฐเฐจเฑเฐจเฐชเฑเฐชเฑเฐกเฑ, เฐถเฐฟเฐเฑเฐทเฐฃเฐจเฑ เฐชเฑเฐฐเฐพเฐฐเฐเฐญเฐฟเฐเฐเฐกเฐพเฐจเฐฟเฐเฐฟ เฐฎเฑเฐฐเฑ `เฐเฐเฐชเฑเฐฒเฑ` เฐฎเฐฐเฐฟเฐฏเฑ `เฐซเฐฟเฐเฑ`เฐเฐฟ เฐเฐพเฐฒเฑ เฐเฑเฐฏเฐตเฐเฑเฐเฑ. เฐเฑเฐฐเฐพเฐจเฑเฐธเฑโเฐซเฐพเฐฐเฑเฐฎเฐฐเฑเฐธเฑ เฐฎเฑเฐกเฐฒเฑเฐธเฑ เฐ
เฐจเฑเฐจเฑ เฐกเฐฟเฐซเฐพเฐฒเฑเฐเฑ เฐเฐพเฐธเฑเฐเฑ-เฐธเฐเฐฌเฐเฐงเฐฟเฐค เฐฒเฐพเฐธเฑ เฐซเฐเฐเฑเฐทเฐจเฑโเฐจเฐฟ เฐเฐฒเฐฟเฐเฐฟ เฐเฐจเฑเฐจเฐพเฐฏเฐจเฐฟ เฐเฑเฐฐเฑเฐคเฑเฐเฐเฑเฐเฑเฐเฐกเฐฟ, เฐเฐพเฐฌเฐเฑเฐเฐฟ เฐฎเฑเฐฐเฑ เฐเฑเฐฐเฑเฐเฑเฐจเฑ เฐตเฐฐเฐเฑ เฐฎเฑเฐฐเฑ เฐเฐเฐฆเฐพเฐจเฐฟเฐจเฐฟ เฐชเฑเฐฐเฑเฐเฑเฐจเฐตเฐฒเฐธเฐฟเฐจ เฐ
เฐตเฐธเฐฐเฐ เฐฒเฑเฐฆเฑ:
```py
>>> from tensorflow.keras.optimizers import Adam
>>> model.compile(optimizer=Adam(3e-5)) # No loss argument!
>>> model.fit(tf_dataset) # doctest: +SKIP
```
## เฐคเฐฐเฐตเฐพเฐค เฐเฐเฐเฐฟ?
เฐเฐชเฑเฐชเฑเฐกเฑ เฐฎเฑเฐฐเฑ ๐ค เฐเฑเฐฐเฐพเฐจเฑเฐธเฑโเฐซเฐพเฐฐเฑเฐฎเฐฐเฑเฐธเฑ เฐคเฑเฐตเฐฐเฐฟเฐค เฐชเฐฐเฑเฐฏเฐเฐจเฐจเฑ เฐชเฑเฐฐเฑเฐคเฐฟ เฐเฑเฐธเฐพเฐฐเฑ, เฐฎเฐพ เฐเฑเฐกเฑโเฐฒเฐจเฑ เฐคเฐจเฐฟเฐเฑ เฐเฑเฐฏเฐเฐกเฐฟ เฐฎเฐฐเฐฟเฐฏเฑ เฐ
เฐจเฑเฐเฑเฐฒ เฐฎเฑเฐกเฐฒเฑโเฐจเฑ เฐตเฑเฐฐเฐพเฐฏเฐกเฐ, เฐเฐพเฐธเฑเฐเฑ เฐเฑเฐธเฐ เฐฎเฑเฐกเฐฒเฑโเฐจเฑ เฐเฐเฑเฐเฐเฐพ เฐคเฑเฐฐเฑเฐเฐฟเฐฆเฐฟเฐฆเฑเฐฆเฐกเฐ เฐฎเฐฐเฐฟเฐฏเฑ เฐธเฑเฐเฑเฐฐเฐฟเฐชเฑเฐเฑโเฐคเฑ เฐฎเฑเฐกเฐฒเฑโเฐเฑ เฐถเฐฟเฐเฑเฐทเฐฃ เฐเฐตเฑเฐตเฐกเฐ เฐตเฐเฐเฐฟ เฐฎเฐฐเฐฟเฐเฐค เฐจเฐฟเฐฐเฑเฐฆเฐฟเฐทเฑเฐเฐฎเฑเฐจ เฐชเฐจเฑเฐฒเฐจเฑ เฐเฐฒเฐพ เฐเฑเฐฏเฐพเฐฒเฑ เฐคเฑเฐฒเฑเฐธเฑเฐเฑเฐเฐกเฐฟ. ๐ค เฐเฑเฐฐเฐพเฐจเฑเฐธเฑโเฐซเฐพเฐฐเฑเฐฎเฐฐเฑเฐธเฑ เฐเฑเฐฐเฑ เฐเฐพเฐจเฑเฐธเฑเฐชเฑเฐเฑโเฐฒ เฐเฑเฐฐเฐฟเฐเฐเฐฟ เฐฎเฐฐเฐฟเฐเฐค เฐคเฑเฐฒเฑเฐธเฑเฐเฑเฐตเฐกเฐพเฐจเฐฟเฐเฐฟ เฐฎเฑเฐเฑ เฐเฐธเฐเฑเฐคเฐฟ เฐเฐเฐเฑ, เฐเฐ เฐเฐชเฑเฐชเฑ เฐเฐพเฐซเฑ เฐคเฐพเฐเฐฟ, เฐฎเฐพ เฐเฐพเฐจเฑเฐธเฑเฐชเฑเฐเฑเฐตเฐฒเฑ เฐเฑเฐกเฑโเฐฒเฐจเฑ เฐเฑเฐกเฐเฐกเฐฟ!
| 0 |
mavonic_private_repos/transformers/docs/source | mavonic_private_repos/transformers/docs/source/ko/fast_tokenizers.md | <!--Copyright 2020 The HuggingFace Team. All rights reserved.
Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
the License. You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
specific language governing permissions and limitations under the License.
โ ๏ธ Note that this file is in Markdown but contain specific syntax for our doc-builder (similar to MDX) that may not be
rendered properly in your Markdown viewer.
-->
# ๐ค Tokenizers ๋ผ์ด๋ธ๋ฌ๋ฆฌ์ ํ ํฌ๋์ด์ ์ฌ์ฉํ๊ธฐ[[use-tokenizers-from-tokenizers]]
[`PreTrainedTokenizerFast`]๋ [๐ค Tokenizers](https://huggingface.co/docs/tokenizers) ๋ผ์ด๋ธ๋ฌ๋ฆฌ์ ๊ธฐ๋ฐํฉ๋๋ค. ๐ค Tokenizers ๋ผ์ด๋ธ๋ฌ๋ฆฌ์ ํ ํฌ๋์ด์ ๋
๐ค Transformers๋ก ๋งค์ฐ ๊ฐ๋จํ๊ฒ ๋ถ๋ฌ์ฌ ์ ์์ต๋๋ค.
๊ตฌ์ฒด์ ์ธ ๋ด์ฉ์ ๋ค์ด๊ฐ๊ธฐ ์ ์, ๋ช ์ค์ ์ฝ๋๋ก ๋๋ฏธ ํ ํฌ๋์ด์ ๋ฅผ ๋ง๋ค์ด ๋ณด๊ฒ ์ต๋๋ค:
```python
>>> from tokenizers import Tokenizer
>>> from tokenizers.models import BPE
>>> from tokenizers.trainers import BpeTrainer
>>> from tokenizers.pre_tokenizers import Whitespace
>>> tokenizer = Tokenizer(BPE(unk_token="[UNK]"))
>>> trainer = BpeTrainer(special_tokens=["[UNK]", "[CLS]", "[SEP]", "[PAD]", "[MASK]"])
>>> tokenizer.pre_tokenizer = Whitespace()
>>> files = [...]
>>> tokenizer.train(files, trainer)
```
์ฐ๋ฆฌ๊ฐ ์ ์ํ ํ์ผ์ ํตํด ์ด์ ํ์ต๋ ํ ํฌ๋์ด์ ๋ฅผ ๊ฐ๊ฒ ๋์์ต๋๋ค. ์ด ๋ฐํ์์์ ๊ณ์ ์ฌ์ฉํ๊ฑฐ๋ JSON ํ์ผ๋ก ์ ์ฅํ์ฌ ๋์ค์ ์ฌ์ฉํ ์ ์์ต๋๋ค.
## ํ ํฌ๋์ด์ ๊ฐ์ฒด๋ก๋ถํฐ ์ง์ ๋ถ๋ฌ์ค๊ธฐ[[loading-directly-from-the-tokenizer-object]]
๐ค Transformers ๋ผ์ด๋ธ๋ฌ๋ฆฌ์์ ์ด ํ ํฌ๋์ด์ ๊ฐ์ฒด๋ฅผ ํ์ฉํ๋ ๋ฐฉ๋ฒ์ ์ดํด๋ณด๊ฒ ์ต๋๋ค.
[`PreTrainedTokenizerFast`] ํด๋์ค๋ ์ธ์คํด์คํ๋ *ํ ํฌ๋์ด์ * ๊ฐ์ฒด๋ฅผ ์ธ์๋ก ๋ฐ์ ์ฝ๊ฒ ์ธ์คํด์คํํ ์ ์์ต๋๋ค:
```python
>>> from transformers import PreTrainedTokenizerFast
>>> fast_tokenizer = PreTrainedTokenizerFast(tokenizer_object=tokenizer)
```
์ด์ `fast_tokenizer` ๊ฐ์ฒด๋ ๐ค Transformers ํ ํฌ๋์ด์ ์์ ๊ณต์ ํ๋ ๋ชจ๋ ๋ฉ์๋์ ํจ๊ป ์ฌ์ฉํ ์ ์์ต๋๋ค! ์์ธํ ๋ด์ฉ์ [ํ ํฌ๋์ด์ ํ์ด์ง](main_classes/tokenizer)๋ฅผ ์ฐธ์กฐํ์ธ์.
## JSON ํ์ผ์์ ๋ถ๋ฌ์ค๊ธฐ[[loading-from-a-JSON-file]]
<!--In order to load a tokenizer from a JSON file, let's first start by saving our tokenizer:-->
JSON ํ์ผ์์ ํ ํฌ๋์ด์ ๋ฅผ ๋ถ๋ฌ์ค๊ธฐ ์ํด, ๋จผ์ ํ ํฌ๋์ด์ ๋ฅผ ์ ์ฅํด ๋ณด๊ฒ ์ต๋๋ค:
```python
>>> tokenizer.save("tokenizer.json")
```
JSON ํ์ผ์ ์ ์ฅํ ๊ฒฝ๋ก๋ `tokenizer_file` ๋งค๊ฐ๋ณ์๋ฅผ ์ฌ์ฉํ์ฌ [`PreTrainedTokenizerFast`] ์ด๊ธฐํ ๋ฉ์๋์ ์ ๋ฌํ ์ ์์ต๋๋ค:
```python
>>> from transformers import PreTrainedTokenizerFast
>>> fast_tokenizer = PreTrainedTokenizerFast(tokenizer_file="tokenizer.json")
```
์ด์ `fast_tokenizer` ๊ฐ์ฒด๋ ๐ค Transformers ํ ํฌ๋์ด์ ์์ ๊ณต์ ํ๋ ๋ชจ๋ ๋ฉ์๋์ ํจ๊ป ์ฌ์ฉํ ์ ์์ต๋๋ค! ์์ธํ ๋ด์ฉ์ [ํ ํฌ๋์ด์ ํ์ด์ง](main_classes/tokenizer)๋ฅผ ์ฐธ์กฐํ์ธ์.
| 0 |
mavonic_private_repos/transformers/docs/source | mavonic_private_repos/transformers/docs/source/ko/model_memory_anatomy.md | <!---
Copyright 2023 The HuggingFace Team. All rights reserved.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
-->
# ๋ชจ๋ธ ํ์ต ํด๋ถํ๊ธฐ [[model-training-anatomy]]
๋ชจ๋ธ ํ๋ จ ์๋์ ๋ฉ๋ชจ๋ฆฌ ํ์ฉ์ ํจ์จ์ฑ์ ํฅ์์ํค๊ธฐ ์ํด ์ ์ฉํ ์ ์๋ ์ฑ๋ฅ ์ต์ ํ ๊ธฐ์ ์ ์ดํดํ๋ ค๋ฉด GPU๊ฐ ํ๋ จ ์ค์ ์ด๋ป๊ฒ ํ์ฉ๋๋์ง, ๊ทธ๋ฆฌ๊ณ ์ํ๋๋ ์ฐ์ฐ์ ๋ฐ๋ผ ์ฐ์ฐ ๊ฐ๋๊ฐ ์ด๋ป๊ฒ ๋ณํ๋์ง์ ์ต์ํด์ ธ์ผ ํฉ๋๋ค.
๋จผ์ GPU ํ์ฉ๊ณผ ๋ชจ๋ธ ํ๋ จ ์คํ์ ๋ํ ์์๋ฅผ ์ดํด๋ณด๊ฒ ์ต๋๋ค. ๋ฐ๋ชจ๋ฅผ ์ํด ๋ช๋ช ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ฅผ ์ค์นํด์ผ ํฉ๋๋ค:
```bash
pip install transformers datasets accelerate nvidia-ml-py3
```
`nvidia-ml-py3` ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ Python ๋ด๋ถ์์ ๋ชจ๋ธ์ ๋ฉ๋ชจ๋ฆฌ ์ฌ์ฉ๋์ ๋ชจ๋ํฐ๋งํ ์ ์๊ฒ ํด์ค๋๋ค. ํฐ๋ฏธ๋์ `nvidia-smi` ๋ช
๋ น์ด์ ์ต์ํ ์ ์๋๋ฐ, ์ด ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ Python์์ ์ง์ ๋์ผํ ์ ๋ณด์ ์ ๊ทผํ ์ ์๊ฒ ํด์ค๋๋ค.
๊ทธ ๋ค์, 100๊ณผ 30000 ์ฌ์ด์ ๋ฌด์์ ํ ํฐ ID์ ๋ถ๋ฅ๊ธฐ๋ฅผ ์ํ ์ด์ง ๋ ์ด๋ธ์ธ ๋๋ฏธ ๋ฐ์ดํฐ๋ฅผ ์์ฑํฉ๋๋ค.
๊ธธ์ด๊ฐ ๊ฐ๊ฐ 512์ธ ์ด 512๊ฐ์ ์ํ์ค๋ฅผ ๊ฐ์ ธ์ PyTorch ํ์์ [`~datasets.Dataset`]์ ์ ์ฅํฉ๋๋ค.
```py
>>> import numpy as np
>>> from datasets import Dataset
>>> seq_len, dataset_size = 512, 512
>>> dummy_data = {
... "input_ids": np.random.randint(100, 30000, (dataset_size, seq_len)),
... "labels": np.random.randint(0, 1, (dataset_size)),
... }
>>> ds = Dataset.from_dict(dummy_data)
>>> ds.set_format("pt")
```
GPU ํ์ฉ ๋ฐ [`Trainer`]๋ก ์คํํ ํ๋ จ ๊ณผ์ ์ ๋ํ ์์ฝ ํต๊ณ๋ฅผ ์ถ๋ ฅํ๊ธฐ ์ํด ๋ ๊ฐ์ ๋์ฐ๋ฏธ ํจ์๋ฅผ ์ ์ํ๊ฒ ์ต๋๋ค:
```py
>>> from pynvml import *
>>> def print_gpu_utilization():
... nvmlInit()
... handle = nvmlDeviceGetHandleByIndex(0)
... info = nvmlDeviceGetMemoryInfo(handle)
... print(f"GPU memory occupied: {info.used//1024**2} MB.")
>>> def print_summary(result):
... print(f"Time: {result.metrics['train_runtime']:.2f}")
... print(f"Samples/second: {result.metrics['train_samples_per_second']:.2f}")
... print_gpu_utilization()
```
์์ํ ๋ GPU ๋ฉ๋ชจ๋ฆฌ๊ฐ ๋น์ด ์๋์ง ํ์ธํด ๋ด
์๋ค:
```py
>>> print_gpu_utilization()
GPU memory occupied: 0 MB.
```
์ข์ต๋๋ค. ๋ชจ๋ธ์ ๋ก๋ํ๊ธฐ ์ ์๋ ์์๋๋ก GPU ๋ฉ๋ชจ๋ฆฌ๊ฐ ์ ์ ๋์ง ์์์ต๋๋ค. ๊ทธ๋ ์ง ์๋ค๋ฉด ์ฌ์ฉ์์ ๊ธฐ๊ธฐ์์ GPU ๋ฉ๋ชจ๋ฆฌ๋ฅผ ์ฌ์ฉํ๋ ๋ชจ๋ ํ๋ก์ธ์ค๋ฅผ ์ค๋จํด์ผ ํฉ๋๋ค. ๊ทธ๋ฌ๋ ์ฌ์ฉ์๋ ๋ชจ๋ ์ฌ์ GPU ๋ฉ๋ชจ๋ฆฌ๋ฅผ ์ฌ์ฉํ ์๋ ์์ต๋๋ค. ๋ชจ๋ธ์ด GPU์ ๋ก๋๋ ๋ ์ปค๋๋ ๋ก๋๋๋ฏ๋ก 1-2GB์ ๋ฉ๋ชจ๋ฆฌ๋ฅผ ์ฐจ์งํ ์ ์์ต๋๋ค. ์ผ๋ง๋ ๋๋์ง ํ์ธํ๊ธฐ ์ํด GPU์ ์์ ํ
์๋ฅผ ๋ก๋ํ์ฌ ์ปค๋์ด ๋ก๋๋๋๋ก ํธ๋ฆฌ๊ฑฐํฉ๋๋ค.
```py
>>> import torch
>>> torch.ones((1, 1)).to("cuda")
>>> print_gpu_utilization()
GPU memory occupied: 1343 MB.
```
์ปค๋๋ง์ผ๋ก๋ GPU ๋ฉ๋ชจ๋ฆฌ์ 1.3GB๋ฅผ ์ฐจ์งํฉ๋๋ค. ์ด์ ๋ชจ๋ธ์ด ์ผ๋ง๋ ๋ง์ ๊ณต๊ฐ์ ์ฌ์ฉํ๋์ง ํ์ธํด ๋ณด๊ฒ ์ต๋๋ค.
## ๋ชจ๋ธ ๋ก๋ [[load-model]]
์ฐ์ , `google-bert/bert-large-uncased` ๋ชจ๋ธ์ ๋ก๋ํฉ๋๋ค. ๋ชจ๋ธ์ ๊ฐ์ค์น๋ฅผ ์ง์ GPU์ ๋ก๋ํด์ ๊ฐ์ค์น๋ง์ด ์ผ๋ง๋ ๋ง์ ๊ณต๊ฐ์ ์ฐจ์งํ๋์ง ํ์ธํ ์ ์์ต๋๋ค.
```py
>>> from transformers import AutoModelForSequenceClassification
>>> model = AutoModelForSequenceClassification.from_pretrained("google-bert/bert-large-uncased").to("cuda")
>>> print_gpu_utilization()
GPU memory occupied: 2631 MB.
```
๋ชจ๋ธ์ ๊ฐ์ค์น๋ง์ผ๋ก๋ GPU ๋ฉ๋ชจ๋ฆฌ๋ฅผ 1.3 GB ์ฐจ์งํ๋ ๊ฒ์ ๋ณผ ์ ์์ต๋๋ค. ์ ํํ ์ซ์๋ ์ฌ์ฉํ๋ GPU์ ๋ฐ๋ผ ๋ค๋ฆ
๋๋ค. ์ต์ GPU์์๋ ๋ชจ๋ธ ์ฌ์ฉ ์๋๋ฅผ ๋์ด๋ ์ต์ ํ๋ ๋ฐฉ์์ผ๋ก ๊ฐ์ค์น๊ฐ ๋ก๋๋๋ฏ๋ก, ๋ชจ๋ธ์ด ๋ ๋ง์ ๊ณต๊ฐ์ ์ฐจ์งํ ์ ์์ต๋๋ค. ์ด์ `nvidia-smi` CLI์ ๋์ผํ ๊ฒฐ๊ณผ๋ฅผ ์ป๋์ง ๋น ๋ฅด๊ฒ ํ์ธํ ์ ์์ต๋๋ค:
```bash
nvidia-smi
```
```bash
Tue Jan 11 08:58:05 2022
+-----------------------------------------------------------------------------+
| NVIDIA-SMI 460.91.03 Driver Version: 460.91.03 CUDA Version: 11.2 |
|-------------------------------+----------------------+----------------------+
| GPU Name Persistence-M| Bus-Id Disp.A | Volatile Uncorr. ECC |
| Fan Temp Perf Pwr:Usage/Cap| Memory-Usage | GPU-Util Compute M. |
| | | MIG M. |
|===============================+======================+======================|
| 0 Tesla V100-SXM2... On | 00000000:00:04.0 Off | 0 |
| N/A 37C P0 39W / 300W | 2631MiB / 16160MiB | 0% Default |
| | | N/A |
+-------------------------------+----------------------+----------------------+
+-----------------------------------------------------------------------------+
| Processes: |
| GPU GI CI PID Type Process name GPU Memory |
| ID ID Usage |
|=============================================================================|
| 0 N/A N/A 3721 C ...nvs/codeparrot/bin/python 2629MiB |
+-----------------------------------------------------------------------------+
```
์ด์ ๊ณผ ๋์ผํ ์ซ์๊ฐ ์ถ๋ ฅ๋๊ณ 16GB ๋ฉ๋ชจ๋ฆฌ๋ฅผ ๊ฐ์ง V100 GPU๋ฅผ ์ฌ์ฉํ๊ณ ์๋ค๋ ๊ฒ๋ ๋ณผ ์ ์์ต๋๋ค. ๊ทธ๋ฌ๋ฏ๋ก ์ด์ ๋ชจ๋ธ ํ๋ จ์ ์์ํ์ฌ GPU ๋ฉ๋ชจ๋ฆฌ ์ฌ์ฉ๋์ด ์ด๋ป๊ฒ ๋ฌ๋ผ์ง๋์ง ๋ณผ ์ ์์ต๋๋ค. ์ฐ์ ๋ช๋ช ํ์ค ํ๋ จ ์ธ์๋ฅผ ์ค์ ํฉ๋๋ค:
```py
default_args = {
"output_dir": "tmp",
"eval_strategy": "steps",
"num_train_epochs": 1,
"log_level": "error",
"report_to": "none",
}
```
<Tip>
์ฌ๋ฌ ์คํ์ ์คํํ ๊ณํ์ด๋ผ๋ฉด, ์คํ ๊ฐ์ ๋ฉ๋ชจ๋ฆฌ๋ฅผ ์ ๋๋ก ๋น์ฐ๊ธฐ ์ํด์ Python ์ปค๋์ ์คํ ์ฌ์ด๋ง๋ค ์ฌ์์ํด์ผ ํฉ๋๋ค.
</Tip>
## ๊ธฐ๋ณธ ํ๋ จ์์์ ๋ฉ๋ชจ๋ฆฌ ํ์ฉ [[memory-utilization-at-vanilla-training]]
[`Trainer`]๋ฅผ ์ฌ์ฉํ์ฌ, GPU ์ฑ๋ฅ ์ต์ ํ ๊ธฐ์ ์ ์ฌ์ฉํ์ง ์๊ณ ๋ฐฐ์น ํฌ๊ธฐ๊ฐ 4์ธ ๋ชจ๋ธ์ ํ๋ จ์ํค๊ฒ ์ต๋๋ค:
```py
>>> from transformers import TrainingArguments, Trainer, logging
>>> logging.set_verbosity_error()
>>> training_args = TrainingArguments(per_device_train_batch_size=4, **default_args)
>>> trainer = Trainer(model=model, args=training_args, train_dataset=ds)
>>> result = trainer.train()
>>> print_summary(result)
```
```
Time: 57.82
Samples/second: 8.86
GPU memory occupied: 14949 MB.
```
์ฐ๋ฆฌ๋ ๋น๊ต์ ์์ ๋ฐฐ์น ํฌ๊ธฐ๋ก๋ ์ ์ฒด GPU ๋ฉ๋ชจ๋ฆฌ๋ฅผ ๊ฑฐ์ ๋ค ์ฐจ์งํ๋ ๊ฒ์ ๋ณผ ์ ์์ต๋๋ค. ๊ทธ๋ฌ๋ ๋ฐฐ์น ํฌ๊ธฐ๊ฐ ํด์๋ก ๋ชจ๋ธ ์๋ ด ์๋๊ฐ ๋นจ๋ผ์ง๊ณ ์ต์ข
์ฑ๋ฅ์ด ํฅ์๋๋ ๊ฒฝ์ฐ๊ฐ ๋ง์ต๋๋ค. ๊ทธ๋์ ์ด์์ ์ผ๋ก๋ GPU ์ ํ์ด ์๋ ์ฐ๋ฆฌ ๋ชจ๋ธ์ ์๊ตฌ์ฌํญ์ ๋ง๊ฒ ๋ฐฐ์น ํฌ๊ธฐ๋ฅผ ์กฐ์ ํ๋ ค๊ณ ํฉ๋๋ค. ํฅ๋ฏธ๋กญ๊ฒ๋ ์ฐ๋ฆฌ๋ ๋ชจ๋ธ์ ํฌ๊ธฐ๋ณด๋ค ํจ์ฌ ๋ ๋ง์ ๋ฉ๋ชจ๋ฆฌ๋ฅผ ์ฌ์ฉํฉ๋๋ค. ์ ์ด๋ฐ ํ์์ด ๋ฐ์ํ๋์ง ์กฐ๊ธ ๋ ์ ์ดํดํ๊ธฐ ์ํด ๋ชจ๋ธ์ ์ฐ์ฐ๊ณผ ๋ฉ๋ชจ๋ฆฌ ์๊ตฌ ์ฌํญ์ ์ดํด๋ณด๊ฒ ์ต๋๋ค.
## ๋ชจ๋ธ์ ์ฐ์ฐ ํด๋ถํ๊ธฐ [[anatomy-of-models-operations]]
ํธ๋์คํฌ๋จธ ์ํคํ
์ฒ์๋ ์ฐ์ฐ ๊ฐ๋(compute-intensity)์ ๋ฐ๋ผ ๊ทธ๋ฃนํ๋ 3๊ฐ์ง ์ฃผ์ ์ฐ์ฐ ๊ทธ๋ฃน์ด ์์ต๋๋ค.
1. **ํ
์ ์ถ์ฝ(Tensor Contractions)**
์ ํ ๋ ์ด์ด์ ๋ฉํฐํค๋ ์ดํ
์
์ ๊ตฌ์ฑ ์์๋ ๋ชจ๋ **ํ๋ ฌ-ํ๋ ฌ ๊ณฑ์
(matrix-matrix multiplications)**์ ์ผ๊ด์ ์ผ๋ก ์ฒ๋ฆฌํฉ๋๋ค. ์ด ์ฐ์ฐ์ ํธ๋์คํฌ๋จธ ํ๋ จ์์ ๊ฐ์ฅ ์ฐ์ฐ ๊ฐ๋๊ฐ ๋์ ๋ถ๋ถ์
๋๋ค.
2. **ํต๊ณ ์ ๊ทํ(Statistical Normalizations)**
์ํํธ๋งฅ์ค์ ๋ ์ด์ด ์ ๊ทํ๋ ํ
์ ์ถ์ฝ๋ณด๋ค ์ฐ์ฐ ๊ฐ๋๊ฐ ๋ฎ์ต๋๋ค. ํ๋ ์ด์์ **๊ฐ์ ์ฐ์ฐ(reduction operations)**์ ํฌํจํ๋ฉฐ, ๊ทธ ๊ฒฐ๊ณผ๋ map์ ํตํด ์ ์ฉ๋ฉ๋๋ค.
3. **์์๋ณ ์ฐ์ฐ์(Element-wise Operators)**
๊ทธ ์ธ ์ฐ์ฐ์๋ค, **ํธํฅ(biases), ๋๋กญ์์(dropout), ํ์ฑํ ํจ์(activations), ์์ฐจ ์ฐ๊ฒฐ(residual connections)**์ด ์ฌ๊ธฐ์ ํด๋นํฉ๋๋ค. ์ด ์ฐ์ฐ๋ค์ ์ฐ์ฐ ๊ฐ๋๊ฐ ๊ฐ์ฅ ๋ฎ์ต๋๋ค.
์ด๋ฌํ ์ง์์ ์ฑ๋ฅ ๋ณ๋ชฉ ํ์์ ๋ถ์ํ ๋ ๋์์ด ๋ ์ ์์ต๋๋ค.
์ด ๋ด์ฉ์ [Data Movement Is All You Need: A Case Study on Optimizing Transformers 2020](https://arxiv.org/abs/2007.00072)์ ์ฐธ๊ณ ํ์์ต๋๋ค.
## ๋ชจ๋ธ์ ๋ฉ๋ชจ๋ฆฌ ๊ตฌ์กฐ [[anatomy-of-models-memory]]
๋ชจ๋ธ์ ํ๋ จ์ํค๋ ๋ฐ๋ ๋จ์ํ GPU์ ๋ชจ๋ธ์ ์ฌ๋ฆฌ๋ ๊ฒ๋ณด๋ค ํจ์ฌ ๋ ๋ง์ ๋ฉ๋ชจ๋ฆฌ๋ฅผ ์ฌ์ฉํ๋ค๋ ๊ฒ์ ๋ณด์์ต๋๋ค. ์ด๋ ํ๋ จ ์ค GPU ๋ฉ๋ชจ๋ฆฌ๋ฅผ ์ฌ์ฉํ๋ ๋ง์ ๊ตฌ์ฑ ์์๊ฐ ์๊ธฐ ๋๋ฌธ์
๋๋ค. GPU ๋ฉ๋ชจ๋ฆฌ์ ๊ตฌ์ฑ ์์๋ ๋ค์๊ณผ ๊ฐ์ต๋๋ค:
1. ๋ชจ๋ธ ๊ฐ์ค์น
2. ์ตํฐ๋ง์ด์ ์ํ
3. ๊ทธ๋ผ๋์ธํธ
4. ๊ทธ๋ผ๋์ธํธ ๊ณ์ฐ์ ์ํด ์ ์ฅ๋ ์๋ฐฉํฅ ํ์ฑํ
5. ์์ ๋ฒํผ
6. ๊ธฐ๋ฅ๋ณ ๋ฉ๋ชจ๋ฆฌ
AdamW๋ฅผ ์ฌ์ฉํ์ฌ ํผํฉ ์ ๋ฐ๋๋ก ํ๋ จ๋ ์ผ๋ฐ์ ์ธ ๋ชจ๋ธ์ ๋ชจ๋ธ ํ๋ผ๋ฏธํฐ๋น 18 ๋ฐ์ดํธ์ ํ์ฑํ ๋ฉ๋ชจ๋ฆฌ๊ฐ ํ์ํฉ๋๋ค. ์ถ๋ก ๋จ๊ณ์์๋ ์ตํฐ๋ง์ด์ ์ ๊ทธ๋ผ๋์ธํธ๊ฐ ํ์ํ์ง ์์ผ๋ฏ๋ก ์ด๋ค์ ์ ์ธํฉ๋๋ค. ๋ฐ๋ผ์ ํผํฉ ์ ๋ฐ๋ ์ถ๋ก ์ ๊ฒฝ์ฐ ๋ชจ๋ธ ๋งค๊ฐ๋ณ์๋น 6 ๋ฐ์ดํธ์ ํ์ฑํ ๋ฉ๋ชจ๋ฆฌ๊ฐ ํ์ํฉ๋๋ค.
์์ธํ ์ดํด๋ณด๊ฒ ์ต๋๋ค.
**๋ชจ๋ธ ๊ฐ์ค์น:**
- fp32 ํ๋ จ์ ๊ฒฝ์ฐ ๋งค๊ฐ ๋ณ์ ์ * 4 ๋ฐ์ดํธ
- ํผํฉ ์ ๋ฐ๋ ํ๋ จ์ ๊ฒฝ์ฐ ๋งค๊ฐ ๋ณ์ ์ * 6 ๋ฐ์ดํธ (๋ฉ๋ชจ๋ฆฌ์ fp32์ fp16 ๋ ๊ฐ์ง ๋ชจ๋ธ์ ์ ์ง)
**์ตํฐ๋ง์ด์ ์ํ:**
- ์ผ๋ฐ AdamW์ ๊ฒฝ์ฐ ๋งค๊ฐ ๋ณ์ ์ * 8 ๋ฐ์ดํธ (2๊ฐ์ง ์ํ ์ ์ง)
- [bitsandbytes](https://github.com/TimDettmers/bitsandbytes)์ ๊ฐ์ 8๋นํธ AdamW ์ตํฐ๋ง์ด์ ์ ๊ฒฝ์ฐ ๋งค๊ฐ ๋ณ์ ์ * 2 ๋ฐ์ดํธ
- Momentum์ ๊ฐ์ง SGD์ ๊ฐ์ ์ตํฐ๋ง์ด์ ์ ๊ฒฝ์ฐ ๋งค๊ฐ ๋ณ์ ์ * 4 ๋ฐ์ดํธ (ํ๋์ ์ํ๋ง ์ ์ง)
**๊ทธ๋ผ๋์ธํธ**
- fp32 ๋๋ ํผํฉ ์ ๋ฐ๋ ํ๋ จ์ ๊ฒฝ์ฐ ๋งค๊ฐ ๋ณ์ ์ * 4 ๋ฐ์ดํธ (๊ทธ๋ผ๋์ธํธ๋ ํญ์ fp32์ผ๋ก ์ ์ง๋ฉ๋๋ค.)
**์๋ฐฉํฅ ํ์ฑํ**
- ํฌ๊ธฐ๋ ์ฌ๋ฌ ์์ธ์ ๋ฐ๋ผ ๋ฌ๋ผ์ง๋ฉฐ, ์ฃผ์ ์์ธ์ ์ํ์ค ๊ธธ์ด, ์๋ ์ํ์ ํฌ๊ธฐ ๋ฐ ๋ฐฐ์น ํฌ๊ธฐ์
๋๋ค.
์๋ฐฉํฅ ๋ฐ ์ญ๋ฐฉํฅ ํจ์์์ ์ ๋ฌ ๋ฐ ๋ฐํ๋๋ ์
๋ ฅ๊ณผ ์ถ๋ ฅ์ด ์์ผ๋ฉฐ, ๊ทธ๋ผ๋์ธํธ ๊ณ์ฐ์ ์ํด ์ ์ฅ๋ ์๋ฐฉํฅ ํ์ฑํ๊ฐ ์์ต๋๋ค.
**์์ ๋ฉ๋ชจ๋ฆฌ**
๋๋ถ์ด ๋ชจ๋ ์ข
๋ฅ์ ์์ ๋ณ์๋ ์ฐ์ฐ์ด ์๋ฃ๋๋ฉด ๊ณง๋ฐ๋ก ํด์ ๋์ง๋ง, ๊ทธ ์๊ฐ์๋ ์ถ๊ฐ ๋ฉ๋ชจ๋ฆฌ๊ฐ ํ์ํ ์ ์๊ณ OOM์ ์ ๋ฐํ ์ ์์ต๋๋ค. ๋ฐ๋ผ์ ์ฝ๋ฉํ ๋ ์ด๋ฌํ ์์ ๋ณ์์ ๋ํด ์ ๋ต์ ์ผ๋ก ์๊ฐํ๊ณ ๋๋ก๋ ๋ ์ด์ ํ์ ์๋ ์์ ๋ณ์๋ฅผ ์ฆ์ ๋ช
์์ ์ผ๋ก ๋ฉ๋ชจ๋ฆฌ์์ ์ ๊ฑฐํ๋ ๊ฒ์ด ์ค์ํฉ๋๋ค.
**๊ธฐ๋ฅ๋ณ ๋ฉ๋ชจ๋ฆฌ**
๊ทธ๋ฐ ๋ค์, ์ํํธ์จ์ด์๋ ํน๋ณํ ๋ฉ๋ชจ๋ฆฌ ์๊ตฌ ์ฌํญ์ด ์์ ์ ์์ต๋๋ค. ์๋ฅผ ๋ค์ด, ๋น ๊ฒ์์ ์ฌ์ฉํ์ฌ ํ
์คํธ๋ฅผ ์์ฑํ ๋ ์ํํธ์จ์ด๋ ์
๋ ฅ๊ณผ ์ถ๋ ฅ ์ฌ๋ณธ์ ์ฌ๋ฌ ๊ฐ ์ ์งํด์ผ ํฉ๋๋ค.
**`forward` vs `backward` ์คํ ์๋**
ํฉ์ฑ๊ณฑ๊ณผ ์ ํ ๋ ์ด์ด์ ๊ฒฝ์ฐ ์๋ฐฉํฅ์ ๋นํด ์ญ๋ฐฉํฅ์์๋ 2๋ฐฐ์ ํ๋กญ์ค๊ฐ ํ์ํ๋ฏ๋ก ์ผ๋ฐ์ ์ผ๋ก 2๋ฐฐ ์ ๋ ๋๋ฆฌ๊ฒ ๋ณํ๋ฉ๋๋ค(์ญ๋ฐฉํฅ์ ๊ฒฝ์ฐ ์ฌ์ด์ฆ๊ฐ ๋ถ์์ฐ์ค๋ฝ๊ธฐ ๋๋ฌธ์, ๋๋ก๋ ๋์ฑ ๋๋ฆด ์๋ ์์ต๋๋ค). ํ์ฑํ๋ ์ผ๋ฐ์ ์ผ๋ก ๋์ญํญ์ด ์ ํ๋์ด ์์ผ๋ฉฐ, ์ผ๋ฐ์ ์ผ๋ก ์๋ฐฉํฅ๋ณด๋ค ์ญ๋ฐฉํฅ์์ ๋ ๋ง์ ๋ฐ์ดํฐ๋ฅผ ์ฝ์ด์ผ ํฉ๋๋ค. (์๋ฅผ ๋ค์ด, ์๋ฐฉํฅ ํ์ฑํ ์ ํ ๋ฒ ์ฉ ์ฝ๊ณ ์ฐ์ง๋ง, ์ญ๋ฐฉํฅ ํ์ฑํ์์๋ ์๋ฐฉํฅ gradOutput๊ณผ ์ถ๋ ฅ์ ๋ํด ์ด ๋ ๋ฒ ์ฝ๊ณ gradInput์ ๋ํด ํ ๋ฒ ์๋๋ค.)
๋ณด๋ค์ํผ, GPU ๋ฉ๋ชจ๋ฆฌ๋ฅผ ์ ์ฝํ๊ฑฐ๋ ์์
์๋๋ฅผ ๋์ผ ์ ์๋ ๋ช ๊ฐ์ง ๋ฐฉ๋ฒ์ด ์์ต๋๋ค.
์ด์ GPU ํ์ฉ๊ณผ ๊ณ์ฐ ์๋์ ์ํฅ์ ์ฃผ๋ ๊ฒ์ด ๋ฌด์์ธ์ง๋ฅผ ์ดํดํ์ผ๋ฏ๋ก, [Methods and tools for efficient training on a single GPU](perf_train_gpu_one) ๋ฌธ์ ํ์ด์ง๋ฅผ ์ฐธ์กฐํ์ฌ ์ฑ๋ฅ ์ต์ ํ ๊ธฐ๋ฒ์ ๋ํด ์์๋ณด์ธ์. | 0 |
mavonic_private_repos/transformers/docs/source | mavonic_private_repos/transformers/docs/source/ko/testing.md | <!--Copyright 2020 The HuggingFace Team. All rights reserved.
Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
the License. You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
specific language governing permissions and limitations under the License.
โ ๏ธ Note that this file is in Markdown but contain specific syntax for our doc-builder (similar to MDX) that may not be
rendered properly in your Markdown viewer.
-->
# ํ
์คํธ[[testing]]
๋จผ์ ๐ค Transformers ๋ชจ๋ธ์ด ์ด๋ป๊ฒ ํ
์คํธ๋๋์ง ์ดํด๋ณด๊ณ , ์๋ก์ด ํ
์คํธ๋ฅผ ์์ฑ ๋ฐ ๊ธฐ์กด ํ
์คํธ๋ฅผ ๊ฐ์ ํ๋ ๋ฐฉ๋ฒ์ ์์๋ด
์๋ค.
์ด ์ ์ฅ์์๋ 2๊ฐ์ ํ
์คํธ ์ค์ํธ๊ฐ ์์ต๋๋ค:
1. `tests` - ์ผ๋ฐ API์ ๋ํ ํ
์คํธ
2. `examples` - API์ ์ผ๋ถ๊ฐ ์๋ ๋ค์ํ ์์ฉ ํ๋ก๊ทธ๋จ์ ๋ํ ํ
์คํธ
## Transformers ํ
์คํธ ๋ฐฉ๋ฒ[[how-transformers-are-tested]]
1. PR์ด ์ ์ถ๋๋ฉด 9๊ฐ์ CircleCi ์์
์ผ๋ก ํ
์คํธ๊ฐ ์งํ๋ฉ๋๋ค. ํด๋น PR์ ๋ํด ์๋ก์ด ์ปค๋ฐ์ด ์์ฑ๋ ๋๋ง๋ค ํ
์คํธ๋ ๋ค์ ์งํ๋ฉ๋๋ค. ์ด ์์
๋ค์
์ด [config ํ์ผ](https://github.com/huggingface/transformers/tree/main/.circleci/config.yml)์ ์ ์๋์ด ์์ผ๋ฏ๋ก ํ์ํ๋ค๋ฉด
์ฌ์ฉ์์ ๋ก์ปฌ ํ๊ฒฝ์์ ๋์ผํ๊ฒ ์ฌํํด ๋ณผ ์ ์์ต๋๋ค.
์ด CI ์์
์ `@slow` ํ
์คํธ๋ฅผ ์คํํ์ง ์์ต๋๋ค.
2. [github actions](https://github.com/huggingface/transformers/actions)์ ์ํด ์คํ๋๋ ์์
์ 3๊ฐ์
๋๋ค:
- [torch hub integration](https://github.com/huggingface/transformers/tree/main/.github/workflows/github-torch-hub.yml):
torch hub integration์ด ์๋ํ๋์ง ํ์ธํฉ๋๋ค.
- [self-hosted (push)](https://github.com/huggingface/transformers/tree/main/.github/workflows/self-push.yml): `main` ๋ธ๋์น์์ ์ปค๋ฐ์ด ์
๋ฐ์ดํธ๋ ๊ฒฝ์ฐ์๋ง GPU๋ฅผ ์ด์ฉํ ๋น ๋ฅธ ํ
์คํธ๋ฅผ ์คํํฉ๋๋ค.
์ด๋ `src`, `tests`, `.github` ํด๋ ์ค ํ๋์ ์ฝ๋๊ฐ ์
๋ฐ์ดํธ๋ ๊ฒฝ์ฐ์๋ง ์คํ๋ฉ๋๋ค.
(model card, notebook, ๊ธฐํ ๋ฑ๋ฑ์ ์ถ๊ฐํ ๊ฒฝ์ฐ ์คํ๋์ง ์๋๋ก ํ๊ธฐ ์ํด์์
๋๋ค)
- [self-hosted runner](https://github.com/huggingface/transformers/tree/main/.github/workflows/self-scheduled.yml): `tests` ๋ฐ `examples`์์
GPU๋ฅผ ์ด์ฉํ ์ผ๋ฐ ํ
์คํธ, ๋๋ฆฐ ํ
์คํธ๋ฅผ ์คํํฉ๋๋ค.
```bash
RUN_SLOW=1 pytest tests/
RUN_SLOW=1 pytest examples/
```
๊ฒฐ๊ณผ๋ [์ฌ๊ธฐ](https://github.com/huggingface/transformers/actions)์์ ํ์ธํ ์ ์์ต๋๋ค.
## ํ
์คํธ ์คํ[[running-tests]]
### ์คํํ ํ
์คํธ ์ ํ[[choosing-which-tests-to-run]]
์ด ๋ฌธ์๋ ํ
์คํธ๋ฅผ ์คํํ๋ ๋ค์ํ ๋ฐฉ๋ฒ์ ๋ํด ์์ธํ ์ค๋ช
ํฉ๋๋ค.
๋ชจ๋ ๋ด์ฉ์ ์ฝ์ ํ์๋, ๋ ์์ธํ ๋ด์ฉ์ด ํ์ํ๋ค๋ฉด [์ฌ๊ธฐ](https://docs.pytest.org/en/latest/usage.html)์์ ํ์ธํ ์ ์์ต๋๋ค.
๋ค์์ ๊ฐ์ฅ ์ ์ฉํ ํ
์คํธ ์คํ ๋ฐฉ๋ฒ ๋ช ๊ฐ์ง์
๋๋ค.
๋ชจ๋ ์คํ:
```console
pytest
```
๋๋:
```bash
make test
```
ํ์๋ ๋ค์๊ณผ ๊ฐ์ด ์ ์๋ฉ๋๋ค:
```bash
python -m pytest -n auto --dist=loadfile -s -v ./tests/
```
์์ ๋ช
๋ น์ด๋ pytest์๊ฒ ์๋์ ๋ด์ฉ์ ์ ๋ฌํฉ๋๋ค:
- ์ฌ์ฉ ๊ฐ๋ฅํ CPU ์ฝ์ด ์๋งํผ ํ
์คํธ ํ๋ก์ธ์ค๋ฅผ ์คํํฉ๋๋ค. (RAM์ด ์ถฉ๋ถํ์ง ์๋ค๋ฉด, ํ
์คํธ ํ๋ก์ธ์ค ์๊ฐ ๋๋ฌด ๋ง์ ์ ์์ต๋๋ค!)
- ๋์ผํ ํ์ผ์ ๋ชจ๋ ํ
์คํธ๋ ๋์ผํ ํ
์คํธ ํ๋ก์ธ์ค์์ ์คํ๋์ด์ผ ํฉ๋๋ค.
- ์ถ๋ ฅ์ ์บก์ฒํ์ง ์์ต๋๋ค.
- ์์ธํ ๋ชจ๋๋ก ์คํํฉ๋๋ค.
### ๋ชจ๋ ํ
์คํธ ๋ชฉ๋ก ๊ฐ์ ธ์ค๊ธฐ[[getting-the-list-of-all-tests]]
ํ
์คํธ ์ค์ํธ์ ๋ชจ๋ ํ
์คํธ:
```bash
pytest --collect-only -q
```
์ง์ ๋ ํ
์คํธ ํ์ผ์ ๋ชจ๋ ํ
์คํธ:
```bash
pytest tests/test_optimization.py --collect-only -q
```
### ํน์ ํ
์คํธ ๋ชจ๋ ์คํ[[run-a-specific-test-module]]
๊ฐ๋ณ ํ
์คํธ ๋ชจ๋ ์คํํ๊ธฐ:
```bash
pytest tests/utils/test_logging.py
```
### ํน์ ํ
์คํธ ์คํ[[run-specific-tests]]
๋๋ถ๋ถ์ ํ
์คํธ ๋ด๋ถ์์๋ unittest๊ฐ ์ฌ์ฉ๋ฉ๋๋ค. ๋ฐ๋ผ์ ํน์ ํ์ ํ
์คํธ๋ฅผ ์คํํ๋ ค๋ฉด ํด๋น ํ
์คํธ๋ฅผ ํฌํจํ๋ unittest ํด๋์ค์ ์ด๋ฆ์ ์์์ผ ํฉ๋๋ค.
์๋ฅผ ๋ค์ด ๋ค์๊ณผ ๊ฐ์ ์ ์์ต๋๋ค:
```bash
pytest tests/test_optimization.py::OptimizationTest::test_adam_w
```
์์ ๋ช
๋ น์ด์ ์๋ฏธ๋ ๋ค์๊ณผ ๊ฐ์ต๋๋ค:
- `tests/test_optimization.py` - ํ
์คํธ๊ฐ ์๋ ํ์ผ
- `OptimizationTest` - ํด๋์ค์ ์ด๋ฆ
- `test_adam_w` - ํน์ ํ
์คํธ ํจ์์ ์ด๋ฆ
ํ์ผ์ ์ฌ๋ฌ ํด๋์ค๊ฐ ํฌํจ๋ ๊ฒฝ์ฐ, ํน์ ํด๋์ค์ ํ
์คํธ๋ง ์คํํ ์๋ ์์ต๋๋ค. ์๋ฅผ ๋ค์ด ๋ค์๊ณผ ๊ฐ์ต๋๋ค:
```bash
pytest tests/test_optimization.py::OptimizationTest
```
์ด ๋ช
๋ น์ด๋ ํด๋น ํด๋์ค ๋ด๋ถ์ ๋ชจ๋ ํ
์คํธ๋ฅผ ์คํํฉ๋๋ค.
์์์ ์ธ๊ธํ ๊ฒ์ฒ๋ผ `OptimizationTest` ํด๋์ค์ ํฌํจ๋ ํ
์คํธ๋ฅผ ํ์ธํ ์ ์์ต๋๋ค.
```bash
pytest tests/test_optimization.py::OptimizationTest --collect-only -q
```
ํค์๋ ํํ์์ ์ฌ์ฉํ์ฌ ํ
์คํธ๋ฅผ ์คํํ ์๋ ์์ต๋๋ค.
`adam`์ด๋ผ๋ ์ด๋ฆ์ ํฌํจํ๋ ํ
์คํธ๋ง ์คํํ๋ ค๋ฉด ๋ค์๊ณผ ๊ฐ์ต๋๋ค:
```bash
pytest -k adam tests/test_optimization.py
```
๋
ผ๋ฆฌ ์ฐ์ฐ์ `and`์ `or`๋ฅผ ์ฌ์ฉํ์ฌ ๋ชจ๋ ํค์๋๊ฐ ์ผ์นํด์ผ ํ๋์ง ๋๋ ์ด๋ ํ๋๊ฐ ์ผ์นํด์ผ ํ๋์ง๋ฅผ ๋ํ๋ผ ์ ์์ต๋๋ค.
`not`์ ๋ถ์ ํ ๋ ์ฌ์ฉํ ์ ์์ต๋๋ค.
`adam`์ด๋ผ๋ ์ด๋ฆ์ ํฌํจํ์ง ์๋ ๋ชจ๋ ํ
์คํธ๋ฅผ ์คํํ๋ ค๋ฉด ๋ค์๊ณผ ๊ฐ์ต๋๋ค:
```bash
pytest -k "not adam" tests/test_optimization.py
```
๋ ๊ฐ์ง ํจํด์ ํ๋๋ก ๊ฒฐํฉํ ์๋ ์์ต๋๋ค:
```bash
pytest -k "ada and not adam" tests/test_optimization.py
```
์๋ฅผ ๋ค์ด `test_adafactor`์ `test_adam_w`๋ฅผ ๋ชจ๋ ์คํํ๋ ค๋ฉด ๋ค์์ ์ฌ์ฉํ ์ ์์ต๋๋ค:
```bash
pytest -k "test_adam_w or test_adam_w" tests/test_optimization.py
```
์ฌ๊ธฐ์ `or`๋ฅผ ์ฌ์ฉํ๋ ๊ฒ์ ์ ์ํ์ธ์. ๋ ํค์๋ ์ค ํ๋๊ฐ ์ผ์นํ๋๋ก ํ๊ธฐ ์ํ ๋ชฉ์ ์ผ๋ก ์ฌ์ฉํ๊ธฐ ๋๋ฌธ์
๋๋ค.
๋ ํจํด์ด ๋ชจ๋ ํฌํจ๋์ด์ผ ํ๋ ํ
์คํธ๋ง ์คํํ๋ ค๋ฉด, `and`๋ฅผ ์ฌ์ฉํด์ผ ํฉ๋๋ค:
```bash
pytest -k "test and ada" tests/test_optimization.py
```
### `accelerate` ํ
์คํธ ์คํ[[run-`accelerate`-tests]]
๋ชจ๋ธ์์ `accelerate` ํ
์คํธ๋ฅผ ์คํํด์ผ ํ ๋๊ฐ ์์ต๋๋ค. ์ด๋ฅผ ์ํด์๋ ๋ช
๋ น์ด์ `-m accelerate_tests`๋ฅผ ์ถ๊ฐํ๋ฉด ๋ฉ๋๋ค.
์๋ฅผ ๋ค์ด, `OPT`์์ ์ด๋ฌํ ํ
์คํธ๋ฅผ ์คํํ๋ ค๋ฉด ๋ค์๊ณผ ๊ฐ์ต๋๋ค:
```bash
RUN_SLOW=1 pytest -m accelerate_tests tests/models/opt/test_modeling_opt.py
```
### ๋ฌธ์ ํ
์คํธ ์คํ[[run-documentation-tests]]
์์ ๋ฌธ์๊ฐ ์ฌ๋ฐ๋ฅธ์ง ํ
์คํธํ๋ ค๋ฉด `doctests`๊ฐ ํต๊ณผํ๋์ง ํ์ธํด์ผ ํฉ๋๋ค.
์๋ฅผ ๋ค์ด, [`WhisperModel.forward`'s docstring](https://github.com/huggingface/transformers/blob/main/src/transformers/models/whisper/modeling_whisper.py#L1017-L1035)๋ฅผ ์ฌ์ฉํด ๋ด
์๋ค:
```python
r"""
Returns:
Example:
```python
>>> import torch
>>> from transformers import WhisperModel, WhisperFeatureExtractor
>>> from datasets import load_dataset
>>> model = WhisperModel.from_pretrained("openai/whisper-base")
>>> feature_extractor = WhisperFeatureExtractor.from_pretrained("openai/whisper-base")
>>> ds = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
>>> inputs = feature_extractor(ds[0]["audio"]["array"], return_tensors="pt")
>>> input_features = inputs.input_features
>>> decoder_input_ids = torch.tensor([[1, 1]]) * model.config.decoder_start_token_id
>>> last_hidden_state = model(input_features, decoder_input_ids=decoder_input_ids).last_hidden_state
>>> list(last_hidden_state.shape)
[1, 2, 512]
```"""
```
์ํ๋ ํ์ผ์ ๋ชจ๋ docstring ์์ ๋ฅผ ์๋์ผ๋ก ํ
์คํธํ๋ ค๋ฉด ๋ค์ ๋ช
๋ น์ ์คํํ๋ฉด ๋ฉ๋๋ค:
```bash
pytest --doctest-modules <path_to_file_or_dir>
```
ํ์ผ์ ํ์ฅ์๊ฐ markdown์ธ ๊ฒฝ์ฐ `--doctest-glob="*.md"` ์ธ์๋ฅผ ์ถ๊ฐํด์ผ ํฉ๋๋ค.
### ์์ ๋ ํ
์คํธ๋ง ์คํ[[run-only-modified-tests]]
์์ ๋ ํ์ผ ๋๋ ํ์ฌ ๋ธ๋์น (Git ๊ธฐ์ค)์ ๊ด๋ จ๋ ํ
์คํธ๋ฅผ ์คํํ๋ ค๋ฉด [pytest-picked](https://github.com/anapaulagomes/pytest-picked)์ ์ฌ์ฉํ ์ ์์ต๋๋ค.
์ด๋ ๋ณ๊ฒฝํ ๋ด์ฉ์ด ํ
์คํธ์ ์ํฅ์ ์ฃผ์ง ์์๋์ง ๋น ๋ฅด๊ฒ ํ์ธํ ์ ์๋ ์ข์ ๋ฐฉ๋ฒ์
๋๋ค.
```bash
pip install pytest-picked
```
```bash
pytest --picked
```
์์ ๋์์ง๋ง, ์์ง ์ปค๋ฐ๋์ง ์์ ๋ชจ๋ ํ์ผ ๋ฐ ํด๋์์ ํ
์คํธ๊ฐ ์คํ๋ฉ๋๋ค.
### ์์ค ์์ ์ ์คํจํ ํ
์คํธ ์๋ ์ฌ์คํ[[automatically-rerun-failed-tests-on-source-modification]]
[pytest-xdist](https://github.com/pytest-dev/pytest-xdist)๋ ๋ชจ๋ ์คํจํ ํ
์คํธ๋ฅผ ๊ฐ์งํ๊ณ ,
ํ์ผ์ ์์ ํ ํ์ ํ์ผ์ ๊ณ์ ์ฌ์คํํ์ฌ ํ
์คํธ๊ฐ ์ฑ๊ณตํ ๋๊น์ง ๊ธฐ๋ค๋ฆฌ๋ ๋งค์ฐ ์ ์ฉํ ๊ธฐ๋ฅ์ ์ ๊ณตํฉ๋๋ค.
๋ฐ๋ผ์ ์์ ํ ๋ด์ฉ์ ํ์ธํ ํ pytest๋ฅผ ๋ค์ ์์ํ ํ์๊ฐ ์์ต๋๋ค.
๋ชจ๋ ํ
์คํธ๊ฐ ํต๊ณผ๋ ๋๊น์ง ์ด ๊ณผ์ ์ ๋ฐ๋ณตํ ํ ๋ค์ ์ ์ฒด ์คํ์ด ์ด๋ฃจ์ด์ง๋๋ค.
```bash
pip install pytest-xdist
```
์ฌ๊ท์ ๋ชจ๋์ ์ฌ์ฉ: `pytest -f` ๋๋ `pytest --looponfail`
ํ์ผ์ ๋ณ๊ฒฝ ์ฌํญ์ `looponfailroots` ๋ฃจํธ ๋๋ ํฐ๋ฆฌ์ ํด๋น ๋ด์ฉ์ (์ฌ๊ท์ ์ผ๋ก) ํ์ธํ์ฌ ๊ฐ์ง๋ฉ๋๋ค.
์ด ๊ฐ์ ๊ธฐ๋ณธ๊ฐ์ด ์๋ํ์ง ์๋ ๊ฒฝ์ฐ,
`setup.cfg`์ ์ค์ ์ต์
์ ๋ณ๊ฒฝํ์ฌ ํ๋ก์ ํธ์์ ๋ณ๊ฒฝํ ์ ์์ต๋๋ค:
```ini
[tool:pytest]
looponfailroots = transformers tests
```
๋๋ `pytest.ini`/`tox.ini`` ํ์ผ:
```ini
[pytest]
looponfailroots = transformers tests
```
์ด๋ ๊ฒ ํ๋ฉด ini-file์ ๋๋ ํฐ๋ฆฌ๋ฅผ ๊ธฐ์ค์ผ๋ก ์๋์ ์ผ๋ก ์ง์ ๋ ๊ฐ ๋๋ ํฐ๋ฆฌ์์ ํ์ผ ๋ณ๊ฒฝ ์ฌํญ๋ง ์ฐพ๊ฒ ๋ฉ๋๋ค.
์ด ๊ธฐ๋ฅ์ ๋์ฒดํ ์ ์๋ ๊ตฌํ ๋ฐฉ๋ฒ์ธ [pytest-watch](https://github.com/joeyespo/pytest-watch)๋ ์์ต๋๋ค.
### ํน์ ํ
์คํธ ๋ชจ๋ ๊ฑด๋๋ฐ๊ธฐ[[skip-a-test-module]]
๋ชจ๋ ํ
์คํธ ๋ชจ๋์ ์คํํ๋ ํน์ ๋ชจ๋์ ์ ์ธํ๋ ค๋ฉด, ์คํํ ํ
์คํธ ๋ชฉ๋ก์ ๋ช
์์ ์ผ๋ก ์ง์ ํ ์ ์์ต๋๋ค.
์๋ฅผ ๋ค์ด, `test_modeling_*.py` ํ
์คํธ๋ฅผ ์ ์ธํ ๋ชจ๋ ํ
์คํธ๋ฅผ ์คํํ๋ ค๋ฉด ๋ค์์ ์ฌ์ฉํ ์ ์์ต๋๋ค:
```bash
pytest *ls -1 tests/*py | grep -v test_modeling*
```
### ์ํ ์ด๊ธฐํ[[clearing state]]
CI ๋น๋ ๋ฐ (์๋์ ๋ํ) ๊ฒฉ๋ฆฌ๊ฐ ์ค์ํ ๊ฒฝ์ฐ, ์บ์๋ฅผ ์ง์์ผ ํฉ๋๋ค:
```bash
pytest --cache-clear tests
```
### ํ
์คํธ๋ฅผ ๋ณ๋ ฌ๋ก ์คํ[[running-tests-in-parallel]]
์ด์ ์ ์ธ๊ธํ ๊ฒ์ฒ๋ผ `make test`๋ ํ
์คํธ๋ฅผ ๋ณ๋ ฌ๋ก ์คํํ๊ธฐ ์ํด
`pytest-xdist` ํ๋ฌ๊ทธ์ธ(`-n X` ์ธ์, ์๋ฅผ ๋ค์ด `-n 2`๋ฅผ ์ฌ์ฉํ์ฌ 2๊ฐ์ ๋ณ๋ ฌ ์์
์คํ)์ ํตํด ์คํ๋ฉ๋๋ค.
`pytest-xdist`์ `--dist=` ์ต์
์ ์ฌ์ฉํ์ฌ ํ
์คํธ๋ฅผ ์ด๋ป๊ฒ ๊ทธ๋ฃนํํ ์ง ์ ์ดํ ์ ์์ต๋๋ค.
`--dist=loadfile`์ ํ๋์ ํ์ผ์ ์๋ ํ
์คํธ๋ฅผ ๋์ผํ ํ๋ก์ธ์ค๋ก ๊ทธ๋ฃนํํฉ๋๋ค.
์คํ๋ ํ
์คํธ์ ์์๊ฐ ๋ค๋ฅด๊ณ ์์ธกํ ์ ์๊ธฐ ๋๋ฌธ์, `pytest-xdist`๋ก ํ
์คํธ ์ค์ํธ๋ฅผ ์คํํ๋ฉด ์คํจ๊ฐ ๋ฐ์ํ ์ ์์ต๋๋ค (๊ฒ์ถ๋์ง ์์ ๊ฒฐํฉ๋ ํ
์คํธ๊ฐ ์๋ ๊ฒฝ์ฐ).
์ด ๊ฒฝ์ฐ [pytest-replay](https://github.com/ESSS/pytest-replay)๋ฅผ ์ฌ์ฉํ๋ฉด ๋์ผํ ์์๋ก ํ
์คํธ๋ฅผ ๋ค์ ์คํํด์
์คํจํ๋ ์ํ์ค๋ฅผ ์ต์ํํ๋ ๋ฐ์ ๋์์ด ๋ฉ๋๋ค.
### ํ
์คํธ ์์์ ๋ฐ๋ณต[[test-order-and-repetition]]
์ ์ฌ์ ์ธ ์ข
์์ฑ ๋ฐ ์ํ ๊ด๋ จ ๋ฒ๊ทธ(tear down)๋ฅผ ๊ฐ์งํ๊ธฐ ์ํด
ํ
์คํธ๋ฅผ ์ฌ๋ฌ ๋ฒ, ์ฐ์์ผ๋ก, ๋ฌด์์๋ก ๋๋ ์ธํธ๋ก ๋ฐ๋ณตํ๋ ๊ฒ์ด ์ข์ต๋๋ค.
๊ทธ๋ฆฌ๊ณ ์ง์ ์ ์ธ ์ฌ๋ฌ ๋ฒ์ ๋ฐ๋ณต์ DL์ ๋ฌด์์์ฑ์ ์ํด ๋ฐ๊ฒฌ๋๋ ์ผ๋ถ ๋ฌธ์ ๋ฅผ ๊ฐ์งํ๋ ๋ฐ์๋ ์ ์ฉํฉ๋๋ค.
#### ํ
์คํธ๋ฅผ ๋ฐ๋ณต[[repeat-tests]]
- [pytest-flakefinder](https://github.com/dropbox/pytest-flakefinder):
```bash
pip install pytest-flakefinder
```
๋ชจ๋ ํ
์คํธ๋ฅผ ์ฌ๋ฌ ๋ฒ ์คํํฉ๋๋ค(๊ธฐ๋ณธ๊ฐ์ 50๋ฒ):
```bash
pytest --flake-finder --flake-runs=5 tests/test_failing_test.py
```
<Tip>
์ด ํ๋ฌ๊ทธ์ธ์ `pytest-xdist`์ `-n` ํ๋๊ทธ์ ํจ๊ป ์๋ํ์ง ์์ต๋๋ค.
</Tip>
<Tip>
`pytest-repeat`๋ผ๋ ๋ ๋ค๋ฅธ ํ๋ฌ๊ทธ์ธ๋ ์์ง๋ง `unittest`์ ํจ๊ป ์๋ํ์ง ์์ต๋๋ค.
</Tip>
#### ํ
์คํธ๋ฅผ ์์์ ์์๋ก ์คํ[[run-tests-in-a-random-order]]
```bash
pip install pytest-random-order
```
์ค์: `pytest-random-order`๊ฐ ์ค์น๋๋ฉด ํ
์คํธ๊ฐ ์๋์ผ๋ก ์์์ ์์๋ก ์์
๋๋ค.
๊ตฌ์ฑ ๋ณ๊ฒฝ์ด๋ ์ปค๋งจ๋ ๋ผ์ธ ์ต์
์ด ํ์ํ์ง ์์ต๋๋ค.
์์ ์ค๋ช
ํ ๊ฒ์ฒ๋ผ ์ด๋ฅผ ํตํด ํ ํ
์คํธ์ ์ํ๊ฐ ๋ค๋ฅธ ํ
์คํธ์ ์ํ์ ์ํฅ์ ๋ฏธ์น๋ ๊ฒฐํฉ๋ ํ
์คํธ๋ฅผ ๊ฐ์งํ ์ ์์ต๋๋ค.
`pytest-random-order`๊ฐ ์ค์น๋๋ฉด ํด๋น ์ธ์
์์ ์ฌ์ฉ๋ ๋๋ค ์๋๊ฐ ์ถ๋ ฅ๋๋ฉฐ ์๋ฅผ ๋ค์ด ๋ค์๊ณผ ๊ฐ์ต๋๋ค:
```bash
pytest tests
[...]
Using --random-order-bucket=module
Using --random-order-seed=573663
```
๋ฐ๋ผ์ ํน์ ์ํ์ค๊ฐ ์คํจํ๋ ๊ฒฝ์ฐ์๋ ์ ํํ ์๋๋ฅผ ์ถ๊ฐํ์ฌ ์ฌํํ ์ ์์ต๋๋ค. ์๋ฅผ ๋ค์ด ๋ค์๊ณผ ๊ฐ์ต๋๋ค:
```bash
pytest --random-order-seed=573663
[...]
Using --random-order-bucket=module
Using --random-order-seed=573663
```
์ ํํ ๋์ผํ ํ
์คํธ ๋ชฉ๋ก(๋๋ ๋ชฉ๋ก์ด ์์)์ ์ฌ์ฉํ๋ ๊ฒฝ์ฐ์๋ง ์ ํํ ์์๋ฅผ ์ฌํํฉ๋๋ค.
๋ชฉ๋ก์ ์๋์ผ๋ก ์ขํ๊ธฐ ์์ํ๋ฉด ๋ ์ด์ ์๋์ ์์กดํ ์ ์๊ณ ์คํจํ๋ ์ ํํ ์์๋ก ์๋์ผ๋ก ๋ชฉ๋ก์ ๋์ดํด์ผํฉ๋๋ค. ๊ทธ๋ฆฌ๊ณ `--random-order-bucket=none`์ ์ฌ์ฉํ์ฌ pytest์๊ฒ ์์๋ฅผ ์์๋ก ์ค์ ํ์ง ์๋๋ก ์๋ ค์ผ ํฉ๋๋ค.
์๋ฅผ ๋ค์ด ๋ค์๊ณผ ๊ฐ์ต๋๋ค:
```bash
pytest --random-order-bucket=none tests/test_a.py tests/test_c.py tests/test_b.py
```
๋ชจ๋ ํ
์คํธ์ ๋ํด ์๊ธฐ๋ฅผ ๋นํ์ฑํํ๋ ค๋ฉด ๋ค์๊ณผ ๊ฐ์ต๋๋ค:
```bash
pytest --random-order-bucket=none
```
๊ธฐ๋ณธ์ ์ผ๋ก `--random-order-bucket=module`์ด ๋ด์ฌ๋์ด ์์ผ๋ฏ๋ก, ๋ชจ๋ ์์ค์์ ํ์ผ์ ์์ต๋๋ค.
๋ํ `class`, `package`, `global` ๋ฐ `none` ์์ค์์๋ ์์ ์ ์์ต๋๋ค.
์์ธํ ๋ด์ฉ์ ํด๋น [๋ฌธ์](https://github.com/jbasko/pytest-random-order)๋ฅผ ์ฐธ์กฐํ์ธ์.
๋ ๋ค๋ฅธ ๋ฌด์์ํ์ ๋์์ [`pytest-randomly`](https://github.com/pytest-dev/pytest-randomly)์
๋๋ค.
์ด ๋ชจ๋์ ๋งค์ฐ ์ ์ฌํ ๊ธฐ๋ฅ/์ธํฐํ์ด์ค๋ฅผ ๊ฐ์ง๊ณ ์์ง๋ง, `pytest-random-order`์ ์๋ ๋ฒํท ๋ชจ๋๋ฅผ ์ฌ์ฉํ ์๋ ์์ต๋๋ค.
์ค์น ํ์๋ ์๋์ผ๋ก ์ ์ฉ๋๋ ๋ฌธ์ ๋ ๋์ผํ๊ฒ ๊ฐ์ง๋๋ค.
### ์ธ๊ด๊ณผ ๋๋์ ๋ณ๊ฒฝ[[look-and-feel-variations]
#### pytest-sugar ์ฌ์ฉ[[pytest-sugar]]
[pytest-sugar](https://github.com/Frozenball/pytest-sugar)๋ ํ
์คํธ๊ฐ ๋ณด์ฌ์ง๋ ํํ๋ฅผ ๊ฐ์ ํ๊ณ ,
์งํ ์ํฉ ๋ฐ๋ฅผ ์ถ๊ฐํ๋ฉฐ, ์คํจํ ํ
์คํธ์ ๊ฒ์ฆ์ ์ฆ์ ํ์ํ๋ ํ๋ฌ๊ทธ์ธ์
๋๋ค. ์ค์นํ๋ฉด ์๋์ผ๋ก ํ์ฑํ๋ฉ๋๋ค.
```bash
pip install pytest-sugar
```
pytest-sugar ์์ด ํ
์คํธ๋ฅผ ์คํํ๋ ค๋ฉด ๋ค์๊ณผ ๊ฐ์ต๋๋ค:
```bash
pytest -p no:sugar
```
๋๋ ์ ๊ฑฐํ์ธ์.
#### ๊ฐ ํ์ ํ
์คํธ ์ด๋ฆ๊ณผ ์งํ ์ํฉ ๋ณด๊ณ [[report-each-sub-test-name-and-its-progress]]
`pytest`๋ฅผ ํตํด ๋จ์ผ ๋๋ ๊ทธ๋ฃน์ ํ
์คํธ๋ฅผ ์คํํ๋ ๊ฒฝ์ฐ(`pip install pytest-pspec` ์ดํ):
```bash
pytest --pspec tests/test_optimization.py
```
#### ์คํจํ ํ
์คํธ ์ฆ์ ํ์[[instantly-shows-failed-tests]]
[pytest-instafail](https://github.com/pytest-dev/pytest-instafail)์ ํ
์คํธ ์ธ์
์ ๋๊น์ง ๊ธฐ๋ค๋ฆฌ์ง ์๊ณ
์คํจ ๋ฐ ์ค๋ฅ๋ฅผ ์ฆ์ ํ์ํฉ๋๋ค.
```bash
pip install pytest-instafail
```
```bash
pytest --instafail
```
### GPU ์ฌ์ฉ ์ฌ๋ถ[[to-GPU-or-not-to-GPU]]
GPU๊ฐ ํ์ฑํ๋ ํ๊ฒฝ์์, CPU ์ ์ฉ ๋ชจ๋๋ก ํ
์คํธํ๋ ค๋ฉด `CUDA_VISIBLE_DEVICES=""`๋ฅผ ์ถ๊ฐํฉ๋๋ค:
```bash
CUDA_VISIBLE_DEVICES="" pytest tests/utils/test_logging.py
```
๋๋ ๋ค์ค GPU๊ฐ ์๋ ๊ฒฝ์ฐ `pytest`์์ ์ฌ์ฉํ GPU๋ฅผ ์ง์ ํ ์๋ ์์ต๋๋ค.
์๋ฅผ ๋ค์ด, GPU `0` ๋ฐ `1`์ด ์๋ ๊ฒฝ์ฐ ๋ค์์ ์คํํ ์ ์์ต๋๋ค:
```bash
CUDA_VISIBLE_DEVICES="1" pytest tests/utils/test_logging.py
```
์ด๋ ๊ฒ ํ๋ฉด ๋ค๋ฅธ GPU์์ ๋ค๋ฅธ ์์
์ ์คํํ๋ ค๋ ๊ฒฝ์ฐ ์ ์ฉํฉ๋๋ค.
์ผ๋ถ ํ
์คํธ๋ ๋ฐ๋์ CPU ์ ์ฉ์ผ๋ก ์คํํด์ผ ํ๋ฉฐ, ์ผ๋ถ๋ CPU ๋๋ GPU ๋๋ TPU์์ ์คํํด์ผ ํ๊ณ , ์ผ๋ถ๋ ์ฌ๋ฌ GPU์์ ์คํํด์ผ ํฉ๋๋ค.
๋ค์ ์คํต ๋ฐ์ฝ๋ ์ดํฐ๋ ํ
์คํธ์ ์๊ตฌ ์ฌํญ์ CPU/GPU/TPU๋ณ๋ก ์ค์ ํ๋ ๋ฐ ์ฌ์ฉ๋ฉ๋๋ค:
- `require_torch` - ์ด ํ
์คํธ๋ torch์์๋ง ์คํ๋ฉ๋๋ค.
- `require_torch_gpu` - `require_torch`์ ์ถ๊ฐ๋ก ์ ์ด๋ 1๊ฐ์ GPU๊ฐ ํ์ํฉ๋๋ค.
- `require_torch_multi_gpu` - `require_torch`์ ์ถ๊ฐ๋ก ์ ์ด๋ 2๊ฐ์ GPU๊ฐ ํ์ํฉ๋๋ค.
- `require_torch_non_multi_gpu` - `require_torch`์ ์ถ๊ฐ๋ก 0๊ฐ ๋๋ 1๊ฐ์ GPU๊ฐ ํ์ํฉ๋๋ค.
- `require_torch_up_to_2_gpus` - `require_torch`์ ์ถ๊ฐ๋ก 0๊ฐ, 1๊ฐ ๋๋ 2๊ฐ์ GPU๊ฐ ํ์ํฉ๋๋ค.
- `require_torch_xla` - `require_torch`์ ์ถ๊ฐ๋ก ์ ์ด๋ 1๊ฐ์ TPU๊ฐ ํ์ํฉ๋๋ค.
GPU ์๊ตฌ ์ฌํญ์ ํ๋ก ์ ๋ฆฌํ๋ฉด ์๋์ ๊ฐ์ต๋๋ใ
:
| n gpus | decorator |
|--------+--------------------------------|
| `>= 0` | `@require_torch` |
| `>= 1` | `@require_torch_gpu` |
| `>= 2` | `@require_torch_multi_gpu` |
| `< 2` | `@require_torch_non_multi_gpu` |
| `< 3` | `@require_torch_up_to_2_gpus` |
์๋ฅผ ๋ค์ด, 2๊ฐ ์ด์์ GPU๊ฐ ์๊ณ pytorch๊ฐ ์ค์น๋์ด ์์ ๋์๋ง ์คํ๋์ด์ผ ํ๋ ํ
์คํธ๋ ๋ค์๊ณผ ๊ฐ์ต๋๋ค:
```python no-style
@require_torch_multi_gpu
def test_example_with_multi_gpu():
```
`tensorflow`๊ฐ ํ์ํ ๊ฒฝ์ฐ `require_tf` ๋ฐ์ฝ๋ ์ดํฐ๋ฅผ ์ฌ์ฉํฉ๋๋ค. ์๋ฅผ ๋ค์ด ๋ค์๊ณผ ๊ฐ์ต๋๋ค:
```python no-style
@require_tf
def test_tf_thing_with_tensorflow():
```
์ด๋ฌํ ๋ฐ์ฝ๋ ์ดํฐ๋ ์ค์ฒฉ๋ ์ ์์ต๋๋ค.
์๋ฅผ ๋ค์ด, ๋๋ฆฐ ํ
์คํธ๋ก ์งํ๋๊ณ pytorch์์ ์ ์ด๋ ํ๋์ GPU๊ฐ ํ์ํ ๊ฒฝ์ฐ ๋ค์๊ณผ ๊ฐ์ด ์ค์ ํ ์ ์์ต๋๋ค:
```python no-style
@require_torch_gpu
@slow
def test_example_slow_on_gpu():
```
`@parametrized`์ ๊ฐ์ ์ผ๋ถ ๋ฐ์ฝ๋ ์ดํฐ๋ ํ
์คํธ ์ด๋ฆ์ ๋ค์ ์์ฑํ๊ธฐ ๋๋ฌธ์ `@require_*` ์คํต ๋ฐ์ฝ๋ ์ดํฐ๋ ์ฌ๋ฐ๋ฅด๊ฒ ์๋ํ๋ ค๋ฉด ํญ์ ๋งจ ๋ง์ง๋ง์ ๋์ด๋์ด์ผ ํฉ๋๋ค.
๋ค์์ ์ฌ๋ฐ๋ฅธ ์ฌ์ฉ ์์
๋๋ค:
```python no-style
@parameterized.expand(...)
@require_torch_multi_gpu
def test_integration_foo():
```
`@pytest.mark.parametrize`์๋ ์ด๋ฌํ ์์ ๋ฌธ์ ๋ ์์ผ๋ฏ๋ก ์ฒ์ ํน์ ๋ง์ง๋ง์ ์์น์ํฌ ์ ์๊ณ ์ด๋ฌํ ๊ฒฝ์ฐ์๋ ์ ์๋ํ ๊ฒ์
๋๋ค.
ํ์ง๋ง unittest๊ฐ ์๋ ๊ฒฝ์ฐ์๋ง ์๋ํฉ๋๋ค.
ํ
์คํธ ๋ด๋ถ์์ ๋ค์์ ์ฌ์ฉํ ์ ์์ต๋๋ค:
- ์ฌ์ฉ ๊ฐ๋ฅํ GPU ์:
```python
from transformers.testing_utils import get_gpu_count
n_gpu = get_gpu_count() #torch์ tf์ ํจ๊ป ์๋
```
### ๋ถ์ฐ ํ๋ จ[[distributed-training]]
`pytest`๋ ๋ถ์ฐ ํ๋ จ์ ์ง์ ์ ์ผ๋ก ๋ค๋ฃจ์ง ๋ชปํฉ๋๋ค.
์ด๋ฅผ ์๋ํ๋ฉด ํ์ ํ๋ก์ธ์ค๊ฐ ์ฌ๋ฐ๋ฅธ ์์
์ ์ํํ์ง ์๊ณ `pytest`๋ผ๊ณ ์๊ฐํ๊ธฐ์ ํ
์คํธ ์ค์ํธ๋ฅผ ๋ฐ๋ณตํด์ ์คํํ๊ฒ ๋ฉ๋๋ค.
๊ทธ๋ฌ๋ ์ผ๋ฐ ํ๋ก์ธ์ค๋ฅผ ์์ฑํ ๋ค์ ์ฌ๋ฌ ์์ปค๋ฅผ ์์ฑํ๊ณ IO ํ์ดํ๋ฅผ ๊ด๋ฆฌํ๋๋ก ํ๋ฉด ๋์ํฉ๋๋ค.
๋ค์์ ์ฌ์ฉ ๊ฐ๋ฅํ ํ
์คํธ์
๋๋ค:
- [test_trainer_distributed.py](https://github.com/huggingface/transformers/tree/main/tests/trainer/test_trainer_distributed.py)
- [test_deepspeed.py](https://github.com/huggingface/transformers/tree/main/tests/deepspeed/test_deepspeed.py)
์คํ ์ง์ ์ผ๋ก ๋ฐ๋ก ์ด๋ํ๋ ค๋ฉด, ํด๋น ํ
์คํธ์์ `execute_subprocess_async` ํธ์ถ์ ๊ฒ์ํ์ธ์.
์ด๋ฌํ ํ
์คํธ๋ฅผ ์คํํ๋ ค๋ฉด ์ ์ด๋ 2๊ฐ์ GPU๊ฐ ํ์ํฉ๋๋ค.
```bash
CUDA_VISIBLE_DEVICES=0,1 RUN_SLOW=1 pytest -sv tests/test_trainer_distributed.py
```
### ์ถ๋ ฅ ์บก์ฒ[[output-capture]]
ํ
์คํธ ์คํ ์ค `stdout` ๋ฐ `stderr`๋ก ์ ์ก๋ ๋ชจ๋ ์ถ๋ ฅ์ด ์บก์ฒ๋ฉ๋๋ค.
ํ
์คํธ๋ ์ค์ ๋ฉ์๋๊ฐ ์คํจํ๋ฉด ์บก์ฒ๋ ์ถ๋ ฅ์ ์ผ๋ฐ์ ์ผ๋ก ์คํจ ์ถ์ ์ ๋ณด์ ํจ๊ป ํ์๋ฉ๋๋ค.
์ถ๋ ฅ ์บก์ฒ๋ฅผ ๋นํ์ฑํํ๊ณ `stdout` ๋ฐ `stderr`๋ฅผ ์ ์์ ์ผ๋ก ๋ฐ์ผ๋ ค๋ฉด `-s` ๋๋ `--capture=no`๋ฅผ ์ฌ์ฉํ์ธ์:
```bash
pytest -s tests/utils/test_logging.py
```
ํ
์คํธ ๊ฒฐ๊ณผ๋ฅผ JUnit ํ์์ ์ถ๋ ฅ์ผ๋ก ๋ณด๋ด๋ ค๋ฉด ๋ค์์ ์ฌ์ฉํ์ธ์:
```bash
py.test tests --junitxml=result.xml
```
### ์์ ์กฐ์ [[color-control]]
์์์ด ์๊ฒ ํ๋ ค๋ฉด ๋ค์๊ณผ ๊ฐ์ด ์ค์ ํ์ธ์(์๋ฅผ ๋ค์ด ํฐ์ ๋ฐฐ๊ฒฝ์ ๋
ธ๋์ ๊ธ์จ๋ ๊ฐ๋
์ฑ์ด ์ข์ง ์์ต๋๋ค):
```bash
pytest --color=no tests/utils/test_logging.py
```
### online pastebin service์ ํ
์คํธ ๋ณด๊ณ ์ ์ ์ก[[sending test report to online pastebin service]]
๊ฐ ํ
์คํธ ์คํจ์ ๋ํ URL์ ๋ง๋ญ๋๋ค:
```bash
pytest --pastebin=failed tests/utils/test_logging.py
```
์ด๋ ๊ฒ ํ๋ฉด ๊ฐ ์คํจ์ ๋ํ URL์ ์ ๊ณตํ๋ remote Paste service์ ํ
์คํธ ์คํ ์ ๋ณด๋ฅผ ์ ์ถํฉ๋๋ค.
์ผ๋ฐ์ ์ธ ํ
์คํธ๋ฅผ ์ ํํ ์๋ ์๊ณ ํน์ ํน์ ์คํจ๋ง ๋ณด๋ด๋ ค๋ฉด `-x`์ ๊ฐ์ด ์ถ๊ฐํ ์๋ ์์ต๋๋ค.
์ ์ฒด ํ
์คํธ ์ธ์
๋ก๊ทธ์ ๋ํ URL์ ์์ฑํฉ๋๋ค:
```bash
pytest --pastebin=all tests/utils/test_logging.py
```
## ํ
์คํธ ์์ฑ[[writing-tests]]
๐ค transformers ํ
์คํธ๋ ๋๋ถ๋ถ `unittest`๋ฅผ ๊ธฐ๋ฐ์ผ๋ก ํ์ง๋ง,
`pytest`์์ ์คํ๋๋ฏ๋ก ๋๋ถ๋ถ์ ๊ฒฝ์ฐ ๋ ์์คํ
์ ๊ธฐ๋ฅ์ ์ฌ์ฉํ ์ ์์ต๋๋ค.
์ง์๋๋ ๊ธฐ๋ฅ์ ๋ํด [์ฌ๊ธฐ](https://docs.pytest.org/en/stable/unittest.html)์์ ํ์ธํ ์ ์์ง๋ง,
๊ธฐ์ตํด์ผ ํ ์ค์ํ ์ ์ ๋๋ถ๋ถ์ `pytest` fixture๊ฐ ์๋ํ์ง ์๋๋ค๋ ๊ฒ์
๋๋ค.
ํ๋ผ๋ฏธํฐํ๋ ์๋ํ์ง ์์ง๋ง, ์ฐ๋ฆฌ๋ ๋น์ทํ ๋ฐฉ์์ผ๋ก ์๋ํ๋ `parameterized` ๋ชจ๋์ ์ฌ์ฉํฉ๋๋ค.
### ๋งค๊ฐ๋ณ์ํ[[parametrization]]
๋์ผํ ํ
์คํธ๋ฅผ ๋ค๋ฅธ ์ธ์๋ก ์ฌ๋ฌ ๋ฒ ์คํํด์ผ ํ๋ ๊ฒฝ์ฐ๊ฐ ์ข
์ข
์์ต๋๋ค.
ํ
์คํธ ๋ด์์ ์ด ์์
์ ์ํํ ์ ์์ง๋ง, ๊ทธ๋ ๊ฒ ํ๋ฉด ํ๋์ ์ธ์ ์ธํธ์ ๋ํด ํ
์คํธ๋ฅผ ์คํํ ์ ์์ต๋๋ค.
```python
# test_this1.py
import unittest
from parameterized import parameterized
class TestMathUnitTest(unittest.TestCase):
@parameterized.expand(
[
("negative", -1.5, -2.0),
("integer", 1, 1.0),
("large fraction", 1.6, 1),
]
)
def test_floor(self, name, input, expected):
assert_equal(math.floor(input), expected)
```
์ด์ ๊ธฐ๋ณธ์ ์ผ๋ก ์ด ํ
์คํธ๋ `test_floor`์ ๋ง์ง๋ง 3๊ฐ ์ธ์๊ฐ
๋งค๊ฐ๋ณ์ ๋ชฉ๋ก์ ํด๋น ์ธ์์ ํ ๋น๋๋ ๊ฒ์ผ๋ก 3๋ฒ ์คํ๋ ๊ฒ์
๋๋ค.
๊ทธ๋ฆฌ๊ณ `negative` ๋ฐ `integer` ๋งค๊ฐ๋ณ์ ์งํฉ๋ง ์คํํ๋ ค๋ฉด ๋ค์๊ณผ ๊ฐ์ด ์คํํ ์ ์์ต๋๋ค:
```bash
pytest -k "negative and integer" tests/test_mytest.py
```
๋๋ `negative` ํ์ ํ
์คํธ๋ฅผ ์ ์ธํ ๋ชจ๋ ์๋ธ ํ
์คํธ๋ฅผ ๋ค์๊ณผ ๊ฐ์ด ์คํํ ์ ์์ต๋๋ค:
```bash
pytest -k "not negative" tests/test_mytest.py
```
์์์ ์ธ๊ธํ `-k` ํํฐ๋ฅผ ์ฌ์ฉํ๋ ๊ฒ ์ธ์๋,
๊ฐ ์๋ธ ํ
์คํธ์ ์ ํํ ์ด๋ฆ์ ํ์ธํ ํ์ ์ผ๋ถ ํน์ ์ ์ฒด ์๋ธ ํ
์คํธ๋ฅผ ์คํํ ์ ์์ต๋๋ค.
```bash
pytest test_this1.py --collect-only -q
```
๊ทธ๋ฆฌ๊ณ ๋ค์์ ๋ด์ฉ์ ํ์ธํ ์ ์์ ๊ฒ์
๋๋ค:
```bash
test_this1.py::TestMathUnitTest::test_floor_0_negative
test_this1.py::TestMathUnitTest::test_floor_1_integer
test_this1.py::TestMathUnitTest::test_floor_2_large_fraction
```
2๊ฐ์ ํน์ ํ ์๋ธ ํ
์คํธ๋ง ์คํํ ์๋ ์์ต๋๋ค:
```bash
pytest test_this1.py::TestMathUnitTest::test_floor_0_negative test_this1.py::TestMathUnitTest::test_floor_1_integer
```
`transformers`์ ๊ฐ๋ฐ์ ์ข
์์ฑ์ ์ด๋ฏธ ์๋ [parameterized](https://pypi.org/project/parameterized/) ๋ชจ๋์
`unittests`์ `pytest` ํ
์คํธ ๋ชจ๋์์ ์๋ํฉ๋๋ค.
๊ทธ๋ฌ๋ ํ
์คํธ๊ฐ `unittest`๊ฐ ์๋ ๊ฒฝ์ฐ `pytest.mark.parametrize`๋ฅผ ์ฌ์ฉํ ์ ์์ต๋๋ค(์ด๋ฏธ ์๋ ์ผ๋ถ ํ
์คํธ์์ ์ฌ์ฉ๋๋ ๊ฒฝ์ฐ๋ ์์ต๋๋ค.
์ฃผ๋ก `examples` ํ์์ ์์ต๋๋ค).
๋ค์์ `pytest`์ `parametrize` ๋ง์ปค๋ฅผ ์ฌ์ฉํ ๋์ผํ ์์
๋๋ค:
```python
# test_this2.py
import pytest
@pytest.mark.parametrize(
"name, input, expected",
[
("negative", -1.5, -2.0),
("integer", 1, 1.0),
("large fraction", 1.6, 1),
],
)
def test_floor(name, input, expected):
assert_equal(math.floor(input), expected)
```
`parameterized`์ ๋ง์ฐฌ๊ฐ์ง๋ก `pytest.mark.parametrize`๋ฅผ ์ฌ์ฉํ๋ฉด
`-k` ํํฐ๊ฐ ์๋ํ์ง ์๋ ๊ฒฝ์ฐ์๋ ์คํํ ์๋ธ ํ
์คํธ๋ฅผ ์ ํํ๊ฒ ์ง์ ํ ์ ์์ต๋๋ค.
๋จ, ์ด ๋งค๊ฐ๋ณ์ํ ํจ์๋ ์๋ธ ํ
์คํธ์ ์ด๋ฆ ์งํฉ์ ์ฝ๊ฐ ๋ค๋ฅด๊ฒ ์์ฑํฉ๋๋ค. ๋ค์๊ณผ ๊ฐ์ ๋ชจ์ต์
๋๋ค:
```bash
pytest test_this2.py --collect-only -q
```
๊ทธ๋ฆฌ๊ณ ๋ค์์ ๋ด์ฉ์ ํ์ธํ ์ ์์ ๊ฒ์
๋๋ค:
```bash
test_this2.py::test_floor[integer-1-1.0]
test_this2.py::test_floor[negative--1.5--2.0]
test_this2.py::test_floor[large fraction-1.6-1]
```
ํน์ ํ ํ
์คํธ์ ๋ํด์๋ง ์คํํ ์๋ ์์ต๋๋ค:
```bash
pytest test_this2.py::test_floor[negative--1.5--2.0] test_this2.py::test_floor[integer-1-1.0]
```
์ด์ ์ ์์์ ๊ฐ์ด ์คํํ ์ ์์ต๋๋ค.
### ํ์ผ ๋ฐ ๋๋ ํฐ๋ฆฌ[[files-and-directories]]
ํ
์คํธ์์ ์ข
์ข
ํ์ฌ ํ
์คํธ ํ์ผ๊ณผ ๊ด๋ จ๋ ์๋์ ์ธ ์์น๋ฅผ ์์์ผ ํ๋ ๊ฒฝ์ฐ๊ฐ ์์ต๋๋ค.
ํ
์คํธ๊ฐ ์ฌ๋ฌ ๋๋ ํฐ๋ฆฌ์์ ํธ์ถ๋๊ฑฐ๋ ๊น์ด๊ฐ ๋ค๋ฅธ ํ์ ๋๋ ํฐ๋ฆฌ์ ์์ ์ ์๊ธฐ ๋๋ฌธ์ ๊ทธ ์์น๋ฅผ ์๋ ๊ฒ์ ๊ฐ๋จํ์ง ์์ต๋๋ค.
`transformers.test_utils.TestCasePlus`๋ผ๋ ํฌํผ ํด๋์ค๋ ๋ชจ๋ ๊ธฐ๋ณธ ๊ฒฝ๋ก๋ฅผ ์ฒ๋ฆฌํ๊ณ ๊ฐ๋จํ ์ก์ธ์๋ฅผ ์ ๊ณตํ์ฌ ์ด ๋ฌธ์ ๋ฅผ ํด๊ฒฐํฉ๋๋ค:
- `pathlib` ๊ฐ์ฒด(์์ ํ ์ ํด์ง ๊ฒฝ๋ก)
- `test_file_path` - ํ์ฌ ํ
์คํธ ํ์ผ ๊ฒฝ๋ก (์: `__file__`)
- test_file_dir` - ํ์ฌ ํ
์คํธ ํ์ผ์ด ํฌํจ๋ ๋๋ ํฐ๋ฆฌ
- tests_dir` - `tests` ํ
์คํธ ์ค์ํธ์ ๋๋ ํฐ๋ฆฌ
- examples_dir` - `examples` ํ
์คํธ ์ค์ํธ์ ๋๋ ํฐ๋ฆฌ
- repo_root_dir` - ์ ์ฅ์ ๋๋ ํฐ๋ฆฌ
- src_dir` - `src`์ ๋๋ ํฐ๋ฆฌ(์: `transformers` ํ์ ๋๋ ํฐ๋ฆฌ๊ฐ ์๋ ๊ณณ)
- ๋ฌธ์์ด๋ก ๋ณํ๋ ๊ฒฝ๋ก---์์ ๋์ผํ์ง๋ง, `pathlib` ๊ฐ์ฒด๊ฐ ์๋ ๋ฌธ์์ด๋ก ๊ฒฝ๋ก๋ฅผ ๋ฐํํฉ๋๋ค:
- `test_file_path_str`
- `test_file_dir_str`
- `tests_dir_str`
- `examples_dir_str`
- `repo_root_dir_str`
- `src_dir_str`
์์ ๋ด์ฉ์ ์ฌ์ฉํ๋ ค๋ฉด ํ
์คํธ๊ฐ 'transformers.test_utils.TestCasePlus'์ ์๋ธํด๋์ค์ ์๋์ง ํ์ธํด์ผ ํฉ๋๋ค.
์๋ฅผ ๋ค์ด ๋ค์๊ณผ ๊ฐ์ต๋๋ค:
```python
from transformers.testing_utils import TestCasePlus
class PathExampleTest(TestCasePlus):
def test_something_involving_local_locations(self):
data_dir = self.tests_dir / "fixtures/tests_samples/wmt_en_ro"
```
๋ง์ฝ `pathlib`๋ฅผ ํตํด ๊ฒฝ๋ก๋ฅผ ์กฐ์ํ ํ์๊ฐ ์๊ฑฐ๋ ๊ฒฝ๋ก๋ฅผ ๋ฌธ์์ด๋ก๋ง ํ์๋ก ํ๋ ๊ฒฝ์ฐ์๋ `pathlib` ๊ฐ์ฒด์ `str()`์ ํธ์ถํ๊ฑฐ๋ `_str`๋ก ๋๋๋ ์ ๊ทผ์๋ฅผ ์ฌ์ฉํ ์ ์์ต๋๋ค.
์๋ฅผ ๋ค์ด ๋ค์๊ณผ ๊ฐ์ต๋๋ค:
```python
from transformers.testing_utils import TestCasePlus
class PathExampleTest(TestCasePlus):
def test_something_involving_stringified_locations(self):
examples_dir = self.examples_dir_str
```
### ์์ ํ์ผ ๋ฐ ๋๋ ํฐ๋ฆฌ[[temporary-files-and-directories]]
๊ณ ์ ํ ์์ ํ์ผ ๋ฐ ๋๋ ํฐ๋ฆฌ๋ฅผ ์ฌ์ฉํ๋ ๊ฒ์ ๋ณ๋ ฌ ํ
์คํธ ์คํ์ ์์ด ํ์์ ์
๋๋ค.
์ด๋ ๊ฒ ํจ์ผ๋ก์จ ํ
์คํธ๋ค์ด ์๋ก์ ๋ฐ์ดํฐ๋ฅผ ๋ฎ์ด์ฐ์ง ์๊ฒ ํ ์ ์์ต๋๋ค. ๋ํ ์ฐ๋ฆฌ๋ ์์ฑ๋ ํ
์คํธ์ ์ข
๋ฃ ๋จ๊ณ์์ ์ด๋ฌํ ์์ ํ์ผ ๋ฐ ๋๋ ํฐ๋ฆฌ๋ฅผ ์ ๊ฑฐํ๊ณ ์ถ์ต๋๋ค.
๋ฐ๋ผ์ ์ด๋ฌํ ์๊ตฌ ์ฌํญ์ ์ถฉ์กฑ์์ผ์ฃผ๋ `tempfile`๊ณผ ๊ฐ์ ํจํค์ง๋ฅผ ์ฌ์ฉํ๋ ๊ฒ์ด ์ค์ํฉ๋๋ค.
๊ทธ๋ฌ๋ ํ
์คํธ๋ฅผ ๋๋ฒ๊น
ํ ๋๋ ์์ ํ์ผ์ด๋ ๋๋ ํฐ๋ฆฌ์ ๋ค์ด๊ฐ๋ ๋ด์ฉ์ ํ์ธํ ์ ์์ด์ผ ํ๋ฉฐ,
์ฌ์คํ๋๋ ๊ฐ ํ
์คํธ๋ง๋ค ์์ ํ์ผ์ด๋ ๋๋ ํฐ๋ฆฌ์ ๊ฒฝ๋ก์ ๋ํด ๋ฌด์์ ๊ฐ์ด ์๋ ์ ํํ ๊ฐ์ ์๊ณ ์ถ์ ๊ฒ์
๋๋ค.
`transformers.test_utils.TestCasePlus`๋ผ๋ ๋์ฐ๋ฏธ ํด๋์ค๋ ์ด๋ฌํ ๋ชฉ์ ์ ๊ฐ์ฅ ์ ํฉํฉ๋๋ค.
์ด ํด๋์ค๋ `unittest.TestCase`์ ํ์ ํด๋์ค์ด๋ฏ๋ก, ์ฐ๋ฆฌ๋ ์ด๊ฒ์ ํ
์คํธ ๋ชจ๋์์ ์ฝ๊ฒ ์์ํ ์ ์์ต๋๋ค.
๋ค์์ ํด๋น ํด๋์ค๋ฅผ ์ฌ์ฉํ๋ ์์์
๋๋ค:
```python
from transformers.testing_utils import TestCasePlus
class ExamplesTests(TestCasePlus):
def test_whatever(self):
tmp_dir = self.get_auto_remove_tmp_dir()
```
์ด ์ฝ๋๋ ๊ณ ์ ํ ์์ ๋๋ ํฐ๋ฆฌ๋ฅผ ์์ฑํ๊ณ `tmp_dir`์ ํด๋น ์์น๋ก ์ค์ ํฉ๋๋ค.
- ๊ณ ์ ํ ์์ ๋๋ ํฐ๋ฆฌ๋ฅผ ์์ฑํฉ๋๋ค:
```python
def test_whatever(self):
tmp_dir = self.get_auto_remove_tmp_dir()
```
`tmp_dir`์๋ ์์ฑ๋ ์์ ๋๋ ํฐ๋ฆฌ์ ๊ฒฝ๋ก๊ฐ ํฌํจ๋ฉ๋๋ค.
์ด๋ ํ
์คํธ์ ์ข
๋ฃ ๋จ๊ณ์์ ์๋์ผ๋ก ์ ๊ฑฐ๋ฉ๋๋ค.
- ์ ํํ ๊ฒฝ๋ก๋ก ์์ ๋๋ ํฐ๋ฆฌ ์์ฑ ํ์ ํ
์คํธ ์์ ์ ์ ๋น์ด ์๋ ์ํ์ธ์ง ํ์ธํ๊ณ , ํ
์คํธ ํ์๋ ๋น์ฐ์ง ๋ง์ธ์.
```python
def test_whatever(self):
tmp_dir = self.get_auto_remove_tmp_dir("./xxx")
```
์ด๊ฒ์ ๋๋ฒ๊น
ํ ๋ ํน์ ๋๋ ํฐ๋ฆฌ๋ฅผ ๋ชจ๋ํฐ๋งํ๊ณ ,
๊ทธ ๋๋ ํฐ๋ฆฌ์ ์ด์ ์ ์คํ๋ ํ
์คํธ๊ฐ ๋ฐ์ดํฐ๋ฅผ ๋จ๊ธฐ์ง ์๋๋ก ํ๋ ๋ฐ์ ์ ์ฉํฉ๋๋ค.
- `before` ๋ฐ `after` ์ธ์๋ฅผ ์ง์ ์ค๋ฒ๋ผ์ด๋ฉํ์ฌ ๊ธฐ๋ณธ ๋์์ ๋ณ๊ฒฝํ ์ ์์ผ๋ฉฐ
๋ค์ ์ค ํ๋์ ๋์์ผ๋ก ์ด์ด์ง๋๋ค:
- `before=True`: ํ
์คํธ ์์ ์ ์์ ๋๋ ํฐ๋ฆฌ๊ฐ ํญ์ ์ง์์ง๋๋ค.
- `before=False`: ์์ ๋๋ ํฐ๋ฆฌ๊ฐ ์ด๋ฏธ ์กด์ฌํ๋ ๊ฒฝ์ฐ ๊ธฐ์กด ํ์ผ์ ๊ทธ๋๋ก ๋จ์ต๋๋ค.
- `after=True`: ํ
์คํธ ์ข
๋ฃ ์ ์์ ๋๋ ํฐ๋ฆฌ๊ฐ ํญ์ ์ญ์ ๋ฉ๋๋ค.
- `after=False`: ํ
์คํธ ์ข
๋ฃ ์ ์์ ๋๋ ํฐ๋ฆฌ๊ฐ ํญ์ ๊ทธ๋๋ก ์ ์ง๋ฉ๋๋ค.
<Tip>
`rm -r`์ ํด๋นํ๋ ๋ช
๋ น์ ์์ ํ๊ฒ ์คํํ๊ธฐ ์ํด,
๋ช
์์ ์ธ `tmp_dir`์ ์ฌ์ฉํ๋ ๊ฒฝ์ฐ ํ๋ก์ ํธ ์ ์ฅ์ ์ฒดํฌ ์์์ ํ์ ๋๋ ํฐ๋ฆฌ๋ง ํ์ฉ๋ฉ๋๋ค.
๋ฐ๋ผ์ ์ค์๋ก `/tmp`๊ฐ ์๋ ์ค์ํ ํ์ผ ์์คํ
์ ์ผ๋ถ๊ฐ ์ญ์ ๋์ง ์๋๋ก ํญ์ `./`๋ก ์์ํ๋ ๊ฒฝ๋ก๋ฅผ ์ ๋ฌํด์ผ ํฉ๋๋ค.
</Tip>
<Tip>
๊ฐ ํ
์คํธ๋ ์ฌ๋ฌ ๊ฐ์ ์์ ๋๋ ํฐ๋ฆฌ๋ฅผ ๋ฑ๋กํ ์ ์์ผ๋ฉฐ,
๋ณ๋๋ก ์์ฒญํ์ง ์๋ ํ ๋ชจ๋ ์๋์ผ๋ก ์ ๊ฑฐ๋ฉ๋๋ค.
</Tip>
### ์์ sys.path ์ค๋ฒ๋ผ์ด๋[[temporary-sys.path-override]]
`sys.path`๋ฅผ ๋ค๋ฅธ ํ
์คํธ๋ก ์์๋ก ์ค๋ฒ๋ผ์ด๋ํ๊ธฐ ์ํด ์๋ฅผ ๋ค์ด `ExtendSysPath` ์ปจํ
์คํธ ๊ด๋ฆฌ์๋ฅผ ์ฌ์ฉํ ์ ์์ต๋๋ค.
์๋ฅผ ๋ค์ด ๋ค์๊ณผ ๊ฐ์ต๋๋ค:
```python
import os
from transformers.testing_utils import ExtendSysPath
bindir = os.path.abspath(os.path.dirname(__file__))
with ExtendSysPath(f"{bindir}/.."):
from test_trainer import TrainerIntegrationCommon # noqa
```
### ํ
์คํธ ๊ฑด๋๋ฐ๊ธฐ[[skipping-tests]]
์ด๊ฒ์ ๋ฒ๊ทธ๊ฐ ๋ฐ๊ฒฌ๋์ด ์๋ก์ด ํ
์คํธ๊ฐ ์์ฑ๋์์ง๋ง ์์ง ๊ทธ ๋ฒ๊ทธ๊ฐ ์์ ๋์ง ์์ ๊ฒฝ์ฐ์ ์ ์ฉํฉ๋๋ค.
์ด ํ
์คํธ๋ฅผ ์ฃผ ์ ์ฅ์์ ์ปค๋ฐํ๋ ค๋ฉด `make test` ์ค์ ๊ฑด๋๋ฐ๋๋ก ํด์ผ ํฉ๋๋ค.
๋ฐฉ๋ฒ:
- **skip**์ ํ
์คํธ๊ฐ ์ผ๋ถ ์กฐ๊ฑด์ด ์ถฉ์กฑ๋ ๊ฒฝ์ฐ์๋ง ํต๊ณผ๋ ๊ฒ์ผ๋ก ์์๋๊ณ , ๊ทธ๋ ์ง ์์ผ๋ฉด pytest๊ฐ ์ ์ฒด ํ
์คํธ๋ฅผ ๊ฑด๋๋ฐ์ด์ผ ํจ์ ์๋ฏธํฉ๋๋ค.
์ผ๋ฐ์ ์ธ ์๋ก๋ Windows๊ฐ ์๋ ํ๋ซํผ์์ Windows ์ ์ฉ ํ
์คํธ๋ฅผ ๊ฑด๋๋ฐ๊ฑฐ๋
์ธ๋ถ ๋ฆฌ์์ค(์๋ฅผ ๋ค์ด ๋ฐ์ดํฐ๋ฒ ์ด์ค)์ ์์กดํ๋ ํ
์คํธ๋ฅผ ๊ฑด๋๋ฐ๋ ๊ฒ์ด ์์ต๋๋ค.
- **xfail**์ ํ
์คํธ๊ฐ ํน์ ํ ์ด์ ๋ก ์ธํด ์คํจํ ๊ฒ์ผ๋ก ์์ํ๋ ๊ฒ์ ์๋ฏธํฉ๋๋ค.
์ผ๋ฐ์ ์ธ ์๋ก๋ ์์ง ๊ตฌํ๋์ง ์์ ๊ธฐ๋ฅ์ด๋ ์์ง ์์ ๋์ง ์์ ๋ฒ๊ทธ์ ํ
์คํธ๊ฐ ์์ต๋๋ค.
`xfail`๋ก ํ์๋ ํ
์คํธ๊ฐ ์์๋๋ก ์คํจํ์ง ์๊ณ ํต๊ณผ๋ ๊ฒฝ์ฐ, ์ด๊ฒ์ xpass์ด๋ฉฐ ํ
์คํธ ๊ฒฐ๊ณผ ์์ฝ์ ๊ธฐ๋ก๋ฉ๋๋ค.
๋ ๊ฐ์ง ์ค์ํ ์ฐจ์ด์ ์ค ํ๋๋ `skip`์ ํ
์คํธ๋ฅผ ์คํํ์ง ์์ง๋ง `xfail`์ ์คํํ๋ค๋ ๊ฒ์
๋๋ค.
๋ฐ๋ผ์ ์ค๋ฅ๊ฐ ์๋ ์ฝ๋๊ฐ ์ผ๋ถ ํ
์คํธ์ ์ํฅ์ ๋ฏธ์น ์ ์๋ ๊ฒฝ์ฐ `xfail`์ ์ฌ์ฉํ์ง ๋ง์ธ์.
#### ๊ตฌํ[[implementation]]
- ์ ์ฒด ํ
์คํธ๋ฅผ ๋ฌด์กฐ๊ฑด ๊ฑด๋๋ฐ๋ ค๋ฉด ๋ค์๊ณผ ๊ฐ์ด ํ ์ ์์ต๋๋ค:
```python no-style
@unittest.skip("this bug needs to be fixed")
def test_feature_x():
```
๋๋ pytest๋ฅผ ํตํด:
```python no-style
@pytest.mark.skip(reason="this bug needs to be fixed")
```
๋๋ `xfail` ๋ฐฉ์์ผ๋ก:
```python no-style
@pytest.mark.xfail
def test_feature_x():
```
- ํ
์คํธ ๋ด๋ถ์์ ๋ด๋ถ ํ์ธ์ ๋ฐ๋ผ ํ
์คํธ๋ฅผ ๊ฑด๋๋ฐ๋ ๋ฐฉ๋ฒ์ ๋ค์๊ณผ ๊ฐ์ต๋๋ค:
```python
def test_feature_x():
if not has_something():
pytest.skip("unsupported configuration")
```
๋๋ ๋ชจ๋ ์ ์ฒด:
```python
import pytest
if not pytest.config.getoption("--custom-flag"):
pytest.skip("--custom-flag is missing, skipping tests", allow_module_level=True)
```
๋๋ `xfail` ๋ฐฉ์์ผ๋ก:
```python
def test_feature_x():
pytest.xfail("expected to fail until bug XYZ is fixed")
```
- import๊ฐ missing๋ ๋ชจ๋์ด ์์ ๋ ๊ทธ ๋ชจ๋์ ๋ชจ๋ ํ
์คํธ๋ฅผ ๊ฑด๋๋ฐ๋ ๋ฐฉ๋ฒ:
```python
docutils = pytest.importorskip("docutils", minversion="0.3")
```
- ์กฐ๊ฑด์ ๋ฐ๋ผ ํ
์คํธ๋ฅผ ๊ฑด๋๋ฐ๋ ๋ฐฉ๋ฒ:
```python no-style
@pytest.mark.skipif(sys.version_info < (3,6), reason="requires python3.6 or higher")
def test_feature_x():
```
๋๋:
```python no-style
@unittest.skipIf(torch_device == "cpu", "Can't do half precision")
def test_feature_x():
```
๋๋ ๋ชจ๋ ์ ์ฒด๋ฅผ ๊ฑด๋๋ฐ๋ ๋ฐฉ๋ฒ:
```python no-style
@pytest.mark.skipif(sys.platform == 'win32', reason="does not run on windows")
class TestClass():
def test_feature_x(self):
```
๋ณด๋ค ์์ธํ ์์ ๋ฐ ๋ฐฉ๋ฒ์ [์ฌ๊ธฐ](https://docs.pytest.org/en/latest/skipping.html)์์ ํ์ธํ ์ ์์ต๋๋ค.
### ๋๋ฆฐ ํ
์คํธ[[slow-tests]]
ํ
์คํธ ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ ์ง์์ ์ผ๋ก ํ์ฅ๋๊ณ ์์ผ๋ฉฐ, ์ผ๋ถ ํ
์คํธ๋ ์คํํ๋ ๋ฐ ๋ช ๋ถ์ด ๊ฑธ๋ฆฝ๋๋ค.
๊ทธ๋ฆฌ๊ณ ์ฐ๋ฆฌ์๊ฒ๋ ํ
์คํธ ์ค์ํธ๊ฐ CI๋ฅผ ํตํด ์๋ฃ๋๊ธฐ๊น์ง ํ ์๊ฐ์ ๊ธฐ๋ค๋ฆด ์ฌ์ ๊ฐ ์์ต๋๋ค.
๋ฐ๋ผ์ ํ์ ํ
์คํธ๋ฅผ ์ํ ์ผ๋ถ ์์ธ๋ฅผ ์ ์ธํ๊ณ ๋๋ฆฐ ํ
์คํธ๋ ๋ค์๊ณผ ๊ฐ์ด ํ์ํด์ผ ํฉ๋๋ค.
```python no-style
from transformers.testing_utils import slow
@slow
def test_integration_foo():
```
`@slow`๋ก ํ์๋ ํ
์คํธ๋ฅผ ์คํํ๋ ค๋ฉด `RUN_SLOW=1` ํ๊ฒฝ ๋ณ์๋ฅผ ์ค์ ํ์ธ์. ์๋ฅผ ๋ค์ด ๋ค์๊ณผ ๊ฐ์ต๋๋ค:
```bash
RUN_SLOW=1 pytest tests
```
`@parameterized`์ ๊ฐ์ ๋ช ๊ฐ์ง ๋ฐ์ฝ๋ ์ดํฐ๋ ํ
์คํธ ์ด๋ฆ์ ๋ค์ ์์ฑํฉ๋๋ค.
๊ทธ๋ฌ๋ฏ๋ก `@slow`์ ๋๋จธ์ง ๊ฑด๋๋ฐ๊ธฐ ๋ฐ์ฝ๋ ์ดํฐ `@require_*`๊ฐ ์ฌ๋ฐ๋ฅด๊ฒ ์๋๋๋ ค๋ฉด ๋ง์ง๋ง์ ๋์ด๋์ด์ผ ํฉ๋๋ค. ๋ค์์ ์ฌ๋ฐ๋ฅธ ์ฌ์ฉ ์์
๋๋ค.
```python no-style
@parameterized.expand(...)
@slow
def test_integration_foo():
```
์ด ๋ฌธ์์ ์ด๋ฐ๋ถ์ ์ค๋ช
๋ ๊ฒ์ฒ๋ผ ๋๋ฆฐ ํ
์คํธ๋ PR์ CI ํ์ธ์ด ์๋ ์์ฝ๋ ์ผ์ ๊ธฐ๋ฐ์ผ๋ก ์คํ๋ฉ๋๋ค.
๋ฐ๋ผ์ PR ์ ์ถ ์ค์ ์ผ๋ถ ๋ฌธ์ ๋ฅผ ๋์น ์ฑ๋ก ๋ณํฉ๋ ์ ์์ต๋๋ค.
์ด๋ฌํ ๋ฌธ์ ๋ค์ ๋ค์๋ฒ์ ์์ ๋ CI ์์
์ค์ ๊ฐ์ง๋ฉ๋๋ค.
ํ์ง๋ง PR์ ์ ์ถํ๊ธฐ ์ ์ ์์ ์ ์ปดํจํฐ์์ ๋๋ฆฐ ํ
์คํธ๋ฅผ ์คํํ๋ ๊ฒ ๋ํ ์ค์ํฉ๋๋ค.
๋๋ฆฐ ํ
์คํธ๋ก ํ์ํด์ผ ํ๋์ง ์ฌ๋ถ๋ฅผ ๊ฒฐ์ ํ๋ ๋๋ต์ ์ธ ๊ฒฐ์ ๊ธฐ์ค์ ๋ค์๊ณผ ๊ฐ์ต๋๋ค.
๋ง์ฝ ํ
์คํธ๊ฐ ๋ผ์ด๋ธ๋ฌ๋ฆฌ์ ๋ด๋ถ ๊ตฌ์ฑ ์์ ์ค ํ๋์ ์ง์ค๋์ด ์๋ค๋ฉด(์: ๋ชจ๋ธ๋ง ํ์ผ, ํ ํฐํ ํ์ผ, ํ์ดํ๋ผ์ธ),
ํด๋น ํ
์คํธ๋ฅผ ๋๋ฆฐ ํ
์คํธ ์ค์ํธ์์ ์คํํด์ผ ํฉ๋๋ค.
๋ง์ฝ ๋ผ์ด๋ธ๋ฌ๋ฆฌ์ ๋ค๋ฅธ ์ธก๋ฉด(์: ๋ฌธ์ ๋๋ ์์ )์ ์ง์ค๋์ด ์๋ค๋ฉด,
ํด๋น ํ
์คํธ๋ฅผ ๋๋ฆฐ ํ
์คํธ ์ค์ํธ์์ ์คํํด์ผ ํฉ๋๋ค. ๊ทธ๋ฆฌ๊ณ ์ด ์ ๊ทผ ๋ฐฉ์์ ๋ณด์ํ๊ธฐ ์ํด ์์ธ๋ฅผ ๋ง๋ค์ด์ผ ํฉ๋๋ค.
- ๋ฌด๊ฑฐ์ด ๊ฐ์ค์น ์ธํธ๋ 50MB๋ณด๋ค ํฐ ๋ฐ์ดํฐ์
์ ๋ค์ด๋ก๋ํด์ผ ํ๋ ๋ชจ๋ ํ
์คํธ(์: ๋ชจ๋ธ ํตํฉ ํ
์คํธ, ํ ํฌ๋์ด์ ํตํฉ ํ
์คํธ, ํ์ดํ๋ผ์ธ ํตํฉ ํ
์คํธ)๋ฅผ
๋๋ฆฐ ํ
์คํธ๋ก ์ค์ ํด์ผ ํฉ๋๋ค.
์๋ก์ด ๋ชจ๋ธ์ ์ถ๊ฐํ๋ ๊ฒฝ์ฐ ํตํฉ ํ
์คํธ์ฉ์ผ๋ก ๋ฌด์์ ๊ฐ์ค์น๋ก ์์ ๋ฒ์ ์ ๋ง๋ค์ด ํ๋ธ์ ์
๋ก๋ํด์ผ ํฉ๋๋ค.
์ด ๋ด์ฉ์ ์๋ ๋จ๋ฝ์์ ์ค๋ช
๋ฉ๋๋ค.
- ํน๋ณํ ๋น ๋ฅด๊ฒ ์คํ๋๋๋ก ์ต์ ํ๋์ง ์์ ํ์ต์ ์ํํด์ผ ํ๋ ํ
์คํธ๋ ๋๋ฆฐ ํ
์คํธ๋ก ์ค์ ํด์ผ ํฉ๋๋ค.
- ๋๋ฆฌ์ง ์์์ผ ํ ํ
์คํธ ์ค ์ผ๋ถ๊ฐ ๊ทน๋๋ก ๋๋ฆฐ ๊ฒฝ์ฐ
์์ธ๋ฅผ ๋์
ํ๊ณ ์ด๋ฅผ `@slow`๋ก ์ค์ ํ ์ ์์ต๋๋ค.
๋์ฉ๋ ํ์ผ์ ๋์คํฌ์ ์ ์ฅํ๊ณ ๋ถ๋ฌ์ค๋ ์๋ ๋ชจ๋ธ๋ง ํ
์คํธ๋ `@slow`์ผ๋ก ํ์๋ ํ
์คํธ์ ์ข์ ์์
๋๋ค.
- CI์์ 1์ด ์ด๋ด์ ํ
์คํธ๊ฐ ์๋ฃ๋๋ ๊ฒฝ์ฐ(๋ค์ด๋ก๋ ํฌํจ)์๋ ๋๋ฆฐ ํ
์คํธ๊ฐ ์๋์ด์ผ ํฉ๋๋ค.
๋๋ฆฐ ํ
์คํธ๊ฐ ์๋ ๊ฒฝ์ฐ์๋ ๋ค์ํ ๋ด๋ถ๋ฅผ ์์ ํ ์ปค๋ฒํ๋ฉด์ ๋น ๋ฅด๊ฒ ์ ์ง๋์ด์ผ ํฉ๋๋ค.
์๋ฅผ ๋ค์ด, ๋ฌด์์ ๊ฐ์ค์น๋ฅผ ์ฌ์ฉํ์ฌ ํน๋ณํ ์์ฑ๋ ์์ ๋ชจ๋ธ๋ก ํ
์คํธํ๋ฉด ์๋นํ ์ปค๋ฒ๋ฆฌ์ง๋ฅผ ์ป์ ์ ์์ต๋๋ค.
์ด๋ฌํ ๋ชจ๋ธ์ ์ต์ํ์ ๋ ์ด์ด ์(์: 2), ์ดํ ํฌ๊ธฐ(์: 1000) ๋ฑ์ ์์๋ง ๊ฐ์ง๋๋ค. ๊ทธ๋ฐ ๋ค์ `@slow` ํ
์คํธ๋ ๋ํ ๋๋ฆฐ ๋ชจ๋ธ์ ์ฌ์ฉํ์ฌ ์ ์ฑ์ ์ธ ํ
์คํธ๋ฅผ ์ํํ ์ ์์ต๋๋ค.
์ด๋ฌํ ์์ ๋ชจ๋ธ์ ์ฌ์ฉํ๋ ๋ฐฉ๋ฒ์ ํ์ธํ๋ ค๋ฉด ๋ค์๊ณผ ๊ฐ์ด *tiny* ๋ชจ๋ธ์ ์ฐพ์๋ณด์ธ์.
```bash
grep tiny tests examples
```
๋ค์์ ์์ ๋ชจ๋ธ[stas/tiny-wmt19-en-de](https://huggingface.co/stas/tiny-wmt19-en-de)์ ๋ง๋
[script](https://github.com/huggingface/transformers/tree/main/scripts/fsmt/fsmt-make-tiny-model.py) ์์์
๋๋ค.
ํน์ ๋ชจ๋ธ์ ์ํคํ
์ฒ์ ๋ง๊ฒ ์ฝ๊ฒ ์กฐ์ ํ ์ ์์ต๋๋ค.
์๋ฅผ ๋ค์ด ๋์ฉ๋ ๋ชจ๋ธ์ ๋ค์ด๋ก๋ํ๋ ๊ฒฝ์ฐ ๋ฐํ์์ ์๋ชป ์ธก์ ํ๊ธฐ ์ฝ์ง๋ง,
๋ก์ปฌ์์ ํ
์คํธํ๋ฉด ๋ค์ด๋ก๋ํ ํ์ผ์ด ์บ์๋์ด ๋ค์ด๋ก๋ ์๊ฐ์ด ์ธก์ ๋์ง ์์ต๋๋ค.
๋์ CI ๋ก๊ทธ์ ์คํ ์๋ ๋ณด๊ณ ์๋ฅผ ํ์ธํ์ธ์(`pytest --durations=0 tests`์ ์ถ๋ ฅ).
์ด ๋ณด๊ณ ์๋ ๋๋ฆฐ ์ด์๊ฐ์ผ๋ก ํ์๋์ง ์๊ฑฐ๋ ๋น ๋ฅด๊ฒ ๋ค์ ์์ฑํด์ผ ํ๋ ๋๋ฆฐ ์ด์๊ฐ์ ์ฐพ๋ ๋ฐ๋ ์ ์ฉํฉ๋๋ค.
CI์์ ํ
์คํธ ์ค์ํธ๊ฐ ๋๋ ค์ง๊ธฐ ์์ํ๋ฉด ์ด ๋ณด๊ณ ์์ ๋งจ ์ ๋ชฉ๋ก์ ๊ฐ์ฅ ๋๋ฆฐ ํ
์คํธ๊ฐ ํ์๋ฉ๋๋ค.
### stdout/stderr ์ถ๋ ฅ ํ
์คํธ[[testing-the-stdout/stderr-output]]
`stdout` ๋ฐ/๋๋ `stderr`๋ก ์ฐ๋ ํจ์๋ฅผ ํ
์คํธํ๋ ค๋ฉด `pytest`์ [capsys ์์คํ
](https://docs.pytest.org/en/latest/capture.html)์ ์ฌ์ฉํ์ฌ ํด๋น ์คํธ๋ฆผ์ ์ก์ธ์คํ ์ ์์ต๋๋ค.
๋ค์๊ณผ ๊ฐ์ด ์ํํ ์ ์์ต๋๋ค.
```python
import sys
def print_to_stdout(s):
print(s)
def print_to_stderr(s):
sys.stderr.write(s)
def test_result_and_stdout(capsys):
msg = "Hello"
print_to_stdout(msg)
print_to_stderr(msg)
out, err = capsys.readouterr() # ์บก์ฒ๋ ์ถ๋ ฅ ์คํธ๋ฆผ ์ฌ์ฉ
# ์ ํ ์ฌํญ: ์บก์ฒ๋ ์คํธ๋ฆผ ์ฌ์์ฑ
sys.stdout.write(out)
sys.stderr.write(err)
# ํ
์คํธ:
assert msg in out
assert msg in err
```
๊ทธ๋ฆฌ๊ณ , ๋ฌผ๋ก ๋๋ถ๋ถ์ ๊ฒฝ์ฐ์๋ `stderr`๋ ์์ธ์ ์ผ๋ถ๋ก ์ ๊ณต๋ฉ๋๋ค.
๊ทธ๋ฌ๋ฏ๋ก ํด๋น ๊ฒฝ์ฐ์๋ try/except๋ฅผ ์ฌ์ฉํด์ผ ํฉ๋๋ค.
```python
def raise_exception(msg):
raise ValueError(msg)
def test_something_exception():
msg = "Not a good value"
error = ""
try:
raise_exception(msg)
except Exception as e:
error = str(e)
assert msg in error, f"{msg} is in the exception:\n{error}"
```
`stdout`๋ฅผ ์บก์ฒํ๋ ๋ ๋ค๋ฅธ ๋ฐฉ๋ฒ์ `contextlib.redirect_stdout`๋ฅผ ์ฌ์ฉํ๋ ๊ฒ์
๋๋ค.
```python
from io import StringIO
from contextlib import redirect_stdout
def print_to_stdout(s):
print(s)
def test_result_and_stdout():
msg = "Hello"
buffer = StringIO()
with redirect_stdout(buffer):
print_to_stdout(msg)
out = buffer.getvalue()
# ์ ํ ์ฌํญ: ์บก์ฒ๋ ์คํธ๋ฆผ ์ฌ์์ฑ
sys.stdout.write(out)
# ํ
์คํธ:
assert msg in out
```
`stdout` ์บก์ฒ์ ๊ด๋ จ๋ ์ค์ํ ๋ฌธ์ ์ค ํ๋๋ ๋ณดํต `print`์์ ์ด์ ์ ์ธ์๋ ๋ด์ฉ์ ์ฌ์ค์ ํ๋ `\r` ๋ฌธ์๊ฐ ํฌํจ๋ ์ ์๋ค๋ ๊ฒ์
๋๋ค.
`pytest`์์๋ ๋ฌธ์ ๊ฐ ์์ง๋ง `pytest -s`์์๋ ์ด๋ฌํ ๋ฌธ์๊ฐ ๋ฒํผ์ ํฌํจ๋๋ฏ๋ก
`-s`๊ฐ ์๊ฑฐ๋ ์๋ ์ํ์์ ํ์คํธ๋ฅผ ์ํํ ์ ์์ผ๋ ค๋ฉด ์บก์ฒ๋ ์ถ๋ ฅ์ ๋ํด ์ถ๊ฐ์ ์ธ ์ ๋ฆฌ๊ฐ ํ์ํฉ๋๋ค.
์ด ๊ฒฝ์ฐ์๋ `re.sub(r'~.*\r', '', buf, 0, re.M)`์ ์ฌ์ฉํ ์ ์์ต๋๋ค.
ํ์ง๋ง ๋์ฐ๋ฏธ ์ปจํ
์คํธ ๊ด๋ฆฌ์ ๋ํผ๋ฅผ ์ฌ์ฉํ๋ฉด
์ถ๋ ฅ์ `\r`์ด ํฌํจ๋์ด ์๋์ง์ ์ฌ๋ถ์ ๊ด๊ณ์์ด ๋ชจ๋ ๊ฒ์ ์๋์ผ๋ก ์ฒ๋ฆฌํ๋ฏ๋ก ํธ๋ฆฌํฉ๋๋ค.
```python
from transformers.testing_utils import CaptureStdout
with CaptureStdout() as cs:
function_that_writes_to_stdout()
print(cs.out)
```
๋ค์์ ์ ์ฒด ํ
์คํธ ์์ ์
๋๋ค.
```python
from transformers.testing_utils import CaptureStdout
msg = "Secret message\r"
final = "Hello World"
with CaptureStdout() as cs:
print(msg + final)
assert cs.out == final + "\n", f"captured: {cs.out}, expecting {final}"
```
`stderr`๋ฅผ ์บก์ฒํ๊ณ ์ถ๋ค๋ฉด, ๋์ `CaptureStderr` ํด๋์ค๋ฅผ ์ฌ์ฉํ์ธ์.
```python
from transformers.testing_utils import CaptureStderr
with CaptureStderr() as cs:
function_that_writes_to_stderr()
print(cs.err)
```
๋ ์คํธ๋ฆผ์ ๋์์ ์บก์ฒํด์ผ ํ๋ค๋ฉด, ๋ถ๋ชจ `CaptureStd` ํด๋์ค๋ฅผ ์ฌ์ฉํ์ธ์.
```python
from transformers.testing_utils import CaptureStd
with CaptureStd() as cs:
function_that_writes_to_stdout_and_stderr()
print(cs.err, cs.out)
```
๋ํ, ํ
์คํธ์ ๋๋ฒ๊น
์ ์ง์ํ๊ธฐ ์ํด
์ด๋ฌํ ์ปจํ
์คํธ ๊ด๋ฆฌ์๋ ๊ธฐ๋ณธ์ ์ผ๋ก ์ปจํ
์คํธ์์ ์ข
๋ฃํ ๋ ์บก์ฒ๋ ์คํธ๋ฆผ์ ์๋์ผ๋ก ๋ค์ ์คํํฉ๋๋ค.
### ๋ก๊ฑฐ ์คํธ๋ฆผ ์บก์ฒ[[capturing-logger-stream]]
๋ก๊ฑฐ ์ถ๋ ฅ์ ๊ฒ์ฆํด์ผ ํ๋ ๊ฒฝ์ฐ `CaptureLogger`๋ฅผ ์ฌ์ฉํ ์ ์์ต๋๋ค.
```python
from transformers import logging
from transformers.testing_utils import CaptureLogger
msg = "Testing 1, 2, 3"
logging.set_verbosity_info()
logger = logging.get_logger("transformers.models.bart.tokenization_bart")
with CaptureLogger(logger) as cl:
logger.info(msg)
assert cl.out, msg + "\n"
```
### ํ๊ฒฝ ๋ณ์๋ฅผ ์ด์ฉํ์ฌ ํ
์คํธ[[testing-with-environment-variables]]
ํน์ ํ
์คํธ์ ํ๊ฒฝ ๋ณ์ ์ํฅ์ ๊ฒ์ฆํ๋ ค๋ฉด
`transformers.testing_utils.mockenv`๋ผ๋ ๋์ฐ๋ฏธ ๋ฐ์ฝ๋ ์ดํฐ๋ฅผ ์ฌ์ฉํ ์ ์์ต๋๋ค.
```python
from transformers.testing_utils import mockenv
class HfArgumentParserTest(unittest.TestCase):
@mockenv(TRANSFORMERS_VERBOSITY="error")
def test_env_override(self):
env_level_str = os.getenv("TRANSFORMERS_VERBOSITY", None)
```
์ผ๋ถ ๊ฒฝ์ฐ์๋ ์ธ๋ถ ํ๋ก๊ทธ๋จ์ ํธ์ถํด์ผํ ์๋ ์๋๋ฐ, ์ด ๋์๋ ์ฌ๋ฌ ๊ฐ์ ๋ก์ปฌ ๊ฒฝ๋ก๋ฅผ ํฌํจํ๋ `os.environ`์์ `PYTHONPATH`์ ์ค์ ์ด ํ์ํฉ๋๋ค.
ํฌํผ ํด๋์ค `transformers.test_utils.TestCasePlus`๊ฐ ๋์์ด ๋ฉ๋๋ค:
```python
from transformers.testing_utils import TestCasePlus
class EnvExampleTest(TestCasePlus):
def test_external_prog(self):
env = self.get_env()
# ์ด์ `env`๋ฅผ ์ฌ์ฉํ์ฌ ์ธ๋ถ ํ๋ก๊ทธ๋จ ํธ์ถ
```
ํ
์คํธ ํ์ผ์ด `tests` ํ
์คํธ ์ค์ํธ ๋๋ `examples`์ ์๋์ง์ ๋ฐ๋ผ
`env[PYTHONPATH]`๊ฐ ๋ ๋๋ ํฐ๋ฆฌ ์ค ํ๋๋ฅผ ํฌํจํ๋๋ก ์ค์ ๋๋ฉฐ,
ํ์ฌ ์ ์ฅ์์ ๋ํด ํ
์คํธ๊ฐ ์ํ๋๋๋ก `src` ๋๋ ํฐ๋ฆฌ๋ ํฌํจ๋ฉ๋๋ค.
ํ
์คํธ ํธ์ถ ์ด์ ์ ์ค์ ๋ ๊ฒฝ์ฐ์๋ `env[PYTHONPATH]`๋ฅผ ๊ทธ๋๋ก ์ฌ์ฉํฉ๋๋ค.
์ด ํฌํผ ๋ฉ์๋๋ `os.environ` ๊ฐ์ฒด์ ์ฌ๋ณธ์ ์์ฑํ๋ฏ๋ก ์๋ณธ์ ๊ทธ๋๋ก ์ ์ง๋ฉ๋๋ค.
### ์ฌํ ๊ฐ๋ฅํ ๊ฒฐ๊ณผ ์ป๊ธฐ[[getting-reproducible-results]]
์ผ๋ถ ์ํฉ์์ ํ
์คํธ์์ ์์์ฑ์ ์ ๊ฑฐํ์ฌ ๋์ผํ๊ฒ ์ฌํ ๊ฐ๋ฅํ ๊ฒฐ๊ณผ๋ฅผ ์ป๊ณ ์ถ์ ์ ์์ต๋๋ค.
์ด๋ฅผ ์ํด์๋ ๋ค์๊ณผ ๊ฐ์ด ์๋๋ฅผ ๊ณ ์ ํด์ผ ํฉ๋๋ค.
```python
seed = 42
# ํ์ด์ฌ RNG
import random
random.seed(seed)
# ํ์ดํ ์น RNG
import torch
torch.manual_seed(seed)
torch.backends.cudnn.deterministic = True
if torch.cuda.is_available():
torch.cuda.manual_seed_all(seed)
# ๋ํ์ด RNG
import numpy as np
np.random.seed(seed)
# ํ
์ํ๋ก RNG
tf.random.set_seed(seed)
```
### ํ
์คํธ ๋๋ฒ๊น
[[debugging tests]]
๊ฒฝ๊ณ ๊ฐ ์๋ ๊ณณ์์ ๋๋ฒ๊ฑฐ๋ฅผ ์์ํ๋ ค๋ฉด ๋ค์์ ์ํํ์ธ์.
```bash
pytest tests/utils/test_logging.py -W error::UserWarning --pdb
```
## Github Actions ์ํฌํ๋ก์ฐ ์์
์ฒ๋ฆฌ[[working-with-github-actions-workflows]]
์
ํ ํธ์ ์ํฌํ๋ก์ฐ CI ์์
์ ํธ๋ฆฌ๊ฑฐํ๋ ค๋ฉด, ๋ค์์ ์ํํด์ผ ํฉ๋๋ค.
1. `transformers` ์๋ณธ์์ ์ ๋ธ๋์น๋ฅผ ๋ง๋ญ๋๋ค(ํฌํฌ๊ฐ ์๋๋๋ค!).
2. ๋ธ๋์น ์ด๋ฆ์ `ci_` ๋๋ `ci-`๋ก ์์ํด์ผ ํฉ๋๋ค(`main`๋ ํธ๋ฆฌ๊ฑฐํ์ง๋ง `main`์์๋ PR์ ํ ์ ์์ต๋๋ค).
๋ํ ํน์ ๊ฒฝ๋ก์ ๋ํด์๋ง ํธ๋ฆฌ๊ฑฐ๋๋ฏ๋ก ์ด ๋ฌธ์๊ฐ ์์ฑ๋ ํ์ ๋ณ๊ฒฝ๋ ๋ด์ฉ์
[์ฌ๊ธฐ](https://github.com/huggingface/transformers/blob/main/.github/workflows/self-push.yml)์ *push:*์์ ํ์ธํ ์ ์์ต๋๋ค.
3. ์ด ๋ธ๋์น์์ PR์ ์์ฑํฉ๋๋ค
4. ๊ทธ๋ฐ ๋ค์ [์ฌ๊ธฐ](https://github.com/huggingface/transformers/actions/workflows/self-push.yml)์์ ์์
์ด ๋ํ๋๋์ง ํ์ธํ ์ ์์ต๋๋ค.
๋ฐฑ๋ก๊ทธ๊ฐ ์๋ ๊ฒฝ์ฐ, ๋ฐ๋ก ์คํ๋์ง ์์ ์๋ ์์ต๋๋ค.
## ์คํ์ ์ธ CI ๊ธฐ๋ฅ ํ
์คํธ[[testing-Experimental-CI-Features]]
CI ๊ธฐ๋ฅ์ ํ
์คํธํ๋ ๊ฒ์ ์ผ๋ฐ CI ์๋์ ๋ฐฉํด๊ฐ ๋ ์ ์๊ธฐ ๋๋ฌธ์ ์ ์ฌ์ ์ผ๋ก ๋ฌธ์ ๊ฐ ๋ฐ์ํ ์ ์์ต๋๋ค.
๋ฐ๋ผ์ ์๋ก์ด CI ๊ธฐ๋ฅ์ ์ถ๊ฐํ๋ ๊ฒฝ์ฐ ๋ค์๊ณผ ๊ฐ์ด ์ํํด์ผ ํฉ๋๋ค.
1. ํ
์คํธํด์ผ ํ ๋ด์ฉ์ ํ
์คํธํ๋ ์๋ก์ด ์ ์ฉ ์์
์ ์์ฑํฉ๋๋ค.
2. ์๋ก์ด ์์
์ ํญ์ ์ฑ๊ณตํด์ผ๋ง ๋
น์ โ๋ฅผ ๋ฐ์ ์ ์์ต๋๋ค(์๋์ ์์ธํ ๋ด์ฉ์ด ์์ต๋๋ค).
3. ๋ค์ํ PR ์ ํ์ ๋ํ ํ์ธ์ ์ํด
(์ฌ์ฉ์ ํฌํฌ ๋ธ๋์น, ํฌํฌ๋์ง ์์ ๋ธ๋์น, github.com UI ์ง์ ํ์ผ ํธ์ง์์ ์์ฑ๋ ๋ธ๋์น, ๊ฐ์ ํธ์ ๋ฑ PR์ ์ ํ์ ์์ฃผ ๋ค์ํฉ๋๋ค.)
๋ฉฐ์น ๋์ ์คํ ์์
์ ๋ก๊ทธ๋ฅผ ๋ชจ๋ํฐ๋งํ๋ฉด์ ์คํํด๋ด
๋๋ค.
(์๋์ ์ผ๋ก ํญ์ ๋
น์์ ํ์ํ๋ฏ๋ก ์์
์ ์ฒด๊ฐ ๋
น์์ ์๋๋ผ๋ ์ ์ ์ ์ํฉ๋๋ค.)
4. ๋ชจ๋ ๊ฒ์ด ์์ ์ ์ธ์ง ํ์ธํ ํ, ์๋ก์ด ๋ณ๊ฒฝ ์ฌํญ์ ๊ธฐ์กด ์์
์ ๋ณํฉํฉ๋๋ค.
์ด๋ ๊ฒ ํ๋ฉด CI ๊ธฐ๋ฅ ์์ฒด์ ๋ํ ์คํ์ด ์ผ๋ฐ ์์
ํ๋ฆ์ ๋ฐฉํด๊ฐ ๋์ง ์์ต๋๋ค.
๊ทธ๋ฌ๋ ์๋ก์ด CI ๊ธฐ๋ฅ์ด ๊ฐ๋ฐ ์ค์ธ ๋์, ํญ์ ์ฑ๊ณตํ๋๋ก ํ ์ ์๋ ๋ฐฉ๋ฒ์ ๋ฌด์์ผ๊น์?
TravisCI์ ๊ฐ์ ์ผ๋ถ CI๋ `ignore-step-failure`๋ฅผ ์ง์ํ๋ฉฐ ์ ์ฒด ์์
์ ์ฑ๊ณตํ ๊ฒ์ผ๋ก ๋ณด๊ณ ํ์ง๋ง,
ํ์ฌ ์ฐ๋ฆฌ๊ฐ ์ฌ์ฉํ๋ CircleCI์ Github Actions๋ ์ด๋ฅผ ์ง์ํ์ง ์์ต๋๋ค.
๋ฐ๋ผ์ ๋ค์๊ณผ ๊ฐ์ ํด๊ฒฐ์ฑ
์ ์ฌ์ฉํ ์ ์์ต๋๋ค.
1. bash ์คํฌ๋ฆฝํธ์์ ๊ฐ๋ฅํ ๋ง์ ์ค๋ฅ๋ฅผ ์ต์ ํ๊ธฐ ์ํด ์คํ ๋ช
๋ น์ ์์ ๋ถ๋ถ์ `set +euo pipefail`์ ์ถ๊ฐํฉ๋๋ค.
2. ๋ง์ง๋ง ๋ช
๋ น์ ๋ฐ๋์ ์ฑ๊ณตํด์ผ ํฉ๋๋ค. `echo "done"` ๋๋ `true`๋ฅผ ์ฌ์ฉํ๋ฉด ๋ฉ๋๋ค.
์์๋ ๋ค์๊ณผ ๊ฐ์ต๋๋ค.
```yaml
- run:
name: run CI experiment
command: |
set +euo pipefail
echo "setting run-all-despite-any-errors-mode"
this_command_will_fail
echo "but bash continues to run"
# emulate another failure
false
# but the last command must be a success
echo "during experiment do not remove: reporting success to CI, even if there were failures"
```
๊ฐ๋จํ ๋ช
๋ น์ ๊ฒฝ์ฐ ๋ค์๊ณผ ๊ฐ์ด ์ํํ ์๋ ์์ต๋๋ค.
```bash
cmd_that_may_fail || true
```
๊ฒฐ๊ณผ์ ๋ง์กฑํ ํ์๋ ๋ฌผ๋ก , ์คํ์ ์ธ ๋จ๊ณ ๋๋ ์์
์ ์ผ๋ฐ ์์
์ ๋๋จธ์ง ๋ถ๋ถ๊ณผ ํตํฉํ๋ฉด์
`set +euo pipefail` ๋๋ ๊ธฐํ ์ถ๊ฐํ ์์๋ฅผ ์ ๊ฑฐํ์ฌ
์คํ ์์
์ด ์ผ๋ฐ CI ์๋์ ๋ฐฉํด๋์ง ์๋๋ก ํด์ผ ํฉ๋๋ค.
์ด ์ ๋ฐ์ ์ธ ๊ณผ์ ์ ์คํ ๋จ๊ณ๊ฐ PR์ ์ ๋ฐ์ ์ธ ์ํ์ ์ํฅ์ ์ฃผ์ง ์๊ณ ์คํจํ๋๋ก
`allow-failure`์ ๊ฐ์ ๊ธฐ๋ฅ์ ์ค์ ํ ์ ์๋ค๋ฉด ํจ์ฌ ๋ ์ฌ์ ์ ๊ฒ์
๋๋ค.
๊ทธ๋ฌ๋ ์์์ ์ธ๊ธํ ๋ฐ์ ๊ฐ์ด CircleCI์ Github Actions๋ ํ์ฌ ์ด๋ฌํ ๊ธฐ๋ฅ๋ค ์ง์ํ์ง ์์ต๋๋ค.
์ด ๊ธฐ๋ฅ์ ์ง์์ ์ํ ํฌํ์ ์ฐธ์ฌํ๊ณ CI ๊ด๋ จ ์ค๋ ๋๋ค์์ ์ด๋ฌํ ์ํฉ์ ํ์ธํ ์๋ ์์ต๋๋ค.
- [Github Actions:](https://github.com/actions/toolkit/issues/399)
- [CircleCI:](https://ideas.circleci.com/ideas/CCI-I-344)
| 0 |
mavonic_private_repos/transformers/docs/source | mavonic_private_repos/transformers/docs/source/ko/run_scripts.md | <!--Copyright 2022 The HuggingFace Team. All rights reserved.
Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
the License. You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
specific language governing permissions and limitations under the License.
โ ๏ธ Note that this file is in Markdown but contain specific syntax for our doc-builder (similar to MDX) that may not be
rendered properly in your Markdown viewer.
-->
# ์คํฌ๋ฆฝํธ๋ก ์คํํ๊ธฐ[[train-with-a-script]]
๐ค Transformers ๋
ธํธ๋ถ๊ณผ ํจ๊ป [PyTorch](https://github.com/huggingface/transformers/tree/main/examples/pytorch), [TensorFlow](https://github.com/huggingface/transformers/tree/main/examples/tensorflow), ๋๋ [JAX/Flax](https://github.com/huggingface/transformers/tree/main/examples/flax)๋ฅผ ์ฌ์ฉํด ํน์ ํ์คํฌ์ ๋ํ ๋ชจ๋ธ์ ํ๋ จํ๋ ๋ฐฉ๋ฒ์ ๋ณด์ฌ์ฃผ๋ ์์ ์คํฌ๋ฆฝํธ๋ ์์ต๋๋ค.
๋ํ [์ฐ๊ตฌ ํ๋ก์ ํธ](https://github.com/huggingface/transformers/tree/main/examples/research_projects) ๋ฐ [๋ ๊ฑฐ์ ์์ ](https://github.com/huggingface/transformers/tree/main/examples/legacy)์์ ๋๋ถ๋ถ ์ปค๋ฎค๋ํฐ์์ ์ ๊ณตํ ์คํฌ๋ฆฝํธ๋ฅผ ์ฐพ์ ์ ์์ต๋๋ค.
์ด๋ฌํ ์คํฌ๋ฆฝํธ๋ ์ ๊ทน์ ์ผ๋ก ์ ์ง ๊ด๋ฆฌ๋์ง ์์ผ๋ฉฐ ์ต์ ๋ฒ์ ์ ๋ผ์ด๋ธ๋ฌ๋ฆฌ์ ํธํ๋์ง ์์ ๊ฐ๋ฅ์ฑ์ด ๋์ ํน์ ๋ฒ์ ์ ๐ค Transformers๋ฅผ ํ์๋ก ํฉ๋๋ค.
์์ ์คํฌ๋ฆฝํธ๊ฐ ๋ชจ๋ ๋ฌธ์ ์์ ๋ฐ๋ก ์๋ํ๋ ๊ฒ์ ์๋๋ฉฐ, ํด๊ฒฐํ๋ ค๋ ๋ฌธ์ ์ ๋ง๊ฒ ์คํฌ๋ฆฝํธ๋ฅผ ๋ณ๊ฒฝํด์ผ ํ ์๋ ์์ต๋๋ค.
์ด๋ฅผ ์ํด ๋๋ถ๋ถ์ ์คํฌ๋ฆฝํธ์๋ ๋ฐ์ดํฐ ์ ์ฒ๋ฆฌ ๋ฐฉ๋ฒ์ด ๋์์์ด ํ์์ ๋ฐ๋ผ ์์ ํ ์ ์์ต๋๋ค.
์์ ์คํฌ๋ฆฝํธ์ ๊ตฌํํ๊ณ ์ถ์ ๊ธฐ๋ฅ์ด ์์ผ๋ฉด pull request๋ฅผ ์ ์ถํ๊ธฐ ์ ์ [ํฌ๋ผ](https://discuss.huggingface.co/) ๋๋ [์ด์](https://github.com/huggingface/transformers/issues)์์ ๋
ผ์ํด ์ฃผ์ธ์.
๋ฒ๊ทธ ์์ ์ ํ์ํ์ง๋ง ๊ฐ๋
์ฑ์ ํฌ์ํ๋ฉด์๊น์ง ๋ ๋ง์ ๊ธฐ๋ฅ์ ์ถ๊ฐํ๋ pull request๋ ๋ณํฉ(merge)ํ์ง ์์ ๊ฐ๋ฅ์ฑ์ด ๋์ต๋๋ค.
์ด ๊ฐ์ด๋์์๋ [PyTorch](https://github.com/huggingface/transformers/tree/main/examples/pytorch/summarization) ๋ฐ [TensorFlow](https://github.com/huggingface/transformers/tree/main/examples/tensorflow/summarization)์์ ์์ฝ ํ๋ จํ๋
์คํฌ๋ฆฝํธ ์์ ๋ฅผ ์คํํ๋ ๋ฐฉ๋ฒ์ ์ค๋ช
ํฉ๋๋ค.
ํน๋ณํ ์ค๋ช
์ด ์๋ ํ ๋ชจ๋ ์์ ๋ ๋ ํ๋ ์์ํฌ ๋ชจ๋์์ ์๋ํ ๊ฒ์ผ๋ก ์์๋ฉ๋๋ค.
## ์ค์ ํ๊ธฐ[[setup]]
์ต์ ๋ฒ์ ์ ์์ ์คํฌ๋ฆฝํธ๋ฅผ ์ฑ๊ณต์ ์ผ๋ก ์คํํ๋ ค๋ฉด ์ ๊ฐ์ ํ๊ฒฝ์์ **์์ค๋ก๋ถํฐ ๐ค Transformers๋ฅผ ์ค์น**ํด์ผ ํฉ๋๋ค:
```bash
git clone https://github.com/huggingface/transformers
cd transformers
pip install .
```
์ด์ ๋ฒ์ ์ ์์ ์คํฌ๋ฆฝํธ๋ฅผ ๋ณด๋ ค๋ฉด ์๋ ํ ๊ธ์ ํด๋ฆญํ์ธ์:
<details>
<summary>์ด์ ๋ฒ์ ์ ๐ค Transformers ์์ </summary>
<ul>
<li><a href="https://github.com/huggingface/transformers/tree/v4.5.1/examples">v4.5.1</a></li>
<li><a href="https://github.com/huggingface/transformers/tree/v4.4.2/examples">v4.4.2</a></li>
<li><a href="https://github.com/huggingface/transformers/tree/v4.3.3/examples">v4.3.3</a></li>
<li><a href="https://github.com/huggingface/transformers/tree/v4.2.2/examples">v4.2.2</a></li>
<li><a href="https://github.com/huggingface/transformers/tree/v4.1.1/examples">v4.1.1</a></li>
<li><a href="https://github.com/huggingface/transformers/tree/v4.0.1/examples">v4.0.1</a></li>
<li><a href="https://github.com/huggingface/transformers/tree/v3.5.1/examples">v3.5.1</a></li>
<li><a href="https://github.com/huggingface/transformers/tree/v3.4.0/examples">v3.4.0</a></li>
<li><a href="https://github.com/huggingface/transformers/tree/v3.3.1/examples">v3.3.1</a></li>
<li><a href="https://github.com/huggingface/transformers/tree/v3.2.0/examples">v3.2.0</a></li>
<li><a href="https://github.com/huggingface/transformers/tree/v3.1.0/examples">v3.1.0</a></li>
<li><a href="https://github.com/huggingface/transformers/tree/v3.0.2/examples">v3.0.2</a></li>
<li><a href="https://github.com/huggingface/transformers/tree/v2.11.0/examples">v2.11.0</a></li>
<li><a href="https://github.com/huggingface/transformers/tree/v2.10.0/examples">v2.10.0</a></li>
<li><a href="https://github.com/huggingface/transformers/tree/v2.9.1/examples">v2.9.1</a></li>
<li><a href="https://github.com/huggingface/transformers/tree/v2.8.0/examples">v2.8.0</a></li>
<li><a href="https://github.com/huggingface/transformers/tree/v2.7.0/examples">v2.7.0</a></li>
<li><a href="https://github.com/huggingface/transformers/tree/v2.6.0/examples">v2.6.0</a></li>
<li><a href="https://github.com/huggingface/transformers/tree/v2.5.1/examples">v2.5.1</a></li>
<li><a href="https://github.com/huggingface/transformers/tree/v2.4.0/examples">v2.4.0</a></li>
<li><a href="https://github.com/huggingface/transformers/tree/v2.3.0/examples">v2.3.0</a></li>
<li><a href="https://github.com/huggingface/transformers/tree/v2.2.0/examples">v2.2.0</a></li>
<li><a href="https://github.com/huggingface/transformers/tree/v2.1.0/examples">v2.1.1</a></li>
<li><a href="https://github.com/huggingface/transformers/tree/v2.0.0/examples">v2.0.0</a></li>
<li><a href="https://github.com/huggingface/transformers/tree/v1.2.0/examples">v1.2.0</a></li>
<li><a href="https://github.com/huggingface/transformers/tree/v1.1.0/examples">v1.1.0</a></li>
<li><a href="https://github.com/huggingface/transformers/tree/v1.0.0/examples">v1.0.0</a></li>
</ul>
</details>
๊ทธ๋ฆฌ๊ณ ๋ค์๊ณผ ๊ฐ์ด ๋ณต์ (clone)ํด์จ ๐ค Transformers ๋ฒ์ ์ ํน์ ๋ฒ์ (์: v3.5.1)์ผ๋ก ์ ํํ์ธ์:
```bash
git checkout tags/v3.5.1
```
์ฌ๋ฐ๋ฅธ ๋ผ์ด๋ธ๋ฌ๋ฆฌ ๋ฒ์ ์ ์ค์ ํ ํ ์ํ๋ ์์ ํด๋๋ก ์ด๋ํ์ฌ ์์ ๋ณ๋ก ๋ผ์ด๋ธ๋ฌ๋ฆฌ์ ๋ํ ์๊ตฌ ์ฌํญ(requirements)์ ์ค์นํฉ๋๋ค:
```bash
pip install -r requirements.txt
```
## ์คํฌ๋ฆฝํธ ์คํํ๊ธฐ[[run-a-script]]
<frameworkcontent>
<pt>
์์ ์คํฌ๋ฆฝํธ๋ ๐ค [Datasets](https://huggingface.co/docs/datasets/) ๋ผ์ด๋ธ๋ฌ๋ฆฌ์์ ๋ฐ์ดํฐ ์ธํธ๋ฅผ ๋ค์ด๋ก๋ํ๊ณ ์ ์ฒ๋ฆฌํฉ๋๋ค.
๊ทธ๋ฐ ๋ค์ ์คํฌ๋ฆฝํธ๋ ์์ฝ ๊ธฐ๋ฅ์ ์ง์ํ๋ ์ํคํ
์ฒ์์ [Trainer](https://huggingface.co/docs/transformers/main_classes/trainer)๋ฅผ ์ฌ์ฉํ์ฌ ๋ฐ์ดํฐ ์ธํธ๋ฅผ ๋ฏธ์ธ ์กฐ์ ํฉ๋๋ค.
๋ค์ ์๋ [CNN/DailyMail](https://huggingface.co/datasets/cnn_dailymail) ๋ฐ์ดํฐ ์ธํธ์์ [T5-small](https://huggingface.co/google-t5/t5-small)์ ๋ฏธ์ธ ์กฐ์ ํฉ๋๋ค.
T5 ๋ชจ๋ธ์ ํ๋ จ ๋ฐฉ์์ ๋ฐ๋ผ ์ถ๊ฐ `source_prefix` ์ธ์๊ฐ ํ์ํ๋ฉฐ, ์ด ํ๋กฌํํธ๋ ์์ฝ ์์
์์ T5์ ์๋ ค์ค๋๋ค.
```bash
python examples/pytorch/summarization/run_summarization.py \
--model_name_or_path google-t5/t5-small \
--do_train \
--do_eval \
--dataset_name cnn_dailymail \
--dataset_config "3.0.0" \
--source_prefix "summarize: " \
--output_dir /tmp/tst-summarization \
--per_device_train_batch_size=4 \
--per_device_eval_batch_size=4 \
--overwrite_output_dir \
--predict_with_generate
```
</pt>
<tf>
์์ ์คํฌ๋ฆฝํธ๋ ๐ค [Datasets](https://huggingface.co/docs/datasets/) ๋ผ์ด๋ธ๋ฌ๋ฆฌ์์ ๋ฐ์ดํฐ ์ธํธ๋ฅผ ๋ค์ด๋ก๋ํ๊ณ ์ ์ฒ๋ฆฌํฉ๋๋ค.
๊ทธ๋ฐ ๋ค์ ์คํฌ๋ฆฝํธ๋ ์์ฝ ๊ธฐ๋ฅ์ ์ง์ํ๋ ์ํคํ
์ฒ์์ Keras๋ฅผ ์ฌ์ฉํ์ฌ ๋ฐ์ดํฐ ์ธํธ๋ฅผ ๋ฏธ์ธ ์กฐ์ ํฉ๋๋ค.
๋ค์ ์๋ [CNN/DailyMail](https://huggingface.co/datasets/cnn_dailymail) ๋ฐ์ดํฐ ์ธํธ์์ [T5-small](https://huggingface.co/google-t5/t5-small)์ ๋ฏธ์ธ ์กฐ์ ํฉ๋๋ค.
T5 ๋ชจ๋ธ์ ํ๋ จ ๋ฐฉ์์ ๋ฐ๋ผ ์ถ๊ฐ `source_prefix` ์ธ์๊ฐ ํ์ํ๋ฉฐ, ์ด ํ๋กฌํํธ๋ ์์ฝ ์์
์์ T5์ ์๋ ค์ค๋๋ค.
```bash
python examples/tensorflow/summarization/run_summarization.py \
--model_name_or_path google-t5/t5-small \
--dataset_name cnn_dailymail \
--dataset_config "3.0.0" \
--output_dir /tmp/tst-summarization \
--per_device_train_batch_size 8 \
--per_device_eval_batch_size 16 \
--num_train_epochs 3 \
--do_train \
--do_eval
```
</tf>
</frameworkcontent>
## ํผํฉ ์ ๋ฐ๋(mixed precision)๋ก ๋ถ์ฐ ํ๋ จํ๊ธฐ[[distributed-training-and-mixed-precision]]
[Trainer](https://huggingface.co/docs/transformers/main_classes/trainer) ํด๋์ค๋ ๋ถ์ฐ ํ๋ จ๊ณผ ํผํฉ ์ ๋ฐ๋(mixed precision)๋ฅผ ์ง์ํ๋ฏ๋ก ์คํฌ๋ฆฝํธ์์๋ ์ฌ์ฉํ ์ ์์ต๋๋ค.
์ด ๋ ๊ฐ์ง ๊ธฐ๋ฅ์ ๋ชจ๋ ํ์ฑํํ๋ ค๋ฉด ๋ค์ ๋ ๊ฐ์ง๋ฅผ ์ค์ ํด์ผ ํฉ๋๋ค:
- `fp16` ์ธ์๋ฅผ ์ถ๊ฐํด ํผํฉ ์ ๋ฐ๋(mixed precision)๋ฅผ ํ์ฑํํฉ๋๋ค.
- `nproc_per_node` ์ธ์๋ฅผ ์ถ๊ฐํด ์ฌ์ฉํ GPU ๊ฐ์๋ฅผ ์ค์ ํฉ๋๋ค.
```bash
torchrun \
--nproc_per_node 8 pytorch/summarization/run_summarization.py \
--fp16 \
--model_name_or_path google-t5/t5-small \
--do_train \
--do_eval \
--dataset_name cnn_dailymail \
--dataset_config "3.0.0" \
--source_prefix "summarize: " \
--output_dir /tmp/tst-summarization \
--per_device_train_batch_size=4 \
--per_device_eval_batch_size=4 \
--overwrite_output_dir \
--predict_with_generate
```
TensorFlow ์คํฌ๋ฆฝํธ๋ ๋ถ์ฐ ํ๋ จ์ ์ํด [`MirroredStrategy`](https://www.tensorflow.org/guide/distributed_training#mirroredstrategy)๋ฅผ ํ์ฉํ๋ฉฐ, ํ๋ จ ์คํฌ๋ฆฝํธ์ ์ธ์๋ฅผ ์ถ๊ฐํ ํ์๊ฐ ์์ต๋๋ค.
๋ค์ค GPU ํ๊ฒฝ์ด๋ผ๋ฉด, TensorFlow ์คํฌ๋ฆฝํธ๋ ๊ธฐ๋ณธ์ ์ผ๋ก ์ฌ๋ฌ ๊ฐ์ GPU๋ฅผ ์ฌ์ฉํฉ๋๋ค.
## TPU ์์์ ์คํฌ๋ฆฝํธ ์คํํ๊ธฐ[[run-a-script-on-a-tpu]]
<frameworkcontent>
<pt>
Tensor Processing Units (TPUs)๋ ์ฑ๋ฅ์ ๊ฐ์ํํ๊ธฐ ์ํด ํน๋ณํ ์ค๊ณ๋์์ต๋๋ค.
PyTorch๋ [XLA](https://www.tensorflow.org/xla) ๋ฅ๋ฌ๋ ์ปดํ์ผ๋ฌ์ ํจ๊ป TPU๋ฅผ ์ง์ํฉ๋๋ค(์์ธํ ๋ด์ฉ์ [์ฌ๊ธฐ](https://github.com/pytorch/xla/blob/master/README.md) ์ฐธ์กฐ).
TPU๋ฅผ ์ฌ์ฉํ๋ ค๋ฉด `xla_spawn.py` ์คํฌ๋ฆฝํธ๋ฅผ ์คํํ๊ณ `num_cores` ์ธ์๋ฅผ ์ฌ์ฉํ์ฌ ์ฌ์ฉํ๋ ค๋ TPU ์ฝ์ด ์๋ฅผ ์ค์ ํฉ๋๋ค.
```bash
python xla_spawn.py --num_cores 8 \
summarization/run_summarization.py \
--model_name_or_path google-t5/t5-small \
--do_train \
--do_eval \
--dataset_name cnn_dailymail \
--dataset_config "3.0.0" \
--source_prefix "summarize: " \
--output_dir /tmp/tst-summarization \
--per_device_train_batch_size=4 \
--per_device_eval_batch_size=4 \
--overwrite_output_dir \
--predict_with_generate
```
</pt>
<tf>
Tensor Processing Units (TPUs)๋ ์ฑ๋ฅ์ ๊ฐ์ํํ๊ธฐ ์ํด ํน๋ณํ ์ค๊ณ๋์์ต๋๋ค.
TensorFlow ์คํฌ๋ฆฝํธ๋ TPU๋ฅผ ํ๋ จ์ ์ฌ์ฉํ๊ธฐ ์ํด [`TPUStrategy`](https://www.tensorflow.org/guide/distributed_training#tpustrategy)๋ฅผ ํ์ฉํฉ๋๋ค.
TPU๋ฅผ ์ฌ์ฉํ๋ ค๋ฉด TPU ๋ฆฌ์์ค์ ์ด๋ฆ์ `tpu` ์ธ์์ ์ ๋ฌํฉ๋๋ค.
```bash
python run_summarization.py \
--tpu name_of_tpu_resource \
--model_name_or_path google-t5/t5-small \
--dataset_name cnn_dailymail \
--dataset_config "3.0.0" \
--output_dir /tmp/tst-summarization \
--per_device_train_batch_size 8 \
--per_device_eval_batch_size 16 \
--num_train_epochs 3 \
--do_train \
--do_eval
```
</tf>
</frameworkcontent>
## ๐ค Accelerate๋ก ์คํฌ๋ฆฝํธ ์คํํ๊ธฐ[[run-a-script-with-accelerate]]
๐ค [Accelerate](https://huggingface.co/docs/accelerate)๋ PyTorch ํ๋ จ ๊ณผ์ ์ ๋ํ ์์ ํ ๊ฐ์์ฑ์ ์ ์งํ๋ฉด์ ์ฌ๋ฌ ์ ํ์ ์ค์ (CPU ์ ์ฉ, ๋ค์ค GPU, TPU)์์ ๋ชจ๋ธ์ ํ๋ จํ ์ ์๋ ํตํฉ ๋ฐฉ๋ฒ์ ์ ๊ณตํ๋ PyTorch ์ ์ฉ ๋ผ์ด๋ธ๋ฌ๋ฆฌ์
๋๋ค.
๐ค Accelerate๊ฐ ์ค์น๋์ด ์๋์ง ํ์ธํ์ธ์:
> ์ฐธ๊ณ : Accelerate๋ ๋น ๋ฅด๊ฒ ๊ฐ๋ฐ ์ค์ด๋ฏ๋ก ์คํฌ๋ฆฝํธ๋ฅผ ์คํํ๋ ค๋ฉด accelerate๋ฅผ ์ค์นํด์ผ ํฉ๋๋ค.
```bash
pip install git+https://github.com/huggingface/accelerate
```
`run_summarization.py` ์คํฌ๋ฆฝํธ ๋์ `run_summarization_no_trainer.py` ์คํฌ๋ฆฝํธ๋ฅผ ์ฌ์ฉํด์ผ ํฉ๋๋ค.
๐ค Accelerate ํด๋์ค๊ฐ ์ง์๋๋ ์คํฌ๋ฆฝํธ๋ ํด๋์ `task_no_trainer.py` ํ์ผ์ด ์์ต๋๋ค.
๋ค์ ๋ช
๋ น์ ์คํํ์ฌ ๊ตฌ์ฑ ํ์ผ์ ์์ฑํ๊ณ ์ ์ฅํฉ๋๋ค:
```bash
accelerate config
```
์ค์ ์ ํ
์คํธํ์ฌ ์ฌ๋ฐ๋ฅด๊ฒ ๊ตฌ์ฑ๋์๋์ง ํ์ธํฉ๋๋ค:
```bash
accelerate test
```
์ด์ ํ๋ จ์ ์์ํ ์ค๋น๊ฐ ๋์์ต๋๋ค:
```bash
accelerate launch run_summarization_no_trainer.py \
--model_name_or_path google-t5/t5-small \
--dataset_name cnn_dailymail \
--dataset_config "3.0.0" \
--source_prefix "summarize: " \
--output_dir ~/tmp/tst-summarization
```
## ์ฌ์ฉ์ ์ ์ ๋ฐ์ดํฐ ์ธํธ ์ฌ์ฉํ๊ธฐ[[use-a-custom-dataset]]
์์ฝ ์คํฌ๋ฆฝํธ๋ ์ฌ์ฉ์ ์ง์ ๋ฐ์ดํฐ ์ธํธ๊ฐ CSV ๋๋ JSON ํ์ผ์ธ ๊ฒฝ์ฐ ์ง์ํฉ๋๋ค.
์ฌ์ฉ์ ์ง์ ๋ฐ์ดํฐ ์ธํธ๋ฅผ ์ฌ์ฉํ๋ ๊ฒฝ์ฐ์๋ ๋ช ๊ฐ์ง ์ถ๊ฐ ์ธ์๋ฅผ ์ง์ ํด์ผ ํฉ๋๋ค:
- `train_file`๊ณผ `validation_file`์ ํ๋ จ ๋ฐ ๊ฒ์ฆ ํ์ผ์ ๊ฒฝ๋ก๋ฅผ ์ง์ ํฉ๋๋ค.
- `text_column`์ ์์ฝํ ์
๋ ฅ ํ
์คํธ์
๋๋ค.
- `summary_column`์ ์ถ๋ ฅํ ๋์ ํ
์คํธ์
๋๋ค.
์ฌ์ฉ์ ์ง์ ๋ฐ์ดํฐ ์ธํธ๋ฅผ ์ฌ์ฉํ๋ ์์ฝ ์คํฌ๋ฆฝํธ๋ ๋ค์๊ณผ ๊ฐ์ต๋๋ค:
```bash
python examples/pytorch/summarization/run_summarization.py \
--model_name_or_path google-t5/t5-small \
--do_train \
--do_eval \
--train_file path_to_csv_or_jsonlines_file \
--validation_file path_to_csv_or_jsonlines_file \
--text_column text_column_name \
--summary_column summary_column_name \
--source_prefix "summarize: " \
--output_dir /tmp/tst-summarization \
--overwrite_output_dir \
--per_device_train_batch_size=4 \
--per_device_eval_batch_size=4 \
--predict_with_generate
```
## ์คํฌ๋ฆฝํธ ํ
์คํธํ๊ธฐ[[test-a-script]]
์ ์ฒด ๋ฐ์ดํฐ ์ธํธ๋ฅผ ๋์์ผ๋ก ํ๋ จ์ ์๋ฃํ๋๋ฐ ๊ฝค ์ค๋ ์๊ฐ์ด ๊ฑธ๋ฆฌ๊ธฐ ๋๋ฌธ์, ์์ ๋ฐ์ดํฐ ์ธํธ์์ ๋ชจ๋ ๊ฒ์ด ์์๋๋ก ์คํ๋๋์ง ํ์ธํ๋ ๊ฒ์ด ์ข์ต๋๋ค.
๋ค์ ์ธ์๋ฅผ ์ฌ์ฉํ์ฌ ๋ฐ์ดํฐ ์ธํธ๋ฅผ ์ต๋ ์ํ ์๋ก ์๋ผ๋
๋๋ค:
- `max_train_samples`
- `max_eval_samples`
- `max_predict_samples`
```bash
python examples/pytorch/summarization/run_summarization.py \
--model_name_or_path google-t5/t5-small \
--max_train_samples 50 \
--max_eval_samples 50 \
--max_predict_samples 50 \
--do_train \
--do_eval \
--dataset_name cnn_dailymail \
--dataset_config "3.0.0" \
--source_prefix "summarize: " \
--output_dir /tmp/tst-summarization \
--per_device_train_batch_size=4 \
--per_device_eval_batch_size=4 \
--overwrite_output_dir \
--predict_with_generate
```
๋ชจ๋ ์์ ์คํฌ๋ฆฝํธ๊ฐ `max_predict_samples` ์ธ์๋ฅผ ์ง์ํ์ง๋ ์์ต๋๋ค.
์คํฌ๋ฆฝํธ๊ฐ ์ด ์ธ์๋ฅผ ์ง์ํ๋์ง ํ์คํ์ง ์์ ๊ฒฝ์ฐ `-h` ์ธ์๋ฅผ ์ถ๊ฐํ์ฌ ํ์ธํ์ธ์:
```bash
examples/pytorch/summarization/run_summarization.py -h
```
## ์ฒดํฌํฌ์ธํธ(checkpoint)์์ ํ๋ จ ์ด์ด์ ํ๊ธฐ[[resume-training-from-checkpoint]]
๋ ๋ค๋ฅธ ์ ์ฉํ ์ต์
์ ์ด์ ์ฒดํฌํฌ์ธํธ์์ ํ๋ จ์ ์ฌ๊ฐํ๋ ๊ฒ์
๋๋ค.
์ด๋ ๊ฒ ํ๋ฉด ํ๋ จ์ด ์ค๋จ๋๋๋ผ๋ ์ฒ์๋ถํฐ ๋ค์ ์์ํ์ง ์๊ณ ์ค๋จํ ๋ถ๋ถ๋ถํฐ ๋ค์ ์์ํ ์ ์์ต๋๋ค.
์ฒดํฌํฌ์ธํธ์์ ํ๋ จ์ ์ฌ๊ฐํ๋ ๋ฐฉ๋ฒ์๋ ๋ ๊ฐ์ง๊ฐ ์์ต๋๋ค.
์ฒซ ๋ฒ์งธ๋ `output_dir previous_output_dir` ์ธ์๋ฅผ ์ฌ์ฉํ์ฌ `output_dir`์ ์ ์ฅ๋ ์ต์ ์ฒดํฌํฌ์ธํธ๋ถํฐ ํ๋ จ์ ์ฌ๊ฐํ๋ ๋ฐฉ๋ฒ์
๋๋ค.
์ด ๊ฒฝ์ฐ `overwrite_output_dir`์ ์ ๊ฑฐํด์ผ ํฉ๋๋ค:
```bash
python examples/pytorch/summarization/run_summarization.py
--model_name_or_path google-t5/t5-small \
--do_train \
--do_eval \
--dataset_name cnn_dailymail \
--dataset_config "3.0.0" \
--source_prefix "summarize: " \
--output_dir /tmp/tst-summarization \
--per_device_train_batch_size=4 \
--per_device_eval_batch_size=4 \
--output_dir previous_output_dir \
--predict_with_generate
```
๋ ๋ฒ์งธ๋ `resume_from_checkpoint path_to_specific_checkpoint` ์ธ์๋ฅผ ์ฌ์ฉํ์ฌ ํน์ ์ฒดํฌํฌ์ธํธ ํด๋์์ ํ๋ จ์ ์ฌ๊ฐํ๋ ๋ฐฉ๋ฒ์
๋๋ค.
```bash
python examples/pytorch/summarization/run_summarization.py
--model_name_or_path google-t5/t5-small \
--do_train \
--do_eval \
--dataset_name cnn_dailymail \
--dataset_config "3.0.0" \
--source_prefix "summarize: " \
--output_dir /tmp/tst-summarization \
--per_device_train_batch_size=4 \
--per_device_eval_batch_size=4 \
--overwrite_output_dir \
--resume_from_checkpoint path_to_specific_checkpoint \
--predict_with_generate
```
## ๋ชจ๋ธ ๊ณต์ ํ๊ธฐ[[share-your-model]]
๋ชจ๋ ์คํฌ๋ฆฝํธ๋ ์ต์ข
๋ชจ๋ธ์ [Model Hub](https://huggingface.co/models)์ ์
๋ก๋ํ ์ ์์ต๋๋ค.
์์ํ๊ธฐ ์ ์ Hugging Face์ ๋ก๊ทธ์ธํ๋์ง ํ์ธํ์ธ์:
```bash
huggingface-cli login
```
๊ทธ๋ฐ ๋ค์ ์คํฌ๋ฆฝํธ์ `push_to_hub` ์ธ์๋ฅผ ์ถ๊ฐํฉ๋๋ค.
์ด ์ธ์๋ Hugging Face ์ฌ์ฉ์ ์ด๋ฆ๊ณผ `output_dir`์ ์ง์ ๋ ํด๋ ์ด๋ฆ์ผ๋ก ์ ์ฅ์๋ฅผ ์์ฑํฉ๋๋ค.
์ ์ฅ์์ ํน์ ์ด๋ฆ์ ์ง์ ํ๋ ค๋ฉด `push_to_hub_model_id` ์ธ์๋ฅผ ์ฌ์ฉํ์ฌ ์ถ๊ฐํฉ๋๋ค.
์ ์ฅ์๋ ๋ค์์คํ์ด์ค ์๋์ ์๋์ผ๋ก ๋์ด๋ฉ๋๋ค.
๋ค์ ์๋ ํน์ ์ ์ฅ์ ์ด๋ฆ์ผ๋ก ๋ชจ๋ธ์ ์
๋ก๋ํ๋ ๋ฐฉ๋ฒ์
๋๋ค:
```bash
python examples/pytorch/summarization/run_summarization.py
--model_name_or_path google-t5/t5-small \
--do_train \
--do_eval \
--dataset_name cnn_dailymail \
--dataset_config "3.0.0" \
--source_prefix "summarize: " \
--push_to_hub \
--push_to_hub_model_id finetuned-t5-cnn_dailymail \
--output_dir /tmp/tst-summarization \
--per_device_train_batch_size=4 \
--per_device_eval_batch_size=4 \
--overwrite_output_dir \
--predict_with_generate
``` | 0 |
mavonic_private_repos/transformers/docs/source | mavonic_private_repos/transformers/docs/source/ko/create_a_model.md | <!--Copyright 2022 The HuggingFace Team. All rights reserved.
Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
the License. You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
specific language governing permissions and limitations under the License.
โ ๏ธ Note that this file is in Markdown but contain specific syntax for our doc-builder (similar to MDX) that may not be
rendered properly in your Markdown viewer.
-->
# ๋ง์ถคํ ์ํคํ
์ฒ ๋ง๋ค๊ธฐ[[create-a-custom-architecture]]
[`AutoClass`](model_doc/auto)๋ ๋ชจ๋ธ ์ํคํ
์ฒ๋ฅผ ์๋์ผ๋ก ์ถ๋ก ํ๊ณ ๋ฏธ๋ฆฌ ํ์ต๋ configuration๊ณผ ๊ฐ์ค์น๋ฅผ ๋ค์ด๋ก๋ํฉ๋๋ค. ์ผ๋ฐ์ ์ผ๋ก ์ฒดํฌํฌ์ธํธ์ ๊ตฌ์ ๋ฐ์ง ์๋ ์ฝ๋๋ฅผ ์์ฑํ๋ ค๋ฉด `AutoClass`๋ฅผ ์ฌ์ฉํ๋ ๊ฒ์ด ์ข์ต๋๋ค. ํ์ง๋ง ํน์ ๋ชจ๋ธ ํ๋ผ๋ฏธํฐ๋ฅผ ๋ณด๋ค ์ธ๋ฐํ๊ฒ ์ ์ดํ๊ณ ์ ํ๋ ์ฌ์ฉ์๋ ๋ช ๊ฐ์ง ๊ธฐ๋ณธ ํด๋์ค๋ง์ผ๋ก ์ปค์คํ
๐ค Transformers ๋ชจ๋ธ์ ์์ฑํ ์ ์์ต๋๋ค. ์ด๋ ๐ค Transformers ๋ชจ๋ธ์ ์ฐ๊ตฌ, ๊ต์ก ๋๋ ์คํํ๋ ๋ฐ ๊ด์ฌ์ด ์๋ ๋ชจ๋ ์ฌ์ฉ์์๊ฒ ํนํ ์ ์ฉํ ์ ์์ต๋๋ค. ์ด ๊ฐ์ด๋์์๋ 'AutoClass'๋ฅผ ์ฌ์ฉํ์ง ์๊ณ ์ปค์คํ
๋ชจ๋ธ์ ๋ง๋๋ ๋ฐฉ๋ฒ์ ๋ํด ์์๋ณด๊ฒ ์ต๋๋ค:
- ๋ชจ๋ธ configuration์ ๊ฐ์ ธ์ค๊ณ ์ฌ์ฉ์ ์ง์ ํฉ๋๋ค.
- ๋ชจ๋ธ ์ํคํ
์ฒ๋ฅผ ์์ฑํฉ๋๋ค.
- ํ
์คํธ์ ์ฌ์ฉํ ๋๋ฆฌ๊ฑฐ๋ ๋น ๋ฅธ ํ ํฐํ๊ธฐ๋ฅผ ๋ง๋ญ๋๋ค.
- ๋น์ ์์
์ ์ํ ์ด๋ฏธ์ง ํ๋ก์ธ์๋ฅผ ์์ฑํฉ๋๋ค.
- ์ค๋์ค ์์
์ ์ํ ํน์ฑ ์ถ์ถ๊ธฐ๋ฅผ ์์ฑํฉ๋๋ค.
- ๋ฉํฐ๋ชจ๋ฌ ์์
์ฉ ํ๋ก์ธ์๋ฅผ ์์ฑํฉ๋๋ค.
## Configuration[[configuration]]
[configuration](main_classes/configuration)์ ๋ชจ๋ธ์ ํน์ ์์ฑ์ ๋ํ๋
๋๋ค. ๊ฐ ๋ชจ๋ธ ๊ตฌ์ฑ์๋ ์๋ก ๋ค๋ฅธ ์์ฑ์ด ์์ต๋๋ค. ์๋ฅผ ๋ค์ด, ๋ชจ๋ NLP ๋ชจ๋ธ์๋ `hidden_size`, `num_attention_heads`, `num_hidden_layers` ๋ฐ `vocab_size` ์์ฑ์ด ๊ณตํต์ผ๋ก ์์ต๋๋ค. ์ด๋ฌํ ์์ฑ์ ๋ชจ๋ธ์ ๊ตฌ์ฑํ attention heads ๋๋ hidden layers์ ์๋ฅผ ์ง์ ํฉ๋๋ค.
[DistilBERT](model_doc/distilbert) ์์ฑ์ ๊ฒ์ฌํ๊ธฐ ์ํด [`DistilBertConfig`]์ ์ ๊ทผํ์ฌ ์์ธํ ์ดํด๋ด
๋๋ค:
```py
>>> from transformers import DistilBertConfig
>>> config = DistilBertConfig()
>>> print(config)
DistilBertConfig {
"activation": "gelu",
"attention_dropout": 0.1,
"dim": 768,
"dropout": 0.1,
"hidden_dim": 3072,
"initializer_range": 0.02,
"max_position_embeddings": 512,
"model_type": "distilbert",
"n_heads": 12,
"n_layers": 6,
"pad_token_id": 0,
"qa_dropout": 0.1,
"seq_classif_dropout": 0.2,
"sinusoidal_pos_embds": false,
"transformers_version": "4.16.2",
"vocab_size": 30522
}
```
[`DistilBertConfig`]๋ ๊ธฐ๋ณธ [`DistilBertModel`]์ ๋น๋ํ๋ ๋ฐ ์ฌ์ฉ๋๋ ๋ชจ๋ ๊ธฐ๋ณธ ์์ฑ์ ํ์ํฉ๋๋ค. ๋ชจ๋ ์์ฑ์ ์ปค์คํฐ๋ง์ด์ง์ด ๊ฐ๋ฅํ๋ฏ๋ก ์คํ์ ์ํ ๊ณต๊ฐ์ ๋ง๋ค ์ ์์ต๋๋ค. ์๋ฅผ ๋ค์ด ๊ธฐ๋ณธ ๋ชจ๋ธ์ ๋ค์๊ณผ ๊ฐ์ด ์ปค์คํฐ๋ง์ด์ฆํ ์ ์์ต๋๋ค:
- `activation` ํ๋ผ๋ฏธํฐ๋ก ๋ค๋ฅธ ํ์ฑํ ํจ์๋ฅผ ์ฌ์ฉํด ๋ณด์ธ์.
- `attention_dropout` ํ๋ผ๋ฏธํฐ๋ฅผ ์ฌ์ฉํ์ฌ ์ดํ
์
ํ๋ฅ ์ ๋ ๋์ ๋๋กญ์์ ๋น์จ์ ์ฌ์ฉํ์ธ์.
```py
>>> my_config = DistilBertConfig(activation="relu", attention_dropout=0.4)
>>> print(my_config)
DistilBertConfig {
"activation": "relu",
"attention_dropout": 0.4,
"dim": 768,
"dropout": 0.1,
"hidden_dim": 3072,
"initializer_range": 0.02,
"max_position_embeddings": 512,
"model_type": "distilbert",
"n_heads": 12,
"n_layers": 6,
"pad_token_id": 0,
"qa_dropout": 0.1,
"seq_classif_dropout": 0.2,
"sinusoidal_pos_embds": false,
"transformers_version": "4.16.2",
"vocab_size": 30522
}
```
์ฌ์ ํ์ต๋ ๋ชจ๋ธ ์์ฑ์ [`~PretrainedConfig.from_pretrained`] ํจ์์์ ์์ ํ ์ ์์ต๋๋ค:
```py
>>> my_config = DistilBertConfig.from_pretrained("distilbert/distilbert-base-uncased", activation="relu", attention_dropout=0.4)
```
๋ชจ๋ธ ๊ตฌ์ฑ์ด ๋ง์กฑ์ค๋ฌ์ฐ๋ฉด [`~PretrainedConfig.save_pretrained`]๋ก ์ ์ฅํ ์ ์์ต๋๋ค. ์ค์ ํ์ผ์ ์ง์ ๋ ์์
๊ฒฝ๋ก์ JSON ํ์ผ๋ก ์ ์ฅ๋ฉ๋๋ค:
```py
>>> my_config.save_pretrained(save_directory="./your_model_save_path")
```
configuration ํ์ผ์ ์ฌ์ฌ์ฉํ๋ ค๋ฉด [`~PretrainedConfig.from_pretrained`]๋ฅผ ์ฌ์ฉํ์ฌ ๊ฐ์ ธ์ค์ธ์:
```py
>>> my_config = DistilBertConfig.from_pretrained("./your_model_save_path/config.json")
```
<Tip>
configuration ํ์ผ์ ๋์
๋๋ฆฌ๋ก ์ ์ฅํ๊ฑฐ๋ ์ฌ์ฉ์ ์ ์ configuration ์์ฑ๊ณผ ๊ธฐ๋ณธ configuration ์์ฑ์ ์ฐจ์ด์ ๋ง ์ ์ฅํ ์๋ ์์ต๋๋ค! ์์ธํ ๋ด์ฉ์ [configuration](main_classes/configuration) ๋ฌธ์๋ฅผ ์ฐธ์กฐํ์ธ์.
</Tip>
## ๋ชจ๋ธ[[model]]
๋ค์ ๋จ๊ณ๋ [๋ชจ๋ธ(model)](main_classes/models)์ ๋ง๋๋ ๊ฒ์
๋๋ค. ๋์จํ๊ฒ ์ํคํ
์ฒ๋ผ๊ณ ๋ ๋ถ๋ฆฌ๋ ๋ชจ๋ธ์ ๊ฐ ๊ณ์ธต์ด ์ํํ๋ ๋์๊ณผ ๋ฐ์ํ๋ ์์
์ ์ ์ํฉ๋๋ค. configuration์ `num_hidden_layers`์ ๊ฐ์ ์์ฑ์ ์ํคํ
์ฒ๋ฅผ ์ ์ํ๋ ๋ฐ ์ฌ์ฉ๋ฉ๋๋ค. ๋ชจ๋ ๋ชจ๋ธ์ ๊ธฐ๋ณธ ํด๋์ค [`PreTrainedModel`]๊ณผ ์
๋ ฅ ์๋ฒ ๋ฉ ํฌ๊ธฐ ์กฐ์ ๋ฐ ์
ํ ์ดํ
์
ํค๋ ๊ฐ์ง ์น๊ธฐ์ ๊ฐ์ ๋ช ๊ฐ์ง ์ผ๋ฐ์ ์ธ ๋ฉ์๋๋ฅผ ๊ณต์ ํฉ๋๋ค. ๋ํ ๋ชจ๋ ๋ชจ๋ธ์ [`torch.nn.Module`](https://pytorch.org/docs/stable/generated/torch.nn.Module.html), [`tf.keras.Model`](https://www.tensorflow.org/api_docs/python/tf/keras/Model) ๋๋ [`flax.linen.Module`](https://flax.readthedocs.io/en/latest/api_reference/flax.linen/module.html)์ ์๋ธํด๋์ค์ด๊ธฐ๋ ํฉ๋๋ค. ์ฆ, ๋ชจ๋ธ์ ๊ฐ ํ๋ ์์ํฌ์ ์ฌ์ฉ๋ฒ๊ณผ ํธํ๋ฉ๋๋ค.
<frameworkcontent>
<pt>
์ฌ์ฉ์ ์ง์ configuration ์์ฑ์ ๋ชจ๋ธ์ ๊ฐ์ ธ์ต๋๋ค:
```py
>>> from transformers import DistilBertModel
>>> my_config = DistilBertConfig.from_pretrained("./your_model_save_path/config.json")
>>> model = DistilBertModel(my_config)
```
์ด์ ์ฌ์ ํ์ต๋ ๊ฐ์ค์น ๋์ ์์์ ๊ฐ์ ๊ฐ์ง ๋ชจ๋ธ์ด ์์ฑ๋ฉ๋๋ค. ์ด ๋ชจ๋ธ์ ํ๋ จํ๊ธฐ ์ ๊น์ง๋ ์ ์ฉํ๊ฒ ์ฌ์ฉํ ์ ์์ต๋๋ค. ํ๋ จ์ ๋น์ฉ๊ณผ ์๊ฐ์ด ๋ง์ด ์์๋๋ ํ๋ก์ธ์ค์
๋๋ค. ์ผ๋ฐ์ ์ผ๋ก ํ๋ จ์ ํ์ํ ๋ฆฌ์์ค์ ์ผ๋ถ๋ง ์ฌ์ฉํ๋ฉด์ ๋ ๋์ ๊ฒฐ๊ณผ๋ฅผ ๋ ๋นจ๋ฆฌ ์ป์ผ๋ ค๋ฉด ์ฌ์ ํ๋ จ๋ ๋ชจ๋ธ์ ์ฌ์ฉํ๋ ๊ฒ์ด ์ข์ต๋๋ค.
์ฌ์ ํ์ต๋ ๋ชจ๋ธ์ [`~PreTrainedModel.from_pretrained`]๋ก ์์ฑํฉ๋๋ค:
```py
>>> model = DistilBertModel.from_pretrained("distilbert/distilbert-base-uncased")
```
๐ค Transformers์์ ์ ๊ณตํ ๋ชจ๋ธ์ ์ฌ์ ํ์ต๋ ๊ฐ์ค์น๋ฅผ ์ฌ์ฉํ๋ ๊ฒฝ์ฐ ๊ธฐ๋ณธ ๋ชจ๋ธ configuration์ ์๋์ผ๋ก ๋ถ๋ฌ์ต๋๋ค. ๊ทธ๋ฌ๋ ์ํ๋ ๊ฒฝ์ฐ ๊ธฐ๋ณธ ๋ชจ๋ธ configuration ์์ฑ์ ์ผ๋ถ ๋๋ ์ ๋ถ๋ฅผ ์ฌ์ฉ์ ์ง์ ์ผ๋ก ๋ฐ๊ฟ ์ ์์ต๋๋ค:
```py
>>> model = DistilBertModel.from_pretrained("distilbert/distilbert-base-uncased", config=my_config)
```
</pt>
<tf>
์ฌ์ฉ์ ์ง์ configuration ์์ฑ์ ๋ชจ๋ธ์ ๋ถ๋ฌ์ต๋๋ค:
```py
>>> from transformers import TFDistilBertModel
>>> my_config = DistilBertConfig.from_pretrained("./your_model_save_path/my_config.json")
>>> tf_model = TFDistilBertModel(my_config)
```
์ด์ ์ฌ์ ํ์ต๋ ๊ฐ์ค์น ๋์ ์์์ ๊ฐ์ ๊ฐ์ง ๋ชจ๋ธ์ด ์์ฑ๋ฉ๋๋ค. ์ด ๋ชจ๋ธ์ ํ๋ จํ๊ธฐ ์ ๊น์ง๋ ์ ์ฉํ๊ฒ ์ฌ์ฉํ ์ ์์ต๋๋ค. ํ๋ จ์ ๋น์ฉ๊ณผ ์๊ฐ์ด ๋ง์ด ์์๋๋ ํ๋ก์ธ์ค์
๋๋ค. ์ผ๋ฐ์ ์ผ๋ก ํ๋ จ์ ํ์ํ ๋ฆฌ์์ค์ ์ผ๋ถ๋ง ์ฌ์ฉํ๋ฉด์ ๋ ๋์ ๊ฒฐ๊ณผ๋ฅผ ๋ ๋นจ๋ฆฌ ์ป์ผ๋ ค๋ฉด ์ฌ์ ํ๋ จ๋ ๋ชจ๋ธ์ ์ฌ์ฉํ๋ ๊ฒ์ด ์ข์ต๋๋ค.
์ฌ์ ํ์ต๋ ๋ชจ๋ธ์ [`~TFPreTrainedModel.from_pretrained`]๋ก ์์ฑํฉ๋๋ค:
```py
>>> tf_model = TFDistilBertModel.from_pretrained("distilbert/distilbert-base-uncased")
```
๐ค Transformers์์ ์ ๊ณตํ ๋ชจ๋ธ์ ์ฌ์ ํ์ต๋ ๊ฐ์ค์น๋ฅผ ์ฌ์ฉํ๋ ๊ฒฝ์ฐ ๊ธฐ๋ณธ ๋ชจ๋ธ configuration์ ์๋์ผ๋ก ๋ถ๋ฌ์ต๋๋ค. ๊ทธ๋ฌ๋ ์ํ๋ ๊ฒฝ์ฐ ๊ธฐ๋ณธ ๋ชจ๋ธ configuration ์์ฑ์ ์ผ๋ถ ๋๋ ์ ๋ถ๋ฅผ ์ฌ์ฉ์ ์ง์ ์ผ๋ก ๋ฐ๊ฟ ์ ์์ต๋๋ค:
```py
>>> tf_model = TFDistilBertModel.from_pretrained("distilbert/distilbert-base-uncased", config=my_config)
```
</tf>
</frameworkcontent>
### ๋ชจ๋ธ ํค๋[[model-heads]]
์ด ์์ ์์ *์๋ ์ํ(hidden state)*๋ฅผ ์ถ๋ ฅํ๋ ๊ธฐ๋ณธ DistilBERT ๋ชจ๋ธ์ ๊ฐ๊ฒ ๋ฉ๋๋ค. ์๋ ์ํ๋ ์ต์ข
์ถ๋ ฅ์ ์์ฑํ๊ธฐ ์ํด ๋ชจ๋ธ ํค๋์ ์
๋ ฅ์ผ๋ก ์ ๋ฌ๋ฉ๋๋ค. ๐ค Transformers๋ ๋ชจ๋ธ์ด ํด๋น ์์
์ ์ง์ํ๋ ํ ๊ฐ ์์
๋ง๋ค ๋ค๋ฅธ ๋ชจ๋ธ ํค๋๋ฅผ ์ ๊ณตํฉ๋๋ค(์ฆ, ๋ฒ์ญ๊ณผ ๊ฐ์ ์ํ์ค ๊ฐ ์์
์๋ DistilBERT๋ฅผ ์ฌ์ฉํ ์ ์์).
<frameworkcontent>
<pt>
์๋ฅผ ๋ค์ด, [`DistilBertForSequenceClassification`]์ ์ํ์ค ๋ถ๋ฅ ํค๋๊ฐ ์๋ ๊ธฐ๋ณธ DistilBERT ๋ชจ๋ธ์
๋๋ค. ์ํ์ค ๋ถ๋ฅ ํค๋๋ ํ๋ง๋ ์ถ๋ ฅ ์์ ์๋ ์ ํ ๋ ์ด์ด์
๋๋ค.
```py
>>> from transformers import DistilBertForSequenceClassification
>>> model = DistilBertForSequenceClassification.from_pretrained("distilbert/distilbert-base-uncased")
```
๋ค๋ฅธ ๋ชจ๋ธ ํค๋๋ก ์ ํํ์ฌ ์ด ์ฒดํฌํฌ์ธํธ๋ฅผ ๋ค๋ฅธ ์์
์ ์ฝ๊ฒ ์ฌ์ฌ์ฉํ ์ ์์ต๋๋ค. ์ง์์๋ต ์์
์ ๊ฒฝ์ฐ, [`DistilBertForQuestionAnswering`] ๋ชจ๋ธ ํค๋๋ฅผ ์ฌ์ฉํ ์ ์์ต๋๋ค. ์ง์์๋ต ํค๋๋ ์จ๊ฒจ์ง ์ํ ์ถ๋ ฅ ์์ ์ ํ ๋ ์ด์ด๊ฐ ์๋ค๋ ์ ์ ์ ์ธํ๋ฉด ์ํ์ค ๋ถ๋ฅ ํค๋์ ์ ์ฌํฉ๋๋ค.
```py
>>> from transformers import DistilBertForQuestionAnswering
>>> model = DistilBertForQuestionAnswering.from_pretrained("distilbert/distilbert-base-uncased")
```
</pt>
<tf>
์๋ฅผ ๋ค์ด, [`TFDistilBertForSequenceClassification`]์ ์ํ์ค ๋ถ๋ฅ ํค๋๊ฐ ์๋ ๊ธฐ๋ณธ DistilBERT ๋ชจ๋ธ์
๋๋ค. ์ํ์ค ๋ถ๋ฅ ํค๋๋ ํ๋ง๋ ์ถ๋ ฅ ์์ ์๋ ์ ํ ๋ ์ด์ด์
๋๋ค.
```py
>>> from transformers import TFDistilBertForSequenceClassification
>>> tf_model = TFDistilBertForSequenceClassification.from_pretrained("distilbert/distilbert-base-uncased")
```
๋ค๋ฅธ ๋ชจ๋ธ ํค๋๋ก ์ ํํ์ฌ ์ด ์ฒดํฌํฌ์ธํธ๋ฅผ ๋ค๋ฅธ ์์
์ ์ฝ๊ฒ ์ฌ์ฌ์ฉํ ์ ์์ต๋๋ค. ์ง์์๋ต ์์
์ ๊ฒฝ์ฐ, [`TFDistilBertForQuestionAnswering`] ๋ชจ๋ธ ํค๋๋ฅผ ์ฌ์ฉํ ์ ์์ต๋๋ค. ์ง์์๋ต ํค๋๋ ์จ๊ฒจ์ง ์ํ ์ถ๋ ฅ ์์ ์ ํ ๋ ์ด์ด๊ฐ ์๋ค๋ ์ ์ ์ ์ธํ๋ฉด ์ํ์ค ๋ถ๋ฅ ํค๋์ ์ ์ฌํฉ๋๋ค.
```py
>>> from transformers import TFDistilBertForQuestionAnswering
>>> tf_model = TFDistilBertForQuestionAnswering.from_pretrained("distilbert/distilbert-base-uncased")
```
</tf>
</frameworkcontent>
## ํ ํฌ๋์ด์ [[tokenizer]]
ํ
์คํธ ๋ฐ์ดํฐ์ ๋ชจ๋ธ์ ์ฌ์ฉํ๊ธฐ ์ ์ ๋ง์ง๋ง์ผ๋ก ํ์ํ ๊ธฐ๋ณธ ํด๋์ค๋ ์์ ํ
์คํธ๋ฅผ ํ
์๋ก ๋ณํํ๋ [ํ ํฌ๋์ด์ ](main_classes/tokenizer)์
๋๋ค. ๐ค Transformers์ ์ฌ์ฉํ ์ ์๋ ํ ํฌ๋์ด์ ๋ ๋ ๊ฐ์ง ์ ํ์ด ์์ต๋๋ค:
- [`PreTrainedTokenizer`]: ํ์ด์ฌ์ผ๋ก ๊ตฌํ๋ ํ ํฌ๋์ด์ ์
๋๋ค.
- [`PreTrainedTokenizerFast`]: Rust ๊ธฐ๋ฐ [๐ค Tokenizer](https://huggingface.co/docs/tokenizers/python/latest/) ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ก ๋ง๋ค์ด์ง ํ ํฌ๋์ด์ ์
๋๋ค. ์ด ํ ํฌ๋์ด์ ๋ Rust๋ก ๊ตฌํ๋์ด ๋ฐฐ์น ํ ํฐํ์์ ํนํ ๋น ๋ฆ
๋๋ค. ๋น ๋ฅธ ํ ํฌ๋์ด์ ๋ ํ ํฐ์ ์๋ ๋จ์ด๋ ๋ฌธ์์ ๋งคํํ๋ *์คํ์
๋งคํ*๊ณผ ๊ฐ์ ์ถ๊ฐ ๋ฉ์๋๋ ์ ๊ณตํฉ๋๋ค.
๋ ํ ํฌ๋์ด์ ๋ชจ๋ ์ธ์ฝ๋ฉ ๋ฐ ๋์ฝ๋ฉ, ์ ํ ํฐ ์ถ๊ฐ, ํน์ ํ ํฐ ๊ด๋ฆฌ์ ๊ฐ์ ์ผ๋ฐ์ ์ธ ๋ฐฉ๋ฒ์ ์ง์ํฉ๋๋ค.
<Tip warning={true}>
๋ชจ๋ ๋ชจ๋ธ์ด ๋น ๋ฅธ ํ ํฌ๋์ด์ ๋ฅผ ์ง์ํ๋ ๊ฒ์ ์๋๋๋ค. ์ด [ํ](index#supported-frameworks)์์ ๋ชจ๋ธ์ ๋น ๋ฅธ ํ ํฌ๋์ด์ ์ง์ ์ฌ๋ถ๋ฅผ ํ์ธํ์ธ์.
</Tip>
ํ ํฌ๋์ด์ ๋ฅผ ์ง์ ํ์ตํ ๊ฒฝ์ฐ, *์ดํ(vocabulary)* ํ์ผ์์ ํ ํฌ๋์ด์ ๋ฅผ ๋ง๋ค ์ ์์ต๋๋ค:
```py
>>> from transformers import DistilBertTokenizer
>>> my_tokenizer = DistilBertTokenizer(vocab_file="my_vocab_file.txt", do_lower_case=False, padding_side="left")
```
์ฌ์ฉ์ ์ง์ ํ ํฌ๋์ด์ ์ ์ดํ๋ ์ฌ์ ํ์ต๋ ๋ชจ๋ธ์ ํ ํฌ๋์ด์ ์์ ์์ฑ๋ ์ดํ์ ๋ค๋ฅผ ์ ์๋ค๋ ์ ์ ๊ธฐ์ตํ๋ ๊ฒ์ด ์ค์ํฉ๋๋ค. ์ฌ์ ํ์ต๋ ๋ชจ๋ธ์ ์ฌ์ฉํ๋ ๊ฒฝ์ฐ ์ฌ์ ํ์ต๋ ๋ชจ๋ธ์ ์ดํ๋ฅผ ์ฌ์ฉํด์ผ ํ๋ฉฐ, ๊ทธ๋ ์ง ์์ผ๋ฉด ์
๋ ฅ์ด ์๋ฏธ๋ฅผ ๊ฐ์ง ๋ชปํฉ๋๋ค. [`DistilBertTokenizer`] ํด๋์ค๋ฅผ ์ฌ์ฉํ์ฌ ์ฌ์ ํ์ต๋ ๋ชจ๋ธ์ ์ดํ๋ก ํ ํฌ๋์ด์ ๋ฅผ ์์ฑํฉ๋๋ค:
```py
>>> from transformers import DistilBertTokenizer
>>> slow_tokenizer = DistilBertTokenizer.from_pretrained("distilbert/distilbert-base-uncased")
```
[`DistilBertTokenizerFast`] ํด๋์ค๋ก ๋น ๋ฅธ ํ ํฌ๋์ด์ ๋ฅผ ์์ฑํฉ๋๋ค:
```py
>>> from transformers import DistilBertTokenizerFast
>>> fast_tokenizer = DistilBertTokenizerFast.from_pretrained("distilbert/distilbert-base-uncased")
```
<Tip>
[`AutoTokenizer`]๋ ๊ธฐ๋ณธ์ ์ผ๋ก ๋น ๋ฅธ ํ ํฌ๋์ด์ ๋ฅผ ๊ฐ์ ธ์ค๋ ค๊ณ ํฉ๋๋ค. ์ด ๋์์ ๋นํ์ฑํํ๋ ค๋ฉด `from_pretrained`์์ `use_fast=False`๋ฅผ ์ค์ ํ๋ฉด ๋ฉ๋๋ค.
</Tip>
## ์ด๋ฏธ์ง ํ๋ก์ธ์[[image-processor]]
์ด๋ฏธ์ง ํ๋ก์ธ์(image processor)๋ ๋น์ ์
๋ ฅ์ ์ฒ๋ฆฌํฉ๋๋ค. ๊ธฐ๋ณธ [`~image_processing_utils.ImageProcessingMixin`] ํด๋์ค์์ ์์ํฉ๋๋ค.
์ฌ์ฉํ๋ ค๋ฉด ์ฌ์ฉ ์ค์ธ ๋ชจ๋ธ๊ณผ ์ฐ๊ฒฐ๋ ์ด๋ฏธ์ง ํ๋ก์ธ์๋ฅผ ์์ฑํฉ๋๋ค. ์๋ฅผ ๋ค์ด, ์ด๋ฏธ์ง ๋ถ๋ฅ์ [ViT](model_doc/vit)๋ฅผ ์ฌ์ฉํ๋ ๊ฒฝ์ฐ ๊ธฐ๋ณธ [`ViTImageProcessor`]๋ฅผ ์์ฑํฉ๋๋ค:
```py
>>> from transformers import ViTImageProcessor
>>> vit_extractor = ViTImageProcessor()
>>> print(vit_extractor)
ViTImageProcessor {
"do_normalize": true,
"do_resize": true,
"feature_extractor_type": "ViTImageProcessor",
"image_mean": [
0.5,
0.5,
0.5
],
"image_std": [
0.5,
0.5,
0.5
],
"resample": 2,
"size": 224
}
```
<Tip>
์ฌ์ฉ์ ์ง์ ์ ์ํ์ง ์๋ ๊ฒฝ์ฐ `from_pretrained` ๋ฉ์๋๋ฅผ ์ฌ์ฉํ์ฌ ๋ชจ๋ธ์ ๊ธฐ๋ณธ ์ด๋ฏธ์ง ํ๋ก์ธ์ ๋งค๊ฐ๋ณ์๋ฅผ ๋ถ๋ฌ์ค๋ฉด ๋ฉ๋๋ค.
</Tip>
์ฌ์ฉ์ ์ง์ ์ด๋ฏธ์ง ํ๋ก์ธ์๋ฅผ ์์ฑํ๋ ค๋ฉด [`ViTImageProcessor`] ํ๋ผ๋ฏธํฐ๋ฅผ ์์ ํฉ๋๋ค:
```py
>>> from transformers import ViTImageProcessor
>>> my_vit_extractor = ViTImageProcessor(resample="PIL.Image.BOX", do_normalize=False, image_mean=[0.3, 0.3, 0.3])
>>> print(my_vit_extractor)
ViTImageProcessor {
"do_normalize": false,
"do_resize": true,
"feature_extractor_type": "ViTImageProcessor",
"image_mean": [
0.3,
0.3,
0.3
],
"image_std": [
0.5,
0.5,
0.5
],
"resample": "PIL.Image.BOX",
"size": 224
}
```
## ํน์ฑ ์ถ์ถ๊ธฐ[[feature-extractor]]
ํน์ฑ ์ถ์ถ๊ธฐ(feature extractor)๋ ์ค๋์ค ์
๋ ฅ์ ์ฒ๋ฆฌํฉ๋๋ค. ๊ธฐ๋ณธ [`~feature_extraction_utils.FeatureExtractionMixin`] ํด๋์ค์์ ์์๋๋ฉฐ, ์ค๋์ค ์
๋ ฅ์ ์ฒ๋ฆฌํ๊ธฐ ์ํด [`SequenceFeatureExtractor`] ํด๋์ค์์ ์์ํ ์๋ ์์ต๋๋ค.
์ฌ์ฉํ๋ ค๋ฉด ์ฌ์ฉ ์ค์ธ ๋ชจ๋ธ๊ณผ ์ฐ๊ฒฐ๋ ํน์ฑ ์ถ์ถ๊ธฐ๋ฅผ ์์ฑํฉ๋๋ค. ์๋ฅผ ๋ค์ด, ์ค๋์ค ๋ถ๋ฅ์ [Wav2Vec2](model_doc/wav2vec2)๋ฅผ ์ฌ์ฉํ๋ ๊ฒฝ์ฐ ๊ธฐ๋ณธ [`Wav2Vec2FeatureExtractor`]๋ฅผ ์์ฑํฉ๋๋ค:
```py
>>> from transformers import Wav2Vec2FeatureExtractor
>>> w2v2_extractor = Wav2Vec2FeatureExtractor()
>>> print(w2v2_extractor)
Wav2Vec2FeatureExtractor {
"do_normalize": true,
"feature_extractor_type": "Wav2Vec2FeatureExtractor",
"feature_size": 1,
"padding_side": "right",
"padding_value": 0.0,
"return_attention_mask": false,
"sampling_rate": 16000
}
```
<Tip>
์ฌ์ฉ์ ์ง์ ์ด ํ์ํ์ง ์์ ๊ฒฝ์ฐ `from_pretrained` ๋ฉ์๋๋ฅผ ์ฌ์ฉํ์ฌ ๋ชจ๋ธ์ ๊ธฐ๋ณธ ํน์ฑ ์ถ์ถ๊ธฐ ใ
๊ฐ๋ณ์๋ฅผ ๋ถ๋ฌ ์ค๋ฉด ๋ฉ๋๋ค.
</Tip>
์ฌ์ฉ์ ์ง์ ํน์ฑ ์ถ์ถ๊ธฐ๋ฅผ ๋ง๋ค๋ ค๋ฉด [`Wav2Vec2FeatureExtractor`] ๋งค๊ฐ๋ณ์๋ฅผ ์์ ํฉ๋๋ค:
```py
>>> from transformers import Wav2Vec2FeatureExtractor
>>> w2v2_extractor = Wav2Vec2FeatureExtractor(sampling_rate=8000, do_normalize=False)
>>> print(w2v2_extractor)
Wav2Vec2FeatureExtractor {
"do_normalize": false,
"feature_extractor_type": "Wav2Vec2FeatureExtractor",
"feature_size": 1,
"padding_side": "right",
"padding_value": 0.0,
"return_attention_mask": false,
"sampling_rate": 8000
}
```
## ํ๋ก์ธ์[[processor]]
๋ฉํฐ๋ชจ๋ฌ ์์
์ ์ง์ํ๋ ๋ชจ๋ธ์ ๊ฒฝ์ฐ, ๐ค Transformers๋ ํน์ฑ ์ถ์ถ๊ธฐ ๋ฐ ํ ํฌ๋์ด์ ์ ๊ฐ์ ์ฒ๋ฆฌ ํด๋์ค๋ฅผ ๋จ์ผ ๊ฐ์ฒด๋ก ํธ๋ฆฌํ๊ฒ ๋ํํ๋ ํ๋ก์ธ์ ํด๋์ค๋ฅผ ์ ๊ณตํฉ๋๋ค. ์๋ฅผ ๋ค์ด, ์๋ ์์ฑ ์ธ์ ์์
(Automatic Speech Recognition task (ASR))์ [`Wav2Vec2Processor`]๋ฅผ ์ฌ์ฉํ๋ค๊ณ ๊ฐ์ ํด ๋ณด๊ฒ ์ต๋๋ค. ์๋ ์์ฑ ์ธ์ ์์
์ ์ค๋์ค๋ฅผ ํ
์คํธ๋ก ๋ณํํ๋ฏ๋ก ํน์ฑ ์ถ์ถ๊ธฐ์ ํ ํฌ๋์ด์ ๊ฐ ํ์ํฉ๋๋ค.
์ค๋์ค ์
๋ ฅ์ ์ฒ๋ฆฌํ ํน์ฑ ์ถ์ถ๊ธฐ๋ฅผ ๋ง๋ญ๋๋ค:
```py
>>> from transformers import Wav2Vec2FeatureExtractor
>>> feature_extractor = Wav2Vec2FeatureExtractor(padding_value=1.0, do_normalize=True)
```
ํ
์คํธ ์
๋ ฅ์ ์ฒ๋ฆฌํ ํ ํฌ๋์ด์ ๋ฅผ ๋ง๋ญ๋๋ค:
```py
>>> from transformers import Wav2Vec2CTCTokenizer
>>> tokenizer = Wav2Vec2CTCTokenizer(vocab_file="my_vocab_file.txt")
```
[`Wav2Vec2Processor`]์์ ํน์ฑ ์ถ์ถ๊ธฐ์ ํ ํฌ๋์ด์ ๋ฅผ ๊ฒฐํฉํฉ๋๋ค:
```py
>>> from transformers import Wav2Vec2Processor
>>> processor = Wav2Vec2Processor(feature_extractor=feature_extractor, tokenizer=tokenizer)
```
configuration๊ณผ ๋ชจ๋ธ์ด๋ผ๋ ๋ ๊ฐ์ง ๊ธฐ๋ณธ ํด๋์ค์ ์ถ๊ฐ ์ ์ฒ๋ฆฌ ํด๋์ค(ํ ํฌ๋์ด์ , ์ด๋ฏธ์ง ํ๋ก์ธ์, ํน์ฑ ์ถ์ถ๊ธฐ ๋๋ ํ๋ก์ธ์)๋ฅผ ์ฌ์ฉํ๋ฉด ๐ค Transformers์์ ์ง์ํ๋ ๋ชจ๋ ๋ชจ๋ธ์ ๋ง๋ค ์ ์์ต๋๋ค. ์ด๋ฌํ ๊ฐ ๊ธฐ๋ณธ ํด๋์ค๋ ๊ตฌ์ฑ์ด ๊ฐ๋ฅํ๋ฏ๋ก ์ํ๋ ํน์ ์์ฑ์ ์ฌ์ฉํ ์ ์์ต๋๋ค. ํ์ต์ ์ํด ๋ชจ๋ธ์ ์ฝ๊ฒ ์ค์ ํ๊ฑฐ๋ ๊ธฐ์กด์ ์ฌ์ ํ์ต๋ ๋ชจ๋ธ์ ์์ ํ์ฌ ๋ฏธ์ธ ์กฐ์ ํ ์ ์์ต๋๋ค.
| 0 |
mavonic_private_repos/transformers/docs/source | mavonic_private_repos/transformers/docs/source/ko/pipeline_webserver.md | <!--โ ๏ธ Note that this file is in Markdown but contain specific syntax for our doc-builder (similar to MDX) that may not be
rendered properly in your Markdown viewer.
-->
# ์น ์๋ฒ๋ฅผ ์ํ ํ์ดํ๋ผ์ธ ์ฌ์ฉํ๊ธฐ[[using_pipelines_for_a_webserver]]
<Tip>
์ถ๋ก ์์ง์ ๋ง๋๋ ๊ฒ์ ๋ณต์กํ ์ฃผ์ ์ด๋ฉฐ, "์ต์ ์" ์๋ฃจ์
์ ๋ฌธ์ ๊ณต๊ฐ์ ๋ฐ๋ผ ๋ฌ๋ผ์ง ๊ฐ๋ฅ์ฑ์ด ๋์ต๋๋ค. CPU ๋๋ GPU๋ฅผ ์ฌ์ฉํ๋์ง์ ๋ฐ๋ผ ๋ค๋ฅด๊ณ ๋ฎ์ ์ง์ฐ ์๊ฐ์ ์ํ๋์ง, ๋์ ์ฒ๋ฆฌ๋์ ์ํ๋์ง, ๋ค์ํ ๋ชจ๋ธ์ ์ง์ํ ์ ์๊ธธ ์ํ๋์ง, ํ๋์ ํน์ ๋ชจ๋ธ์ ๊ณ ๋๋ก ์ต์ ํํ๊ธธ ์ํ๋์ง ๋ฑ์ ๋ฐ๋ผ ๋ฌ๋ผ์ง๋๋ค. ์ด ์ฃผ์ ๋ฅผ ํด๊ฒฐํ๋ ๋ฐฉ๋ฒ์๋ ์ฌ๋ฌ ๊ฐ์ง๊ฐ ์์ผ๋ฏ๋ก, ์ด ์ฅ์์ ์ ์ํ๋ ๊ฒ์ ์ฒ์ ์๋ํด ๋ณด๊ธฐ์ ์ข์ ์ถ๋ฐ์ ์ผ ์๋ ์์ง๋ง, ์ด ์ฅ์ ์ฝ๋ ์ฌ๋ฌ๋ถ์ด ํ์๋ก ํ๋ ์ต์ ์ ์๋ฃจ์
์ ์๋ ์ ์์ต๋๋ค.
</Tip>
ํต์ฌ์ ์ผ๋ก ์ดํดํด์ผ ํ ์ ์ [dataset](pipeline_tutorial#using-pipelines-on-a-dataset)๋ฅผ ๋ค๋ฃฐ ๋์ ๋ง์ฐฌ๊ฐ์ง๋ก ๋ฐ๋ณต์๋ฅผ ์ฌ์ฉ ๊ฐ๋ฅํ๋ค๋ ๊ฒ์
๋๋ค. ์๋ํ๋ฉด, ์น ์๋ฒ๋ ๊ธฐ๋ณธ์ ์ผ๋ก ์์ฒญ์ ๊ธฐ๋ค๋ฆฌ๊ณ ๋ค์ด์ค๋ ๋๋ก ์ฒ๋ฆฌํ๋ ์์คํ
์ด๊ธฐ ๋๋ฌธ์
๋๋ค.
๋ณดํต ์น ์๋ฒ๋ ๋ค์ํ ์์ฒญ์ ๋์์ ๋ค๋ฃจ๊ธฐ ์ํด ๋งค์ฐ ๋ค์คํ๋ ๊ตฌ์กฐ(๋ฉํฐ ์ค๋ ๋ฉ, ๋น๋๊ธฐ ๋ฑ)๋ฅผ ์ง๋๊ณ ์์ต๋๋ค. ๋ฐ๋ฉด์, ํ์ดํ๋ผ์ธ(๋๋ถ๋ถ ํ์ดํ๋ผ์ธ ์์ ์๋ ๋ชจ๋ธ)์ ๋ณ๋ ฌ์ฒ๋ฆฌ์ ๊ทธ๋ค์ง ์ข์ง ์์ต๋๋ค. ์๋ํ๋ฉด ํ์ดํ๋ผ์ธ์ ๋ง์ RAM์ ์ฐจ์งํ๊ธฐ ๋๋ฌธ์
๋๋ค. ๋ฐ๋ผ์, ํ์ดํ๋ผ์ธ์ด ์คํ ์ค์ด๊ฑฐ๋ ๊ณ์ฐ ์ง์ฝ์ ์ธ ์์
์ค์ผ ๋ ๋ชจ๋ ์ฌ์ฉ ๊ฐ๋ฅํ ๋ฆฌ์์ค๋ฅผ ์ ๊ณตํ๋ ๊ฒ์ด ๊ฐ์ฅ ์ข์ต๋๋ค.
์ด ๋ฌธ์ ๋ฅผ ์ฐ๋ฆฌ๋ ์น ์๋ฒ๊ฐ ์์ฒญ์ ๋ฐ๊ณ ๋ณด๋ด๋ ๊ฐ๋ฒผ์ด ๋ถํ๋ฅผ ์ฒ๋ฆฌํ๊ณ , ์ค์ ์์
์ ์ฒ๋ฆฌํ๋ ๋จ์ผ ์ค๋ ๋๋ฅผ ๊ฐ๋ ๋ฐฉ๋ฒ์ผ๋ก ํด๊ฒฐํ ๊ฒ์
๋๋ค. ์ด ์์ ๋ `starlette` ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ฅผ ์ฌ์ฉํฉ๋๋ค.
์ค์ ํ๋ ์์ํฌ๋ ์ค์ํ์ง ์์ง๋ง, ๋ค๋ฅธ ํ๋ ์์ํฌ๋ฅผ ์ฌ์ฉํ๋ ๊ฒฝ์ฐ ๋์ผํ ํจ๊ณผ๋ฅผ ๋ณด๊ธฐ ์ํด์ ์ฝ๋๋ฅผ ์กฐ์ ํ๊ฑฐ๋ ๋ณ๊ฒฝํด์ผ ํ ์ ์์ต๋๋ค.
`server.py`๋ฅผ ์์ฑํ์ธ์:
```py
from starlette.applications import Starlette
from starlette.responses import JSONResponse
from starlette.routing import Route
from transformers import pipeline
import asyncio
async def homepage(request):
payload = await request.body()
string = payload.decode("utf-8")
response_q = asyncio.Queue()
await request.app.model_queue.put((string, response_q))
output = await response_q.get()
return JSONResponse(output)
async def server_loop(q):
pipe = pipeline(model="google-bert/bert-base-uncased")
while True:
(string, response_q) = await q.get()
out = pipe(string)
await response_q.put(out)
app = Starlette(
routes=[
Route("/", homepage, methods=["POST"]),
],
)
@app.on_event("startup")
async def startup_event():
q = asyncio.Queue()
app.model_queue = q
asyncio.create_task(server_loop(q))
```
์ด์ ๋ค์ ๋ช
๋ น์ด๋ก ์คํ์ํฌ ์ ์์ต๋๋ค:
```bash
uvicorn server:app
```
์ด์ ์ฟผ๋ฆฌ๋ฅผ ๋ ๋ ค๋ณผ ์ ์์ต๋๋ค:
```bash
curl -X POST -d "test [MASK]" http://localhost:8000/
#[{"score":0.7742936015129089,"token":1012,"token_str":".","sequence":"test."},...]
```
์, ์ด์ ์น ์๋ฒ๋ฅผ ๋ง๋๋ ๋ฐฉ๋ฒ์ ๋ํ ์ข์ ๊ฐ๋
์ ์๊ฒ ๋์์ต๋๋ค!
์ค์ํ ์ ์ ๋ชจ๋ธ์ **ํ ๋ฒ๋ง** ๊ฐ์ ธ์จ๋ค๋ ๊ฒ์
๋๋ค. ๋ฐ๋ผ์ ์น ์๋ฒ์๋ ๋ชจ๋ธ์ ์ฌ๋ณธ์ด ์์ต๋๋ค. ์ด๋ฐ ๋ฐฉ์์ ๋ถํ์ํ RAM์ด ์ฌ์ฉ๋์ง ์์ต๋๋ค. ๊ทธ๋ฐ ๋ค์ ํ ๋ฉ์ปค๋์ฆ์ ์ฌ์ฉํ๋ฉด, ๋ค์๊ณผ ๊ฐ์
๋์ ๋ฐฐ์น๋ฅผ ์ฌ์ฉํ๊ธฐ ์ํด ์ถ๋ก ์ ๋จ๊ณ์ ๋ช ๊ฐ์ ํญ๋ชฉ์ ์ถ์ ํ๋ ๊ฒ๊ณผ ๊ฐ์ ๋ฉ์ง ์์
์ ํ ์ ์์ต๋๋ค:
<Tip warning={true}>
์ฝ๋๋ ์๋์ ์ผ๋ก ๊ฐ๋
์ฑ์ ์ํด ์์ฌ ์ฝ๋์ฒ๋ผ ์์ฑ๋์์ต๋๋ค!
์๋ ์ฝ๋๋ฅผ ์๋์ํค๊ธฐ ์ ์ ์์คํ
์์์ด ์ถฉ๋ถํ์ง ํ์ธํ์ธ์!
</Tip>
```py
(string, rq) = await q.get()
strings = []
queues = []
while True:
try:
(string, rq) = await asyncio.wait_for(q.get(), timeout=0.001) # 1ms
except asyncio.exceptions.TimeoutError:
break
strings.append(string)
queues.append(rq)
strings
outs = pipe(strings, batch_size=len(strings))
for rq, out in zip(queues, outs):
await rq.put(out)
```
๋ค์ ๋ง์ ๋๋ฆฌ์๋ฉด, ์ ์๋ ์ฝ๋๋ ๊ฐ๋
์ฑ์ ์ํด ์ต์ ํ๋์์ผ๋ฉฐ, ์ต์์ ์ฝ๋๋ ์๋๋๋ค.
์ฒซ์งธ, ๋ฐฐ์น ํฌ๊ธฐ ์ ํ์ด ์์ผ๋ฉฐ ์ด๋ ์ผ๋ฐ์ ์ผ๋ก ์ข์ ๋ฐฉ์์ด ์๋๋๋ค.
๋์งธ, ๋ชจ๋ ํ ๊ฐ์ ธ์ค๊ธฐ์์ ํ์์์์ด ์ฌ์ค์ ๋๋ฏ๋ก ์ถ๋ก ์ ์คํํ๊ธฐ ์ ์ 1ms๋ณด๋ค ํจ์ฌ ์ค๋ ๊ธฐ๋ค๋ฆด ์ ์์ต๋๋ค(์ฒซ ๋ฒ์งธ ์์ฒญ์ ๊ทธ๋งํผ ์ง์ฐ์ํด).
๋จ์ผ 1ms ๊ธธ์ด์ ๋ฐ๋๋ผ์ธ์ ๋๋ ํธ์ด ๋ ์ข์ต๋๋ค.
์ด ๋ฐฉ์์ ์ฌ์ฉํ๋ฉด ํ๊ฐ ๋น์ด ์์ด๋ ํญ์ 1ms๋ฅผ ๊ธฐ๋ค๋ฆฌ๊ฒ ๋ ๊ฒ์
๋๋ค.
ํ์ ์๋ฌด๊ฒ๋ ์์ ๋ ์ถ๋ก ์ ์ํ๋ ๊ฒฝ์ฐ์๋ ์ต์ ์ ๋ฐฉ๋ฒ์ด ์๋ ์ ์์ต๋๋ค.
ํ์ง๋ง ๋ฐฐ์น ์์
์ด ์ฌ์ฉ๋ก์ ๋ฐ๋ผ ์ ๋ง๋ก ์ค์ํ๋ค๋ฉด ์๋ฏธ๊ฐ ์์ ์๋ ์์ต๋๋ค.
๋ค์ ๋งํ์ง๋ง, ์ต์์ ์๋ฃจ์
์ ์์ต๋๋ค.
## ๊ณ ๋ คํด์ผ ํ ๋ช ๊ฐ์ง ์ฌํญ[[few_things_you_might want_to_consider]]
### ์๋ฌ ํ์ธ[[error_checking]]
ํ๋ก๋์
ํ๊ฒฝ์์๋ ๋ฌธ์ ๊ฐ ๋ฐ์ํ ์ฌ์ง๊ฐ ๋ง์ต๋๋ค.
๋ฉ๋ชจ๋ฆฌ๊ฐ ๋ชจ์๋ผ๊ฑฐ๋, ๊ณต๊ฐ์ด ๋ถ์กฑํ๊ฑฐ๋, ๋ชจ๋ธ์ ๊ฐ์ ธ์ค๋ ๋ฐ์ ์คํจํ๊ฑฐ๋, ์ฟผ๋ฆฌ๊ฐ ์๋ชป๋์๊ฑฐ๋, ์ฟผ๋ฆฌ๋ ์ ํํด๋ ๋ชจ๋ธ ์ค์ ์ด ์๋ชป๋์ด ์คํ์ ์คํจํ๋ ๋ฑ๋ฑ ๋ง์ ๊ฒฝ์ฐ๊ฐ ์กด์ฌํฉ๋๋ค.
์ผ๋ฐ์ ์ผ๋ก ์๋ฒ๊ฐ ์ฌ์ฉ์์๊ฒ ์ค๋ฅ๋ฅผ ์ถ๋ ฅํ๋ ๊ฒ์ด ์ข์ผ๋ฏ๋ก
์ค๋ฅ๋ฅผ ํ์ํ๊ธฐ ์ํด `try...except` ๋ฌธ์ ๋ง์ด ์ถ๊ฐํ๋ ๊ฒ์ด ์ข์ต๋๋ค.
ํ์ง๋ง ๋ณด์ ์ํฉ์ ๋ฐ๋ผ ๋ชจ๋ ์ค๋ฅ๋ฅผ ํ์ํ๋ ๊ฒ์ ๋ณด์์ ์ํํ ์๋ ์๋ค๋ ์ ์ ๋ช
์ฌํด์ผํฉ๋๋ค.
### ์ํท ๋ธ๋ ์ดํน[[circuit_breaking]]
์น ์๋ฒ๋ ์ผ๋ฐ์ ์ผ๋ก ์ํท ๋ธ๋ ์ดํน์ ์ํํ ๋ ๋ ๋์ ์ํฉ์ ์ง๋ฉดํฉ๋๋ค.
์ฆ, ์ด๋ ์๋ฒ๊ฐ ์ฟผ๋ฆฌ๋ฅผ ๋ฌด๊ธฐํ ๊ธฐ๋ค๋ฆฌ๋ ๋์ ๊ณผ๋ถํ ์ํ์ผ ๋ ์ ์ ํ ์ค๋ฅ๋ฅผ ๋ฐํํ๋ ๊ฒ์ ์๋ฏธํฉ๋๋ค.
์๋ฒ๊ฐ ๋งค์ฐ ์ค๋ ์๊ฐ ๋์ ๋๊ธฐํ๊ฑฐ๋ ์ ๋นํ ์๊ฐ์ด ์ง๋ ํ์ 504 ์๋ฌ๋ฅผ ๋ฐํํ๋ ๋์ 503 ์๋ฌ๋ฅผ ๋น ๋ฅด๊ฒ ๋ฐํํ๊ฒ ํ๋ ๊ฒ์
๋๋ค.
์ ์๋ ์ฝ๋์๋ ๋จ์ผ ํ๊ฐ ์์ผ๋ฏ๋ก ๊ตฌํํ๊ธฐ๊ฐ ๋น๊ต์ ์ฝ์ต๋๋ค.
ํ ํฌ๊ธฐ๋ฅผ ํ์ธํ๋ ๊ฒ์ ์น ์๋ฒ๊ฐ ๊ณผ๋ถํ ์ํญ ํ์ ์์ ๋ ์๋ฌ๋ฅผ ๋ฐํํ๊ธฐ ์ํ ๊ฐ์ฅ ๊ธฐ์ด์ ์ธ ์์
์
๋๋ค.
### ๋ฉ์ธ ์ฐ๋ ๋ ์ฐจ๋จ[[blocking_the_main_thread]]
ํ์ฌ PyTorch๋ ๋น๋๊ธฐ ์ฒ๋ฆฌ๋ฅผ ์ง์ํ์ง ์์ผ๋ฉฐ, ์คํ ์ค์๋ ๋ฉ์ธ ์ค๋ ๋๊ฐ ์ฐจ๋จ๋ฉ๋๋ค.
๋ฐ๋ผ์ PyTorch๋ฅผ ๋ณ๋์ ์ค๋ ๋/ํ๋ก์ธ์ค์์ ์คํํ๋๋ก ๊ฐ์ ํ๋ ๊ฒ์ด ์ข์ต๋๋ค.
์ฌ๊ธฐ์๋ ์ด ์์
์ด ์ํ๋์ง ์์์ต๋๋ค. ์๋ํ๋ฉด ์ฝ๋๊ฐ ํจ์ฌ ๋ ๋ณต์กํ๊ธฐ ๋๋ฌธ์
๋๋ค(์ฃผ๋ก ์ค๋ ๋, ๋น๋๊ธฐ ์ฒ๋ฆฌ, ํ๊ฐ ์๋ก ์ ๋ง์ง ์๊ธฐ ๋๋ฌธ์
๋๋ค).
ํ์ง๋ง ๊ถ๊ทน์ ์ผ๋ก๋ ๊ฐ์ ์์
์ ์ํํ๋ ๊ฒ์
๋๋ค.
๋จ์ผ ํญ๋ชฉ์ ์ถ๋ก ์ด ์ค๋ ๊ฑธ๋ฆฐ๋ค๋ฉด (> 1์ด), ๋ฉ์ธ ์ฐ๋ ๋๋ฅผ ์ฐจ๋จํ๋ ๊ฒ์ ์ค์ํ ์ ์์ต๋๋ค. ์๋ํ๋ฉด ์ด ๊ฒฝ์ฐ ์ถ๋ก ์ค ๋ชจ๋ ์ฟผ๋ฆฌ๋ ์ค๋ฅ๋ฅผ ๋ฐ๊ธฐ ์ ์ 1์ด๋ฅผ ๊ธฐ๋ค๋ ค์ผ ํ๊ธฐ ๋๋ฌธ์
๋๋ค.
### ๋์ ๋ฐฐ์น[[dynamic_batching]]
์ผ๋ฐ์ ์ผ๋ก, ๋ฐฐ์น ์ฒ๋ฆฌ๊ฐ 1๊ฐ ํญ๋ชฉ์ ํ ๋ฒ์ ์ ๋ฌํ๋ ๊ฒ์ ๋นํด ๋ฐ๋์ ์ฑ๋ฅ ํฅ์์ด ์๋ ๊ฒ์ ์๋๋๋ค(์์ธํ ๋ด์ฉ์ [`batching details`](./main_classes/pipelines#pipeline-batching)์ ์ฐธ๊ณ ํ์ธ์).
ํ์ง๋ง ์ฌ๋ฐ๋ฅธ ์ค์ ์์ ์ฌ์ฉํ๋ฉด ๋งค์ฐ ํจ๊ณผ์ ์ผ ์ ์์ต๋๋ค.
API์๋ ๊ธฐ๋ณธ์ ์ผ๋ก ์๋ ์ ํ์ ๊ฐ๋ฅ์ฑ์ด ๋งค์ฐ ๋๊ธฐ ๋๋ฌธ์ ๋์ ๋ฐฐ์น ์ฒ๋ฆฌ๊ฐ ์์ต๋๋ค.
ํ์ง๋ง ๋งค์ฐ ํฐ ๋ชจ๋ธ์ธ BLOOM ์ถ๋ก ์ ๊ฒฝ์ฐ ๋์ ๋ฐฐ์น ์ฒ๋ฆฌ๋ ๋ชจ๋ ์ฌ๋์๊ฒ ์ ์ ํ ๊ฒฝํ์ ์ ๊ณตํ๋ ๋ฐ **ํ์**์
๋๋ค.
| 0 |
mavonic_private_repos/transformers/docs/source | mavonic_private_repos/transformers/docs/source/ko/community.md | <!--โ ๏ธ Note that this file is in Markdown but contain specific syntax for our doc-builder (similar to MDX) that may not be
rendered properly in your Markdown viewer.
-->
# ์ปค๋ฎค๋ํฐ [[community]]
์ด ํ์ด์ง๋ ์ปค๋ฎค๋ํฐ์์ ๊ฐ๋ฐํ ๐ค Transformers ๋ฆฌ์์ค๋ฅผ ์ฌ๊ตฌ์ฑํ ํ์ด์ง์
๋๋ค.
## ์ปค๋ฎค๋ํฐ ๋ฆฌ์์ค: [[community-resources]]
| ๋ฆฌ์์ค | ์ค๋ช
| ๋ง๋ ์ด |
|:----------|:-------------|------:|
| [Hugging Face Transformers ์ฉ์ด์ง ํ๋์์นด๋](https://www.darigovresearch.com/huggingface-transformers-glossary-flashcards) | [Transformers ๋ฌธ์ ์ฉ์ด์ง](glossary)์ ๊ธฐ๋ฐ์ผ๋ก ํ ํ๋์์นด๋ ์ธํธ๋ก, ์ง์์ ์ฅ๊ธฐ์ ์ผ๋ก ์ ์งํ๊ธฐ ์ํด ํน๋ณํ ์ค๊ณ๋ ์คํ์์ค ํฌ๋ก์ค ํ๋ซํผ ์ฑ์ธ [Anki](https://apps.ankiweb.net/)๋ฅผ ์ฌ์ฉํ์ฌ ์ฝ๊ฒ ํ์ต/์์ ํ ์ ์๋ ํํ๋ก ์ ์๋์์ต๋๋ค. [ํ๋์์นด๋ ์ฌ์ฉ๋ฒ์ ๋ํ ์๊ฐ ๋์์](https://www.youtube.com/watch?v=Dji_h7PILrw)์ ์ฐธ์กฐํ์ธ์. | [Darigov ๋ฆฌ์์น](https://www.darigovresearch.com/) |
## ์ปค๋ฎค๋ํฐ ๋
ธํธ๋ถ: [[community-notebooks]]
| ๋
ธํธ๋ถ | ์ค๋ช
| ๋ง๋ ์ด | |
|:----------|:-------------|:-------------|------:|
| [๊ฐ์ฌ๋ฅผ ์์ฑํ๊ธฐ ์ํด ์ฌ์ ํ๋ จ๋ ํธ๋์คํฌ๋จธ๋ฅผ ๋ฏธ์ธ ์กฐ์ ํ๊ธฐ](https://github.com/AlekseyKorshuk/huggingartists) | GPT-2 ๋ชจ๋ธ์ ๋ฏธ์ธ ์กฐ์ ํ์ฌ ์ข์ํ๋ ์ํฐ์คํธ์ ์คํ์ผ๋ก ๊ฐ์ฌ๋ฅผ ์์ฑํ๋ ๋ฐฉ๋ฒ | [Aleksey Korshuk](https://github.com/AlekseyKorshuk) | [](https://colab.research.google.com/github/AlekseyKorshuk/huggingartists/blob/master/huggingartists-demo.ipynb) |
| [Tensorflow 2๋ก T5 ํ๋ จํ๊ธฐ](https://github.com/snapthat/TF-T5-text-to-text) | Tensorflow 2๋ฅผ ์ฌ์ฉํ์ฌ T5๋ฅผ ํ๋ จ์ํค๋ ๋ฐฉ๋ฒ. ์ด ๋
ธํธ๋ถ์ Tensorflow 2๋ก SQUAD๋ฅผ ์ฌ์ฉํ์ฌ ๊ตฌํํ ์ง์์๋ต ์์
์ ๋ณด์ฌ์ค๋๋ค. | [Muhammad Harris](https://github.com/HarrisDePerceptron) |[](https://colab.research.google.com/github/snapthat/TF-T5-text-to-text/blob/master/snapthatT5/notebooks/TF-T5-Datasets%20Training.ipynb) |
| [TPU์์ T5 ํ๋ จํ๊ธฐ](https://github.com/patil-suraj/exploring-T5/blob/master/T5_on_TPU.ipynb) | Transformers์ Nlp๋ฅผ ์ฌ์ฉํ์ฌ SQUAD๋ก T5๋ฅผ ํ๋ จํ๋ ๋ฐฉ๋ฒ | [Suraj Patil](https://github.com/patil-suraj) |[](https://colab.research.google.com/github/patil-suraj/exploring-T5/blob/master/T5_on_TPU.ipynb#scrollTo=QLGiFCDqvuil) |
| [๋ถ๋ฅ ๋ฐ ๊ฐ๊ด์ ๋ฌธ์ ๋ฅผ ์ํด T5 ๋ฏธ์ธ ์กฐ์ ํ๊ธฐ](https://github.com/patil-suraj/exploring-T5/blob/master/t5_fine_tuning.ipynb) | ๋ถ๋ฅ ๋ฐ ๊ฐ๊ด์ ๋ฌธ์ ์ ๋ง๊ฒ ํ
์คํธ-ํ
์คํธ ํ์์ ์ฌ์ฉํ์ฌ PyTorch Lightning์ผ๋ก T5๋ฅผ ๋ฏธ์ธ ์กฐ์ ํ๋ ๋ฐฉ๋ฒ | [Suraj Patil](https://github.com/patil-suraj) | [](https://colab.research.google.com/github/patil-suraj/exploring-T5/blob/master/t5_fine_tuning.ipynb) |
| [์๋ก์ด ๋ฐ์ดํฐ ์ธํธ์ ์ธ์ด๋ก DialoGPT ๋ฏธ์ธ ์กฐ์ ํ๊ธฐ](https://github.com/ncoop57/i-am-a-nerd/blob/master/_notebooks/2020-05-12-chatbot-part-1.ipynb) | ์์ ๋ํํ ์ฑ๋ด์ ๋ง๋ค๊ธฐ ์ํด ์๋ก์ด ๋ฐ์ดํฐ ์ธํธ๋ก DialoGPT ๋ชจ๋ธ์ ๋ฏธ์ธ ์กฐ์ ํ๋ ๋ฐฉ๋ฒ | [Nathan Cooper](https://github.com/ncoop57) | [](https://colab.research.google.com/github/ncoop57/i-am-a-nerd/blob/master/_notebooks/2020-05-12-chatbot-part-1.ipynb) |
| [Reformer๋ก ๊ธด ์ํ์ค ๋ชจ๋ธ๋งํ๊ธฐ](https://github.com/patrickvonplaten/notebooks/blob/master/PyTorch_Reformer.ipynb) | Reformer๋ก ์ต๋ 50๋ง ํ ํฐ์ ์ํ์ค๋ฅผ ํ๋ จํ๋ ๋ฐฉ๋ฒ | [Patrick von Platen](https://github.com/patrickvonplaten) | [](https://colab.research.google.com/github/patrickvonplaten/notebooks/blob/master/PyTorch_Reformer.ipynb) |
| [์์ฝ์ ์ํด BART ๋ฏธ์ธ ์กฐ์ ํ๊ธฐ](https://github.com/ohmeow/ohmeow_website/blob/master/posts/2021-05-25-mbart-sequence-classification-with-blurr.ipynb) | blurr๋ฅผ ์ฌ์ฉํ์ฌ fastai๋ก ์์ฝํ๊ธฐ ์ํด BART๋ฅผ ๋ฏธ์ธ ์กฐ์ ํ๋ ๋ฐฉ๋ฒ | [Wayde Gilliam](https://ohmeow.com/) | [](https://colab.research.google.com/github/ohmeow/ohmeow_website/blob/master/posts/2021-05-25-mbart-sequence-classification-with-blurr.ipynb) |
| [๋ค๋ฅธ ์ฌ๋์ ํธ์์ผ๋ก ์ฌ์ ํ๋ จ๋ ํธ๋์คํฌ๋จธ ๋ฏธ์ธ ์กฐ์ ํ๊ธฐ](https://colab.research.google.com/github/borisdayma/huggingtweets/blob/master/huggingtweets-demo.ipynb) | GPT-2 ๋ชจ๋ธ์ ๋ฏธ์ธ ์กฐ์ ํ์ฌ ์ข์ํ๋ ํธ์ํฐ ๊ณ์ ์คํ์ผ๋ก ํธ์์ ์์ฑํ๋ ๋ฐฉ๋ฒ | [Boris Dayma](https://github.com/borisdayma) | [](https://colab.research.google.com/github/borisdayma/huggingtweets/blob/master/huggingtweets-demo.ipynb) |
| [Weights & Biases๋ก ๐ค Hugging Face ๋ชจ๋ธ ์ต์ ํํ๊ธฐ](https://colab.research.google.com/github/wandb/examples/blob/master/colabs/huggingface/Optimize_Hugging_Face_models_with_Weights_%26_Biases.ipynb) | W&B์ Hugging Face์ ํตํฉ์ ๋ณด์ฌ์ฃผ๋ ์ ์ฒด ํํ ๋ฆฌ์ผ | [Boris Dayma](https://github.com/borisdayma) | [](https://colab.research.google.com/github/wandb/examples/blob/master/colabs/huggingface/Optimize_Hugging_Face_models_with_Weights_%26_Biases.ipynb) |
| [Longformer ์ฌ์ ํ๋ จํ๊ธฐ](https://github.com/allenai/longformer/blob/master/scripts/convert_model_to_long.ipynb) | ๊ธฐ์กด ์ฌ์ ํ๋ จ๋ ๋ชจ๋ธ์ "๊ธด" ๋ฒ์ ์ ๋น๋ํ๋ ๋ฐฉ๋ฒ | [Iz Beltagy](https://beltagy.net) | [](https://colab.research.google.com/github/allenai/longformer/blob/master/scripts/convert_model_to_long.ipynb) |
| [QA๋ฅผ ์ํด Longformer ๋ฏธ์ธ ์กฐ์ ํ๊ธฐ](https://github.com/patil-suraj/Notebooks/blob/master/longformer_qa_training.ipynb) | QA ์์
์ ์ํด Longformer๋ฅผ ๋ฏธ์ธ ์กฐ์ ํ๋ ๋ฐฉ๋ฒ | [Suraj Patil](https://github.com/patil-suraj) | [](https://colab.research.google.com/github/patil-suraj/Notebooks/blob/master/longformer_qa_training.ipynb) |
| [๐ค Nlp๋ก ๋ชจ๋ธ ํ๊ฐํ๊ธฐ](https://github.com/patrickvonplaten/notebooks/blob/master/How_to_evaluate_Longformer_on_TriviaQA_using_NLP.ipynb) | `Nlp`๋ก TriviaQA์์ Longformer๋ฅผ ํ๊ฐํ๋ ๋ฐฉ๋ฒ | [Patrick von Platen](https://github.com/patrickvonplaten) | [](https://colab.research.google.com/drive/1m7eTGlPmLRgoPkkA7rkhQdZ9ydpmsdLE?usp=sharing) |
| [๊ฐ์ ๋ฒ์ ์ถ์ถ์ ์ํด T5 ๋ฏธ์ธ ์กฐ์ ํ๊ธฐ](https://github.com/enzoampil/t5-intro/blob/master/t5_qa_training_pytorch_span_extraction.ipynb) | ๊ฐ์ ๋ฒ์ ์ถ์ถ์ ์ํด ํ
์คํธ-ํ
์คํธ ํ์์ ์ฌ์ฉํ์ฌ PyTorch Lightning์ผ๋ก T5๋ฅผ ๋ฏธ์ธ ์กฐ์ ํ๋ ๋ฐฉ๋ฒ | [Lorenzo Ampil](https://github.com/enzoampil) | [](https://colab.research.google.com/github/enzoampil/t5-intro/blob/master/t5_qa_training_pytorch_span_extraction.ipynb) |
| [๋ค์ค ํด๋์ค ๋ถ๋ฅ๋ฅผ ์ํด DistilBert ๋ฏธ์ธ ์กฐ์ ํ๊ธฐ](https://github.com/abhimishra91/transformers-tutorials/blob/master/transformers_multiclass_classification.ipynb) | ๋ค์ค ํด๋์ค ๋ถ๋ฅ๋ฅผ ์ํด PyTorch๋ฅผ ์ฌ์ฉํ์ฌ DistilBert๋ฅผ ๋ฏธ์ธ ์กฐ์ ํ๋ ๋ฐฉ๋ฒ | [Abhishek Kumar Mishra](https://github.com/abhimishra91) | [](https://colab.research.google.com/github/abhimishra91/transformers-tutorials/blob/master/transformers_multiclass_classification.ipynb)|
| [๋ค์ค ๋ ์ด๋ธ ๋ถ๋ฅ๋ฅผ ์ํด BERT ๋ฏธ์ธ ์กฐ์ ํ๊ธฐ](https://github.com/abhimishra91/transformers-tutorials/blob/master/transformers_multi_label_classification.ipynb) | ๋ค์ค ๋ ์ด๋ธ ๋ถ๋ฅ๋ฅผ ์ํด PyTorch๋ฅผ ์ฌ์ฉํ์ฌ BERT๋ฅผ ๋ฏธ์ธ ์กฐ์ ํ๋ ๋ฐฉ๋ฒ | [Abhishek Kumar Mishra](https://github.com/abhimishra91) | [](https://colab.research.google.com/github/abhimishra91/transformers-tutorials/blob/master/transformers_multi_label_classification.ipynb)|
| [์์ฝ์ ์ํด T5 ๋ฏธ์ธ ์กฐ์ ํ๊ธฐ](https://github.com/abhimishra91/transformers-tutorials/blob/master/transformers_summarization_wandb.ipynb) | ์์ฝ์ ์ํด PyTorch๋ก T5๋ฅผ ๋ฏธ์ธ ์กฐ์ ํ๊ณ WandB๋ก ์คํ์ ์ถ์ ํ๋ ๋ฐฉ๋ฒ | [Abhishek Kumar Mishra](https://github.com/abhimishra91) | [](https://colab.research.google.com/github/abhimishra91/transformers-tutorials/blob/master/transformers_summarization_wandb.ipynb)|
| [๋์ ํจ๋ฉ/๋ฒ์ผํ
์ผ๋ก Transformers ๋ฏธ์ธ ์กฐ์ ์๋ ๋์ด๊ธฐ](https://github.com/ELS-RD/transformers-notebook/blob/master/Divide_Hugging_Face_Transformers_training_time_by_2_or_more.ipynb)| ๋์ ํจ๋ฉ/๋ฒ์ผํ
์ ์ฌ์ฉํ์ฌ ๋ฏธ์ธ ์กฐ์ ์๋๋ฅผ 2๋ฐฐ๋ก ๋์ด๋ ๋ฐฉ๋ฒ |[Michael Benesty](https://github.com/pommedeterresautee) |[](https://colab.research.google.com/drive/1CBfRU1zbfu7-ijiOqAAQUA-RJaxfcJoO?usp=sharing)|
|[๋ง์คํน๋ ์ธ์ด ๋ชจ๋ธ๋ง์ ์ํด Reformer ์ฌ์ ํ๋ จํ๊ธฐ](https://github.com/patrickvonplaten/notebooks/blob/master/Reformer_For_Masked_LM.ipynb)| ์๋ฐฉํฅ ์
ํ ์ดํ
์
๋ ์ด์ด๋ฅผ ์ด์ฉํด์ Reformer ๋ชจ๋ธ์ ํ๋ จํ๋ ๋ฐฉ๋ฒ | [Patrick von Platen](https://github.com/patrickvonplaten) | [](https://colab.research.google.com/drive/1tzzh0i8PgDQGV3SMFUGxM7_gGae3K-uW?usp=sharing)|
| [Sci-BERT ํ์ฅ ๋ฐ ๋ฏธ์ธ ์กฐ์ ํ๊ธฐ](https://github.com/lordtt13/word-embeddings/blob/master/COVID-19%20Research%20Data/COVID-SciBERT.ipynb)| CORD ๋ฐ์ดํฐ ์ธํธ๋ก AllenAI์์ ์ฌ์ ํ๋ จ๋ SciBERT ๋ชจ๋ธ์ ์ดํ๋ฅผ ๋๋ฆฌ๊ณ ํ์ดํ๋ผ์ธ์ ๊ตฌ์ถํ๋ ๋ฐฉ๋ฒ | [Tanmay Thakur](https://github.com/lordtt13) | [](https://colab.research.google.com/drive/1rqAR40goxbAfez1xvF3hBJphSCsvXmh8)|
| [์์ฝ์ ์ํด Trainer API๋ก BlenderBotSmall ๋ฏธ์ธ ์กฐ์ ํ๊ธฐ](https://github.com/lordtt13/transformers-experiments/blob/master/Custom%20Tasks/fine-tune-blenderbot_small-for-summarization.ipynb)| ์์ฝ์ ์ํด Trainer API๋ฅผ ์ฌ์ฉํ์ฌ ์ฌ์ฉ์ ์ง์ ๋ฐ์ดํฐ ์ธํธ๋ก BlenderBotSmall ๋ฏธ์ธ ์กฐ์ ํ๊ธฐ | [Tanmay Thakur](https://github.com/lordtt13) | [](https://colab.research.google.com/drive/19Wmupuls7mykSGyRN_Qo6lPQhgp56ymq?usp=sharing)|
| [ํตํฉ ๊ธฐ์ธ๊ธฐ(Integrated Gradient)๋ฅผ ์ด์ฉํ์ฌ Electra ๋ฏธ์ธ ์กฐ์ ํ๊ณ ํด์ํ๊ธฐ](https://github.com/elsanns/xai-nlp-notebooks/blob/master/electra_fine_tune_interpret_captum_ig.ipynb) | ๊ฐ์ ๋ถ์์ ์ํด Electra๋ฅผ ๋ฏธ์ธ ์กฐ์ ํ๊ณ Captum ํตํฉ ๊ธฐ์ธ๊ธฐ๋ก ์์ธก์ ํด์ํ๋ ๋ฐฉ๋ฒ | [Eliza Szczechla](https://elsanns.github.io) | [](https://colab.research.google.com/github/elsanns/xai-nlp-notebooks/blob/master/electra_fine_tune_interpret_captum_ig.ipynb)|
| [Trainer ํด๋์ค๋ก ๋น์์ด๊ถ GPT-2 ๋ชจ๋ธ ๋ฏธ์ธ ์กฐ์ ํ๊ธฐ](https://github.com/philschmid/fine-tune-GPT-2/blob/master/Fine_tune_a_non_English_GPT_2_Model_with_Huggingface.ipynb) | Trainer ํด๋์ค๋ก ๋น์์ด๊ถ GPT-2 ๋ชจ๋ธ์ ๋ฏธ์ธ ์กฐ์ ํ๋ ๋ฐฉ๋ฒ | [Philipp Schmid](https://www.philschmid.de) | [](https://colab.research.google.com/github/philschmid/fine-tune-GPT-2/blob/master/Fine_tune_a_non_English_GPT_2_Model_with_Huggingface.ipynb)|
|[๋ค์ค ๋ผ๋ฒจ ๋ถ๋ฅ ์์
์ ์ํด DistilBERT ๋ชจ๋ธ ๋ฏธ์ธ ์กฐ์ ํ๊ธฐ](https://github.com/DhavalTaunk08/Transformers_scripts/blob/master/Transformers_multilabel_distilbert.ipynb) | ๋ค์ค ๋ผ๋ฒจ ๋ถ๋ฅ ์์
์ ์ํด DistilBERT ๋ชจ๋ธ์ ๋ฏธ์ธ ์กฐ์ ํ๋ ๋ฐฉ๋ฒ | [Dhaval Taunk](https://github.com/DhavalTaunk08) | [](https://colab.research.google.com/github/DhavalTaunk08/Transformers_scripts/blob/master/Transformers_multilabel_distilbert.ipynb)|
|[๋ฌธ์ฅ์ ๋ถ๋ฅ๋ฅผ ์ํด ALBERT ๋ฏธ์ธ ์กฐ์ ํ๊ธฐ](https://github.com/NadirEM/nlp-notebooks/blob/master/Fine_tune_ALBERT_sentence_pair_classification.ipynb) | ๋ฌธ์ฅ์ ๋ถ๋ฅ ์์
์ ์ํด ALBERT ๋ชจ๋ธ ๋๋ ๋ค๋ฅธ BERT ๊ธฐ๋ฐ ๋ชจ๋ธ์ ๋ฏธ์ธ ์กฐ์ ํ๋ ๋ฐฉ๋ฒ | [Nadir El Manouzi](https://github.com/NadirEM) | [](https://colab.research.google.com/github/NadirEM/nlp-notebooks/blob/master/Fine_tune_ALBERT_sentence_pair_classification.ipynb)|
|[๊ฐ์ ๋ถ์์ ์ํด Roberta ๋ฏธ์ธ ์กฐ์ ํ๊ธฐ](https://github.com/DhavalTaunk08/NLP_scripts/blob/master/sentiment_analysis_using_roberta.ipynb) | ๊ฐ์ ๋ถ์์ ์ํด Roberta ๋ชจ๋ธ์ ๋ฏธ์ธ ์กฐ์ ํ๋ ๋ฐฉ๋ฒ | [Dhaval Taunk](https://github.com/DhavalTaunk08) | [](https://colab.research.google.com/github/DhavalTaunk08/NLP_scripts/blob/master/sentiment_analysis_using_roberta.ipynb)|
|[์ง๋ฌธ ์์ฑ ๋ชจ๋ธ ํ๊ฐํ๊ธฐ](https://github.com/flexudy-pipe/qugeev) | seq2seq ํธ๋์คํฌ๋จธ ๋ชจ๋ธ์ด ์์ฑํ ์ง๋ฌธ๊ณผ ์ด์ ๋ํ ๋ต๋ณ์ด ์ผ๋ง๋ ์ ํํ๊ฐ์? | [Pascal Zoleko](https://github.com/zolekode) | [](https://colab.research.google.com/drive/1bpsSqCQU-iw_5nNoRm_crPq6FRuJthq_?usp=sharing)|
|[DistilBERT์ Tensorflow๋ก ํ
์คํธ ๋ถ๋ฅํ๊ธฐ](https://github.com/peterbayerle/huggingface_notebook/blob/main/distilbert_tf.ipynb) | ํ
์คํธ ๋ถ๋ฅ๋ฅผ ์ํด TensorFlow๋ก DistilBERT๋ฅผ ๋ฏธ์ธ ์กฐ์ ํ๋ ๋ฐฉ๋ฒ | [Peter Bayerle](https://github.com/peterbayerle) | [](https://colab.research.google.com/github/peterbayerle/huggingface_notebook/blob/main/distilbert_tf.ipynb)|
|[CNN/Dailail ์์ฝ์ ์ํด ์ธ์ฝ๋-๋์ฝ๋ ๋ชจ๋ธ์ BERT ํ์ฉํ๊ธฐ](https://github.com/patrickvonplaten/notebooks/blob/master/BERT2BERT_for_CNN_Dailymail.ipynb) | CNN/Dailail ์์ฝ์ ์ํด *google-bert/bert-base-uncased* ์ฒดํฌํฌ์ธํธ๋ฅผ ํ์ฉํ์ฌ *EncoderDecoderModel*์ ์๋ฐ์
ํ๋ ๋ฐฉ๋ฒ | [Patrick von Platen](https://github.com/patrickvonplaten) | [](https://colab.research.google.com/github/patrickvonplaten/notebooks/blob/master/BERT2BERT_for_CNN_Dailymail.ipynb)|
|[BBC XSum ์์ฝ์ ์ํด ์ธ์ฝ๋-๋์ฝ๋ ๋ชจ๋ธ์ RoBERTa ํ์ฉํ๊ธฐ](https://github.com/patrickvonplaten/notebooks/blob/master/RoBERTaShared_for_BBC_XSum.ipynb) | BBC/XSum ์์ฝ์ ์ํด *FacebookAI/roberta-base* ์ฒดํฌํฌ์ธํธ๋ฅผ ํ์ฉํ์ฌ ๊ณต์ *EncoderDecoderModel*์ ์๋ฐ์
ํ๋ ๋ฐฉ๋ฒ | [Patrick von Platen](https://github.com/patrickvonplaten) | [](https://colab.research.google.com/github/patrickvonplaten/notebooks/blob/master/RoBERTaShared_for_BBC_XSum.ipynb)|
|[์์ฐจ์ ์ง๋ฌธ ๋ต๋ณ(SQA)์ ์ํด TAPAS ๋ฏธ์ธ ์กฐ์ ํ๊ธฐ](https://github.com/NielsRogge/Transformers-Tutorials/blob/master/TAPAS/Fine_tuning_TapasForQuestionAnswering_on_SQA.ipynb) | *tapas-base* ์ฒดํฌํฌ์ธํธ๋ฅผ ํ์ฉํ์ฌ ์์ฐจ์ ์ง๋ฌธ ๋ต๋ณ(SQA) ๋ฐ์ดํฐ ์ธํธ๋ก *TapasForQuestionAnswering*์ ๋ฏธ์ธ ์กฐ์ ํ๋ ๋ฐฉ๋ฒ | [Niels Rogge](https://github.com/nielsrogge) | [](https://colab.research.google.com/github/NielsRogge/Transformers-Tutorials/blob/master/TAPAS/Fine_tuning_TapasForQuestionAnswering_on_SQA.ipynb)|
|[ํ ์ฌ์ค ๊ฒ์ฌ(TabFact)๋ก TAPAS ํ๊ฐํ๊ธฐ](https://github.com/NielsRogge/Transformers-Tutorials/blob/master/TAPAS/Evaluating_TAPAS_on_the_Tabfact_test_set.ipynb) | ๐ค Datasets์ ๐ค Transformer ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ฅผ ํจ๊ป ์ฌ์ฉํ์ฌ *tapas-base-finetuned-tabfact* ์ฒดํฌํฌ์ธํธ๋ก ๋ฏธ์ธ ์กฐ์ ๋ *TapasForSequenceClassification*์ ํ๊ฐํ๋ ๋ฐฉ๋ฒ | [Niels Rogge](https://github.com/nielsrogge) | [](https://colab.research.google.com/github/NielsRogge/Transformers-Tutorials/blob/master/TAPAS/Evaluating_TAPAS_on_the_Tabfact_test_set.ipynb)|
|[๋ฒ์ญ์ ์ํด mBART ๋ฏธ์ธ ์กฐ์ ํ๊ธฐ](https://colab.research.google.com/github/vasudevgupta7/huggingface-tutorials/blob/main/translation_training.ipynb) | ํ๋์ด์์ ์์ด๋ก ๋ฒ์ญํ๊ธฐ ์ํด Seq2SeqTrainer๋ฅผ ์ฌ์ฉํ์ฌ mBART๋ฅผ ๋ฏธ์ธ ์กฐ์ ํ๋ ๋ฐฉ๋ฒ | [Vasudev Gupta](https://github.com/vasudevgupta7) | [](https://colab.research.google.com/github/vasudevgupta7/huggingface-tutorials/blob/main/translation_training.ipynb)|
|[FUNSD(์์ ์ดํด ๋ฐ์ดํฐ ์ธํธ)๋ก LayoutLM ๋ฏธ์ธ ์กฐ์ ํ๊ธฐ](https://github.com/NielsRogge/Transformers-Tutorials/blob/master/LayoutLM/Fine_tuning_LayoutLMForTokenClassification_on_FUNSD.ipynb) | ์ค์บํ ๋ฌธ์์์ ์ ๋ณด ์ถ์ถ์ ์ํด FUNSD ๋ฐ์ดํฐ ์ธํธ๋ก *LayoutLMForTokenClassification*์ ๋ฏธ์ธ ์กฐ์ ํ๋ ๋ฐฉ๋ฒ | [Niels Rogge](https://github.com/nielsrogge) | [](https://colab.research.google.com/github/NielsRogge/Transformers-Tutorials/blob/master/LayoutLM/Fine_tuning_LayoutLMForTokenClassification_on_FUNSD.ipynb)|
|[DistilGPT2 ๋ฏธ์ธ ์กฐ์ ํ๊ณ ๋ฐ ํ
์คํธ ์์ฑํ๊ธฐ](https://colab.research.google.com/github/tripathiaakash/DistilGPT2-Tutorial/blob/main/distilgpt2_fine_tuning.ipynb) | DistilGPT2๋ฅผ ๋ฏธ์ธ ์กฐ์ ํ๊ณ ํ
์คํธ๋ฅผ ์์ฑํ๋ ๋ฐฉ๋ฒ | [Aakash Tripathi](https://github.com/tripathiaakash) | [](https://colab.research.google.com/github/tripathiaakash/DistilGPT2-Tutorial/blob/main/distilgpt2_fine_tuning.ipynb)|
|[์ต๋ 8K ํ ํฐ์์ LED ๋ฏธ์ธ ์กฐ์ ํ๊ธฐ](https://github.com/patrickvonplaten/notebooks/blob/master/Fine_tune_Longformer_Encoder_Decoder_(LED)_for_Summarization_on_pubmed.ipynb) | ๊ธด ๋ฒ์๋ฅผ ์์ฝํ๊ธฐ ์ํด PubMed๋ก LED๋ฅผ ๋ฏธ์ธ ์กฐ์ ํ๋ ๋ฐฉ๋ฒ | [Patrick von Platen](https://github.com/patrickvonplaten) | [](https://colab.research.google.com/github/patrickvonplaten/notebooks/blob/master/Fine_tune_Longformer_Encoder_Decoder_(LED)_for_Summarization_on_pubmed.ipynb)|
|[Arxiv๋ก LED ํ๊ฐํ๊ธฐ](https://github.com/patrickvonplaten/notebooks/blob/master/LED_on_Arxiv.ipynb) | ๊ธด ๋ฒ์ ์์ฝ์ ๋ํด LED๋ฅผ ํจ๊ณผ์ ์ผ๋ก ํ๊ฐํ๋ ๋ฐฉ๋ฒ | [Patrick von Platen](https://github.com/patrickvonplaten) | [](https://colab.research.google.com/github/patrickvonplaten/notebooks/blob/master/LED_on_Arxiv.ipynb)|
|[RVL-CDIP(๋ฌธ์ ์ด๋ฏธ์ง ๋ถ๋ฅ ๋ฐ์ดํฐ ์ธํธ)๋ก LayoutLM ๋ฏธ์ธ ์กฐ์ ํ๊ธฐ)](https://github.com/NielsRogge/Transformers-Tutorials/blob/master/LayoutLM/Fine_tuning_LayoutLMForSequenceClassification_on_RVL_CDIP.ipynb) | ์ค์บ ๋ฌธ์ ๋ถ๋ฅ๋ฅผ ์ํด RVL-CDIP ๋ฐ์ดํฐ ์ธํธ๋ก *LayoutLMForSequenceClassification*์ ๋ฏธ์ธ ์กฐ์ ํ๋ ๋ฐฉ๋ฒ | [Niels Rogge](https://github.com/nielsrogge) | [](https://colab.research.google.com/github/NielsRogge/Transformers-Tutorials/blob/master/LayoutLM/Fine_tuning_LayoutLMForSequenceClassification_on_RVL_CDIP.ipynb)|
|[GPT2 ์กฐ์ ์ ํตํ Wav2Vec2 CTC ๋์ฝ๋ฉ](https://github.com/voidful/huggingface_notebook/blob/main/xlsr_gpt.ipynb) | ์ธ์ด ๋ชจ๋ธ ์กฐ์ ์ ํตํด CTC ์ํ์ค๋ฅผ ๋์ฝ๋ฉํ๋ ๋ฐฉ๋ฒ | [Eric Lam](https://github.com/voidful) | [](https://colab.research.google.com/drive/1e_z5jQHYbO2YKEaUgzb1ww1WwiAyydAj?usp=sharing)|
|[Trainer ํด๋์ค๋ก ๋ ๊ฐ ์ธ์ด๋ก ์์ฝํ๊ธฐ ์ํด BART ๋ฏธ์ธ ์กฐ์ ํ๊ธฐ](https://github.com/elsanns/xai-nlp-notebooks/blob/master/fine_tune_bart_summarization_two_langs.ipynb) | Trainer ํด๋์ค๋ก ๋ ๊ฐ ์ธ์ด๋ก ์์ฝํ๊ธฐ ์ํด BART ๋ฏธ์ธ ์กฐ์ ํ๋ ๋ฐฉ๋ฒ | [Eliza Szczechla](https://github.com/elsanns) | [](https://colab.research.google.com/github/elsanns/xai-nlp-notebooks/blob/master/fine_tune_bart_summarization_two_langs.ipynb)|
|[Trivia QA๋ก Big Bird ํ๊ฐํ๊ธฐ](https://github.com/patrickvonplaten/notebooks/blob/master/Evaluating_Big_Bird_on_TriviaQA.ipynb) | Trivia QA๋ก ๊ธด ๋ฌธ์ ์ง๋ฌธ์ ๋ํ ๋ต๋ณ์ ๋ํด BigBird๋ฅผ ํ๊ฐํ๋ ๋ฐฉ๋ฒ | [Patrick von Platen](https://github.com/patrickvonplaten) | [](https://colab.research.google.com/github/patrickvonplaten/notebooks/blob/master/Evaluating_Big_Bird_on_TriviaQA.ipynb)|
| [Wav2Vec2๋ฅผ ์ฌ์ฉํ์ฌ ๋์์ ์บก์
๋ง๋ค๊ธฐ](https://github.com/Muennighoff/ytclipcc/blob/main/wav2vec_youtube_captions.ipynb) | Wav2Vec์ผ๋ก ์ค๋์ค๋ฅผ ํ
์คํธ๋ก ๋ณํํ์ฌ ๋ชจ๋ ๋์์์์ YouTube ์บก์
๋ง๋๋ ๋ฐฉ๋ฒ | [Niklas Muennighoff](https://github.com/Muennighoff) |[](https://colab.research.google.com/github/Muennighoff/ytclipcc/blob/main/wav2vec_youtube_captions.ipynb) |
| [PyTorch Lightning์ ์ฌ์ฉํ์ฌ CIFAR-10์ผ๋ก ๋น์ ํธ๋์คํฌ๋จธ ๋ฏธ์ธ ์กฐ์ ํ๊ธฐ](https://github.com/NielsRogge/Transformers-Tutorials/blob/master/VisionTransformer/Fine_tuning_the_Vision_Transformer_on_CIFAR_10_with_PyTorch_Lightning.ipynb) | HuggingFace Transformers, Datasets, PyTorch Lightning์ ์ฌ์ฉํ์ฌ CIFAR-10์ผ๋ก ๋น์ ํธ๋์คํฌ๋จธ(ViT)๋ฅผ ๋ฏธ์ธ ์กฐ์ ํ๋ ๋ฐฉ๋ฒ | [Niels Rogge](https://github.com/nielsrogge) |[](https://colab.research.google.com/github/NielsRogge/Transformers-Tutorials/blob/master/VisionTransformer/Fine_tuning_the_Vision_Transformer_on_CIFAR_10_with_PyTorch_Lightning.ipynb) |
| [๐ค Trainer๋ฅผ ์ฌ์ฉํ์ฌ CIFAR-10์์ ๋น์ ํธ๋์คํฌ๋จธ ๋ฏธ์ธ ์กฐ์ ํ๊ธฐ](https://github.com/NielsRogge/Transformers-Tutorials/blob/master/VisionTransformer/Fine_tuning_the_Vision_Transformer_on_CIFAR_10_with_the_%F0%9F%A4%97_Trainer.ipynb) | Datasets, ๐ค Trainer๋ฅผ ์ฌ์ฉํ์ฌ CIFAR-10์์ ๋น์ ํธ๋์คํฌ๋จธ(ViT)๋ฅผ ๋ฏธ์ธ ์กฐ์ ํ๋ ๋ฐฉ๋ฒ | [Niels Rogge](https://github.com/nielsrogge) |[](https://colab.research.google.com/github/NielsRogge/Transformers-Tutorials/blob/master/VisionTransformer/Fine_tuning_the_Vision_Transformer_on_CIFAR_10_with_the_%F0%9F%A4%97_Trainer.ipynb) |
| [๊ฐ์ฒด ์
๋ ฅ ๋ฐ์ดํฐ ์ธํธ์ธ Open Entity๋ก LUKE ํ๊ฐํ๊ธฐ](https://github.com/studio-ousia/luke/blob/master/notebooks/huggingface_open_entity.ipynb) | Open Entity ๋ฐ์ดํฐ ์ธํธ๋ก *LukeForEntityClassification*์ ํ๊ฐํ๋ ๋ฐฉ๋ฒ | [Ikuya Yamada](https://github.com/ikuyamada) |[](https://colab.research.google.com/github/studio-ousia/luke/blob/master/notebooks/huggingface_open_entity.ipynb) |
| [๊ด๊ณ ์ถ์ถ ๋ฐ์ดํฐ ์ธํธ์ธ TACRED๋ก LUKE ํ๊ฐํ๊ธฐ](https://github.com/studio-ousia/luke/blob/master/notebooks/huggingface_tacred.ipynb) | TACRED ๋ฐ์ดํฐ ์ธํธ๋ก *LukeForEntityPairClassification*์ ํ๊ฐํ๋ ๋ฐฉ๋ฒ | [Ikuya Yamada](https://github.com/ikuyamada) |[](https://colab.research.google.com/github/studio-ousia/luke/blob/master/notebooks/huggingface_tacred.ipynb) |
| [์ค์ NER ๋ฒค์น๋งํฌ์ธ CoNLL-2003์ผ๋ก LUKE ํ๊ฐํ๊ธฐ](https://github.com/studio-ousia/luke/blob/master/notebooks/huggingface_conll_2003.ipynb) | CoNLL-2003 ๋ฐ์ดํฐ ์ธํธ๋ก *LukeForEntitySpanClassification*๋ฅผ ํ๊ฐํ๋ ๋ฐฉ๋ฒ | [Ikuya Yamada](https://github.com/ikuyamada) |[](https://colab.research.google.com/github/studio-ousia/luke/blob/master/notebooks/huggingface_conll_2003.ipynb) |
| [PubMed ๋ฐ์ดํฐ ์ธํธ๋ก BigBird-Pegasus ํ๊ฐํ๊ธฐ](https://github.com/vasudevgupta7/bigbird/blob/main/notebooks/bigbird_pegasus_evaluation.ipynb) | PubMed ๋ฐ์ดํฐ ์ธํธ๋ก *BigBirdPegasusForConditionalGeneration*๋ฅผ ํ๊ฐํ๋ ๋ฐฉ๋ฒ | [Vasudev Gupta](https://github.com/vasudevgupta7) | [](https://colab.research.google.com/github/vasudevgupta7/bigbird/blob/main/notebooks/bigbird_pegasus_evaluation.ipynb) |
| [Wav2Vec2๋ฅผ ์ฌ์ฉํด์ ์์ฑ ๊ฐ์ ๋ถ๋ฅํ๊ธฐ](https://github/m3hrdadfi/soxan/blob/main/notebooks/Emotion_recognition_in_Greek_speech_using_Wav2Vec2.ipynb) | ๊ฐ์ ๋ถ๋ฅ๋ฅผ ์ํด ์ฌ์ ํ๋ จ๋ Wav2Vec2 ๋ชจ๋ธ์ MEGA ๋ฐ์ดํฐ ์ธํธ์ ํ์ฉํ๋ ๋ฐฉ๋ฒ | [Mehrdad Farahani](https://github.com/m3hrdadfi) | [](https://colab.research.google.com/github/m3hrdadfi/soxan/blob/main/notebooks/Emotion_recognition_in_Greek_speech_using_Wav2Vec2.ipynb) |
| [DETR๋ก ์ด๋ฏธ์ง์์ ๊ฐ์ฒด ํ์งํ๊ธฐ](https://github.com/NielsRogge/Transformers-Tutorials/blob/master/DETR/DETR_minimal_example_(with_DetrFeatureExtractor).ipynb) | ํ๋ จ๋ *DetrForObjectDetection* ๋ชจ๋ธ์ ์ฌ์ฉํ์ฌ ์ด๋ฏธ์ง์์ ๊ฐ์ฒด๋ฅผ ํ์งํ๊ณ ์ดํ
์
์ ์๊ฐํํ๋ ๋ฐฉ๋ฒ | [Niels Rogge](https://github.com/NielsRogge) | [](https://colab.research.google.com/github/NielsRogge/Transformers-Tutorials/blob/master/DETR/DETR_minimal_example_(with_DetrFeatureExtractor).ipynb) |
| [์ฌ์ฉ์ ์ง์ ๊ฐ์ฒด ํ์ง ๋ฐ์ดํฐ ์ธํธ๋ก DETR ๋ฏธ์ธ ์กฐ์ ํ๊ธฐ](https://github.com/NielsRogge/Transformers-Tutorials/blob/master/DETR/Fine_tuning_DetrForObjectDetection_on_custom_dataset_(balloon).ipynb) | ์ฌ์ฉ์ ์ง์ ๊ฐ์ฒด ํ์ง ๋ฐ์ดํฐ ์ธํธ๋ก *DetrForObjectDetection*์ ๋ฏธ์ธ ์กฐ์ ํ๋ ๋ฐฉ๋ฒ | [Niels Rogge](https://github.com/NielsRogge) | [](https://colab.research.google.com/github/NielsRogge/Transformers-Tutorials/blob/master/DETR/Fine_tuning_DetrForObjectDetection_on_custom_dataset_(balloon).ipynb) |
| [๊ฐ์ฒด๋ช
์ธ์์ ์ํด T5 ๋ฏธ์ธ ์กฐ์ ํ๊ธฐ](https://github.com/ToluClassics/Notebooks/blob/main/T5_Ner_Finetuning.ipynb) | ๊ฐ์ฒด๋ช
์ธ์ ์์
์ ์ํด *T5*๋ฅผ ๋ฏธ์ธ ์กฐ์ ํ๋ ๋ฐฉ๋ฒ | [Ogundepo Odunayo](https://github.com/ToluClassics) | [](https://colab.research.google.com/drive/1obr78FY_cBmWY5ODViCmzdY6O1KB65Vc?usp=sharing) |
| 0 |
mavonic_private_repos/transformers/docs/source | mavonic_private_repos/transformers/docs/source/ko/tf_xla.md | <!--Copyright 2023 The HuggingFace Team. All rights reserved.
Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
the License. You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
specific language governing permissions and limitations under the License.
โ ๏ธ Note that this file is in Markdown but contain specific syntax for our doc-builder (similar to MDX) that may not be
rendered properly in your Markdown viewer.
-->
# TensorFlow ๋ชจ๋ธ์ ์ํ XLA ํตํฉ [[xla-integration-for-tensorflow-models]]
[[open-in-colab]]
XLA(Accelerated Linear Algebra)๋ TensorFlow ๋ชจ๋ธ์ ์คํ ์๊ฐ์ ๊ฐ์ํํ๊ธฐ ์ํ ์ปดํ์ผ๋ฌ์
๋๋ค. [๊ณต์ ๋ฌธ์](https://www.tensorflow.org/xla)์ ๋ฐ๋ฅด๋ฉด ๋ค์๊ณผ ๊ฐ์ต๋๋ค:
XLA(Accelerated Linear Algebra)๋ ์ ํ ๋์๋ฅผ ์ํ ๋๋ฉ์ธ ํนํ ์ปดํ์ผ๋ฌ๋ก, TensorFlow ๋ชจ๋ธ์ ์์ค ์ฝ๋ ๋ณ๊ฒฝ ์์ด ๊ฐ์ํํ ์ ์์ต๋๋ค.
TensorFlow์์ XLA๋ฅผ ์ฌ์ฉํ๋ ๊ฒ์ ๊ฐ๋จํฉ๋๋ค. XLA๋ `tensorflow` ๋ผ์ด๋ธ๋ฌ๋ฆฌ ๋ด์ ํจํค์ง๋ก ์ ๊ณต๋๋ฉฐ, [`tf.function`](https://www.tensorflow.org/guide/intro_to_graphs)๊ณผ ๊ฐ์ ๊ทธ๋ํ ์์ฑ ํจ์์์ `jit_compile` ์ธ์๋ฅผ ์ฌ์ฉํ์ฌ ํ์ฑํํ ์ ์์ต๋๋ค. `fit()` ๋ฐ `predict()`์ ๊ฐ์ Keras ๋ฉ์๋๋ฅผ ์ฌ์ฉํ๋ ๊ฒฝ์ฐ, `jit_compile` ์ธ์๋ฅผ `model.compile()`์ ์ ๋ฌํ์ฌ XLA๋ฅผ ๊ฐ๋จํ๊ฒ ํ์ฑํํ ์ ์์ต๋๋ค. ๊ทธ๋ฌ๋ XLA๋ ์ด๋ฌํ ๋ฉ์๋์ ๊ตญํ๋์ง ์๊ณ ์์์ `tf.function`์ ๊ฐ์ํํ๋ ๋ฐ์๋ ์ฌ์ฉํ ์ ์์ต๋๋ค.
๐ค Transformers์์๋ [GPT2](https://huggingface.co/docs/transformers/model_doc/gpt2), [T5](https://huggingface.co/docs/transformers/model_doc/t5), [OPT](https://huggingface.co/docs/transformers/model_doc/opt)์ ๊ฐ์ ๋ชจ๋ธ์ ํ
์คํธ ์์ฑ, ๊ทธ๋ฆฌ๊ณ [Whisper](https://huggingface.co/docs/transformers/model_doc/whisper)์ ๊ฐ์ ๋ชจ๋ธ์ ์์ฑ ์ฒ๋ฆฌ๋ฅผ ํฌํจํ์ฌ ์ฌ๋ฌ TensorFlow ๋ฉ์๋๊ฐ XLA์ ํธํ๋๋๋ก ๋ค์ ์์ฑ๋์์ต๋๋ค.
์ ํํ ์๋ ํฅ์์ ๋ชจ๋ธ์ ๋ฐ๋ผ ๋ค๋ฅด์ง๋ง, ๐ค Transformers ๋ด์ TensorFlow ํ
์คํธ ์์ฑ ๋ชจ๋ธ์ ๊ฒฝ์ฐ ์ต๋ 100๋ฐฐ์ ์๋ ํฅ์์ ํ์ธํ์ต๋๋ค. ์ด ๋ฌธ์์์๋ ์ด๋ฌํ ๋ชจ๋ธ์ ๋ํด XLA๋ฅผ ์ฌ์ฉํ์ฌ ์ต๋ ์ฑ๋ฅ์ ์ป๋ ๋ฐฉ๋ฒ์ ์ค๋ช
ํฉ๋๋ค. ๋ํ XLA ํตํฉ์ ๋ฒค์น๋งํฌ ๋ฐ ๋์์ธ ์ฒ ํ์ ๋ํ ์ถ๊ฐ ์๋ฃ ๋งํฌ๋ ์ ๊ณตํ ๊ฒ์
๋๋ค.
## XLA๋ฅผ ์ฌ์ฉํ์ฌ TF ํจ์ ์คํํ๊ธฐ [[running-tf-functions-with-xla]]
TensorFlow์์ ๋ค์๊ณผ ๊ฐ์ ๋ชจ๋ธ์ ๊ณ ๋ คํด ๋ด
์๋ค:
```py
import tensorflow as tf
model = tf.keras.Sequential(
[tf.keras.layers.Dense(10, input_shape=(10,), activation="relu"), tf.keras.layers.Dense(5, activation="softmax")]
)
```
์ ๋ชจ๋ธ์ ์ฐจ์์ด `(10, )`์ธ ์
๋ ฅ์ ๋ฐ์ต๋๋ค. ๋ค์๊ณผ ๊ฐ์ด ๋ชจ๋ธ์ ์ฌ์ฉํ์ฌ ์์ ํ๋ฅผ ์คํํ ์ ์์ต๋๋ค:
```py
# ๋ชจ๋ธ์ ๋ํ ์์์ ์
๋ ฅ์ ์์ฑํฉ๋๋ค.
batch_size = 16
input_vector_dim = 10
random_inputs = tf.random.normal((batch_size, input_vector_dim))
# ์์ ํ๋ฅผ ์คํํฉ๋๋ค.
_ = model(random_inputs)
```
XLA๋ก ์ปดํ์ผ๋ ํจ์๋ก ์์ ํ๋ฅผ ์คํํ๋ ค๋ฉด ๋ค์๊ณผ ๊ฐ์ด ํด์ผ ํฉ๋๋ค:
```py
xla_fn = tf.function(model, jit_compile=True)
_ = xla_fn(random_inputs)
```
`model`์ ๊ธฐ๋ณธ `call()` ํจ์๋ XLA ๊ทธ๋ํ๋ฅผ ์ปดํ์ผํ๋ ๋ฐ ์ฌ์ฉ๋ฉ๋๋ค. ๊ทธ๋ฌ๋ ๋ค๋ฅธ ๋ชจ๋ธ ํจ์๋ฅผ XLA๋ก ์ปดํ์ผํ๋ ค๋ฉด ๋ค์๊ณผ ๊ฐ์ด ํ ์๋ ์์ต๋๋ค:
```py
my_xla_fn = tf.function(model.my_xla_fn, jit_compile=True)
```
## ๐ค Transformers์์ XLA๋ฅผ ์ฌ์ฉํ์ฌ TF ํ
์คํธ ์์ฑ ๋ชจ๋ธ ์คํํ๊ธฐ [[running-a-tf-text-generation-model-with-xla-from-transformers]]
๐ค Transformers์์ XLA๋ก ๊ฐ์ํ๋ ์์ฑ์ ํ์ฑํํ๋ ค๋ฉด ์ต์ ๋ฒ์ ์ `transformers`๊ฐ ์ค์น๋์ด ์์ด์ผ ํฉ๋๋ค. ๋ค์๊ณผ ๊ฐ์ด ์ค์นํ ์ ์์ต๋๋ค:
```bash
pip install transformers --upgrade
```
๊ทธ๋ฆฌ๊ณ ๋ค์ ์ฝ๋๋ฅผ ์คํํ ์ ์์ต๋๋ค:
```py
import tensorflow as tf
from transformers import AutoTokenizer, TFAutoModelForCausalLM
# ์ต์ ๋ฒ์ ์ Transformers๊ฐ ์ค์น๋์ด ์์ง ์๋ค๋ฉด ์ค๋ฅ๊ฐ ๋ฐ์ํฉ๋๋ค.
from transformers.utils import check_min_version
check_min_version("4.21.0")
tokenizer = AutoTokenizer.from_pretrained("openai-community/gpt2", padding_side="left", pad_token="</s>")
model = TFAutoModelForCausalLM.from_pretrained("openai-community/gpt2")
input_string = ["TensorFlow is"]
# XLA ์์ฑ ํจ์๋ฅผ ๋ง๋ค๊ธฐ ์ํ ํ ์ค
xla_generate = tf.function(model.generate, jit_compile=True)
tokenized_input = tokenizer(input_string, return_tensors="tf")
generated_tokens = xla_generate(**tokenized_input, num_beams=2)
decoded_text = tokenizer.decode(generated_tokens[0], skip_special_tokens=True)
print(f"Generated -- {decoded_text}")
# Generated -- TensorFlow is an open-source, open-source, distributed-source application # framework for the
```
์ ์ ์๋ฏ์ด, `generate()`์์ XLA๋ฅผ ํ์ฑํํ๋ ๊ฒ์ ๋จ ํ ์ค์ ์ฝ๋์
๋๋ค. ์ฝ๋์ ๋๋จธ์ง ๋ถ๋ถ์ ๋ณ๊ฒฝ๋์ง ์์ต๋๋ค. ๊ทธ๋ฌ๋ ์ ์ฝ๋ ์ค๋ํซ์์๋ XLA์ ํน์ ํ ๋ช ๊ฐ์ง ์ฃผ์ํ ์ ์ด ์์ต๋๋ค. XLA๊ฐ ๊ฐ์ ธ๋ค์ค ์๋ ํฅ์์ ์คํํ๊ธฐ ์ํด์๋ ์ด๋ฅผ ์๊ณ ์์ด์ผ ํฉ๋๋ค. ๋ค์ ์น์
์์ ์ด์ ๋ํด ๋
ผ์ํฉ๋๋ค.
## ์ฃผ์ํ ์ [[gotchas-to-be-aware-of]]
XLA ํ์ฑํ ํจ์(`xla_generate()`์ ๊ฐ์)๋ฅผ ์ฒ์ ์คํํ ๋ ๋ด๋ถ์ ์ผ๋ก ๊ณ์ฐ ๊ทธ๋ํ๋ฅผ ์ถ๋ก ํ๋ ค๊ณ ํ๋ฉฐ, ์ด๋ ์๊ฐ์ด ์์๋ฉ๋๋ค. ์ด ๊ณผ์ ์ [โ์ถ์ (tracing)โ](https://www.tensorflow.org/guide/intro_to_graphs#when_is_a_function_tracing)์ด๋ผ๊ณ ์๋ ค์ ธ ์์ต๋๋ค.
์์ฑ ์๊ฐ์ด ๋น ๋ฅด์ง ์๋ค๋ ๊ฒ์ ์ ์ ์์ ๊ฒ์
๋๋ค. `xla_generate()`(๋๋ ๋ค๋ฅธ XLA ํ์ฑํ ํจ์)์ ์ฐ์ ํธ์ถ์ ํจ์์ ์ ๋ฌ๋ ์
๋ ฅ์ด ์ด๊ธฐ์ ๊ตฌ์ถ๋ ๊ณ์ฐ ๊ทธ๋ํ์ ๋์ผํ ํํ๋ฅผ ๋ฐ๋ฅธ๋ค๋ฉด, ๊ณ์ฐ ๊ทธ๋ํ๋ฅผ ์ถ๋ก ํ ํ์๊ฐ ์์ต๋๋ค. ์ด๋ ์
๋ ฅ ํํ๊ฐ ๊ณ ์ ๋ ๋ชจ๋ฌ๋ฆฌํฐ(์: ์ด๋ฏธ์ง)์๋ ๋ฌธ์ ๊ฐ ๋์ง ์์ง๋ง, ๊ฐ๋ณ ์
๋ ฅ ํํ ๋ชจ๋ฌ๋ฆฌํฐ(์: ํ
์คํธ)๋ฅผ ์ฌ์ฉํ ๋ ์ฃผ์ํด์ผ ํฉ๋๋ค.
`xla_generate()`๊ฐ ํญ์ ๋์ผํ ์
๋ ฅ ํํ๋ก ๋์ํ๋๋ก ํ๋ ค๋ฉด, ํ ํฌ๋์ด์ ๋ฅผ ํธ์ถํ ๋ `padding` ์ธ์๋ฅผ ์ง์ ํ ์ ์์ต๋๋ค.
```py
import tensorflow as tf
from transformers import AutoTokenizer, TFAutoModelForCausalLM
tokenizer = AutoTokenizer.from_pretrained("openai-community/gpt2", padding_side="left", pad_token="</s>")
model = TFAutoModelForCausalLM.from_pretrained("openai-community/gpt2")
input_string = ["TensorFlow is"]
xla_generate = tf.function(model.generate, jit_compile=True)
# ์ฌ๊ธฐ์, padding ์ต์
์ด ์๋ ํ ํฌ๋์ด์ ๋ฅผ ํธ์ถํฉ๋๋ค.
tokenized_input = tokenizer(input_string, pad_to_multiple_of=8, padding=True, return_tensors="tf")
generated_tokens = xla_generate(**tokenized_input, num_beams=2)
decoded_text = tokenizer.decode(generated_tokens[0], skip_special_tokens=True)
print(f"Generated -- {decoded_text}")
```
์ด๋ ๊ฒ ํ๋ฉด `xla_generate()`์ ๋ํ ์
๋ ฅ์ด ํญ์ ์ถ์ ๋ ํํ๋ก ์ ๋ฌ๋์ด ์์ฑ ์๊ฐ์ด ๊ฐ์ํ๋ฉ๋๋ค. ๋ค์ ์ฝ๋๋ก ์ด๋ฅผ ํ์ธํ ์ ์์ต๋๋ค:
```py
import time
import tensorflow as tf
from transformers import AutoTokenizer, TFAutoModelForCausalLM
tokenizer = AutoTokenizer.from_pretrained("openai-community/gpt2", padding_side="left", pad_token="</s>")
model = TFAutoModelForCausalLM.from_pretrained("openai-community/gpt2")
xla_generate = tf.function(model.generate, jit_compile=True)
for input_string in ["TensorFlow is", "TensorFlow is a", "TFLite is a"]:
tokenized_input = tokenizer(input_string, pad_to_multiple_of=8, padding=True, return_tensors="tf")
start = time.time_ns()
generated_tokens = xla_generate(**tokenized_input, num_beams=2)
end = time.time_ns()
print(f"Execution time -- {(end - start) / 1e6:.1f} ms\n")
```
Tesla T4 GPU์์๋ ๋ค์๊ณผ ๊ฐ์ ์ถ๋ ฅ์ ์์ํ ์ ์์ต๋๋ค:
```bash
Execution time -- 30819.6 ms
Execution time -- 79.0 ms
Execution time -- 78.9 ms
```
`xla_generate()`์ ์ฒซ ๋ฒ์งธ ํธ์ถ์ ์ถ์ ๋๋ฌธ์ ์๊ฐ์ด ์ค๋ ๊ฑธ๋ฆฌ์ง๋ง, ์ฐ์ ํธ์ถ์ ๋ช ๋ฐฐ๋ ๋น ๋ฆ
๋๋ค. ์์ฑ ์ต์
์ ๋ํ ์ด๋ค ๋ณ๊ฒฝ์ด๋ ๋ค์ ์ถ์ ์ ์ ๋ฐํ๋ฏ๋ก ์์ฑ ์๊ฐ์ด ๋๋ ค์ง ์ ์์์ ๋ช
์ฌํ์ธ์.
์ด ๋ฌธ์์์๋ ๐ค Transformers์์ ์ ๊ณตํ๋ ๋ชจ๋ ํ
์คํธ ์์ฑ ์ต์
์ ๋ค๋ฃจ์ง ์์์ต๋๋ค. ๊ณ ๊ธ ์ฌ์ฉ ์ฌ๋ก์ ๋ํด ๋ฌธ์๋ฅผ ์ฐธ์กฐํ์๊ธฐ ๋ฐ๋๋๋ค.
## ์ถ๊ฐ ์๋ฃ [[additional-resources]]
์ฌ๊ธฐ์ ๐ค Transformers์ XLA์ ๋ํด ๋ ์์ธํ ์๊ณ ์ถ์ ๊ฒฝ์ฐ ๋์์ด ๋ ์ ์๋ ๋ช ๊ฐ์ง ์ถ๊ฐ ์๋ฃ๋ฅผ ์ ๊ณตํฉ๋๋ค.
* [์ด Colab ๋
ธํธ๋ถ](https://colab.research.google.com/github/huggingface/blog/blob/main/notebooks/91_tf_xla_generate.ipynb)์ XLA์ ํธํ๋๋ ์ธ์ฝ๋-๋์ฝ๋([T5](https://huggingface.co/docs/transformers/model_doc/t5)์ ๊ฐ์) ๋ฐ ๋์ฝ๋ ์ ์ฉ([GPT2](https://huggingface.co/docs/transformers/model_doc/gpt2)์ ๊ฐ์) ํ
์คํธ ์์ฑ ๋ชจ๋ธ์ ์คํํด ๋ณผ ์ ์๋ ๋ํํ ๋ฐ๋ชจ๋ฅผ ์ ๊ณตํฉ๋๋ค.
* [์ด ๋ธ๋ก๊ทธ ๊ธ](https://huggingface.co/blog/tf-xla-generate)์ TensorFlow์์ XLA์ ๋ํ ์น์ ํ ์๊ฐ์ ํจ๊ป XLA์ ํธํ๋๋ ๋ชจ๋ธ์ ๋น๊ต ๋ฒค์น๋งํฌ์ ๋ํ ๊ฐ์๋ฅผ ์ ๊ณตํฉ๋๋ค.
* [์ด ๋ธ๋ก๊ทธ ๊ธ](https://blog.tensorflow.org/2022/11/how-hugging-face-improved-text-generation-performance-with-xla.html)์ ๐ค Transformers์ TensorFlow ๋ชจ๋ธ์ XLA ์ง์์ ์ถ๊ฐํ๋ ๊ฒ์ ๋ํ ๋์์ธ ์ฒ ํ์ ๋
ผ์ํฉ๋๋ค.
* XLA์ TensorFlow ๊ทธ๋ํ์ ๋ํด ๋ ์์ธํ ์๊ณ ์ถ์ ๊ฒฝ์ฐ ์ถ์ฒํ๋ ๊ธ:
* [XLA: ๊ธฐ๊ณ ํ์ต์ ์ํ ์ต์ ํ ์ปดํ์ผ๋ฌ](https://www.tensorflow.org/xla)
* [๊ทธ๋ํ ๋ฐ tf.function ์๊ฐ](https://www.tensorflow.org/guide/intro_to_graphs)
* [tf.function์ผ๋ก ์ฑ๋ฅ ํฅ์ํ๊ธฐ](https://www.tensorflow.org/guide/function) | 0 |
mavonic_private_repos/transformers/docs/source | mavonic_private_repos/transformers/docs/source/ko/attention.md | <!--Copyright 2023 The HuggingFace Team. All rights reserved.
Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
the License. You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
specific language governing permissions and limitations under the License.
โ ๏ธ Note that this file is in Markdown but contain specific syntax for our doc-builder (similar to MDX) that may not be
rendered properly in your Markdown viewer.
-->
# ์ดํ
์
๋ฉ์ปค๋์ฆ[[attention_mechanisms]]
๋๋ถ๋ถ์ ํธ๋์คํฌ๋จธ ๋ชจ๋ธ์ ์ ๋ฐฉํ๋ ฌ์ธ ์ ์ฒด ์ดํ
์
์ ์ฌ์ฉํฉ๋๋ค.
ํ์ง๋ง ์ด๋ ๊ธด ํ
์คํธ๋ฅผ ๋ค๋ฃฐ ๋๋ ํฐ ๊ณ์ฐ ๋ณ๋ชฉ ํ์์ ์ ๋ฐํ ์ ์์ต๋๋ค.
`Longformer`์ `Reformer`๋ ํ๋ จ ์๋๋ฅผ ๋์ด๊ธฐ ์ํด ์ดํ
์
ํ๋ ฌ์ ํฌ์ ๋ฒ์ ์ ์ฌ์ฉํ์ฌ ํจ์จ์ ๋์ด๋ ค๋ ๋ชจ๋ธ์
๋๋ค.
## LSH ์ดํ
์
[[lsh_attention]]
[Reformer](model_doc/reformer)๋ LSH(Locality Sensitive Hashing) ์ดํ
์
์ ์ฌ์ฉํฉ๋๋ค. softmax(QK^t)์์๋ ํ๋ ฌ QK^t์ (softmax ์ฐจ์์์) ๊ฐ์ฅ ํฐ ์์๋ค๋ง ์ ์ฉํ ๊ธฐ์ฌ๋ฅผ ํ ๊ฒ์
๋๋ค.
๋ฐ๋ผ์ ๊ฐ๊ฐ์ ์ฟผ๋ฆฌ q์ ๋ํด, q์ ๊ฐ๊น์ด ํค k๋ง ๊ณ ๋ คํ ์ ์์ต๋๋ค. ํด์ ํจ์๋ q์ k๊ฐ ๊ฐ๊น์ด์ง ์ฌ๋ถ๋ฅผ ๊ฒฐ์ ํ๋ ๋ฐ ์ฌ์ฉ๋ฉ๋๋ค.
์ดํ
์
๋ง์คํฌ๋ ํ์ฌ ํ ํฐ์ ๋ง์คํนํ์ฌ ๋ณ๊ฒฝ๋ฉ๋๋ค. ์ด ๋ ์ฒซ ๋ฒ์งธ ์์น์ ํ ํฐ์ ์ ์ธํฉ๋๋ค. ์๋ํ๋ฉด ์ฟผ๋ฆฌ์ ํค๊ฐ ๋์ผํ ๊ฐ์ ๊ฐ๊ฒ ๋๊ธฐ ๋๋ฌธ์
๋๋ค(์๋ก ๋งค์ฐ ์ ์ฌํจ).
ํด์๋ ์ฝ๊ฐ์ ๋ฌด์์์ฑ์ ๊ฐ์ง ์ ์์ผ๋ฏ๋ก, ์ค์ ๋ก๋ ์ฌ๋ฌ ๊ฐ์ ํด์ ํจ์๊ฐ ์ฌ์ฉ๋๊ณ (`n_rounds` ๋งค๊ฐ๋ณ์์ ์ํด ๊ฒฐ์ ๋จ) ๊ทธ ํ์ ํ๊ท ๊ฐ์ ์ทจํ๊ฒ ๋ฉ๋๋ค.
## ์ง์ญ ์ดํ
์
[[local_attention]]
[Longformer](model_doc/longformer)๋ ์ง์ญ ์ดํ
์
์ ์ฌ์ฉํฉ๋๋ค. ์ข
์ข
ํน์ ํ ํฐ์ ๋ํด ์ง์ญ ์ปจํ
์คํธ(์: ์ผ์ชฝ๊ณผ ์ค๋ฅธ์ชฝ์ ์๋ ๋ ๊ฐ์ ํ ํฐ์ ๋ฌด์์ธ๊ฐ์?)๋ง์ผ๋ก๋ ์์
์ ์ํํ๋๋ฐ ์ถฉ๋ถํฉ๋๋ค.
๋ํ ์์ ์ฐฝ(window)์ ๊ฐ์ง ์ดํ
์
๋ ์ด์ด๋ฅผ ์์์ผ๋ก์จ ๋ง์ง๋ง ๋ ์ด์ด๋ ์ฐฝ ๋ด์ ํ ํฐ๋ฟ๋ง ์๋๋ผ ๋ ๋ง์ ์์ ํ ํฐ์ ๋ํ ์์ฉ ์์ญ(receptive field)์ ๊ฐ๊ฒ ๋์ด ์ ์ฒด ๋ฌธ์ฅ์ ํํ์ ๊ตฌ์ถํ ์ ์์ต๋๋ค.
์ฌ์ ์ ์ ํ๋ ์ผ๋ถ ์
๋ ฅ ํ ํฐ๋ค์ ์ ์ญ ์ดํ
์
์ ๋ฐ์ต๋๋ค. ์ด ๋ช ๊ฐ์ ํ ํฐ์ ๋ํด์๋ ์ดํ
์
ํ๋ ฌ์ด ๋ชจ๋ ํ ํฐ์ ์ ๊ทผํ ์ ์์ผ๋ฉฐ, ์ด ๊ณผ์ ์ ๋์นญ์ ์ผ๋ก ์ด๋ฃจ์ด์ง๋๋ค.
๋ค๋ฅธ ๋ชจ๋ ํ ํฐ๋ค์ ๋ก์ปฌ ์ฐฝ ๋ด์ ํ ํฐ๋ค์ ๋ํด ํด๋น ํน์ ํ ํฐ๋ค์๋ ์ ๊ทผํ ์ ์์ต๋๋ค. ์ด๋ ๋
ผ๋ฌธ์ Figure 2d์์ ๋ํ๋๋ฉฐ, ์๋์ ์ํ ์ดํ
์
๋ง์คํฌ๊ฐ ์ ์๋์ด ์์ต๋๋ค:
<div class="flex justify-center">
<img scale="50 %" align="center" src="https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/local_attention_mask.png"/>
</div>
์ ์ ํ๋ผ๋ฏธํฐ์ ์ดํ
์
ํ๋ ฌ์ ์ฌ์ฉํ๋ฉด ๋ชจ๋ธ์ด ๋ ํฐ ์ํ์ค ์
๋ ฅ ๊ธธ์ด๋ฅผ ๊ฐ์ง ์ ์์ต๋๋ค.
## ๋ค๋ฅธ ๋ฐฉ๋ฒ๋ค[[other_tricks]]
### ์ถ๋ณ ์์น ์ธ์ฝ๋ฉ[[axial_positional_encodings]]
[Reformer](model_doc/reformer)๋ ์ถ๋ณ ์์น ์ธ์ฝ๋ฉ(axial positional encodings)์ ์ฌ์ฉํฉ๋๋ค. ๊ธฐ์กด์ ํธ๋์คํฌ๋จธ ๋ชจ๋ธ์์๋ ์์น ์ธ์ฝ๋ฉ ํ๋ ฌ E๋ ํฌ๊ธฐ๊ฐ \\(l \times d\\)์ธ ํ๋ ฌ์ด๋ฉฐ,
์ฌ๊ธฐ์ \\(l\\)์ ์ํ์ค ๊ธธ์ด(sequence length)์ด๊ณ \\(d\\)๋ ์จ๊ฒจ์ง ์ํ(hidden state)์ ์ฐจ์์
๋๋ค. ๋งค์ฐ ๊ธด ํ
์คํธ์ ๊ฒฝ์ฐ, ์ด ํ๋ ฌ์ ๋งค์ฐ ํฌ๋ฉฐ GPU ์์์ ๊ณต๊ฐ์ ๋ง์ด ์ฐจ์งํ ์ ์์ต๋๋ค.
์ด๋ฅผ ์ํํ๊ธฐ ์ํด, ์ถ๋ณ ์์น ์ธ์ฝ๋ฉ์ ํฐ ํ๋ ฌ E๋ฅผ ๋ ๊ฐ์ ์์ ํ๋ ฌ E1๊ณผ E2๋ก ๋ถํดํฉ๋๋ค. ์ด๋ E1์ ํฌ๊ธฐ๋ \\(l_{1} \times d_{1}\\)์ด๊ณ , E2์ ํฌ๊ธฐ๋ \\(l_{2} \times d_{2}\\)์
๋๋ค.
์ด๋ \\(l_{1} \times l_{2} = l\\)์ด๊ณ \\(d_{1} + d_{2} = d\\)(๊ธธ์ด์ ๋ํ ๊ณฑ์
์ฐ์ฐ์ ์ฌ์ฉํ๋ฉด ํจ์ฌ ์์์ง๋๋ค). E์ ์๊ฐ ๋จ๊ณ j์ ๋ํ ์๋ฒ ๋ฉ์ E1์์ ์๊ฐ ๋จ๊ณ \\(j \% l1\\)์ ์๋ฒ ๋ฉ๊ณผ E2์์ ์๊ฐ ๋จ๊ณ \\(j // l1\\)์ ์๋ฒ ๋ฉ์ ์ฐ๊ฒฐํ์ฌ ์ป์ต๋๋ค. | 0 |
mavonic_private_repos/transformers/docs/source | mavonic_private_repos/transformers/docs/source/ko/bertology.md | <!--Copyright 2020 The HuggingFace Team. All rights reserved.
Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
the License. You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
specific language governing permissions and limitations under the License.
โ ๏ธ Note that this file is in Markdown but contain specific syntax for our doc-builder (similar to MDX) that may not be
rendered properly in your Markdown viewer.
-->
# BERTology
BERT์ ๊ฐ์ ๋๊ท๋ชจ ํธ๋์คํฌ๋จธ์ ๋ด๋ถ ๋์์ ์กฐ์ฌํ๋ ์ฐ๊ตฌ ๋ถ์ผ๊ฐ ์ ์ ๋ ์ค์ํด์ง๊ณ ์์ต๋๋ค.
ํน์๋ "BERTology"๋ผ ์นญํ๊ธฐ๋ ํฉ๋๋ค. ์ด ๋ถ์ผ์ ์ข์ ์์๋ ๋ค์๊ณผ ๊ฐ์ต๋๋ค:
- BERT๋ ๊ณ ์ ์ ์ธ NLP ํ์ดํ๋ผ์ธ์ ์ฌ๋ฐ๊ฒฌ - Ian Tenney, Dipanjan Das, Ellie Pavlick:
https://arxiv.org/abs/1905.05950
- 16๊ฐ์ ํค๋๊ฐ ์ ๋ง๋ก 1๊ฐ๋ณด๋ค ๋์๊ฐ? - Paul Michel, Omer Levy, Graham Neubig:
https://arxiv.org/abs/1905.10650
- BERT๋ ๋ฌด์์ ๋ณด๋๊ฐ? BERT์ ์ดํ
์
๋ถ์ - Kevin Clark, Urvashi Khandelwal, Omer Levy, Christopher D. Manning:
https://arxiv.org/abs/1906.04341
- CAT-probing: ํ๋ก๊ทธ๋๋ฐ ์ธ์ด์ ๋ํด ์ฌ์ ํ๋ จ๋ ๋ชจ๋ธ์ด ์ด๋ป๊ฒ ์ฝ๋ ๊ตฌ์กฐ๋ฅผ ๋ณด๋์ง ์์๋ณด๊ธฐ ์ํ ๋ฉํธ๋ฆญ ๊ธฐ๋ฐ ์ ๊ทผ ๋ฐฉ๋ฒ:
https://arxiv.org/abs/2210.04633
์ฐ๋ฆฌ๋ ์ด ์๋ก์ด ์ฐ๊ตฌ ๋ถ์ผ์ ๋ฐ์ ์ ๋๊ธฐ ์ํด, BERT/GPT/GPT-2 ๋ชจ๋ธ์ ๋ด๋ถ ํํ์ ์ดํด๋ณผ ์ ์๋ ๋ช ๊ฐ์ง ๊ธฐ๋ฅ์ ์ถ๊ฐํ์ต๋๋ค.
์ด ๊ธฐ๋ฅ๋ค์ ์ฃผ๋ก Paul Michel์ ํ๋ฅญํ ์์
์ ์ฐธ๊ณ ํ์ฌ ๊ฐ๋ฐ๋์์ต๋๋ค
(https://arxiv.org/abs/1905.10650):
- BERT/GPT/GPT-2์ ๋ชจ๋ ์๋ ์ํ์ ์ ๊ทผํ๊ธฐ,
- BERT/GPT/GPT-2์ ๊ฐ ํค๋์ ๋ชจ๋ ์ดํ
์
๊ฐ์ค์น์ ์ ๊ทผํ๊ธฐ,
- ํค๋์ ์ถ๋ ฅ ๊ฐ๊ณผ ๊ทธ๋๋์ธํธ๋ฅผ ๊ฒ์ํ์ฌ ํค๋ ์ค์๋ ์ ์๋ฅผ ๊ณ์ฐํ๊ณ https://arxiv.org/abs/1905.10650์์ ์ค๋ช
๋ ๋๋ก ํค๋๋ฅผ ์ ๊ฑฐํ๋ ๊ธฐ๋ฅ์ ์ ๊ณตํฉ๋๋ค.
์ด๋ฌํ ๊ธฐ๋ฅ๋ค์ ์ดํดํ๊ณ ์ง์ ์ฌ์ฉํด๋ณผ ์ ์๋๋ก [bertology.py](https://github.com/huggingface/transformers/tree/main/examples/research_projects/bertology/run_bertology.py) ์์ ์คํฌ๋ฆฝํธ๋ฅผ ์ถ๊ฐํ์ต๋๋ค. ์ด ์์ ์คํฌ๋ฆฝํธ์์๋ GLUE์ ๋ํด ์ฌ์ ํ๋ จ๋ ๋ชจ๋ธ์์ ์ ๋ณด๋ฅผ ์ถ์ถํ๊ณ ๋ชจ๋ธ์ ๊ฐ์ง์น๊ธฐ(prune)ํด๋ด
๋๋ค.
| 0 |
mavonic_private_repos/transformers/docs/source | mavonic_private_repos/transformers/docs/source/ko/transformers_agents.md | <!--Copyright 2023 The HuggingFace Team. All rights reserved.
Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
the License. You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
specific language governing permissions and limitations under the License.
โ ๏ธ Note that this file is in Markdown but contain specific syntax for our doc-builder (similar to MDX) that may not be
rendered properly in your Markdown viewer.
-->
# Transformers Agent [[transformers-agent]]
<Tip warning={true}>
Transformers Agent๋ ์คํ ์ค์ธ API๋ก ์ธ์ ๋ ์ง ๋ณ๊ฒฝ๋ ์ ์์ต๋๋ค.
API ๋๋ ๊ธฐ๋ฐ ๋ชจ๋ธ์ด ๋ณ๊ฒฝ๋๊ธฐ ์ฝ๊ธฐ ๋๋ฌธ์ ์์ด์ ํธ๊ฐ ๋ฐํํ๋ ๊ฒฐ๊ณผ๋ ๋ฌ๋ผ์ง ์ ์์ต๋๋ค.
</Tip>
Transformers ๋ฒ์ 4.29.0.์์ *๋๊ตฌ*์ *์์ด์ ํธ*๋ผ๋ ์ปจ์
์ ๋์
ํ์ต๋๋ค. [์ด colab](https://colab.research.google.com/drive/1c7MHD-T1forUPGcC_jlwsIptOzpG3hSj)์์ ์ฌ์ฉํด๋ณผ ์ ์์ต๋๋ค.
๊ฐ๋จํ ๋งํ๋ฉด, Agent๋ ํธ๋์คํฌ๋จธ ์์ ์์ฐ์ด API๋ฅผ ์ ๊ณตํฉ๋๋ค.
์์ ๋ ๋๊ตฌ ์ธํธ๋ฅผ ์ ์ํ๊ณ , ์์ฐ์ด๋ฅผ ํด์ํ์ฌ ์ด๋ฌํ ๋๊ตฌ๋ฅผ ์ฌ์ฉํ ์ ์๋ ์์ด์ ํธ๋ฅผ ์ค๊ณํ์ต๋๋ค.
์ด API๋ ํ์ฅ์ด ๊ฐ๋ฅํ๋๋ก ์ค๊ณ ๋์์ต๋๋ค.
์ฃผ์ ๋๊ตฌ๋ฅผ ์ ๋ณํด๋์์ง๋ง, ์ปค๋ฎค๋ํฐ์์ ๊ฐ๋ฐํ ๋ชจ๋ ๋๊ตฌ๋ฅผ ์ฌ์ฉํ ์ ์๋๋ก ์์คํ
์ ์ฝ๊ฒ ํ์ฅํ ์ ์๋ ๋ฐฉ๋ฒ๋ ๋ณด์ฌ๋๋ฆฌ๊ฒ ์ต๋๋ค.
๋ช ๊ฐ์ง ์๋ฅผ ํตํด ์๋ก์ด API๋ก ๋ฌด์์ ํ ์ ์๋์ง ์ดํด๋ณด๊ฒ ์ต๋๋ค.
์ด API๋ ํนํ ๋ฉํฐ๋ชจ๋ฌ ์์
์์ ๊ฐ๋ ฅํ๋ฏ๋ก ์ด๋ฏธ์ง๋ฅผ ์์ฑํ๊ณ ํ
์คํธ๋ฅผ ์๋ฆฌ๋ด์ด ์ฝ์ด๋ณด๊ฒ ์ต๋๋ค.
```py
agent.run("Caption the following image", image=image)
```
| **Input** | **Output** |
|-----------------------------------------------------------------------------------------------------------------------------|-----------------------------------|
| <img src="https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/transformers/beaver.png" width=200> | A beaver is swimming in the water |
---
```py
agent.run("Read the following text out loud", text=text)
```
| **Input** | **Output** |
|-------------------------------------------------------------------------------------------------------------------------|----------------------------------------------|
| A beaver is swimming in the water | <audio controls><source src="https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/transformers/tts_example.wav" type="audio/wav"> your browser does not support the audio element. </audio>
---
```py
agent.run(
"In the following `document`, where will the TRRF Scientific Advisory Council Meeting take place?",
document=document,
)
```
| **Input** | **Output** |
|-----------------------------------------------------------------------------------------------------------------------------|----------------|
| <img src="https://datasets-server.huggingface.co/assets/hf-internal-testing/example-documents/--/hf-internal-testing--example-documents/test/0/image/image.jpg" width=200> | ballroom foyer |
## ๋ฐ๋ก ์์ํ๊ธฐ [[quickstart]]
`agent.run`์ ์ฌ์ฉํ๋ ค๋ฉด ๋จผ์ ๋๊ท๋ชจ ์ธ์ด ๋ชจ๋ธ(LLM)์ธ ์์ด์ ํธ๋ฅผ ์ธ์คํด์คํํด์ผ ํฉ๋๋ค.
์ ํฌ๋ openAI ๋ชจ๋ธ๋ฟ๋ง ์๋๋ผ BigCode ๋ฐ OpenAssistant์ ์คํ์์ค ๋์ฒด ๋ชจ๋ธ๋ ์ง์ํฉ๋๋ค.
openAI ๋ชจ๋ธ์ ์ฑ๋ฅ์ด ๋ ์ฐ์ํ์ง๋ง(๋จ, openAI API ํค๊ฐ ํ์ํ๋ฏ๋ก ๋ฌด๋ฃ๋ก ์ฌ์ฉํ ์ ์์),
Hugging Face๋ BigCode์ OpenAssistant ๋ชจ๋ธ์ ์๋ํฌ์ธํธ์ ๋ํ ๋ฌด๋ฃ ์ก์ธ์ค๋ฅผ ์ ๊ณตํ๊ณ ์์ต๋๋ค.
์ฐ์ ๋ชจ๋ ๊ธฐ๋ณธ ์ข
์์ฑ์ ์ค์นํ๋ ค๋ฉด `agents`๋ฅผ ์ถ๊ฐ๋ก ์ค์นํ์ธ์.
```bash
pip install transformers[agents]
```
openAI ๋ชจ๋ธ์ ์ฌ์ฉํ๋ ค๋ฉด `openai` ์ข
์์ฑ์ ์ค์นํ ํ [`OpenAiAgent`]๋ฅผ ์ธ์คํด์คํํฉ๋๋ค:
```bash
pip install openai
```
```py
from transformers import OpenAiAgent
agent = OpenAiAgent(model="text-davinci-003", api_key="<your_api_key>")
```
BigCode ๋๋ OpenAssistant๋ฅผ ์ฌ์ฉํ๋ ค๋ฉด ๋จผ์ ๋ก๊ทธ์ธํ์ฌ Inference API์ ์ก์ธ์คํ์ธ์:
```py
from huggingface_hub import login
login("<YOUR_TOKEN>")
```
๊ทธ๋ฐ ๋ค์ ์์ด์ ํธ๋ฅผ ์ธ์คํด์คํํฉ๋๋ค.
```py
from transformers import HfAgent
# Starcoder
agent = HfAgent("https://api-inference.huggingface.co/models/bigcode/starcoder")
# StarcoderBase
# agent = HfAgent("https://api-inference.huggingface.co/models/bigcode/starcoderbase")
# OpenAssistant
# agent = HfAgent(url_endpoint="https://api-inference.huggingface.co/models/OpenAssistant/oasst-sft-4-pythia-12b-epoch-3.5")
```
ํ์ฌ Hugging Face์์ ๋ฌด๋ฃ๋ก ์ ๊ณตํ๋ ์ถ๋ก API๋ฅผ ์ฌ์ฉํ๊ณ ์์ต๋๋ค.
์ด ๋ชจ๋ธ์ ๋ํ ์์ฒด ์ถ๋ก ์๋ํฌ์ธํธ๊ฐ ์๋ ๊ฒฝ์ฐ(๋๋ ๋ค๋ฅธ ์๋ํฌ์ธํธ๊ฐ ์๋ ๊ฒฝ์ฐ) ์์ URL์ ํด๋น URL ์๋ํฌ์ธํธ๋ก ๋ฐ๊ฟ ์ ์์ต๋๋ค.
<Tip>
StarCoder์ OpenAssistant๋ ๋ฌด๋ฃ๋ก ์ฌ์ฉํ ์ ์์ผ๋ฉฐ ๊ฐ๋จํ ์์
์์ ๋๋ผ์ธ ์ ๋๋ก ์ ์๋ํฉ๋๋ค.
๊ทธ๋ฌ๋ ๋ ๋ณต์กํ ํ๋กฌํํธ๋ฅผ ์ฒ๋ฆฌํ ๋๋ ์ฒดํฌํฌ์ธํธ๊ฐ ์ ์๋ํ์ง ์์ต๋๋ค.
์ด๋ฌํ ๋ฌธ์ ๊ฐ ๋ฐ์ํ๋ฉด OpenAI ๋ชจ๋ธ์ ์ฌ์ฉํด ๋ณด์๊ธฐ ๋ฐ๋๋๋ค. ์์ฝ๊ฒ๋ ์คํ์์ค๋ ์๋์ง๋ง ํ์ฌ๋ก์๋ ๋ ๋์ ์ฑ๋ฅ์ ์ ๊ณตํฉ๋๋ค.
</Tip>
์ด์ ์ค๋น๊ฐ ์๋ฃ๋์์ต๋๋ค! ์ด์ ์์ ๋กญ๊ฒ ์ฌ์ฉํ ์ ์๋ ๋ ๊ฐ์ง API์ ๋ํด ์์ธํ ์์๋ณด๊ฒ ์ต๋๋ค.
### ๋จ์ผ ์คํ (run) [[single-execution-(run)]]
๋จ์ผ ์คํ ๋ฐฉ๋ฒ์ ์์ด์ ํธ์ [`~Agent.run`] ๋ฉ์๋๋ฅผ ์ฌ์ฉํ๋ ๊ฒฝ์ฐ์
๋๋ค:
```py
agent.run("Draw me a picture of rivers and lakes.")
```
<img src="https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/transformers/rivers_and_lakes.png" width=200>
์ํํ๋ ค๋ ์์
์ ์ ํฉํ ๋๊ตฌ๋ฅผ ์๋์ผ๋ก ์ ํํ์ฌ ์ ์ ํ๊ฒ ์คํํฉ๋๋ค.
๋์ผํ ๋ช
๋ น์ด์์ ํ๋ ๋๋ ์ฌ๋ฌ ๊ฐ์ ์์
์ ์ํํ ์ ์์ต๋๋ค
(๋ค๋ง, ๋ช
๋ น์ด๊ฐ ๋ณต์กํ ์๋ก ์์ด์ ํธ๊ฐ ์คํจํ ๊ฐ๋ฅ์ฑ์ด ๋์์ง๋๋ค).
```py
agent.run("Draw me a picture of the sea then transform the picture to add an island")
```
<img src="https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/transformers/sea_and_island.png" width=200>
<br/>
๋ชจ๋ [`~Agent.run`] ์์
์ ๋
๋ฆฝ์ ์ด๋ฏ๋ก ๋ค๋ฅธ ์์
์ผ๋ก ์ฌ๋ฌ ๋ฒ ์ฐ์ํด์ ์คํํ ์ ์์ต๋๋ค.
`agent`๋ ํฐ ์ธ์ด ๋ชจ๋ธ์ผ ๋ฟ์ด๋ฏ๋ก ํ๋กฌํํธ์ ์ฝ๊ฐ์ ๋ณํ๋ฅผ ์ฃผ๋ฉด ์์ ํ ๋ค๋ฅธ ๊ฒฐ๊ณผ๊ฐ ๋์ฌ ์ ์๋ค๋ ์ ์ ์ ์ํ์ธ์.
์ํํ๋ ค๋ ์์
์ ์ต๋ํ ๋ช
ํํ๊ฒ ์ค๋ช
ํ๋ ๊ฒ์ด ์ค์ํฉ๋๋ค.
์ข์ ํ๋กฌํํธ๋ฅผ ์์ฑํ๋ ๋ฐฉ๋ฒ์ [์ฌ๊ธฐ](custom_tools#writing-good-user-inputs)์์ ์์ธํ ํ์ธํ ์ ์์ต๋๋ค.
์ฌ๋ฌ ์คํ์ ๊ฑธ์ณ ์ํ๋ฅผ ์ ์งํ๊ฑฐ๋ ํ
์คํธ๊ฐ ์๋ ๊ฐ์ฒด๋ฅผ ์์ด์ ํธ์๊ฒ ์ ๋ฌํ๋ ค๋ ๊ฒฝ์ฐ์๋ ์์ด์ ํธ๊ฐ ์ฌ์ฉํ ๋ณ์๋ฅผ ์ง์ ํ ์ ์์ต๋๋ค.
์๋ฅผ ๋ค์ด ๊ฐ๊ณผ ํธ์์ ์ฒซ ๋ฒ์งธ ์ด๋ฏธ์ง๋ฅผ ์์ฑํ ๋ค,
๋ชจ๋ธ์ด ํด๋น ๊ทธ๋ฆผ์ ์ฌ์ ์ถ๊ฐํ๋๋ก ๋ค์๊ณผ ๊ฐ์ด ์์ฒญํ ์ ์์ต๋๋ค:
```python
picture = agent.run("Generate a picture of rivers and lakes.")
updated_picture = agent.run("Transform the image in `picture` to add an island to it.", picture=picture)
```
<Tip>
์ด ๋ฐฉ๋ฒ์ ๋ชจ๋ธ์ด ์์ฒญ์ ์ดํดํ์ง ๋ชปํ๊ณ ๋๊ตฌ๋ฅผ ํผํฉํ ๋ ์ ์ฉํ ์ ์์ต๋๋ค. ์๋ฅผ ๋ค๋ฉด ๋ค์๊ณผ ๊ฐ์ต๋๋ค:
```py
agent.run("Draw me the picture of a capybara swimming in the sea")
```
์ฌ๊ธฐ์ ๋ชจ๋ธ์ ๋ ๊ฐ์ง ๋ฐฉ์์ผ๋ก ํด์ํ ์ ์์ต๋๋ค:
- `text-to-image`์ด ๋ฐ๋ค์์ ํค์์น๋ ์นดํผ๋ฐ๋ผ๋ฅผ ์์ฑํ๋๋ก ํฉ๋๋ค.
- ๋๋ `text-to-image`์ด ์นดํผ๋ฐ๋ผ๋ฅผ ์์ฑํ ๋ค์ `image-transformation` ๋๊ตฌ๋ฅผ ์ฌ์ฉํ์ฌ ๋ฐ๋ค์์ ํค์์น๋๋ก ํฉ๋๋ค.
์ฒซ ๋ฒ์งธ ์๋๋ฆฌ์ค๋ฅผ ๊ฐ์ ๋ก ์คํํ๋ ค๋ฉด ํ๋กฌํํธ๋ฅผ ์ธ์๋ก ์ ๋ฌํ์ฌ ์คํํ ์ ์์ต๋๋ค:
```py
agent.run("Draw me a picture of the `prompt`", prompt="a capybara swimming in the sea")
```
</Tip>
### ๋ํ ๊ธฐ๋ฐ ์คํ (chat) [[chat-based-execution-(chat)]]
์์ด์ ํธ๋ [`~Agent.chat`] ๋ฉ์๋๋ฅผ ์ฌ์ฉํ๋ ๋ํ ๊ธฐ๋ฐ ์ ๊ทผ ๋ฐฉ์๋ ์์ต๋๋ค:
```py
agent.chat("Generate a picture of rivers and lakes")
```
<img src="https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/transformers/rivers_and_lakes.png" width=200>
```py
agent.chat("Transform the picture so that there is a rock in there")
```
<img src="https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/transformers/rivers_and_lakes_and_beaver.png" width=200>
<br/>
์ด ๋ฐฉ์์ ์ฌ๋ฌ ๋ช
๋ น์ด์ ๊ฑธ์ณ ์ํ๋ฅผ ์ ์งํ๊ณ ์ ํ ๋ ํฅ๋ฏธ๋ก์ด ์ ๊ทผ ๋ฐฉ์์
๋๋ค.
์คํ์ฉ์ผ๋ก ๋ ์ข์ง๋ง ๋ณต์กํ ๋ช
๋ น์ด๋ณด๋ค๋
๋จ์ผ ๋ช
๋ น์ด([`~Agent.run`] ๋ฉ์๋๊ฐ ๋ ์ ์ฒ๋ฆฌํ๋ ๋ช
๋ น์ด)์ ํจ์ฌ ๋ ์ ์๋ํ๋ ๊ฒฝํฅ์ด ์์ต๋๋ค.
์ด ๋ฉ์๋๋ ํ
์คํธ๊ฐ ์๋ ์ ํ์ด๋ ํน์ ํ๋กฌํํธ๋ฅผ ์ ๋ฌํ๋ ค๋ ๊ฒฝ์ฐ ์ธ์๋ฅผ ๋ฐ์ ์๋ ์์ต๋๋ค.
### โ ๏ธ ์๊ฒฉ ์คํ [[remote-execution]]
๋ฐ๋ชจ ๋ชฉ์ ๊ณผ ๋ชจ๋ ์ค์ ์์ ์ฌ์ฉํ ์ ์๋๋ก
์์ด์ ํธ๊ฐ ์ ๊ทผํ ์ ์๋ ๋ช ๊ฐ์ง ๊ธฐ๋ณธ ๋๊ตฌ์ ๋ํ ์๊ฒฉ ์คํ๊ธฐ๋ฅผ ๋ง๋ค์์ต๋๋ค.
์ด๋ฌํ ๋๊ตฌ๋ [inference endpoints](https://huggingface.co/inference-endpoints)๋ฅผ ์ฌ์ฉํ์ฌ ๋ง๋ค์ด์ก์ต๋๋ค.
์๊ฒฉ ์คํ๊ธฐ ๋๊ตฌ๋ฅผ ์ง์ ์ค์ ํ๋ ๋ฐฉ๋ฒ์ ๋ณด๋ ค๋ฉด [์ฌ์ฉ์ ์ ์ ๋๊ตฌ ๊ฐ์ด๋](./custom_tools)๋ฅผ ์ฝ์ด๋ณด์๊ธฐ ๋ฐ๋๋๋ค.
์๊ฒฉ ๋๊ตฌ๋ก ์คํํ๋ ค๋ฉด [`~Agent.run`] ๋๋ [`~Agent.chat`] ์ค ํ๋์ `remote=True`๋ฅผ ์ง์ ํ๊ธฐ๋ง ํ๋ฉด ๋ฉ๋๋ค.
์๋ฅผ ๋ค์ด ๋ค์ ๋ช
๋ น์ ๋ง์ RAM์ด๋ GPU ์์ด๋ ๋ชจ๋ ์ฅ์น์์ ํจ์จ์ ์ผ๋ก ์คํํ ์ ์์ต๋๋ค:
```py
agent.run("Draw me a picture of rivers and lakes", remote=True)
```
[`~Agent.chat`]๋ ๋ง์ฐฌ๊ฐ์ง์
๋๋ค:
```py
agent.chat("Draw me a picture of rivers and lakes", remote=True)
```
### ์ฌ๊ธฐ์ ๋ฌด์จ ์ผ์ด ์ผ์ด๋๋ ๊ฑฐ์ฃ ? ๋๊ตฌ๋ ๋ฌด์์ด๊ณ , ์์ด์ ํธ๋ ๋ฌด์์ธ๊ฐ์? [[whats-happening-here-what-are-tools-and-what-are-agents]]
<img src="https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/transformers/diagram.png">
#### ์์ด์ ํธ [[agents]]
์ฌ๊ธฐ์ "์์ด์ ํธ"๋ ๋๊ท๋ชจ ์ธ์ด ๋ชจ๋ธ์ด๋ฉฐ, ํน์ ๋๊ตฌ ๋ชจ์์ ์ ๊ทผํ ์ ์๋๋ก ํ๋กฌํํธํ๊ณ ์์ต๋๋ค.
LLM์ ์์ ์ฝ๋ ์ํ์ ์์ฑํ๋ ๋ฐ ์๋นํ ๋ฅ์ํ๋ฏ๋ก,
์ด ์ฅ์ ์ ํ์ฉํด ๋๊ตฌ ๋ชจ์์ ์ฌ์ฉํ์ฌ ์์
์ ์ํํ๋ ์์ ์ฝ๋ ์ํ์ ์ ๊ณตํ๋ผ๋ ๋ฉ์์ง๋ฅผ ํ์ํฉ๋๋ค.
๊ทธ๋ฐ ๋ค์ ์์ด์ ํธ์๊ฒ ์ ๊ณตํ๋ ์์
๊ณผ ์ ๊ณตํ๋ ๋๊ตฌ์ ๋ํ ์ค๋ช
์ผ๋ก ์ด ํ๋กฌํํธ๊ฐ ์๋ฃ๋ฉ๋๋ค.
์ด๋ ๊ฒ ํ๋ฉด ์ฌ์ฉ ์ค์ธ ๋๊ตฌ๋ค์ ๋ฌธ์์ ์ ๊ทผํ ์ ์์ผ๋ฉฐ, ํด๋น ๋๊ตฌ๋ค์ ์
๋ ฅ๊ณผ ์ถ๋ ฅ์ ์์ํ๊ณ , ๊ด๋ จ๋ ์ฝ๋๋ฅผ ์์ฑํ ์ ์์ต๋๋ค.
#### ๋๊ตฌ [[tools]]
๋๊ตฌ๋ ๋งค์ฐ ๊ฐ๋จํฉ๋๋ค. ์ด๋ฆ๊ณผ ์ค๋ช
์ด ์๋ ๋จ์ผ ๊ธฐ๋ฅ์ผ๋ก ๊ตฌ์ฑ๋์ด ์์ต๋๋ค.
๊ทธ๋ฐ ๋ค์ ์ด๋ฌํ ๋๊ตฌ์ ์ค๋ช
์ ์ฌ์ฉํ์ฌ ์๋ด์์๊ฒ ํ๋กฌํํธ๋ฅผ ํ์ํฉ๋๋ค.
์ด ํ๋กฌํํธ๋ฅผ ํตํด ์๋ด์์๊ฒ ์ฟผ๋ฆฌ์์ ์์ฒญ๋ ์์
์ ์ํํ๊ธฐ ์ํด ๋๊ตฌ๋ฅผ ํ์ฉํ๋ ๋ฐฉ๋ฒ์ ๋ณด์ฌ์ค๋๋ค.
์์ด์ ํธ๊ฐ ๋งค์ฐ ์์์ ์ธ ๋๊ตฌ๋ฅผ ์ฌ์ฉํ์ฌ ๋ ๋์ ์ฝ๋๋ฅผ ์์ฑํ๊ธฐ ๋๋ฌธ์ ํ์ดํ๋ผ์ธ์ด ์๋ ์์ ํ ์๋ก์ด ๋๊ตฌ๋ฅผ ์ฌ์ฉํฉ๋๋ค.
ํ์ดํ๋ผ์ธ์ ๋ ๋ง์ด ๋ฆฌํฉํฐ๋ง๋๋ฉฐ ์ข
์ข
์ฌ๋ฌ ์์
์ ํ๋๋ก ๊ฒฐํฉํฉ๋๋ค.
๋๊ตฌ๋ ํ๋์ ๋งค์ฐ ๊ฐ๋จํ ์์
์๋ง ์ง์คํ๋๋ก ๋์ด ์์ต๋๋ค.
#### ์ฝ๋ ์คํ?! [[code-execution]]
๊ทธ๋ฐ ๋ค์ ์ด ์ฝ๋๋ ๋๊ตฌ์ ํจ๊ป ์ ๋ฌ๋ ์
๋ ฅ ์ธํธ์ ๋ํด ์์ Python ์ธํฐํ๋ฆฌํฐ๋ฅผ ์ฌ์ฉํ์ฌ ์คํ๋ฉ๋๋ค.
"์์ ์ฝ๋ ์คํ์ด๋ผ๋!"์ด๋ผ๊ณ ๋น๋ช
์ ์ง๋ฅด๋ ์๋ฆฌ๊ฐ ๋ค๋ฆฌ๊ฒ ์ง๋ง, ๊ทธ๋ ์ง ์์ ์ด์ ๋ฅผ ์ค๋ช
ํ๊ฒ ์ต๋๋ค.
ํธ์ถํ ์ ์๋ ํจ์๋ ์ ๊ณตํ ๋๊ตฌ์ ์ธ์ ๊ธฐ๋ฅ๋ฟ์ด๋ฏ๋ก ์ด๋ฏธ ์คํํ ์ ์๋ ๊ธฐ๋ฅ์ด ์ ํ๋์ด ์์ต๋๋ค.
Hugging Face ๋๊ตฌ๋ก ์ ํ๋์ด ์๋ค๋ฉด ์์ ํ ๊ฒ์
๋๋ค.
๊ทธ๋ฆฌ๊ณ ์ดํธ๋ฆฌ๋ทฐํธ ์กฐํ๋ ๊ฐ์ ธ์ค๊ธฐ๋ฅผ ํ์ฉํ์ง ์์ผ๋ฏ๋ก
(์ด์ฐจํผ ์์ ํจ์ ์งํฉ์ ์
/์ถ๋ ฅ์ ์ ๋ฌํ ๋๋ ํ์ํ์ง ์์์ผ ํฉ๋๋ค)
๊ฐ์ฅ ๋ช
๋ฐฑํ ๊ณต๊ฒฉ(์ด์ฐจํผ LLM์ ์ถ๋ ฅํ๋ผ๋ ๋ฉ์์ง๋ฅผ ํ์ํด์ผ ํฉ๋๋ค)์ ๋ฌธ์ ๊ฐ ๋์ง ์์ต๋๋ค.
๋งค์ฐ ์์ ํ๊ฒ ํ๊ณ ์ถ๋ค๋ฉด ์ถ๊ฐ ์ธ์ return_code=True๋ฅผ ์ฌ์ฉํ์ฌ run() ๋ฉ์๋๋ฅผ ์คํํ๋ฉด ๋ฉ๋๋ค.
์ด ๊ฒฝ์ฐ ์์ด์ ํธ๊ฐ ์คํํ ์ฝ๋๋ฅผ ๋ฐํํ๊ณ ์คํํ ์ง ์ฌ๋ถ๋ฅผ ๊ฒฐ์ ํ ์ ์์ต๋๋ค.
๋ถ๋ฒ์ ์ธ ์ฐ์ฐ์ ์ํํ๋ ค๊ณ ํ๊ฑฐ๋ ์์ด์ ํธ๊ฐ ์์ฑํ ์ฝ๋์ ์ผ๋ฐ์ ์ธ ํ์ด์ฌ ์ค๋ฅ๊ฐ ์๋ ๊ฒฝ์ฐ
์คํ์ด ์ค์ง๋ฉ๋๋ค.
### ์์ ๋ ๋๊ตฌ ๋ชจ์ [[a-curated-set-of-tools]]
์ ํฌ๋ ์ด๋ฌํ ์์ด์ ํธ๋ค์ ์ญ๋์ ๊ฐํํ ์ ์๋ ์ผ๋ จ์ ๋๊ตฌ๋ฅผ ํ์ธํ๊ณ ์์ต๋๋ค.
๋ค์์ ์ฐ๋๋ ๋๊ตฌ์ ์ต์ ๋ชฉ๋ก์
๋๋ค:
- **๋ฌธ์ ์ง๋ฌธ ๋ต๋ณ**: ์ด๋ฏธ์ง ํ์์ ๋ฌธ์(์: PDF)๊ฐ ์ฃผ์ด์ง๋ฉด ์ด ๋ฌธ์์ ๋ํ ์ง๋ฌธ์ ๋ต๋ณํฉ๋๋ค. ([Donut](./model_doc/donut))
- **ํ
์คํธ ์ง๋ฌธ ๋ต๋ณ**: ๊ธด ํ
์คํธ์ ์ง๋ฌธ์ด ์ฃผ์ด์ง๋ฉด ํ
์คํธ์์ ์ง๋ฌธ์ ๋ต๋ณํฉ๋๋ค. ([Flan-T5](./model_doc/flan-t5))
- **๋ฌด์กฐ๊ฑด ์ด๋ฏธ์ง ์บก์
๋**: ์ด๋ฏธ์ง์ ์บก์
์ ๋ต๋๋ค! ([BLIP](./model_doc/blip))
- **์ด๋ฏธ์ง ์ง๋ฌธ ๋ต๋ณ**: ์ด๋ฏธ์ง๊ฐ ์ฃผ์ด์ง๋ฉด ์ด ์ด๋ฏธ์ง์ ๋ํ ์ง๋ฌธ์ ๋ต๋ณํ๊ธฐ. ([VILT](./model_doc/vilt))
- **์ด๋ฏธ์ง ๋ถํ **: ์ด๋ฏธ์ง์ ํ๋กฌํํธ๊ฐ ์ฃผ์ด์ง๋ฉด ํด๋น ํ๋กฌํํธ์ ๋ถํ ๋ง์คํฌ๋ฅผ ์ถ๋ ฅํฉ๋๋ค. ([CLIPSeg](./model_doc/clipseg))
- **์์ฑ์ ํ
์คํธ๋ก ๋ณํ**: ์ฌ๋์ด ๋งํ๋ ์ค๋์ค ๋
น์์ด ์ฃผ์ด์ง๋ฉด ์์ฑ์ ํ
์คํธ๋ก ๋ณํํฉ๋๋ค. ([Whisper](./model_doc/whisper))
- **ํ
์คํธ ์์ฑ ๋ณํ**: ํ
์คํธ๋ฅผ ์์ฑ์ผ๋ก ๋ณํํฉ๋๋ค. ([SpeechT5](./model_doc/speecht5))
- **์ ๋ก ์ท(zero-shot) ํ
์คํธ ๋ถ๋ฅ**: ํ
์คํธ์ ๋ ์ด๋ธ ๋ชฉ๋ก์ด ์ฃผ์ด์ง๋ฉด ํ
์คํธ์ ๊ฐ์ฅ ๊ด๋ จ ์๋ ๋ ์ด๋ธ์ ์๋ณํฉ๋๋ค. ([BART](./model_doc/bart))
- **ํ
์คํธ ์์ฝ**: ๊ธด ํ
์คํธ๋ฅผ ํ ๋ฌธ์ฅ ๋๋ ๋ช ๋ฌธ์ฅ์ผ๋ก ์์ฝํฉ๋๋ค. ([BART](./model_doc/bart))
- **๋ฒ์ญ**: ํ
์คํธ๋ฅผ ์ง์ ๋ ์ธ์ด๋ก ๋ฒ์ญํฉ๋๋ค. ([NLLB](./model_doc/nllb))
์ด๋ฌํ ๋๊ตฌ๋ ํธ๋์คํฌ๋จธ์ ํตํฉ๋์ด ์์ผ๋ฉฐ, ์๋ฅผ ๋ค์ด ์๋์ผ๋ก๋ ์ฌ์ฉํ ์ ์์ต๋๋ค:
```py
from transformers import load_tool
tool = load_tool("text-to-speech")
audio = tool("This is a text to speech tool")
```
### ์ฌ์ฉ์ ์ ์ ๋๊ตฌ [[custom-tools]]
์์ ๋ ๋๊ตฌ ์ธํธ๋ ์์ง๋ง, ์ด ๊ตฌํ์ด ์ ๊ณตํ๋ ๊ฐ์ฅ ํฐ ๊ฐ์น๋ ์ฌ์ฉ์ ์ง์ ๋๊ตฌ๋ฅผ ๋น ๋ฅด๊ฒ ๋ง๋ค๊ณ ๊ณต์ ํ ์ ์๋ค๋ ์ ์
๋๋ค.
๋๊ตฌ์ ์ฝ๋๋ฅผ Hugging Face Space๋ ๋ชจ๋ธ ์ ์ฅ์์ ํธ์ํ๋ฉด ์์ด์ ํธ์๊ฒ ์ง์ ๋๊ตฌ๋ฅผ ํ์ฉํ ์ ์์ต๋๋ค. [`huggingface-tools` organization](https://huggingface.co/huggingface-tools)์ ๋ช ๊ฐ์ง **ํธ๋์คํฌ๋จธ์ ๊ตฌ์ ๋ฐ์ง ์๋** ํด์ ์ถ๊ฐํ์ต๋๋ค:
- **ํ
์คํธ ๋ค์ด๋ก๋**: ์น URL์์ ํ
์คํธ๋ฅผ ๋ค์ด๋ก๋ํฉ๋๋ค.
- **ํ
์คํธ ์ด๋ฏธ์ง ๋ณํ**: ํ๋กฌํํธ์ ๋ฐ๋ผ ์ด๋ฏธ์ง๋ฅผ ์์ฑํ์ฌ ์์ ์ ์ธ ํ์ฐ์ ํ์ฉํฉ๋๋ค.
- **์ด๋ฏธ์ง ๋ณํ**: ์ด๊ธฐ ์ด๋ฏธ์ง์ ํ๋กฌํํธ๊ฐ ์ฃผ์ด์ง ์ด๋ฏธ์ง๋ฅผ ์์ ํ๊ณ , ์์ ์ ์ธ ํ์ฐ์ ํ์ฉํ๋ ์ง์ ํฝ์
2 ํฝ์
์ ํ์ฉํฉ๋๋ค.
- **ํ
์คํธ ๋น๋์ค ๋ณํ**: ํ๋กฌํํธ์ ๋ฐ๋ผ ์์ ๋น๋์ค๋ฅผ ์์ฑํ๋ฉฐ, damo-vilab์ ํ์ฉํฉ๋๋ค.
์ ํฌ๊ฐ ์ฒ์๋ถํฐ ์ฌ์ฉํ๊ณ ์๋ ํ
์คํธ-์ด๋ฏธ์ง ๋ณํ ๋๊ตฌ๋ [*huggingface-tools/text-to-image*](https://huggingface.co/spaces/huggingface-tools/text-to-image)์ ์๋ ์๊ฒฉ ๋๊ตฌ์
๋๋ค! ์ ํฌ๋ ์ด ๋๊ตฌ์ ๋ค๋ฅธ ์กฐ์ง์ ์ด๋ฌํ ๋๊ตฌ๋ฅผ ๊ณ์ ์ถ์ํ์ฌ ์ด ๊ตฌํ์ ๋์ฑ ๊ฐํํ ๊ฒ์
๋๋ค.
์์ด์ ํธ๋ ๊ธฐ๋ณธ์ ์ผ๋ก [`huggingface-tools`](https://huggingface.co/huggingface-tools)์ ์๋ ๋๊ตฌ์ ์ ๊ทผํ ์ ์์ต๋๋ค.
[๋ค์ ๊ฐ์ด๋](custom_tools)์์ ๋๊ตฌ๋ฅผ ์์ฑํ๊ณ ๊ณต์ ํ๋ ๋ฐฉ๋ฒ๊ณผ Hub์ ์๋ ์ฌ์ฉ์ ์ง์ ๋๊ตฌ๋ฅผ ํ์ฉํ๋ ๋ฐฉ๋ฒ์ ๋ํด ์ค๋ช
ํฉ๋๋ค.
### ์ฝ๋ ์์ฑ[[code-generation]]
์ง๊ธ๊น์ง ์์ด์ ํธ๋ฅผ ์ฌ์ฉํ์ฌ ์์
์ ์ํํ๋ ๋ฐฉ๋ฒ์ ๋ณด์ฌ๋๋ ธ์ต๋๋ค. ํ์ง๋ง ์์ด์ ํธ๋ ๋งค์ฐ ์ ํ๋ Python ์ธํฐํ๋ฆฌํฐ๋ฅผ ์ฌ์ฉํ์ฌ ์คํํ ์ฝ๋๋ง ์์ฑํ๊ณ ์์ต๋๋ค. ๋ค๋ฅธ ์ค์ ์์ ์์ฑ๋ ์ฝ๋๋ฅผ ์ฌ์ฉํ๋ ค๋ ๊ฒฝ์ฐ ์์ด์ ํธ์๊ฒ ๋๊ตฌ ์ ์ ๋ฐ ์ ํํ ๊ฐ์ ธ์ค๊ธฐ์ ํจ๊ป ์ฝ๋๋ฅผ ๋ฐํํ๋ผ๋ ๋ฉ์์ง๋ฅผ ํ์ํ ์ ์์ต๋๋ค.
์๋ฅผ ๋ค์ด ๋ค์ ๋ช
๋ น์ด๋
```python
agent.run("Draw me a picture of rivers and lakes", return_code=True)
```
๋ค์ ์ฝ๋๋ฅผ ๋ฐํํฉ๋๋ค.
```python
from transformers import load_tool
image_generator = load_tool("huggingface-tools/text-to-image")
image = image_generator(prompt="rivers and lakes")
```
์ด ์ฝ๋๋ ์ง์ ์์ ํ๊ณ ์คํํ ์ ์์ต๋๋ค. | 0 |
mavonic_private_repos/transformers/docs/source | mavonic_private_repos/transformers/docs/source/ko/custom_tools.md | <!--Copyright 2023 The HuggingFace Team. All rights reserved.
Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
the License. You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
specific language governing permissions and limitations under the License.
-->
# ์ฌ์ฉ์ ์ ์ ๋๊ตฌ์ ํ๋กฌํํธ[[custom-tools-and-prompts]]
<Tip>
Transformers์ ๊ด๋ จํ์ฌ ์ด๋ค ๋๊ตฌ์ ์์ด์ ํธ๊ฐ ์๋์ง ์ ๋ชจ๋ฅด์ ๋ค๋ฉด [Transformers Agents](transformers_agents) ํ์ด์ง๋ฅผ ๋จผ์ ์ฝ์ด๋ณด์๊ธฐ ๋ฐ๋๋๋ค.
</Tip>
<Tip warning={true}>
Transformers Agents๋ ์คํ ์ค์ธ API๋ก ์ธ์ ๋ ์ง ๋ณ๊ฒฝ๋ ์ ์์ต๋๋ค.
API ๋๋ ๊ธฐ๋ฐ ๋ชจ๋ธ์ด ๋ณ๊ฒฝ๋๊ธฐ ์ฝ๊ธฐ ๋๋ฌธ์ ์์ด์ ํธ๊ฐ ๋ฐํํ๋ ๊ฒฐ๊ณผ๋ ๋ฌ๋ผ์ง ์ ์์ต๋๋ค.
</Tip>
์์ด์ ํธ์๊ฒ ๊ถํ์ ๋ถ์ฌํ๊ณ ์๋ก์ด ์์
์ ์ํํ๊ฒ ํ๋ ค๋ฉด ์ฌ์ฉ์ ์ ์ ๋๊ตฌ์ ํ๋กฌํํธ๋ฅผ ๋ง๋ค๊ณ ์ฌ์ฉํ๋ ๊ฒ์ด ๋ฌด์๋ณด๋ค ์ค์ํฉ๋๋ค.
์ด ๊ฐ์ด๋์์๋ ๋ค์๊ณผ ๊ฐ์ ๋ด์ฉ์ ์ดํด๋ณด๊ฒ ์ต๋๋ค:
- ํ๋กฌํํธ๋ฅผ ์ฌ์ฉ์ ์ ์ํ๋ ๋ฐฉ๋ฒ
- ์ฌ์ฉ์ ์ ์ ๋๊ตฌ๋ฅผ ์ฌ์ฉํ๋ ๋ฐฉ๋ฒ
- ์ฌ์ฉ์ ์ ์ ๋๊ตฌ๋ฅผ ๋ง๋๋ ๋ฐฉ๋ฒ
## ํ๋กฌํํธ๋ฅผ ์ฌ์ฉ์ ์ ์ํ๊ธฐ[[customizing-the-prompt]]
[Transformers Agents](transformers_agents)์์ ์ค๋ช
ํ ๊ฒ์ฒ๋ผ ์์ด์ ํธ๋ [`~Agent.run`] ๋ฐ [`~Agent.chat`] ๋ชจ๋์์ ์คํํ ์ ์์ต๋๋ค.
`run`(์คํ) ๋ชจ๋์ `chat`(์ฑํ
) ๋ชจ๋ ๋ชจ๋ ๋์ผํ ๋ก์ง์ ๊ธฐ๋ฐ์ผ๋ก ํฉ๋๋ค.
์์ด์ ํธ๋ฅผ ๊ตฌ๋ํ๋ ์ธ์ด ๋ชจ๋ธ์ ๊ธด ํ๋กฌํํธ์ ๋ฐ๋ผ ์กฐ๊ฑด์ด ์ง์ ๋๊ณ , ์ค์ง ํ ํฐ์ ๋๋ฌํ ๋๊น์ง ๋ค์ ํ ํฐ์ ์์ฑํ์ฌ ํ๋กฌํํธ๋ฅผ ์์ํฉ๋๋ค.
`chat` ๋ชจ๋์์๋ ํ๋กฌํํธ๊ฐ ์ด์ ์ฌ์ฉ์ ์
๋ ฅ ๋ฐ ๋ชจ๋ธ ์์ฑ์ผ๋ก ์ฐ์ฅ๋๋ค๋ ์ ์ด ๋ ๋ชจ๋์ ์ ์ผํ ์ฐจ์ด์ ์
๋๋ค.
์ด๋ฅผ ํตํด ์์ด์ ํธ๊ฐ ๊ณผ๊ฑฐ ์ํธ์์ฉ์ ์ ๊ทผํ ์ ์๊ฒ ๋๋ฏ๋ก ์์ด์ ํธ์๊ฒ ์ผ์ข
์ ๋ฉ๋ชจ๋ฆฌ๋ฅผ ์ ๊ณตํ๋ ์
์
๋๋ค.
### ํ๋กฌํํธ์ ๊ตฌ์กฐ[[structure-of-the-prompt]]
์ด๋ป๊ฒ ํ๋กฌํํธ ์ฌ์ฉ์ ์ ์๋ฅผ ์ ํ ์ ์๋์ง ์ดํดํ๊ธฐ ์ํด ํ๋กฌํํธ์ ๊ตฌ์กฐ๋ฅผ ์์ธํ ์ดํด๋ด
์๋ค.
ํ๋กฌํํธ๋ ํฌ๊ฒ ๋ค ๋ถ๋ถ์ผ๋ก ๊ตฌ์ฑ๋์ด ์์ต๋๋ค.
- 1. ๋์
: ์์ด์ ํธ๊ฐ ์ด๋ป๊ฒ ํ๋ํด์ผ ํ๋์ง, ๋๊ตฌ์ ๊ฐ๋
์ ๋ํ ์ค๋ช
.
- 2. ๋ชจ๋ ๋๊ตฌ์ ๋ํ ์ค๋ช
. ์ด๋ ๋ฐํ์์ ์ฌ์ฉ์๊ฐ ์ ์/์ ํํ ๋๊ตฌ๋ก ๋์ ์ผ๋ก ๋์ฒด๋๋ `<<all_tools>>` ํ ํฐ์ผ๋ก ์ ์๋ฉ๋๋ค.
- 3. ์์
์์ ๋ฐ ํด๋น ์๋ฃจ์
์ธํธ.
- 4. ํ์ฌ ์์ ๋ฐ ํด๊ฒฐ ์์ฒญ.
๊ฐ ๋ถ๋ถ์ ๋ ์ ์ดํดํ ์ ์๋๋ก ์งง์ ๋ฒ์ ์ ํตํด `run` ํ๋กฌํํธ๊ฐ ์ด๋ป๊ฒ ๋ณด์ด๋์ง ์ดํด๋ณด๊ฒ ์ต๋๋ค:
````text
I will ask you to perform a task, your job is to come up with a series of simple commands in Python that will perform the task.
[...]
You can print intermediate results if it makes sense to do so.
Tools:
- document_qa: This is a tool that answers a question about a document (pdf). It takes an input named `document` which should be the document containing the information, as well as a `question` that is the question about the document. It returns a text that contains the answer to the question.
- image_captioner: This is a tool that generates a description of an image. It takes an input named `image` which should be the image to the caption and returns a text that contains the description in English.
[...]
Task: "Answer the question in the variable `question` about the image stored in the variable `image`. The question is in French."
I will use the following tools: `translator` to translate the question into English and then `image_qa` to answer the question on the input image.
Answer:
```py
translated_question = translator(question=question, src_lang="French", tgt_lang="English")
print(f"The translated question is {translated_question}.")
answer = image_qa(image=image, question=translated_question)
print(f"The answer is {answer}")
```
Task: "Identify the oldest person in the `document` and create an image showcasing the result as a banner."
I will use the following tools: `document_qa` to find the oldest person in the document, then `image_generator` to generate an image according to the answer.
Answer:
```py
answer = document_qa(document, question="What is the oldest person?")
print(f"The answer is {answer}.")
image = image_generator("A banner showing " + answer)
```
[...]
Task: "Draw me a picture of rivers and lakes"
I will use the following
````
๋์
(*"๋๊ตฌ:"* ์์ ํ
์คํธ)์์๋ ๋ชจ๋ธ์ด ์ด๋ป๊ฒ ์๋ํ๊ณ ๋ฌด์์ ํด์ผ ํ๋์ง ์ ํํ๊ฒ ์ค๋ช
ํฉ๋๋ค.
์์ด์ ํธ๋ ํญ์ ๊ฐ์ ๋ฐฉ์์ผ๋ก ์๋ํด์ผ ํ๋ฏ๋ก ์ด ๋ถ๋ถ์ ์ฌ์ฉ์ ์ ์ํ ํ์๊ฐ ์์ ๊ฐ๋ฅ์ฑ์ด ๋์ต๋๋ค.
๋ ๋ฒ์งธ ๋ถ๋ถ(*"๋๊ตฌ"* ์๋์ ๊ธ๋จธ๋ฆฌ ๊ธฐํธ)์ `run` ๋๋ `chat`์ ํธ์ถํ ๋ ๋์ ์ผ๋ก ์ถ๊ฐ๋ฉ๋๋ค.
์ ํํ `agent.toolbox`์ ์๋ ๋๊ตฌ ์๋งํผ ๊ธ๋จธ๋ฆฌ ๊ธฐํธ๊ฐ ์๊ณ , ๊ฐ ๊ธ๋จธ๋ฆฌ ๊ธฐํธ๋ ๋๊ตฌ์ ์ด๋ฆ๊ณผ ์ค๋ช
์ผ๋ก ๊ตฌ์ฑ๋ฉ๋๋ค:
```text
- <tool.name>: <tool.description>
```
๋ฌธ์ ์ง์์๋ต ๋๊ตฌ๋ฅผ ๊ฐ์ ธ์ค๊ณ ์ด๋ฆ๊ณผ ์ค๋ช
์ ์ถ๋ ฅํด์ ๋น ๋ฅด๊ฒ ํ์ธํด ๋ณด๊ฒ ์ต๋๋ค.
```py
from transformers import load_tool
document_qa = load_tool("document-question-answering")
print(f"- {document_qa.name}: {document_qa.description}")
```
๊ทธ๋ฌ๋ฉด ๋ค์ ๊ฒฐ๊ณผ๊ฐ ์ถ๋ ฅ๋ฉ๋๋ค:
```text
- document_qa: This is a tool that answers a question about a document (pdf). It takes an input named `document` which should be the document containing the information, as well as a `question` that is the question about the document. It returns a text that contains the answer to the question.
```
์ฌ๊ธฐ์ ๋๊ตฌ ์ด๋ฆ์ด ์งง๊ณ ์ ํํ๋ค๋ ๊ฒ์ ์ ์ ์์ต๋๋ค.
์ค๋ช
์ ๋ ๋ถ๋ถ์ผ๋ก ๊ตฌ์ฑ๋์ด ์๋๋ฐ, ์ฒซ ๋ฒ์งธ ๋ถ๋ถ์์๋ ๋๊ตฌ์ ๊ธฐ๋ฅ์ ์ค๋ช
ํ๊ณ ๋ ๋ฒ์งธ ๋ถ๋ถ์์๋ ์์๋๋ ์
๋ ฅ ์ธ์์ ๋ฐํ ๊ฐ์ ๋ช
์ํฉ๋๋ค.
์์ด์ ํธ๊ฐ ๋๊ตฌ๋ฅผ ์ฌ๋ฐ๋ฅด๊ฒ ์ฌ์ฉํ๋ ค๋ฉด ์ข์ ๋๊ตฌ ์ด๋ฆ๊ณผ ๋๊ตฌ ์ค๋ช
์ด ๋งค์ฐ ์ค์ํฉ๋๋ค.
์์ด์ ํธ๊ฐ ๋๊ตฌ์ ๋ํด ์ ์ ์๋ ์ ์ผํ ์ ๋ณด๋ ์ด๋ฆ๊ณผ ์ค๋ช
๋ฟ์ด๋ฏ๋ก, ์ด ๋ ๊ฐ์ง๋ฅผ ์ ํํ๊ฒ ์์ฑํ๊ณ ๋๊ตฌ ์์์ ์๋ ๊ธฐ์กด ๋๊ตฌ์ ์คํ์ผ๊ณผ ์ผ์นํ๋์ง ํ์ธํด์ผ ํฉ๋๋ค.
ํนํ ์ด๋ฆ์ ๋ฐ๋ผ ์์๋๋ ๋ชจ๋ ์ธ์๊ฐ ์ค๋ช
์ ์ฝ๋ ์คํ์ผ๋ก ์ธ๊ธ๋์ด ์๋์ง, ์์๋๋ ์ ํ๊ณผ ๊ทธ ์ ํ์ด ๋ฌด์์ธ์ง์ ๋ํ ์ค๋ช
์ด ํฌํจ๋์ด ์๋์ง ํ์ธํ์ธ์.
<Tip>
๋๊ตฌ์ ์ด๋ค ์ด๋ฆ๊ณผ ์ค๋ช
์ด ์์ด์ผ ํ๋์ง ์ดํดํ๋ ค๋ฉด ์์ ๋ Transformers ๋๊ตฌ์ ์ด๋ฆ๊ณผ ์ค๋ช
์ ํ์ธํ์ธ์.
[`Agent.toolbox`] ์์ฑ์ ๊ฐ์ง ๋ชจ๋ ๋๊ตฌ๋ฅผ ๋ณผ ์ ์์ต๋๋ค.
</Tip>
์ธ ๋ฒ์งธ ๋ถ๋ถ์๋ ์์ด์ ํธ๊ฐ ์ด๋ค ์ข
๋ฅ์ ์ฌ์ฉ์ ์์ฒญ์ ๋ํด ์ด๋ค ์ฝ๋๋ฅผ ์์ฑํด์ผ ํ๋์ง ์ ํํ๊ฒ ๋ณด์ฌ์ฃผ๋ ์์ ๋ ์์ ์ธํธ๊ฐ ํฌํจ๋์ด ์์ต๋๋ค.
์์ด์ ํธ๋ฅผ ์ง์ํ๋ ๋๊ท๋ชจ ์ธ์ด ๋ชจ๋ธ์ ํ๋กฌํํธ์์ ํจํด์ ์ธ์ํ๊ณ ์๋ก์ด ๋ฐ์ดํฐ๋ก ํจํด์ ๋ฐ๋ณตํ๋ ๋ฐ ๋งค์ฐ ๋ฅ์ํฉ๋๋ค.
๋ฐ๋ผ์ ์์ด์ ํธ๊ฐ ์ค์ ๋ก ์ฌ๋ฐ๋ฅธ ์คํ ๊ฐ๋ฅํ ์ฝ๋๋ฅผ ์์ฑํ ๊ฐ๋ฅ์ฑ์ ๊ทน๋ํํ๋ ๋ฐฉ์์ผ๋ก ์์ ๋ฅผ ์์ฑํ๋ ๊ฒ์ด ๋งค์ฐ ์ค์ํฉ๋๋ค.
ํ ๊ฐ์ง ์๋ฅผ ์ดํด๋ณด๊ฒ ์ต๋๋ค:
````text
Task: "Identify the oldest person in the `document` and create an image showcasing the result as a banner."
I will use the following tools: `document_qa` to find the oldest person in the document, then `image_generator` to generate an image according to the answer.
Answer:
```py
answer = document_qa(document, question="What is the oldest person?")
print(f"The answer is {answer}.")
image = image_generator("A banner showing " + answer)
```
````
์์
์ค๋ช
, ์์ด์ ํธ๊ฐ ์ํํ๋ ค๋ ์์
์ ๋ํ ์ค๋ช
, ๋ง์ง๋ง์ผ๋ก ์์ฑ๋ ์ฝ๋, ์ด ์ธ ๋ถ๋ถ์ผ๋ก ๊ตฌ์ฑ๋ ํ๋กฌํํธ๋ ๋ชจ๋ธ์ ๋ฐ๋ณตํ์ฌ ์ ๊ณต๋ฉ๋๋ค.
ํ๋กฌํํธ์ ์ผ๋ถ์ธ ๋ชจ๋ ์์ ๋ ์ด๋ฌํ ์ ํํ ํจํด์ผ๋ก ๋์ด ์์ผ๋ฏ๋ก, ์์ด์ ํธ๊ฐ ์ ํ ํฐ์ ์์ฑํ ๋ ์ ํํ ๋์ผํ ํจํด์ ์ฌํํ ์ ์์ต๋๋ค.
ํ๋กฌํํธ ์์ ๋ Transformers ํ์ด ์ ๋ณํ๊ณ ์ผ๋ จ์ [problem statements](https://github.com/huggingface/transformers/blob/main/src/transformers/tools/evaluate_agent.py)์ ๋ฐ๋ผ ์๊ฒฉํ๊ฒ ํ๊ฐํ์ฌ
์์ด์ ํธ์ ํ๋กฌํํธ๊ฐ ์์ด์ ํธ์ ์ค์ ์ฌ์ฉ ์ฌ๋ก๋ฅผ ์ต๋ํ ์ ํด๊ฒฐํ ์ ์๋๋ก ๋ณด์ฅํฉ๋๋ค.
ํ๋กฌํํธ์ ๋ง์ง๋ง ๋ถ๋ถ์ ๋ค์์ ํด๋นํฉ๋๋ค:
```text
Task: "Draw me a picture of rivers and lakes"
I will use the following
```
์ด๋ ์์ด์ ํธ๊ฐ ์๋ฃํด์ผ ํ ์ต์ข
์ ์ธ ๋ฏธ์์ฑ ์์ ์
๋๋ค. ๋ฏธ์์ฑ ์์ ๋ ์ค์ ์ฌ์ฉ์ ์
๋ ฅ์ ๋ฐ๋ผ ๋์ ์ผ๋ก ๋ง๋ค์ด์ง๋๋ค.
์ ์์์ ๊ฒฝ์ฐ ์ฌ์ฉ์๊ฐ ๋ค์๊ณผ ๊ฐ์ด ์คํํ์ต๋๋ค:
```py
agent.run("Draw me a picture of rivers and lakes")
```
์ฌ์ฉ์ ์
๋ ฅ - *์ฆ* Task: *"Draw me a picture of rivers and lakes"*๊ฐ ํ๋กฌํํธ ํ
ํ๋ฆฟ์ ๋ง์ถฐ "Task: <task> \n\n I will use the following"๋ก ์บ์คํ
๋ฉ๋๋ค.
์ด ๋ฌธ์ฅ์ ์์ด์ ํธ์๊ฒ ์กฐ๊ฑด์ด ์ ์ฉ๋๋ ํ๋กฌํํธ์ ๋ง์ง๋ง ์ค์ ๊ตฌ์ฑํ๋ฏ๋ก ์์ด์ ํธ๊ฐ ์ด์ ์์ ์์ ์ํํ ๊ฒ๊ณผ ์ ํํ ๋์ผํ ๋ฐฉ์์ผ๋ก ์์ ๋ฅผ ์๋ฃํ๋๋ก ๊ฐ๋ ฅํ๊ฒ ์ํฅ์ ๋ฏธ์นฉ๋๋ค.
๋๋ฌด ์์ธํ ์ค๋ช
ํ์ง ์๋๋ผ๋ ์ฑํ
ํ
ํ๋ฆฟ์ ํ๋กฌํํธ ๊ตฌ์กฐ๋ ๋์ผํ์ง๋ง ์์ ์ ์คํ์ผ์ด ์ฝ๊ฐ ๋ค๋ฆ
๋๋ค. *์๋ฅผ ๋ค๋ฉด*:
````text
[...]
=====
Human: Answer the question in the variable `question` about the image stored in the variable `image`.
Assistant: I will use the tool `image_qa` to answer the question on the input image.
```py
answer = image_qa(text=question, image=image)
print(f"The answer is {answer}")
```
Human: I tried this code, it worked but didn't give me a good result. The question is in French
Assistant: In this case, the question needs to be translated first. I will use the tool `translator` to do this.
```py
translated_question = translator(question=question, src_lang="French", tgt_lang="English")
print(f"The translated question is {translated_question}.")
answer = image_qa(text=translated_question, image=image)
print(f"The answer is {answer}")
```
=====
[...]
````
`run` ํ๋กฌํํธ์ ์์๋ ๋ฐ๋๋ก, ๊ฐ `chat` ํ๋กฌํํธ์ ์์๋ *Human(์ฌ๋)*๊ณผ *Assistant(์ด์์คํดํธ)* ๊ฐ์ ํ๋ ์ด์์ ๊ตํ์ด ์์ต๋๋ค. ๋ชจ๋ ๊ตํ์ `run` ํ๋กฌํํธ์ ์์ ์ ์ฌํ ๊ตฌ์กฐ๋ก ๋์ด ์์ต๋๋ค.
์ฌ์ฉ์์ ์
๋ ฅ์ด *Human:* ๋ค์ ์ถ๊ฐ๋๋ฉฐ, ์์ด์ ํธ์๊ฒ ์ฝ๋๋ฅผ ์์ฑํ๊ธฐ ์ ์ ์ํํด์ผ ํ ์์
์ ๋จผ์ ์์ฑํ๋ผ๋ ๋ฉ์์ง๊ฐ ํ์๋ฉ๋๋ค.
๊ตํ์ ์ด์ ๊ตํ์ ๊ธฐ๋ฐ์ผ๋ก ํ ์ ์์ผ๋ฏ๋ก ์์ ๊ฐ์ด ์ฌ์ฉ์๊ฐ "**์ด** ์ฝ๋๋ฅผ ์๋ํ์ต๋๋ค"๋ผ๊ณ ์
๋ ฅํ๋ฉด ์ด์ ์ ์์ฑ๋ ์์ด์ ํธ์ ์ฝ๋๋ฅผ ์ฐธ์กฐํ์ฌ ๊ณผ๊ฑฐ ๊ตํ์ ์ฐธ์กฐํ ์ ์์ต๋๋ค.
`.chat`์ ์คํํ๋ฉด ์ฌ์ฉ์์ ์
๋ ฅ ๋๋ *์์
*์ด ๋ฏธ์์ฑ๋ ์์์ ์์๋ก ์บ์คํ
๋ฉ๋๋ค:
```text
Human: <user-input>\n\nAssistant:
```
๊ทธ๋ฌ๋ฉด ์์ด์ ํธ๊ฐ ์ด๋ฅผ ์์ฑํฉ๋๋ค. `run` ๋ช
๋ น๊ณผ ๋ฌ๋ฆฌ `chat` ๋ช
๋ น์ ์๋ฃ๋ ์์ ๋ฅผ ํ๋กฌํํธ์ ์ถ๊ฐํ์ฌ ์์ด์ ํธ์๊ฒ ๋ค์ `chat` ์ฐจ๋ก์ ๋ํ ๋ ๋ง์ ๋ฌธ๋งฅ์ ์ ๊ณตํฉ๋๋ค.
์ด์ ํ๋กฌํํธ๊ฐ ์ด๋ป๊ฒ ๊ตฌ์ฑ๋์ด ์๋์ง ์์์ผ๋ ์ด๋ป๊ฒ ์ฌ์ฉ์ ์ ์ํ ์ ์๋์ง ์ดํด๋ด
์๋ค!
### ์ข์ ์ฌ์ฉ์ ์
๋ ฅ ์์ฑํ๊ธฐ[[writing-good-user-inputs]]
๋๊ท๋ชจ ์ธ์ด ๋ชจ๋ธ์ด ์ฌ์ฉ์์ ์๋๋ฅผ ์ดํดํ๋ ๋ฅ๋ ฅ์ด ์ ์ ๋ ํฅ์๋๊ณ ์์ง๋ง, ์์ด์ ํธ๊ฐ ์ฌ๋ฐ๋ฅธ ์์
์ ์ ํํ ์ ์๋๋ก ์ต๋ํ ์ ํ์ฑ์ ์ ์งํ๋ ๊ฒ์ ํฐ ๋์์ด ๋ฉ๋๋ค.
์ต๋ํ ์ ํํ๋ค๋ ๊ฒ์ ๋ฌด์์ ์๋ฏธํ ๊น์?
์์ด์ ํธ๋ ํ๋กฌํํธ์์ ๋๊ตฌ ์ด๋ฆ ๋ชฉ๋ก๊ณผ ํด๋น ์ค๋ช
์ ๋ณผ ์ ์์ต๋๋ค.
๋ ๋ง์ ๋๊ตฌ๊ฐ ์ถ๊ฐ๋ ์๋ก ์์ด์ ํธ๊ฐ ์ฌ๋ฐ๋ฅธ ๋๊ตฌ๋ฅผ ์ ํํ๊ธฐ๊ฐ ๋ ์ด๋ ค์์ง๊ณ ์คํํ ๋๊ตฌ์ ์ฌ๋ฐ๋ฅธ ์์๋ฅผ ์ ํํ๋ ๊ฒ์ ๋์ฑ ์ด๋ ค์์ง๋๋ค.
์ผ๋ฐ์ ์ธ ์คํจ ์ฌ๋ก๋ฅผ ์ดํด๋ณด๊ฒ ์ต๋๋ค. ์ฌ๊ธฐ์๋ ๋ถ์ํ ์ฝ๋๋ง ๋ฐํํ๊ฒ ์ต๋๋ค.
```py
from transformers import HfAgent
agent = HfAgent("https://api-inference.huggingface.co/models/bigcode/starcoder")
agent.run("Show me a tree", return_code=True)
```
๊ทธ๋ฌ๋ฉด ๋ค์ ๊ฒฐ๊ณผ๊ฐ ์ถ๋ ฅ๋ฉ๋๋ค:
```text
==Explanation from the agent==
I will use the following tool: `image_segmenter` to create a segmentation mask for the image.
==Code generated by the agent==
mask = image_segmenter(image, prompt="tree")
```
์ฐ๋ฆฌ๊ฐ ์ํ๋ ๊ฒฐ๊ณผ๊ฐ ์๋ ์๋ ์์ต๋๋ค. ๋์ ๋๋ฌด ์ด๋ฏธ์ง๊ฐ ์์ฑ๋๊ธฐ๋ฅผ ์ํ ๊ฐ๋ฅ์ฑ์ด ๋ ๋์ต๋๋ค.
๋ฐ๋ผ์ ์์ด์ ํธ๊ฐ ํน์ ๋๊ตฌ๋ฅผ ์ฌ์ฉํ๋๋ก ์ ๋ํ๋ ค๋ฉด ๋๊ตฌ์ ์ด๋ฆ๊ณผ ์ค๋ช
์ ์๋ ์ค์ํ ํค์๋๋ฅผ ์ฌ์ฉํ๋ ๊ฒ์ด ๋งค์ฐ ์ ์ฉํ ์ ์์ต๋๋ค. ํ๋ฒ ์ดํด๋ณด๊ฒ ์ต๋๋ค.
```py
agent.toolbox["image_generator"].description
```
```text
'This is a tool that creates an image according to a prompt, which is a text description. It takes an input named `prompt` which contains the image description and outputs an image.
```
์ด๋ฆ๊ณผ ์ค๋ช
์ "image", "prompt", "create" ๋ฐ "generate" ํค์๋๋ฅผ ์ฌ์ฉํฉ๋๋ค. ์ด ๋จ์ด๋ค์ ์ฌ์ฉํ๋ฉด ๋ ์ ์๋ํ ๊ฐ๋ฅ์ฑ์ด ๋์ต๋๋ค. ํ๋กฌํํธ๋ฅผ ์กฐ๊ธ ๋ ๊ตฌ์ฒดํํด ๋ณด๊ฒ ์ต๋๋ค.
```py
agent.run("Create an image of a tree", return_code=True)
```
์ด ์ฝ๋๋ ๋ค์ ํ๋กฌํํธ๋ฅผ ๋ง๋ค์ด๋
๋๋ค:
```text
==Explanation from the agent==
I will use the following tool `image_generator` to generate an image of a tree.
==Code generated by the agent==
image = image_generator(prompt="tree")
```
ํจ์ฌ ๋ซ๋ค์! ์ ํฌ๊ฐ ์ํ๋ ๊ฒ๊ณผ ๋น์ทํด ๋ณด์
๋๋ค.
์ฆ, ์์ด์ ํธ๊ฐ ์์
์ ์ฌ๋ฐ๋ฅธ ๋๊ตฌ์ ์ฌ๋ฐ๋ฅด๊ฒ ๋งคํํ๋ ๋ฐ ์ด๋ ค์์ ๊ฒช๊ณ ์๋ค๋ฉด ๋๊ตฌ ์ด๋ฆ๊ณผ ์ค๋ช
์์ ๊ฐ์ฅ ๊ด๋ จ์ฑ์ด ๋์ ํค์๋๋ฅผ ์ฐพ์๋ณด๊ณ ์ด๋ฅผ ํตํด ์์
์์ฒญ์ ๊ตฌ์ฒดํํด ๋ณด์ธ์.
### ๋๊ตฌ ์ค๋ช
์ฌ์ฉ์ ์ ์ํ๊ธฐ[[customizing-the-tool-descriptions]]
์์ ์ดํด๋ณธ ๊ฒ์ฒ๋ผ ์์ด์ ํธ๋ ๊ฐ ๋๊ตฌ์ ์ด๋ฆ๊ณผ ์ค๋ช
์ ์ก์ธ์คํ ์ ์์ต๋๋ค.
๊ธฐ๋ณธ ๋๊ตฌ์๋ ๋งค์ฐ ์ ํํ ์ด๋ฆ๊ณผ ์ค๋ช
์ด ์์ด์ผ ํ์ง๋ง ํน์ ์ฌ์ฉ ์ฌ๋ก์ ๋ง๊ฒ ๋๊ตฌ์ ์ค๋ช
์ด๋ ์ด๋ฆ์ ๋ณ๊ฒฝํ๋ ๊ฒ์ด ๋์์ด ๋ ์๋ ์์ต๋๋ค.
์ด๋ ๋งค์ฐ ์ ์ฌํ ์ฌ๋ฌ ๋๊ตฌ๋ฅผ ์ถ๊ฐํ๊ฑฐ๋ ํน์ ๋๋ฉ์ธ(*์*: ์ด๋ฏธ์ง ์์ฑ ๋ฐ ๋ณํ)์๋ง ์์ด์ ํธ๋ฅผ ์ฌ์ฉํ๋ ค๋ ๊ฒฝ์ฐ์ ํนํ ์ค์ํด์ง ์ ์์ต๋๋ค.
์ผ๋ฐ์ ์ธ ๋ฌธ์ ๋ ์ด๋ฏธ์ง ์์ฑ ์์
์ ๋ง์ด ์ฌ์ฉ๋๋ ๊ฒฝ์ฐ ์์ด์ ํธ๊ฐ ์ด๋ฏธ์ง ์์ฑ๊ณผ ์ด๋ฏธ์ง ๋ณํ/์์ ์ ํผ๋ํ๋ ๊ฒ์
๋๋ค. *์๋ฅผ ๋ค์ด,*
```py
agent.run("Make an image of a house and a car", return_code=True)
```
๊ทธ๋ฌ๋ฉด ๋ค์ ๊ฒฐ๊ณผ๊ฐ ์ถ๋ ฅ๋ฉ๋๋ค:
```text
==Explanation from the agent==
I will use the following tools `image_generator` to generate an image of a house and `image_transformer` to transform the image of a car into the image of a house.
==Code generated by the agent==
house_image = image_generator(prompt="A house")
car_image = image_generator(prompt="A car")
house_car_image = image_transformer(image=car_image, prompt="A house")
```
๊ฒฐ๊ณผ๋ฌผ์ด ์ฐ๋ฆฌ๊ฐ ์ฌ๊ธฐ์ ์ํ๋ ๊ฒ๊ณผ ์ ํํ ์ผ์นํ์ง ์์ ์ ์์ต๋๋ค. ์์ด์ ํธ๊ฐ `image_generator`์ `image_transformer`์ ์ฐจ์ด์ ์ ์ดํดํ๊ธฐ ์ด๋ ค์์ ๋ ๊ฐ์ง๋ฅผ ํจ๊ป ์ฌ์ฉํ๋ ๊ฒฝ์ฐ๊ฐ ๋ง์ ๊ฒ ๊ฐ์ต๋๋ค.
์ฌ๊ธฐ์ `image_transformer`์ ๋๊ตฌ ์ด๋ฆ๊ณผ ์ค๋ช
์ ๋ณ๊ฒฝํ์ฌ ์์ด์ ํธ๊ฐ ๋์ธ ์ ์์ต๋๋ค.
"image" ๋ฐ "prompt"์ ์ฝ๊ฐ ๋ถ๋ฆฌํ๊ธฐ ์ํด `modifier`๋ผ๊ณ ๋์ ๋ถ๋ฅด๊ฒ ์ต๋๋ค:
```py
agent.toolbox["modifier"] = agent.toolbox.pop("image_transformer")
agent.toolbox["modifier"].description = agent.toolbox["modifier"].description.replace(
"transforms an image according to a prompt", "modifies an image"
)
```
์ด์ "modify"์ ์ ์ด๋ฏธ์ง ํ๋ก์ธ์๋ฅผ ์ฌ์ฉํ๋ผ๋ ๊ฐ๋ ฅํ ์ ํธ์ด๋ฏ๋ก ์์ ํ๋กฌํํธ์ ๋์์ด ๋ ๊ฒ์
๋๋ค. ๋ค์ ์คํํด ๋ด
์๋ค.
```py
agent.run("Make an image of a house and a car", return_code=True)
```
์ฌ๊ธฐ์ ๋ค์๊ณผ ๊ฐ์ ๊ฒฐ๊ณผ๋ฅผ ์ป๊ฒ ๋ฉ๋๋ค:
```text
==Explanation from the agent==
I will use the following tools: `image_generator` to generate an image of a house, then `image_generator` to generate an image of a car.
==Code generated by the agent==
house_image = image_generator(prompt="A house")
car_image = image_generator(prompt="A car")
```
์ฐ๋ฆฌ๊ฐ ์ผ๋์ ๋์๋ ๊ฒ๊ณผ ํ์คํ ๋ ๊ฐ๊น์์ก์ต๋๋ค! ํ์ง๋ง ์ง๊ณผ ์๋์ฐจ๊ฐ ๋ชจ๋ ๊ฐ์ ์ด๋ฏธ์ง์ ํฌํจ๋๋ฉด ์ข๊ฒ ์ต๋๋ค. ์์
์ ๋จ์ผ ์ด๋ฏธ์ง ์์ฑ์ ๋ ์ง์คํ๋ฉด ๋์์ด ๋ ๊ฒ์
๋๋ค:
```py
agent.run("Create image: 'A house and car'", return_code=True)
```
```text
==Explanation from the agent==
I will use the following tool: `image_generator` to generate an image.
==Code generated by the agent==
image = image_generator(prompt="A house and car")
```
<Tip warning={true}>
์์ด์ ํธ๋ ์ฌ์ ํ ํนํ ์ฌ๋ฌ ๊ฐ์ฒด์ ์ด๋ฏธ์ง๋ฅผ ์์ฑํ๋ ๊ฒ๊ณผ ๊ฐ์ด ์ฝ๊ฐ ๋ ๋ณต์กํ ์ฌ์ฉ ์ฌ๋ก์์ ์ทจ์ฝํ ๊ฒฝ์ฐ๊ฐ ๋ง์ต๋๋ค.
์์ผ๋ก ๋ช ๋ฌ ์์ ์์ด์ ํธ ์์ฒด์ ๊ธฐ๋ณธ ํ๋กฌํํธ๊ฐ ๋์ฑ ๊ฐ์ ๋์ด ์์ด์ ํธ๊ฐ ๋ค์ํ ์ฌ์ฉ์ ์
๋ ฅ์ ๋์ฑ ๊ฐ๋ ฅํ๊ฒ ๋์ํ ์ ์๋๋ก ํ ์์ ์
๋๋ค.
</Tip>
### ์ ์ฒด ํ๋กฌํํธ ์ฌ์ฉ์ ์ ์ํ๊ธฐ[[customizing-the-whole-prompt]]
์ฌ์ฉ์์๊ฒ ์ต๋ํ์ ์ ์ฐ์ฑ์ ์ ๊ณตํ๊ธฐ ์ํด [์](#structure-of-the-prompt)์ ์ค๋ช
๋ ์ ์ฒด ํ๋กฌํํธ ํ
ํ๋ฆฟ์ ์ฌ์ฉ์๊ฐ ๋ฎ์ด์ธ ์ ์์ต๋๋ค.
์ด ๊ฒฝ์ฐ ์ฌ์ฉ์ ์ ์ ํ๋กฌํํธ์ ์๊ฐ ์น์
, ๋๊ตฌ ์น์
, ์์ ์น์
๋ฐ ๋ฏธ์์ฑ ์์ ์น์
์ด ํฌํจ๋์ด ์๋์ง ํ์ธํ์ธ์.
`run` ํ๋กฌํํธ ํ
ํ๋ฆฟ์ ๋ฎ์ด์ฐ๋ ค๋ฉด ๋ค์๊ณผ ๊ฐ์ด ํ๋ฉด ๋ฉ๋๋ค:
```py
template = """ [...] """
agent = HfAgent(your_endpoint, run_prompt_template=template)
```
<Tip warning={true}>
์์ด์ ํธ๊ฐ ์ฌ์ฉ ๊ฐ๋ฅํ ๋๊ตฌ๋ฅผ ์ธ์ํ๊ณ ์ฌ์ฉ์์ ํ๋กฌํํธ๋ฅผ ์ฌ๋ฐ๋ฅด๊ฒ ์ฝ์
ํ ์ ์๋๋ก `<<all_tools>>` ๋ฌธ์์ด๊ณผ `<<prompt>>`๋ฅผ `template` ์ด๋๊ฐ์ ์ ์ํด์ผ ํฉ๋๋ค.
</Tip>
๋ง์ฐฌ๊ฐ์ง๋ก `chat` ํ๋กฌํํธ ํ
ํ๋ฆฟ์ ๋ฎ์ด์ธ ์ ์์ต๋๋ค. `chat` ๋ชจ๋์์๋ ํญ์ ๋ค์๊ณผ ๊ฐ์ ๊ตํ ํ์์ ์ฌ์ฉํ๋ค๋ ์ ์ ์ ์ํ์ธ์:
```text
Human: <<task>>
Assistant:
```
๋ฐ๋ผ์ ์ฌ์ฉ์ ์ ์ `chat` ํ๋กฌํํธ ํ
ํ๋ฆฟ์ ์์ ์์๋ ์ด ํ์์ ์ฌ์ฉํ๋ ๊ฒ์ด ์ค์ํฉ๋๋ค.
๋ค์๊ณผ ๊ฐ์ด ์ธ์คํด์คํ ํ ๋ `chat` ํ
ํ๋ฆฟ์ ๋ฎ์ด์ธ ์ ์์ต๋๋ค.
```python
template = """ [...] """
agent = HfAgent(url_endpoint=your_endpoint, chat_prompt_template=template)
```
<Tip warning={true}>
์์ด์ ํธ๊ฐ ์ฌ์ฉ ๊ฐ๋ฅํ ๋๊ตฌ๋ฅผ ์ธ์ํ ์ ์๋๋ก `<<all_tools>>` ๋ฌธ์์ด์ `template` ์ด๋๊ฐ์ ์ ์ํด์ผ ํฉ๋๋ค.
</Tip>
๋ ๊ฒฝ์ฐ ๋ชจ๋ ์ปค๋ฎค๋ํฐ์ ๋๊ตฐ๊ฐ๊ฐ ํธ์คํ
ํ๋ ํ
ํ๋ฆฟ์ ์ฌ์ฉํ๋ ค๋ ๊ฒฝ์ฐ ํ๋กฌํํธ ํ
ํ๋ฆฟ ๋์ ์ ์ฅ์ ID๋ฅผ ์ ๋ฌํ ์ ์์ต๋๋ค.
๊ธฐ๋ณธ ํ๋กฌํํธ๋ [์ด ์ ์ฅ์](https://huggingface.co/datasets/huggingface-tools/default-prompts)๋ฅผ ์๋ก ๋ค ์ ์์ต๋๋ค.
Hub์ ์ ์ฅ์์ ์ฌ์ฉ์ ์ ์ ํ๋กฌํํธ๋ฅผ ์
๋ก๋ํ์ฌ ์ปค๋ฎค๋ํฐ์ ๊ณต์ ํ๋ ค๋ฉด ๋ค์์ ํ์ธํ์ธ์:
- ๋ฐ์ดํฐ ์ธํธ ์ ์ฅ์๋ฅผ ์ฌ์ฉํ์ธ์.
- `run` ๋ช
๋ น์ ๋ํ ํ๋กฌํํธ ํ
ํ๋ฆฟ์ `run_prompt_template.txt`๋ผ๋ ํ์ผ์ ๋ฃ์ผ์ธ์.
- `chat` ๋ช
๋ น์ ๋ํ ํ๋กฌํํธ ํ
ํ๋ฆฟ์ `chat_prompt_template.txt`๋ผ๋ ํ์ผ์ ๋ฃ์ผ์ธ์.
## ์ฌ์ฉ์ ์ ์ ๋๊ตฌ ์ฌ์ฉํ๊ธฐ[[using-custom-tools]]
์ด ์น์
์์๋ ์ด๋ฏธ์ง ์์ฑ์ ํนํ๋ ๋ ๊ฐ์ง ๊ธฐ์กด ์ฌ์ฉ์ ์ ์ ๋๊ตฌ๋ฅผ ํ์ฉํ๊ฒ ์ต๋๋ค:
- ๋ ๋ง์ ์ด๋ฏธ์ง ์์ ์ ํ์ฉํ๊ธฐ ์ํด [huggingface-tools/image-transformation](https://huggingface.co/spaces/huggingface-tools/image-transformation)์
[diffusers/controlnet-canny-tool](https://huggingface.co/spaces/diffusers/controlnet-canny-tool)๋ก ๋์ฒดํฉ๋๋ค.
- ๊ธฐ๋ณธ ๋๊ตฌ ์์์ ์ด๋ฏธ์ง ์
์ค์ผ์ผ๋ง์ ์ํ ์๋ก์ด ๋๊ตฌ๊ฐ ์ถ๊ฐ๋์์ต๋๋ค:
[diffusers/latent-upscaler-tool](https://huggingface.co/spaces/diffusers/latent-upscaler-tool)๊ฐ ๊ธฐ์กด ์ด๋ฏธ์ง ๋ณํ ๋๊ตฌ๋ฅผ ๋์ฒดํฉ๋๋ค.
ํธ๋ฆฌํ [`load_tool`] ํจ์๋ฅผ ์ฌ์ฉํ์ฌ ์ฌ์ฉ์ ์ ์ ๋๊ตฌ๋ฅผ ๊ฐ์ ธ์ค๋ ๊ฒ์ผ๋ก ์์ํ๊ฒ ์ต๋๋ค:
```py
from transformers import load_tool
controlnet_transformer = load_tool("diffusers/controlnet-canny-tool")
upscaler = load_tool("diffusers/latent-upscaler-tool")
```
์์ด์ ํธ์๊ฒ ์ฌ์ฉ์ ์ ์ ๋๊ตฌ๋ฅผ ์ถ๊ฐํ๋ฉด ๋๊ตฌ์ ์ค๋ช
๊ณผ ์ด๋ฆ์ด ์์ด์ ํธ์ ํ๋กฌํํธ์ ์๋์ผ๋ก ํฌํจ๋ฉ๋๋ค.
๋ฐ๋ผ์ ์์ด์ ํธ๊ฐ ์ฌ์ฉ ๋ฐฉ๋ฒ์ ์ดํดํ ์ ์๋๋ก ์ฌ์ฉ์ ์ ์ ๋๊ตฌ์ ์ค๋ช
๊ณผ ์ด๋ฆ์ ์ ์์ฑํด์ผ ํฉ๋๋ค.
`controlnet_transformer`์ ์ค๋ช
๊ณผ ์ด๋ฆ์ ์ดํด๋ณด๊ฒ ์ต๋๋ค:
```py
print(f"Description: '{controlnet_transformer.description}'")
print(f"Name: '{controlnet_transformer.name}'")
```
๊ทธ๋ฌ๋ฉด ๋ค์ ๊ฒฐ๊ณผ๊ฐ ์ถ๋ ฅ๋ฉ๋๋ค:
```text
Description: 'This is a tool that transforms an image with ControlNet according to a prompt.
It takes two inputs: `image`, which should be the image to transform, and `prompt`, which should be the prompt to use to change it. It returns the modified image.'
Name: 'image_transformer'
```
์ด๋ฆ๊ณผ ์ค๋ช
์ด ์ ํํ๊ณ [ํ๋ ์ดํ
๋ ๋๊ตฌ ์ธํธ(curated set of tools)](./transformers_agents#a-curated-set-of-tools)์ ์คํ์ผ์ ๋ง์ต๋๋ค.
๋ค์์ผ๋ก, `controlnet_transformer`์ `upscaler`๋ก ์์ด์ ํธ๋ฅผ ์ธ์คํด์คํํด ๋ด
์๋ค:
```py
tools = [controlnet_transformer, upscaler]
agent = HfAgent("https://api-inference.huggingface.co/models/bigcode/starcoder", additional_tools=tools)
```
์ด ๋ช
๋ น์ ์คํํ๋ฉด ๋ค์ ์ ๋ณด๊ฐ ํ์๋ฉ๋๋ค:
```text
image_transformer has been replaced by <transformers_modules.diffusers.controlnet-canny-tool.bd76182c7777eba9612fc03c0
8718a60c0aa6312.image_transformation.ControlNetTransformationTool object at 0x7f1d3bfa3a00> as provided in `additional_tools`
```
ํ๋ ์ดํ
๋ ๋๊ตฌ ์ธํธ์๋ ์ด๋ฏธ 'image_transformer' ๋๊ตฌ๊ฐ ์์ผ๋ฉฐ, ์ด ๋๊ตฌ๋ ์ฌ์ฉ์ ์ ์ ๋๊ตฌ๋ก ๋์ฒด๋ฉ๋๋ค.
<Tip>
๊ธฐ์กด ๋๊ตฌ์ ๋๊ฐ์ ์์
์ ์ฌ์ฉ์ ์ ์ ๋๊ตฌ๋ฅผ ์ฌ์ฉํ๋ ค๋ ๊ฒฝ์ฐ ๊ธฐ์กด ๋๊ตฌ๋ฅผ ๋ฎ์ด์ฐ๋ ๊ฒ์ด ์ ์ฉํ ์ ์์ต๋๋ค.
์์ด์ ํธ๊ฐ ํด๋น ์์
์ ๋ฅ์ํ๊ธฐ ๋๋ฌธ์
๋๋ค.
์ด ๊ฒฝ์ฐ ์ฌ์ฉ์ ์ ์ ๋๊ตฌ๊ฐ ๋ฎ์ด์ด ๋๊ตฌ์ ์ ํํ ๋์ผํ API๋ฅผ ๋ฐ๋ผ์ผ ํ๋ฉฐ, ๊ทธ๋ ์ง ์์ผ๋ฉด ํด๋น ๋๊ตฌ๋ฅผ ์ฌ์ฉํ๋ ๋ชจ๋ ์์ ๊ฐ ์
๋ฐ์ดํธ๋๋๋ก ํ๋กฌํํธ ํ
ํ๋ฆฟ์ ์กฐ์ ํด์ผ ํ๋ค๋ ์ ์ ์ ์ํ์ธ์.
</Tip>
์
์ค์ผ์ผ๋ฌ ๋๊ตฌ์ ์ง์ ๋ 'image_upscaler'๋ผ๋ ์ด๋ฆ ์์ง ๊ธฐ๋ณธ ๋๊ตฌ ์์์๋ ์กด์ฌํ์ง ์๊ธฐ ๋๋ฌธ์, ๋๊ตฌ ๋ชฉ๋ก์ ํด๋น ์ด๋ฆ์ด ๊ฐ๋จํ ์ถ๊ฐ๋์์ต๋๋ค.
์์ด์ ํธ๊ฐ ํ์ฌ ์ฌ์ฉํ ์ ์๋ ๋๊ตฌ ์์๋ ์ธ์ ๋ ์ง `agent.toolbox` ์์ฑ์ ํตํด ํ์ธํ ์ ์์ต๋๋ค:
```py
print("\n".join([f"- {a}" for a in agent.toolbox.keys()]))
```
```text
- document_qa
- image_captioner
- image_qa
- image_segmenter
- transcriber
- summarizer
- text_classifier
- text_qa
- text_reader
- translator
- image_transformer
- text_downloader
- image_generator
- video_generator
- image_upscaler
```
์์ด์ ํธ์ ๋๊ตฌ ์์์ `image_upscaler`๊ฐ ์ถ๊ฐ๋ ์ ์ ์ฃผ๋ชฉํ์ธ์.
์ด์ ์๋ก์ด ๋๊ตฌ๋ฅผ ์ฌ์ฉํด๋ด
์๋ค! [Transformers Agents Quickstart](./transformers_agents#single-execution-run)์์ ์์ฑํ ์ด๋ฏธ์ง๋ฅผ ๋ค์ ์ฌ์ฉํ๊ฒ ์ต๋๋ค.
```py
from diffusers.utils import load_image
image = load_image(
"https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/transformers/rivers_and_lakes.png"
)
```
<img src="https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/transformers/rivers_and_lakes.png" width=200>
์ด๋ฏธ์ง๋ฅผ ์๋ฆ๋ค์ด ๊ฒจ์ธ ํ๊ฒฝ์ผ๋ก ๋ฐ๊ฟ ๋ด
์๋ค:
```py
image = agent.run("Transform the image: 'A frozen lake and snowy forest'", image=image)
```
```text
==Explanation from the agent==
I will use the following tool: `image_transformer` to transform the image.
==Code generated by the agent==
image = image_transformer(image, prompt="A frozen lake and snowy forest")
```
<img src="https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/transformers/rivers_and_lakes_winter.png" width=200>
์๋ก์ด ์ด๋ฏธ์ง ์ฒ๋ฆฌ ๋๊ตฌ๋ ์ด๋ฏธ์ง๋ฅผ ๋งค์ฐ ๊ฐ๋ ฅํ๊ฒ ์์ ํ ์ ์๋ ControlNet์ ๊ธฐ๋ฐ์ผ๋ก ํฉ๋๋ค.
๊ธฐ๋ณธ์ ์ผ๋ก ์ด๋ฏธ์ง ์ฒ๋ฆฌ ๋๊ตฌ๋ 512x512 ํฝ์
ํฌ๊ธฐ์ ์ด๋ฏธ์ง๋ฅผ ๋ฐํํฉ๋๋ค. ์ด๋ฅผ ์
์ค์ผ์ผ๋งํ ์ ์๋์ง ์ดํด๋ด
์๋ค.
```py
image = agent.run("Upscale the image", image)
```
```text
==Explanation from the agent==
I will use the following tool: `image_upscaler` to upscale the image.
==Code generated by the agent==
upscaled_image = image_upscaler(image)
```
<img src="https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/transformers/rivers_and_lakes_winter_upscale.png" width=400>
์์ด์ ํธ๋ ์
์ค์ผ์ผ๋ฌ ๋๊ตฌ์ ์ค๋ช
๊ณผ ์ด๋ฆ๋ง ๋ณด๊ณ ๋ฐฉ๊ธ ์ถ๊ฐํ ์
์ค์ผ์ผ๋ฌ ๋๊ตฌ์ "์ด๋ฏธ์ง ์
์ค์ผ์ผ๋ง"์ด๋ผ๋ ํ๋กฌํํธ๋ฅผ ์๋์ผ๋ก ๋งคํํ์ฌ ์ฌ๋ฐ๋ฅด๊ฒ ์คํํ์ต๋๋ค.
๋ค์์ผ๋ก ์ ์ฌ์ฉ์ ์ ์ ๋๊ตฌ๋ฅผ ๋ง๋๋ ๋ฐฉ๋ฒ์ ์ดํด๋ณด๊ฒ ์ต๋๋ค.
### ์ ๋๊ตฌ ์ถ๊ฐํ๊ธฐ[[adding-new-tools]]
์ด ์น์
์์๋ ์์ด์ ํธ์๊ฒ ์ถ๊ฐํ ์ ์๋ ์ ๋๊ตฌ๋ฅผ ๋ง๋๋ ๋ฐฉ๋ฒ์ ๋ณด์ฌ ๋๋ฆฝ๋๋ค.
#### ์ ๋๊ตฌ ๋ง๋ค๊ธฐ[[creating-a-new-tool]]
๋จผ์ ๋๊ตฌ๋ฅผ ๋ง๋๋ ๊ฒ๋ถํฐ ์์ํ๊ฒ ์ต๋๋ค.
ํน์ ์์
์ ๋ํด ๊ฐ์ฅ ๋ง์ ๋ค์ด๋ก๋๋ฅผ ๋ฐ์ Hugging Face Hub์ ๋ชจ๋ธ์ ๊ฐ์ ธ์ค๋, ๊ทธ๋ค์ง ์ ์ฉํ์ง๋ ์์ง๋ง ์ฌ๋ฏธ์๋ ์์
์ ์ถ๊ฐํ๊ฒ ์ต๋๋ค.
๋ค์ ์ฝ๋๋ฅผ ์ฌ์ฉํ๋ฉด ๋ฉ๋๋ค:
```python
from huggingface_hub import list_models
task = "text-classification"
model = next(iter(list_models(filter=task, sort="downloads", direction=-1)))
print(model.id)
```
`text-classification`(ํ
์คํธ ๋ถ๋ฅ) ์์
์ ๊ฒฝ์ฐ `'facebook/bart-large-mnli'`๋ฅผ ๋ฐํํ๊ณ , `translation`(๋ฒ์ญ) ์์
์ ๊ฒฝ์ฐ `'google-t5/t5-base'`๋ฅผ ๋ฐํํฉ๋๋ค.
์ด๋ฅผ ์์ด์ ํธ๊ฐ ํ์ฉํ ์ ์๋ ๋๊ตฌ๋ก ๋ณํํ๋ ค๋ฉด ์ด๋ป๊ฒ ํด์ผ ํ ๊น์?
๋ชจ๋ ๋๊ตฌ๋ ํ์ํ ์ฃผ์ ์์ฑ์ ๋ณด์ ํ๋ ์ํผํด๋์ค `Tool`์ ์์กดํฉ๋๋ค. ์ด๋ฅผ ์์ํ๋ ํด๋์ค๋ฅผ ๋ง๋ค์ด ๋ณด๊ฒ ์ต๋๋ค:
```python
from transformers import Tool
class HFModelDownloadsTool(Tool):
pass
```
์ด ํด๋์ค์๋ ๋ช ๊ฐ์ง ์๊ตฌ์ฌํญ์ด ์์ต๋๋ค:
- ๋๊ตฌ ์์ฒด์ ์ด๋ฆ์ ํด๋นํ๋ `name` ์์ฑ. ์ํ๋ช
์ด ์๋ ๋ค๋ฅธ ๋๊ตฌ์ ํธํ๋๋๋ก `model_download_counter`๋ก ์ด๋ฆ์ ์ง์ ํ๊ฒ ์ต๋๋ค.
- ์์ด์ ํธ์ ํ๋กฌํํธ๋ฅผ ์ฑ์ฐ๋ ๋ฐ ์ฌ์ฉ๋๋ ์์ฑ `description`.
- `inputs` ๋ฐ `outputs` ์์ฑ. ์ด๋ฅผ ์ ์ํ๋ฉด Python ์ธํฐํ๋ฆฌํฐ๊ฐ ์ ํ์ ๋ํ ์ ๋ณด์ ์
๊ฐํ ์ ํ์ ํ๋ ๋ฐ ๋์์ด ๋๋ฉฐ,
๋๊ตฌ๋ฅผ ํ๋ธ์ ํธ์ํ ๋ gradio ๋ฐ๋ชจ๋ฅผ ์์ฑํ ์ ์์ต๋๋ค.
๋ ์์ฑ ๋ชจ๋ ๊ฐ์ 'ํ
์คํธ', '์ด๋ฏธ์ง' ๋๋ '์ค๋์ค'๊ฐ ๋ ์ ์๋ ์์ ๊ฐ์ ๋ฆฌ์คํธ์
๋๋ค.
- ์ถ๋ก ์ฝ๋๊ฐ ํฌํจ๋ `__call__` ๋ฉ์๋. ์ด๊ฒ์ด ์ฐ๋ฆฌ๊ฐ ์์์ ๋ค๋ฃจ์๋ ์ฝ๋์
๋๋ค!
์ด์ ํด๋์ค์ ๋ชจ์ต์ ๋ค์๊ณผ ๊ฐ์ต๋๋ค:
```python
from transformers import Tool
from huggingface_hub import list_models
class HFModelDownloadsTool(Tool):
name = "model_download_counter"
description = (
"This is a tool that returns the most downloaded model of a given task on the Hugging Face Hub. "
"It takes the name of the category (such as text-classification, depth-estimation, etc), and "
"returns the name of the checkpoint."
)
inputs = ["text"]
outputs = ["text"]
def __call__(self, task: str):
model = next(iter(list_models(filter=task, sort="downloads", direction=-1)))
return model.id
```
์ด์ ๋๊ตฌ๋ฅผ ์์ฝ๊ฒ ์ฌ์ฉํ ์ ์๊ฒ ๋์์ต๋๋ค.
๋๊ตฌ๋ฅผ ํ์ผ์ ์ ์ฅํ๊ณ ๋ฉ์ธ ์คํฌ๋ฆฝํธ์์ ๊ฐ์ ธ์ต๋๋ค. ์ด ํ์ผ์ ์ด๋ฆ์ `model_downloads.py`๋ก ์ง์ ํ๋ฉด ๊ฒฐ๊ณผ์ ์ผ๋ก ๊ฐ์ ธ์ค๊ธฐ ์ฝ๋๋ ๋ค์๊ณผ ๊ฐ์ต๋๋ค:
```python
from model_downloads import HFModelDownloadsTool
tool = HFModelDownloadsTool()
```
๋ค๋ฅธ ์ฌ๋๋ค์ด ์ด ๊ธฐ๋ฅ์ ํ์ฉํ ์ ์๋๋ก ํ๊ณ ์ด๊ธฐํ๋ฅผ ๋ ๊ฐ๋จํ๊ฒ ํ๋ ค๋ฉด ๋ค์์คํ์ด์ค ์๋์ Hub๋ก ํธ์ํ๋ ๊ฒ์ด ์ข์ต๋๋ค.
๊ทธ๋ ๊ฒ ํ๋ ค๋ฉด `tool` ๋ณ์์์ `push_to_hub`๋ฅผ ํธ์ถํ๋ฉด ๋ฉ๋๋ค:
```python
tool.push_to_hub("hf-model-downloads")
```
์ด์ ํ๋ธ์ ์ฝ๋๊ฐ ์๊ฒผ์ต๋๋ค! ๋ง์ง๋ง ๋จ๊ณ์ธ ์์ด์ ํธ๊ฐ ์ฝ๋๋ฅผ ์ฌ์ฉํ๋๋ก ํ๋ ๋จ๊ณ๋ฅผ ์ดํด๋ณด๊ฒ ์ต๋๋ค.
#### ์์ด์ ํธ๊ฐ ๋๊ตฌ๋ฅผ ์ฌ์ฉํ๊ฒ ํ๊ธฐ[[Having-the-agent-use-the-tool]]
์ด์ ์ด๋ฐ ์์ผ๋ก ํ๋ธ์ ์กด์ฌํ๋ ๋๊ตฌ๋ฅผ ์ธ์คํด์คํํ ์ ์์ต๋๋ค(๋๊ตฌ์ ์ฌ์ฉ์ ์ด๋ฆ์ ๋ณ๊ฒฝํ์ธ์):
We now have our tool that lives on the Hub which can be instantiated as such (change the user name for your tool):
```python
from transformers import load_tool
tool = load_tool("lysandre/hf-model-downloads")
```
์ด ๋๊ตฌ๋ฅผ ์์ด์ ํธ์์ ์ฌ์ฉํ๋ ค๋ฉด ์์ด์ ํธ ์ด๊ธฐํ ๋ฉ์๋์ `additional_tools` ๋งค๊ฐ๋ณ์์ ์ ๋ฌํ๊ธฐ๋ง ํ๋ฉด ๋ฉ๋๋ค:
```python
from transformers import HfAgent
agent = HfAgent("https://api-inference.huggingface.co/models/bigcode/starcoder", additional_tools=[tool])
agent.run(
"Can you read out loud the name of the model that has the most downloads in the 'text-to-video' task on the Hugging Face Hub?"
)
```
๊ทธ๋ฌ๋ฉด ๋ค์๊ณผ ๊ฐ์ ๊ฒฐ๊ณผ๊ฐ ์ถ๋ ฅ๋ฉ๋๋ค:
```text
==Code generated by the agent==
model = model_download_counter(task="text-to-video")
print(f"The model with the most downloads is {model}.")
audio_model = text_reader(model)
==Result==
The model with the most downloads is damo-vilab/text-to-video-ms-1.7b.
```
and generates the following audio.
| **Audio** |
|------------------------------------------------------------------------------------------------------------------------------------------------------|
| <audio controls><source src="https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/transformers/damo.wav" type="audio/wav"/> |
<Tip>
LLM์ ๋ฐ๋ผ ์ผ๋ถ๋ ๋งค์ฐ ์ทจ์ฝํ๊ธฐ ๋๋ฌธ์ ์ ๋๋ก ์๋ํ๋ ค๋ฉด ๋งค์ฐ ์ ํํ ํ๋กฌํํธ๊ฐ ํ์ํฉ๋๋ค.
์์ด์ ํธ๊ฐ ๋๊ตฌ๋ฅผ ์ ํ์ฉํ๊ธฐ ์ํด์๋ ๋๊ตฌ์ ์ด๋ฆ๊ณผ ์ค๋ช
์ ์ ์ ์ํ๋ ๊ฒ์ด ๋ฌด์๋ณด๋ค ์ค์ํฉ๋๋ค.
</Tip>
### ๊ธฐ์กด ๋๊ตฌ ๋์ฒดํ๊ธฐ[[replacing-existing-tools]]
์์ด์ ํธ์ ๋๊ตฌ ์์์ ์ ํญ๋ชฉ์ ๋ฐฐ์ ํ๊ธฐ๋ง ํ๋ฉด ๊ธฐ์กด ๋๊ตฌ๋ฅผ ๋์ฒดํ ์ ์์ต๋๋ค. ๋ฐฉ๋ฒ์ ๋ค์๊ณผ ๊ฐ์ต๋๋ค:
```python
from transformers import HfAgent, load_tool
agent = HfAgent("https://api-inference.huggingface.co/models/bigcode/starcoder")
agent.toolbox["image-transformation"] = load_tool("diffusers/controlnet-canny-tool")
```
<Tip>
๋ค๋ฅธ ๋๊ตฌ๋ก ๊ต์ฒดํ ๋๋ ์ฃผ์ํ์ธ์! ์ด ์์
์ผ๋ก ์์ด์ ํธ์ ํ๋กฌํํธ๋ ์กฐ์ ๋ฉ๋๋ค.
์์
์ ๋ ์ ํฉํ ํ๋กฌํํธ๊ฐ ์์ผ๋ฉด ์ข์ ์ ์์ง๋ง,
๋ค๋ฅธ ๋๊ตฌ๋ณด๋ค ๋ ๋ง์ด ์ ํ๋๊ฑฐ๋ ์ ์ํ ๋๊ตฌ ๋์ ๋ค๋ฅธ ๋๊ตฌ๊ฐ ์ ํ๋ ์๋ ์์ต๋๋ค.
</Tip>
## gradio-tools ์ฌ์ฉํ๊ธฐ[[leveraging-gradio-tools]]
[gradio-tools](https://github.com/freddyaboulton/gradio-tools)๋ Hugging Face Spaces๋ฅผ ๋๊ตฌ๋ก ์ฌ์ฉํ ์ ์๋ ๊ฐ๋ ฅํ ๋ผ์ด๋ธ๋ฌ๋ฆฌ์
๋๋ค.
๊ธฐ์กด์ ๋ง์ Spaces๋ฟ๋ง ์๋๋ผ ์ฌ์ฉ์ ์ ์ Spaces๋ฅผ ์ฌ์ฉํ์ฌ ๋์์ธํ ์ ์๋๋ก ์ง์ํฉ๋๋ค.
์ฐ๋ฆฌ๋ `Tool.from_gradio` ๋ฉ์๋๋ฅผ ์ฌ์ฉํ์ฌ `gradio_tools`์ ๋ํ ์ง์์ ์ ๊ณตํฉ๋๋ค.
์๋ฅผ ๋ค์ด, ํ๋กฌํํธ๋ฅผ ๊ฐ์ ํ๊ณ ๋ ๋์ ์ด๋ฏธ์ง๋ฅผ ์์ฑํ๊ธฐ ์ํด `gradio-tools` ํดํท์์ ์ ๊ณต๋๋ `StableDiffusionPromptGeneratorTool` ๋๊ตฌ๋ฅผ ํ์ฉํ๊ณ ์ ํฉ๋๋ค.
๋จผ์ `gradio_tools`์์ ๋๊ตฌ๋ฅผ ๊ฐ์ ธ์์ ์ธ์คํด์คํํฉ๋๋ค:
```python
from gradio_tools import StableDiffusionPromptGeneratorTool
gradio_tool = StableDiffusionPromptGeneratorTool()
```
ํด๋น ์ธ์คํด์ค๋ฅผ `Tool.from_gradio` ๋ฉ์๋์ ์ ๋ฌํฉ๋๋ค:
```python
from transformers import Tool
tool = Tool.from_gradio(gradio_tool)
```
์ด์ ์ผ๋ฐ์ ์ธ ์ฌ์ฉ์ ์ ์ ๋๊ตฌ์ ๋๊ฐ์ด ๊ด๋ฆฌํ ์ ์์ต๋๋ค.
์ด๋ฅผ ํ์ฉํ์ฌ `a rabbit wearing a space suit'(์ฐ์ฃผ๋ณต์ ์
์ ํ ๋ผ)๋ผ๋ ํ๋กฌํํธ๋ฅผ ๊ฐ์ ํ์ต๋๋ค:
```python
from transformers import HfAgent
agent = HfAgent("https://api-inference.huggingface.co/models/bigcode/starcoder", additional_tools=[tool])
agent.run("Generate an image of the `prompt` after improving it.", prompt="A rabbit wearing a space suit")
```
๋ชจ๋ธ์ด ๋๊ตฌ๋ฅผ ์ ์ ํ ํ์ฉํฉ๋๋ค:
```text
==Explanation from the agent==
I will use the following tools: `StableDiffusionPromptGenerator` to improve the prompt, then `image_generator` to generate an image according to the improved prompt.
==Code generated by the agent==
improved_prompt = StableDiffusionPromptGenerator(prompt)
print(f"The improved prompt is {improved_prompt}.")
image = image_generator(improved_prompt)
```
๋ง์ง๋ง์ผ๋ก ์ด๋ฏธ์ง๋ฅผ ์์ฑํ๊ธฐ ์ ์:
<img src="https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/transformers/rabbit.png">
<Tip warning={true}>
gradio-tools๋ ๋ค๋ฅธ ๋ชจ๋ฌ๋ฆฌํฐ๋ก ์์
ํ ๋์๋ *ํ
์คํธ* ์
๋ ฅ ๋ฐ ์ถ๋ ฅ์ ํ์๋ก ํฉ๋๋ค.
์ด ๊ตฌํ์ ์ด๋ฏธ์ง ๋ฐ ์ค๋์ค ๊ฐ์ฒด์์ ์๋ํฉ๋๋ค.
ํ์ฌ๋ ์ด ๋ ๊ฐ์ง๊ฐ ํธํ๋์ง ์์ง๋ง ์ง์ ๊ฐ์ ์ ์ํด ๋
ธ๋ ฅํ๋ฉด์ ๋น ๋ฅด๊ฒ ํธํ๋ ๊ฒ์
๋๋ค.
</Tip>
## ํฅํ Langchain๊ณผ์ ํธํ์ฑ[[future-compatibility-with-langchain]]
์ ํฌ๋ Langchain์ ์ข์ํ๋ฉฐ ๋งค์ฐ ๋งค๋ ฅ์ ์ธ ๋๊ตฌ ๋ชจ์์ ๊ฐ์ง๊ณ ์๋ค๊ณ ์๊ฐํฉ๋๋ค.
์ด๋ฌํ ๋๊ตฌ๋ฅผ ์ฒ๋ฆฌํ๊ธฐ ์ํด Langchain์ ๋ค๋ฅธ ๋ชจ๋ฌ๋ฆฌํฐ์ ์์
ํ ๋์๋ *ํ
์คํธ* ์
๋ ฅ๊ณผ ์ถ๋ ฅ์ ํ์๋ก ํฉ๋๋ค.
์ด๋ ์ข
์ข
๊ฐ์ฒด์ ์ง๋ ฌํ๋(์ฆ, ๋์คํฌ์ ์ ์ฅ๋) ๋ฒ์ ์
๋๋ค.
์ด ์ฐจ์ด๋ก ์ธํด transformers-agents์ Langchain ๊ฐ์๋ ๋ฉํฐ ๋ชจ๋ฌ๋ฆฌํฐ๊ฐ ์ฒ๋ฆฌ๋์ง ์์ต๋๋ค.
ํฅํ ๋ฒ์ ์์ ์ด ์ ํ์ด ํด๊ฒฐ๋๊ธฐ๋ฅผ ๋ฐ๋ผ๋ฉฐ, ์ด ํธํ์ฑ์ ๋ฌ์ฑํ ์ ์๋๋ก ์ด๋ ฌํ Langchain ์ฌ์ฉ์์ ๋์์ ํ์ํฉ๋๋ค.
์ ํฌ๋ ๋ ๋์ ์ง์์ ์ ๊ณตํ๊ณ ์ ํฉ๋๋ค. ๋์์ ์ฃผ๊ณ ์ถ์ผ์๋ค๋ฉด, [์ด์๋ฅผ ์ด์ด](https://github.com/huggingface/transformers/issues/new) ์๊ฒฌ์ ๊ณต์ ํด ์ฃผ์ธ์.
| 0 |
mavonic_private_repos/transformers/docs/source | mavonic_private_repos/transformers/docs/source/ko/torchscript.md | <!--Copyright 2022 The HuggingFace Team. All rights reserved.
Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
the License. You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
specific language governing permissions and limitations under the License.
โ ๏ธ Note that this file is in Markdown but contain specific syntax for our doc-builder (similar to MDX) that may not be
rendered properly in your Markdown viewer.
-->
# TorchScript๋ก ๋ด๋ณด๋ด๊ธฐ[[export-to-torchscript]]
<Tip>
TorchScript๋ฅผ ํ์ฉํ ์คํ์ ์์ง ์ด๊ธฐ ๋จ๊ณ๋ก, ๊ฐ๋ณ์ ์ธ ์
๋ ฅ ํฌ๊ธฐ ๋ชจ๋ธ๋ค์ ํตํด ๊ทธ ๊ธฐ๋ฅ์ฑ์ ๊ณ์ ํ๊ตฌํ๊ณ ์์ต๋๋ค.
์ด ๊ธฐ๋ฅ์ ์ ํฌ๊ฐ ๊ด์ฌ์ ๋๊ณ ์๋ ๋ถ์ผ ์ค ํ๋์ด๋ฉฐ,
์์ผ๋ก ์ถ์๋ ๋ฒ์ ์์ ๋ ๋ง์ ์ฝ๋ ์์ , ๋ ์ ์ฐํ ๊ตฌํ, ๊ทธ๋ฆฌ๊ณ Python ๊ธฐ๋ฐ ์ฝ๋์ ์ปดํ์ผ๋ TorchScript๋ฅผ ๋น๊ตํ๋ ๋ฒค์น๋งํฌ๋ฅผ ๋ฑ์ ํตํด ๋ถ์์ ์ฌํํ ์์ ์
๋๋ค.
</Tip>
[TorchScript ๋ฌธ์](https://pytorch.org/docs/stable/jit.html)์์๋ ์ด๋ ๊ฒ ๋งํฉ๋๋ค.
> TorchScript๋ PyTorch ์ฝ๋์์ ์ง๋ ฌํ ๋ฐ ์ต์ ํ ๊ฐ๋ฅํ ๋ชจ๋ธ์ ์์ฑํ๋ ๋ฐฉ๋ฒ์
๋๋ค.
[JIT๊ณผ TRACE](https://pytorch.org/docs/stable/jit.html)๋ ๊ฐ๋ฐ์๊ฐ ๋ชจ๋ธ์ ๋ด๋ณด๋ด์ ํจ์จ ์งํฅ์ ์ธ C++ ํ๋ก๊ทธ๋จ๊ณผ ๊ฐ์ ๋ค๋ฅธ ํ๋ก๊ทธ๋จ์์ ์ฌ์ฌ์ฉํ ์ ์๋๋ก ํ๋ PyTorch ๋ชจ๋์
๋๋ค.
PyTorch ๊ธฐ๋ฐ Python ํ๋ก๊ทธ๋จ๊ณผ ๋ค๋ฅธ ํ๊ฒฝ์์ ๋ชจ๋ธ์ ์ฌ์ฌ์ฉํ ์ ์๋๋ก, ๐ค Transformers ๋ชจ๋ธ์ TorchScript๋ก ๋ด๋ณด๋ผ ์ ์๋ ์ธํฐํ์ด์ค๋ฅผ ์ ๊ณตํฉ๋๋ค.
์ด ๋ฌธ์์์๋ TorchScript๋ฅผ ์ฌ์ฉํ์ฌ ๋ชจ๋ธ์ ๋ด๋ณด๋ด๊ณ ์ฌ์ฉํ๋ ๋ฐฉ๋ฒ์ ์ค๋ช
ํฉ๋๋ค.
๋ชจ๋ธ์ ๋ด๋ณด๋ด๋ ค๋ฉด ๋ ๊ฐ์ง๊ฐ ํ์ํฉ๋๋ค:
- `torchscript` ํ๋๊ทธ๋ก ๋ชจ๋ธ ์ธ์คํด์คํ
- ๋๋ฏธ ์
๋ ฅ์ ์ฌ์ฉํ ์์ ํ(forward pass)
์ด ํ์ ์กฐ๊ฑด๋ค์ ์๋์ ์์ธํ ์ค๋ช
๋ ๊ฒ์ฒ๋ผ ๊ฐ๋ฐ์๋ค์ด ์ฃผ์ํด์ผ ํ ์ฌ๋ฌ ์ฌํญ๋ค์ ์๋ฏธํฉ๋๋ค.
## TorchScript ํ๋๊ทธ์ ๋ฌถ์ธ ๊ฐ์ค์น(tied weights)[[torchscript-flag-and-tied-weights]]
`torchscript` ํ๋๊ทธ๊ฐ ํ์ํ ์ด์ ๋ ๋๋ถ๋ถ์ ๐ค Transformers ์ธ์ด ๋ชจ๋ธ์์ `Embedding` ๋ ์ด์ด์ `Decoding` ๋ ์ด์ด ๊ฐ์ ๋ฌถ์ธ ๊ฐ์ค์น(tied weights)๊ฐ ์กด์ฌํ๊ธฐ ๋๋ฌธ์
๋๋ค.
TorchScript๋ ๋ฌถ์ธ ๊ฐ์ค์น๋ฅผ ๊ฐ์ง ๋ชจ๋ธ์ ๋ด๋ณด๋ผ ์ ์์ผ๋ฏ๋ก, ๋ฏธ๋ฆฌ ๊ฐ์ค์น๋ฅผ ํ๊ณ ๋ณต์ ํด์ผ ํฉ๋๋ค.
`torchscript` ํ๋๊ทธ๋ก ์ธ์คํด์คํ๋ ๋ชจ๋ธ์ `Embedding` ๋ ์ด์ด์ `Decoding` ๋ ์ด์ด๊ฐ ๋ถ๋ฆฌ๋์ด ์์ผ๋ฏ๋ก ์ดํ์ ํ๋ จํด์๋ ์ ๋ฉ๋๋ค.
ํ๋ จ์ ํ๊ฒ ๋๋ฉด ๋ ๋ ์ด์ด ๊ฐ ๋๊ธฐํ๊ฐ ํด์ ๋์ด ์์์น ๋ชปํ ๊ฒฐ๊ณผ๊ฐ ๋ฐ์ํ ์ ์์ต๋๋ค.
์ธ์ด ๋ชจ๋ธ ํค๋๋ฅผ ๊ฐ์ง ์์ ๋ชจ๋ธ์ ๊ฐ์ค์น๊ฐ ๋ฌถ์ฌ ์์ง ์์์ ์ด ๋ฌธ์ ๊ฐ ๋ฐ์ํ์ง ์์ต๋๋ค.
์ด๋ฌํ ๋ชจ๋ธ๋ค์ `torchscript` ํ๋๊ทธ ์์ด ์์ ํ๊ฒ ๋ด๋ณด๋ผ ์ ์์ต๋๋ค.
## ๋๋ฏธ ์
๋ ฅ๊ณผ ํ์ค ๊ธธ์ด[[dummy-inputs-and-standard-lengths]]
๋๋ฏธ ์
๋ ฅ(dummy inputs)์ ๋ชจ๋ธ์ ์์ ํ(forward pass)์ ์ฌ์ฉ๋ฉ๋๋ค.
์
๋ ฅ ๊ฐ์ด ๋ ์ด์ด๋ฅผ ํตํด ์ ํ๋๋ ๋์, PyTorch๋ ๊ฐ ํ
์์์ ์คํ๋ ๋ค๋ฅธ ์ฐ์ฐ์ ์ถ์ ํฉ๋๋ค.
์ด๋ฌํ ๊ธฐ๋ก๋ ์ฐ์ฐ์ ๋ชจ๋ธ์ *์ถ์ (trace)*์ ์์ฑํ๋ ๋ฐ ์ฌ์ฉ๋ฉ๋๋ค.
์ถ์ ์ ์
๋ ฅ์ ์ฐจ์์ ๊ธฐ์ค์ผ๋ก ์์ฑ๋ฉ๋๋ค.
๋ฐ๋ผ์ ๋๋ฏธ ์
๋ ฅ์ ์ฐจ์์ ์ ํ๋์ด, ๋ค๋ฅธ ์ํ์ค ๊ธธ์ด๋ ๋ฐฐ์น ํฌ๊ธฐ์์๋ ์๋ํ์ง ์์ต๋๋ค.
๋ค๋ฅธ ํฌ๊ธฐ๋ก ์๋ํ ๊ฒฝ์ฐ ๋ค์๊ณผ ๊ฐ์ ์ค๋ฅ๊ฐ ๋ฐ์ํฉ๋๋ค:
```
`The expanded size of the tensor (3) must match the existing size (7) at non-singleton dimension 2`
```
์ถ๋ก ์ค ๋ชจ๋ธ์ ๊ณต๊ธ๋ ๊ฐ์ฅ ํฐ ์
๋ ฅ๋งํผ ํฐ ๋๋ฏธ ์
๋ ฅ ํฌ๊ธฐ๋ก ๋ชจ๋ธ์ ์ถ์ ํ๋ ๊ฒ์ด ์ข์ต๋๋ค.
ํจ๋ฉ์ ๋๋ฝ๋ ๊ฐ์ ์ฑ์ฐ๋ ๋ฐ ๋์์ด ๋ ์ ์์ต๋๋ค.
๊ทธ๋ฌ๋ ๋ชจ๋ธ์ด ๋ ํฐ ์
๋ ฅ ํฌ๊ธฐ๋ก ์ถ์ ๋๊ธฐ ๋๋ฌธ์, ํ๋ ฌ์ ์ฐจ์์ด ์ปค์ง๊ณ ๊ณ์ฐ๋์ด ๋ง์์ง๋๋ค.
๋ค์ํ ์ํ์ค ๊ธธ์ด ๋ชจ๋ธ์ ๋ด๋ณด๋ผ ๋๋ ๊ฐ ์
๋ ฅ์ ๋ํด ์ํ๋๋ ์ด ์ฐ์ฐ ํ์์ ์ฃผ์ํ๊ณ ์ฑ๋ฅ์ ์ฃผ์ ๊น๊ฒ ํ์ธํ์ธ์.
## Python์์ TorchScript ์ฌ์ฉํ๊ธฐ[[using-torchscript-in-python]]
์ด ์น์
์์๋ ๋ชจ๋ธ์ ์ ์ฅํ๊ณ ๊ฐ์ ธ์ค๋ ๋ฐฉ๋ฒ, ์ถ์ ์ ์ฌ์ฉํ์ฌ ์ถ๋ก ํ๋ ๋ฐฉ๋ฒ์ ๋ณด์ฌ์ค๋๋ค.
### ๋ชจ๋ธ ์ ์ฅํ๊ธฐ[[saving-a-model]]
`BertModel`์ TorchScript๋ก ๋ด๋ณด๋ด๋ ค๋ฉด `BertConfig` ํด๋์ค์์ `BertModel`์ ์ธ์คํด์คํํ ๋ค์, `traced_bert.pt`๋ผ๋ ํ์ผ๋ช
์ผ๋ก ๋์คํฌ์ ์ ์ฅํ๋ฉด ๋ฉ๋๋ค.
```python
from transformers import BertModel, BertTokenizer, BertConfig
import torch
enc = BertTokenizer.from_pretrained("google-bert/bert-base-uncased")
# ์
๋ ฅ ํ
์คํธ ํ ํฐํํ๊ธฐ
text = "[CLS] Who was Jim Henson ? [SEP] Jim Henson was a puppeteer [SEP]"
tokenized_text = enc.tokenize(text)
# ์
๋ ฅ ํ ํฐ ์ค ํ๋๋ฅผ ๋ง์คํนํ๊ธฐ
masked_index = 8
tokenized_text[masked_index] = "[MASK]"
indexed_tokens = enc.convert_tokens_to_ids(tokenized_text)
segments_ids = [0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1]
# ๋๋ฏธ ์
๋ ฅ ๋ง๋ค๊ธฐ
tokens_tensor = torch.tensor([indexed_tokens])
segments_tensors = torch.tensor([segments_ids])
dummy_input = [tokens_tensor, segments_tensors]
# torchscript ํ๋๊ทธ๋ก ๋ชจ๋ธ ์ด๊ธฐํํ๊ธฐ
# ์ด ๋ชจ๋ธ์ LM ํค๋๊ฐ ์์ผ๋ฏ๋ก ํ์ํ์ง ์์ง๋ง, ํ๋๊ทธ๋ฅผ True๋ก ์ค์ ํฉ๋๋ค.
config = BertConfig(
vocab_size_or_config_json_file=32000,
hidden_size=768,
num_hidden_layers=12,
num_attention_heads=12,
intermediate_size=3072,
torchscript=True,
)
# ๋ชจ๋ธ์ ์ธ์คํดํธํํ๊ธฐ
model = BertModel(config)
# ๋ชจ๋ธ์ ํ๊ฐ ๋ชจ๋๋ก ๋์ด์ผ ํฉ๋๋ค.
model.eval()
# ๋ง์ฝ *from_pretrained*๋ฅผ ์ฌ์ฉํ์ฌ ๋ชจ๋ธ์ ์ธ์คํด์คํํ๋ ๊ฒฝ์ฐ, TorchScript ํ๋๊ทธ๋ฅผ ์ฝ๊ฒ ์ค์ ํ ์ ์์ต๋๋ค
model = BertModel.from_pretrained("google-bert/bert-base-uncased", torchscript=True)
# ์ถ์ ์์ฑํ๊ธฐ
traced_model = torch.jit.trace(model, [tokens_tensor, segments_tensors])
torch.jit.save(traced_model, "traced_bert.pt")
```
### ๋ชจ๋ธ ๊ฐ์ ธ์ค๊ธฐ[[loading-a-model]]
์ด์ ์ด์ ์ ์ ์ฅํ `BertModel`, ์ฆ `traced_bert.pt`๋ฅผ ๋์คํฌ์์ ๊ฐ์ ธ์ค๊ณ , ์ด์ ์ ์ด๊ธฐํํ `dummy_input`์์ ์ฌ์ฉํ ์ ์์ต๋๋ค.
```python
loaded_model = torch.jit.load("traced_bert.pt")
loaded_model.eval()
all_encoder_layers, pooled_output = loaded_model(*dummy_input)
```
### ์ถ์ ๋ ๋ชจ๋ธ์ ์ฌ์ฉํ์ฌ ์ถ๋ก ํ๊ธฐ[[using-a-traced-model-for-inference]]
`__call__` ์ด์ค ์ธ๋์ค์ฝ์ด(dunder) ๋ฉ์๋๋ฅผ ์ฌ์ฉํ์ฌ ์ถ๋ก ์ ์ถ์ ๋ ๋ชจ๋ธ์ ์ฌ์ฉํ์ธ์:
```python
traced_model(tokens_tensor, segments_tensors)
```
## Neuron SDK๋ก Hugging Face TorchScript ๋ชจ๋ธ์ AWS์ ๋ฐฐํฌํ๊ธฐ[[deploy-hugging-face-torchscript-models-to-aws-with-the-neuron-sdk]]
AWS๊ฐ ํด๋ผ์ฐ๋์์ ์ ๋น์ฉ, ๊ณ ์ฑ๋ฅ ๋จธ์ ๋ฌ๋ ์ถ๋ก ์ ์ํ [Amazon EC2 Inf1](https://aws.amazon.com/ec2/instance-types/inf1/) ์ธ์คํด์ค ์ ํ๊ตฐ์ ์ถ์ํ์ต๋๋ค.
Inf1 ์ธ์คํด์ค๋ ๋ฅ๋ฌ๋ ์ถ๋ก ์ํฌ๋ก๋์ ํนํ๋ ๋ง์ถค ํ๋์จ์ด ๊ฐ์๊ธฐ์ธ AWS Inferentia ์นฉ์ผ๋ก ๊ตฌ๋๋ฉ๋๋ค.
[AWS Neuron](https://awsdocs-neuron.readthedocs-hosted.com/en/latest/#)์ Inferentia๋ฅผ ์ํ SDK๋ก, Inf1์ ๋ฐฐํฌํ๊ธฐ ์ํ transformers ๋ชจ๋ธ ์ถ์ ๋ฐ ์ต์ ํ๋ฅผ ์ง์ํฉ๋๋ค.
Neuron SDK๋ ๋ค์๊ณผ ๊ฐ์ ๊ธฐ๋ฅ์ ์ ๊ณตํฉ๋๋ค:
1. ์ฝ๋ ํ ์ค๋ง ๋ณ๊ฒฝํ๋ฉด ํด๋ผ์ฐ๋ ์ถ๋ก ๋ฅผ ์ํด TorchScript ๋ชจ๋ธ์ ์ถ์ ํ๊ณ ์ต์ ํํ ์ ์๋ ์ฌ์ด API
2. ์ฆ์ ์ฌ์ฉ ๊ฐ๋ฅํ ์ฑ๋ฅ ์ต์ ํ๋ก [๋น์ฉ ํจ์จ ํฅ์](https://awsdocs-neuron.readthedocs-hosted.com/en/latest/neuron-guide/benchmark/>)
3. [PyTorch](https://awsdocs-neuron.readthedocs-hosted.com/en/latest/src/examples/pytorch/bert_tutorial/tutorial_pretrained_bert.html) ๋๋ [TensorFlow](https://awsdocs-neuron.readthedocs-hosted.com/en/latest/src/examples/tensorflow/huggingface_bert/huggingface_bert.html)๋ก ๊ตฌ์ถ๋ Hugging Face transformers ๋ชจ๋ธ ์ง์
### ์์ฌ์ [[implications]]
[BERT (Bidirectional Encoder Representations from Transformers)](https://huggingface.co/docs/transformers/main/model_doc/bert) ์ํคํ
์ฒ ๋๋ ๊ทธ ๋ณํ์ธ [distilBERT](https://huggingface.co/docs/transformers/main/model_doc/distilbert) ๋ฐ [roBERTa](https://huggingface.co/docs/transformers/main/model_doc/roberta)๋ฅผ ๊ธฐ๋ฐ์ผ๋ก ํ Transformers ๋ชจ๋ธ์ ์ถ์ถ ๊ธฐ๋ฐ ์ง์์๋ต, ์ํ์ค ๋ถ๋ฅ ๋ฐ ํ ํฐ ๋ถ๋ฅ์ ๊ฐ์ ๋น์์ฑ ์์
์ Inf1์์ ์ต์์ ์ฑ๋ฅ์ ๋ณด์
๋๋ค.
๊ทธ๋ฌ๋ ํ
์คํธ ์์ฑ ์์
๋ [AWS Neuron MarianMT ํํ ๋ฆฌ์ผ](https://awsdocs-neuron.readthedocs-hosted.com/en/latest/src/examples/pytorch/transformers-marianmt.html)์ ๋ฐ๋ผ Inf1์์ ์คํ๋๋๋ก ์กฐ์ ํ ์ ์์ต๋๋ค.
Inferentia์์ ๋ฐ๋ก ๋ณํํ ์ ์๋ ๋ชจ๋ธ์ ๋ํ ์์ธํ ์ ๋ณด๋ Neuron ๋ฌธ์์ [Model Architecture Fit](https://awsdocs-neuron.readthedocs-hosted.com/en/latest/neuron-guide/models/models-inferentia.html#models-inferentia) ์น์
์์ ํ์ธํ ์ ์์ต๋๋ค.
### ์ข
์์ฑ[[dependencies]]
AWS Neuron์ ์ฌ์ฉํ์ฌ ๋ชจ๋ธ์ ๋ณํํ๋ ค๋ฉด [Neuron SDK ํ๊ฒฝ](https://awsdocs-neuron.readthedocs-hosted.com/en/latest/neuron-guide/neuron-frameworks/pytorch-neuron/index.html#installation-guide)์ด ํ์ํฉ๋๋ค.
์ด๋ [AWS Deep Learning AMI](https://docs.aws.amazon.com/dlami/latest/devguide/tutorial-inferentia-launching.html)์ ๋ฏธ๋ฆฌ ๊ตฌ์ฑ๋์ด ์์ต๋๋ค.
### AWS Neuron์ผ๋ก ๋ชจ๋ธ ๋ณํํ๊ธฐ[[converting-a-model-for-aws-neuron]]
`BertModel`์ ์ถ์ ํ๋ ค๋ฉด, [Python์์ TorchScript ์ฌ์ฉํ๊ธฐ](torchscript#using-torchscript-in-python)์์์ ๋์ผํ ์ฝ๋๋ฅผ ์ฌ์ฉํด์ AWS NEURON์ฉ ๋ชจ๋ธ์ ๋ณํํฉ๋๋ค.
`torch.neuron` ํ๋ ์์ํฌ ์ต์คํ
์
์ ๊ฐ์ ธ์ Python API๋ฅผ ํตํด Neuron SDK์ ๊ตฌ์ฑ ์์์ ์ ๊ทผํฉ๋๋ค:
```python
from transformers import BertModel, BertTokenizer, BertConfig
import torch
import torch.neuron
```
๋ค์ ์ค๋ง ์์ ํ๋ฉด ๋ฉ๋๋ค:
```diff
- torch.jit.trace(model, [tokens_tensor, segments_tensors])
+ torch.neuron.trace(model, [token_tensor, segments_tensors])
```
์ด๋ก์จ Neuron SDK๊ฐ ๋ชจ๋ธ์ ์ถ์ ํ๊ณ Inf1 ์ธ์คํด์ค์ ์ต์ ํํ ์ ์๊ฒ ๋ฉ๋๋ค.
AWS Neuron SDK์ ๊ธฐ๋ฅ, ๋๊ตฌ, ์์ ํํ ๋ฆฌ์ผ ๋ฐ ์ต์ ์
๋ฐ์ดํธ์ ๋ํด ์์ธํ ์์๋ณด๋ ค๋ฉด [AWS NeuronSDK ๋ฌธ์](https://awsdocs-neuron.readthedocs-hosted.com/en/latest/index.html)๋ฅผ ์ฐธ์กฐํ์ธ์.
| 0 |
mavonic_private_repos/transformers/docs/source | mavonic_private_repos/transformers/docs/source/ko/_config.py | # docstyle-ignore
INSTALL_CONTENT = """
# Transformers ์ค์น ๋ฐฉ๋ฒ
! pip install transformers datasets evaluate accelerate
# ๋ง์ง๋ง ๋ฆด๋ฆฌ์ค ๋์ ์์ค์์ ์ค์นํ๋ ค๋ฉด, ์ ๋ช
๋ น์ ์ฃผ์์ผ๋ก ๋ฐ๊พธ๊ณ ์๋ ๋ช
๋ น์ ํด์ ํ์ธ์.
# ! pip install git+https://github.com/huggingface/transformers.git
"""
notebook_first_cells = [{"type": "code", "content": INSTALL_CONTENT}]
black_avoid_patterns = {
"{processor_class}": "FakeProcessorClass",
"{model_class}": "FakeModelClass",
"{object_class}": "FakeObjectClass",
}
| 0 |
mavonic_private_repos/transformers/docs/source | mavonic_private_repos/transformers/docs/source/ko/performance.md | <!---
Copyright 2021 The HuggingFace Team. All rights reserved.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
โ ๏ธ Note that this file is in Markdown but contain specific syntax for our doc-builder (similar to MDX) that may not be
rendered properly in your Markdown viewer.
-->
# ์ฑ๋ฅ ๋ฐ ํ์ฅ์ฑ [[performance-and-scalability]]
์ ์ ๋ ํฐ ๊ท๋ชจ์ ํธ๋์คํฌ๋จธ ๋ชจ๋ธ์ ํ๋ จํ๊ณ ํ๋ก๋์
์ ๋ฐฐํฌํ๋ ๋ฐ์๋ ๋ค์ํ ์ด๋ ค์์ด ๋ฐ๋ฆ
๋๋ค. ํ๋ จ ์ค์๋ ๋ชจ๋ธ์ด ์ฌ์ฉ ๊ฐ๋ฅํ GPU ๋ฉ๋ชจ๋ฆฌ๋ณด๋ค ๋ ๋ง์ ๋ฉ๋ชจ๋ฆฌ๋ฅผ ํ์๋ก ํ๊ฑฐ๋ ํ๋ จ ์๋๊ฐ ๋งค์ฐ ๋๋ฆด ์ ์์ผ๋ฉฐ, ์ถ๋ก ์ ์ํด ๋ฐฐํฌํ ๋๋ ์ ํ ํ๊ฒฝ์์ ์๊ตฌ๋๋ ์ฒ๋ฆฌ๋์ผ๋ก ์ธํด ๊ณผ๋ถํ๊ฐ ๋ฐ์ํ ์ ์์ต๋๋ค. ์ด ๋ฌธ์๋ ์ด๋ฌํ ๋ฌธ์ ๋ฅผ ๊ทน๋ณตํ๊ณ ์ฌ์ฉ ์ฌ๋ก์ ๊ฐ์ฅ ์ ํฉํ ์ค์ ์ ์ฐพ๋๋ก ๋์์ ์ฃผ๊ธฐ ์ํด ์ค๊ณ๋์์ต๋๋ค. ํ๋ จ๊ณผ ์ถ๋ก ์ผ๋ก ๊ฐ์ด๋๋ฅผ ๋ถํ ํ๋๋ฐ, ์ด๋ ๊ฐ๊ฐ ๋ค๋ฅธ ๋ฌธ์ ์ ํด๊ฒฐ ๋ฐฉ๋ฒ์ด ์๊ธฐ ๋๋ฌธ์
๋๋ค. ๊ทธ๋ฆฌ๊ณ ๊ฐ ๊ฐ์ด๋์๋ ๋ค์ํ ์ข
๋ฅ์ ํ๋์จ์ด ์ค์ ์ ๋ํ ๋ณ๋์ ๊ฐ์ด๋๊ฐ ์์ต๋๋ค(์: ํ๋ จ์ ์ํ ๋จ์ผ GPU vs ๋ค์ค GPU ๋๋ ์ถ๋ก ์ ์ํ CPU vs GPU).
์ด ๋ฌธ์๋ ์ฌ์ฉ์์ ์ํฉ์ ์ ์ฉํ ์ ์๋ ๋ฐฉ๋ฒ๋ค์ ๋ํ ๊ฐ์ ๋ฐ ์์์ ์ญํ ์ ํฉ๋๋ค.
## ํ๋ จ [[training]]
ํจ์จ์ ์ธ ํธ๋์คํฌ๋จธ ๋ชจ๋ธ ํ๋ จ์๋ GPU๋ TPU์ ๊ฐ์ ๊ฐ์๊ธฐ๊ฐ ํ์ํฉ๋๋ค. ๊ฐ์ฅ ์ผ๋ฐ์ ์ธ ๊ฒฝ์ฐ๋ ๋จ์ผ GPU๋ง ์ฌ์ฉํ๋ ๊ฒฝ์ฐ์ง๋ง, ๋ค์ค GPU ๋ฐ CPU ํ๋ จ์ ๋ํ ์น์
๋ ์์ต๋๋ค(๊ณง ๋ ๋ง์ ๋ด์ฉ์ด ์ถ๊ฐ๋ ์์ ).
<Tip>
์ฐธ๊ณ : ๋จ์ผ GPU ์น์
์์ ์๊ฐ๋ ๋๋ถ๋ถ์ ์ ๋ต(์: ํผํฉ ์ ๋ฐ๋ ํ๋ จ ๋๋ ๊ทธ๋ผ๋์ธํธ ๋์ )์ ์ผ๋ฐ์ ์ธ ๋ชจ๋ธ ํ๋ จ์๋ ์ ์ฉ๋๋ฏ๋ก, ๋ค์ค GPU๋ CPU ํ๋ จ๊ณผ ๊ฐ์ ์น์
์ ์ดํด๋ณด๊ธฐ ์ ์ ๊ผญ ์ฐธ๊ณ ํ์๊ธธ ๋ฐ๋๋๋ค.
</Tip>
### ๋จ์ผ GPU [[single-gpu]]
๋จ์ผ GPU์์ ๋๊ท๋ชจ ๋ชจ๋ธ์ ํ๋ จํ๋ ๊ฒ์ ์ด๋ ค์ธ ์ ์์ง๋ง, ์ด๋ฅผ ๊ฐ๋ฅํ๊ฒ ํ๋ ์ฌ๋ฌ ๊ฐ์ง ๋๊ตฌ์ ๋ฐฉ๋ฒ์ด ์์ต๋๋ค. ์ด ์น์
์์๋ ํผํฉ ์ ๋ฐ๋ ํ๋ จ, ๊ทธ๋ผ๋์ธํธ ๋์ ๋ฐ ์ฒดํฌํฌ์ธํ
, ํจ์จ์ ์ธ ์ตํฐ๋ง์ด์ , ์ต์ ์ ๋ฐฐ์น ํฌ๊ธฐ๋ฅผ ๊ฒฐ์ ํ๊ธฐ ์ํ ์ ๋ต ๋ฑ์ ๋ํด ๋
ผ์ํฉ๋๋ค.
[๋จ์ผ GPU ํ๋ จ ์น์
์ผ๋ก ์ด๋](perf_train_gpu_one)
### ๋ค์ค GPU [[multigpu]]
๋จ์ผ GPU์์ ํ๋ จํ๋ ๊ฒ์ด ๋๋ฌด ๋๋ฆฌ๊ฑฐ๋ ๋๊ท๋ชจ ๋ชจ๋ธ์ ์ ํฉํ์ง ์์ ๊ฒฝ์ฐ๋ ์์ต๋๋ค. ๋ค์ค GPU ์ค์ ์ผ๋ก ์ ํํ๋ ๊ฒ์ ๋
ผ๋ฆฌ์ ์ธ ๋จ๊ณ์ด์ง๋ง, ์ฌ๋ฌ GPU์์ ํ ๋ฒ์ ํ๋ จํ๋ ค๋ฉด ๊ฐ GPU๋ง๋ค ๋ชจ๋ธ์ ์ ์ฒด ์ฌ๋ณธ์ ๋์ง, ํน์ ๋ชจ๋ธ ์์ฒด๋ ์ฌ๋ฌ GPU์ ๋ถ์ฐํ์ฌ ๋์ง ๋ฑ ์๋ก์ด ๊ฒฐ์ ์ ๋ด๋ ค์ผ ํฉ๋๋ค. ์ด ์น์
์์๋ ๋ฐ์ดํฐ, ํ
์ ๋ฐ ํ์ดํ๋ผ์ธ ๋ณ๋ ฌํ์ ๋ํด ์ดํด๋ด
๋๋ค.
[๋ค์ค GPU ํ๋ จ ์น์
์ผ๋ก ์ด๋](perf_train_gpu_many)
### CPU [[cpu]]
[CPU ํ๋ จ ์น์
์ผ๋ก ์ด๋](perf_train_cpu)
### TPU [[tpu]]
[_๊ณง ์ ๊ณต๋ ์์ _](perf_train_tpu)
### ํน์ํ ํ๋์จ์ด [[specialized-hardware]]
[_๊ณง ์ ๊ณต๋ ์์ _](perf_train_special)
## ์ถ๋ก [[inference]]
์ ํ ๋ฐ ์๋น์ค ํ๊ฒฝ์์ ๋๊ท๋ชจ ๋ชจ๋ธ์ ํจ์จ์ ์ผ๋ก ์ถ๋ก ํ๋ ๊ฒ์ ๋ชจ๋ธ์ ํ๋ จํ๋ ๊ฒ๋งํผ ์ด๋ ค์ธ ์ ์์ต๋๋ค. ์ด์ด์ง๋ ์น์
์์๋ CPU ๋ฐ ๋จ์ผ/๋ค์ค GPU ์ค์ ์์ ์ถ๋ก ์ ์งํํ๋ ๋จ๊ณ๋ฅผ ์ดํด๋ด
๋๋ค.
### CPU [[cpu]]
[CPU ์ถ๋ก ์น์
์ผ๋ก ์ด๋](perf_infer_cpu)
### ๋จ์ผ GPU [[single-gpu]]
[๋จ์ผ GPU ์ถ๋ก ์น์
์ผ๋ก ์ด๋](perf_infer_gpu_one)
### ๋ค์ค GPU [[multigpu]]
[๋ค์ค GPU ์ถ๋ก ์น์
์ผ๋ก ์ด๋](perf_infer_gpu_many)
### ํน์ํ ํ๋์จ์ด [[specialized-hardware]]
[_๊ณง ์ ๊ณต๋ ์์ _](perf_infer_special)
## ํ๋์จ์ด [[hardware]]
ํ๋์จ์ด ์น์
์์๋ ์์ ๋ง์ ๋ฅ๋ฌ๋ ์ฅ๋น๋ฅผ ๊ตฌ์ถํ ๋ ์ ์ฉํ ํ๊ณผ ์๋ น์ ์ดํด๋ณผ ์ ์์ต๋๋ค.
[ํ๋์จ์ด ์น์
์ผ๋ก ์ด๋](perf_hardware)
## ๊ธฐ์ฌํ๊ธฐ [[contribute]]
์ด ๋ฌธ์๋ ์์ฑ๋์ง ์์ ์ํ์ด๋ฉฐ, ์ถ๊ฐํด์ผ ํ ๋ด์ฉ์ด๋ ์์ ์ฌํญ์ด ๋ง์ด ์์ต๋๋ค. ๋ฐ๋ผ์ ์ถ๊ฐํ๊ฑฐ๋ ์์ ํ ๋ด์ฉ์ด ์์ผ๋ฉด ์ฃผ์ ํ์ง ๋ง๊ณ PR์ ์ด์ด ์ฃผ์๊ฑฐ๋, ์์ธํ ๋ด์ฉ์ ๋
ผ์ํ๊ธฐ ์ํด Issue๋ฅผ ์์ํด ์ฃผ์๊ธฐ ๋ฐ๋๋๋ค.
A๊ฐ B๋ณด๋ค ์ข๋ค๊ณ ํ๋ ๊ธฐ์ฌ๋ฅผ ํ ๋๋, ์ฌํ ๊ฐ๋ฅํ ๋ฒค์น๋งํฌ์/๋๋ ํด๋น ์ ๋ณด์ ์ถ์ฒ ๋งํฌ๋ฅผ ํฌํจํด์ฃผ์ธ์(๋น์ ์ผ๋ก๋ถํฐ์ ์ง์ ์ ์ธ ์ ๋ณด๊ฐ ์๋ ๊ฒฝ์ฐ). | 0 |
mavonic_private_repos/transformers/docs/source | mavonic_private_repos/transformers/docs/source/ko/tflite.md | <!--Copyright 2023 The HuggingFace Team. All rights reserved.
Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
the License. You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
specific language governing permissions and limitations under the License.
โ ๏ธ Note that this file is in Markdown but contain specific syntax for our doc-builder (similar to MDX) that may not be
rendered properly in your Markdown viewer.
-->
# TFLite๋ก ๋ด๋ณด๋ด๊ธฐ[[export-to-tflite]]
[TensorFlow Lite](https://www.tensorflow.org/lite/guide)๋ ์์์ด ์ ํ๋ ํด๋ํฐ, ์๋ฒ ๋๋ ์์คํ
, ์ฌ๋ฌผ์ธํฐ๋ท(IoT) ๊ธฐ๊ธฐ์์
๊ธฐ๊ณํ์ต ๋ชจ๋ธ์ ๋ฐฐํฌํ๊ธฐ ์ํ ๊ฒฝ๋ ํ๋ ์์ํฌ์
๋๋ค.
TFLite๋ ์ฐ์ฐ ๋ฅ๋ ฅ, ๋ฉ๋ชจ๋ฆฌ, ์ ๋ ฅ ์๋น๊ฐ ์ ํ๋ ๊ธฐ๊ธฐ์์ ๋ชจ๋ธ์ ํจ์จ์ ์ผ๋ก ์ต์ ํํ๊ณ ์คํํ๊ธฐ ์ํด
์ค๊ณ๋์์ต๋๋ค.
TensorFlow Lite ๋ชจ๋ธ์ `.tflite` ํ์ผ ํ์ฅ์๋ก ์๋ณ๋๋ ํน์ํ๊ณ ํจ์จ์ ์ธ ํด๋์ฉ ํฌ๋งท์ผ๋ก ํํ๋ฉ๋๋ค.
๐ค Optimum์ `exporters.tflite` ๋ชจ๋๋ก ๐ค Transformers ๋ชจ๋ธ์ TFLite๋ก ๋ด๋ณด๋ด๋ ๊ธฐ๋ฅ์ ์ ๊ณตํฉ๋๋ค.
์ง์๋๋ ๋ชจ๋ธ ์ํคํ
์ฒ ๋ชฉ๋ก์ [๐ค Optimum ๋ฌธ์](https://huggingface.co/docs/optimum/exporters/tflite/overview)๋ฅผ ์ฐธ๊ณ ํ์ธ์.
๋ชจ๋ธ์ TFLite๋ก ๋ด๋ณด๋ด๋ ค๋ฉด, ํ์ํ ์ข
์์ฑ์ ์ค์นํ์ธ์:
```bash
pip install optimum[exporters-tf]
```
๋ชจ๋ ์ฌ์ฉ ๊ฐ๋ฅํ ์ธ์๋ฅผ ํ์ธํ๋ ค๋ฉด, [๐ค Optimum ๋ฌธ์](https://huggingface.co/docs/optimum/main/en/exporters/tflite/usage_guides/export_a_model)๋ฅผ ์ฐธ๊ณ ํ๊ฑฐ๋
ํฐ๋ฏธ๋์์ ๋์๋ง์ ์ดํด๋ณด์ธ์:
```bash
optimum-cli export tflite --help
```
์๋ฅผ ๋ค์ด ๐ค Hub์์์ `google-bert/bert-base-uncased` ๋ชจ๋ธ ์ฒดํฌํฌ์ธํธ๋ฅผ ๋ด๋ณด๋ด๋ ค๋ฉด, ๋ค์ ๋ช
๋ น์ ์คํํ์ธ์:
```bash
optimum-cli export tflite --model google-bert/bert-base-uncased --sequence_length 128 bert_tflite/
```
๋ค์๊ณผ ๊ฐ์ด ์งํ ์ํฉ์ ๋ํ๋ด๋ ๋ก๊ทธ์ ๊ฒฐ๊ณผ๋ฌผ์ธ `model.tflite`๊ฐ ์ ์ฅ๋ ์์น๋ฅผ ๋ณด์ฌ์ฃผ๋ ๋ก๊ทธ๊ฐ ํ์๋ฉ๋๋ค:
```bash
Validating TFLite model...
-[โ] TFLite model output names match reference model (logits)
- Validating TFLite Model output "logits":
-[โ] (1, 128, 30522) matches (1, 128, 30522)
-[x] values not close enough, max diff: 5.817413330078125e-05 (atol: 1e-05)
The TensorFlow Lite export succeeded with the warning: The maximum absolute difference between the output of the reference model and the TFLite exported model is not within the set tolerance 1e-05:
- logits: max diff = 5.817413330078125e-05.
The exported model was saved at: bert_tflite
```
์ ์์ ๋ ๐ค Hub์์์ ์ฒดํฌํฌ์ธํธ๋ฅผ ๋ด๋ณด๋ด๋ ๋ฐฉ๋ฒ์ ๋ณด์ฌ์ค๋๋ค.
๋ก์ปฌ ๋ชจ๋ธ์ ๋ด๋ณด๋ธ๋ค๋ฉด, ๋จผ์ ๋ชจ๋ธ ๊ฐ์ค์น์ ํ ํฌ๋์ด์ ํ์ผ์ด ๋ชจ๋ ๊ฐ์ ๋๋ ํฐ๋ฆฌ( `local_path` )์ ์ ์ฅ๋๋์ง ํ์ธํ์ธ์.
CLI๋ฅผ ์ฌ์ฉํ ๋, ๐ค Hub์์์ ์ฒดํฌํฌ์ธํธ ์ด๋ฆ ๋์ `model` ์ธ์์ `local_path`๋ฅผ ์ ๋ฌํ๋ฉด ๋ฉ๋๋ค. | 0 |
mavonic_private_repos/transformers/docs/source | mavonic_private_repos/transformers/docs/source/ko/perf_train_cpu.md | <!--Copyright 2022 The HuggingFace Team. All rights reserved.
Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
the License. You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
โ ๏ธ Note that this file is in Markdown but contain specific syntax for our doc-builder (similar to MDX) that may not be
rendered properly in your Markdown viewer.
-->
# CPU์์ ํจ์จ์ ์ธ ํ๋ จ [[efficient-training-on-cpu]]
์ด ๊ฐ์ด๋๋ CPU์์ ๋๊ท๋ชจ ๋ชจ๋ธ์ ํจ์จ์ ์ผ๋ก ํ๋ จํ๋ ๋ฐ ์ด์ ์ ๋ง์ถฅ๋๋ค.
## IPEX์ ํผํฉ ์ ๋ฐ๋ [[mixed-precision-with-ipex]]
IPEX๋ AVX-512 ์ด์์ ์ง์ํ๋ CPU์ ์ต์ ํ๋์ด ์์ผ๋ฉฐ, AVX2๋ง ์ง์ํ๋ CPU์๋ ๊ธฐ๋ฅ์ ์ผ๋ก ์๋ํฉ๋๋ค. ๋ฐ๋ผ์ AVX-512 ์ด์์ Intel CPU ์ธ๋์์๋ ์ฑ๋ฅ์ ์ด์ ์ด ์์ ๊ฒ์ผ๋ก ์์๋์ง๋ง, AVX2๋ง ์ง์ํ๋ CPU (์: AMD CPU ๋๋ ์ค๋๋ Intel CPU)์ ๊ฒฝ์ฐ์๋ IPEX ์๋์์ ๋ ๋์ ์ฑ๋ฅ์ ๋ณด์ผ ์ ์์ง๋ง ์ด๋ ๋ณด์ฅ๋์ง ์์ต๋๋ค. IPEX๋ Float32์ BFloat16๋ฅผ ๋ชจ๋ ์ฌ์ฉํ์ฌ CPU ํ๋ จ์ ์ํ ์ฑ๋ฅ ์ต์ ํ๋ฅผ ์ ๊ณตํฉ๋๋ค. BFloat16์ ์ฌ์ฉ์ ๋ค์ ์น์
์ ์ฃผ์ ์ด์ ์
๋๋ค.
์ ์ ๋ฐ๋ ๋ฐ์ดํฐ ํ์
์ธ BFloat16์ 3์ธ๋ Xeonยฎ Scalable ํ๋ก์ธ์ (์ฝ๋๋ช
: Cooper Lake)์์ AVX512 ๋ช
๋ น์ด ์งํฉ์ ๋ค์ดํฐ๋ธ๋ก ์ง์ํด ์์ผ๋ฉฐ, ๋ค์ ์ธ๋์ Intelยฎ Xeonยฎ Scalable ํ๋ก์ธ์์์ Intelยฎ Advanced Matrix Extensions (Intelยฎ AMX) ๋ช
๋ น์ด ์งํฉ์ ์ง์ํ์ฌ ์ฑ๋ฅ์ ํฌ๊ฒ ํฅ์์ํฌ ์์ ์
๋๋ค. CPU ๋ฐฑ์๋์ ์๋ ํผํฉ ์ ๋ฐ๋ ๊ธฐ๋ฅ์ PyTorch-1.10๋ถํฐ ํ์ฑํ๋์์ต๋๋ค. ๋์์, Intelยฎ Extension for PyTorch์์ BFloat16์ ๋ํ CPU์ ์๋ ํผํฉ ์ ๋ฐ๋ ๋ฐ ์ฐ์ฐ์์ BFloat16 ์ต์ ํ๋ฅผ ๋๊ท๋ชจ๋ก ํ์ฑํํ๊ณ , PyTorch ๋ง์คํฐ ๋ธ๋์น๋ก ๋ถ๋ถ์ ์ผ๋ก ์
์คํธ๋ฆผ์ ๋ฐ์ํ์ต๋๋ค. ์ฌ์ฉ์๋ค์ IPEX ์๋ ํผํฉ ์ ๋ฐ๋๋ฅผ ์ฌ์ฉํ์ฌ ๋ ๋์ ์ฑ๋ฅ๊ณผ ์ฌ์ฉ์ ๊ฒฝํ์ ์ป์ ์ ์์ต๋๋ค.
[์๋ ํผํฉ ์ ๋ฐ๋](https://intel.github.io/intel-extension-for-pytorch/cpu/latest/tutorials/features/amp.html)์ ๋ํ ์์ธํ ์ ๋ณด๋ฅผ ํ์ธํ์ญ์์ค.
### IPEX ์ค์น: [[ipex-installation]]
IPEX ๋ฆด๋ฆฌ์ค๋ PyTorch๋ฅผ ๋ฐ๋ผ๊ฐ๋๋ค. pip๋ฅผ ํตํด ์ค์นํ๋ ค๋ฉด:
| PyTorch Version | IPEX version |
| :---------------: | :----------: |
| 1.13 | 1.13.0+cpu |
| 1.12 | 1.12.300+cpu |
| 1.11 | 1.11.200+cpu |
| 1.10 | 1.10.100+cpu |
```bash
pip install intel_extension_for_pytorch==<version_name> -f https://developer.intel.com/ipex-whl-stable-cpu
```
[IPEX ์ค์น](https://intel.github.io/intel-extension-for-pytorch/cpu/latest/tutorials/installation.html)์ ๋ํ ๋ ๋ง์ ์ ๊ทผ ๋ฐฉ๋ฒ์ ํ์ธํ์ญ์์ค.
### Trainer์์์ ์ฌ์ฉ๋ฒ [[usage-in-trainer]]
Trainer์์ IPEX์ ์๋ ํผํฉ ์ ๋ฐ๋๋ฅผ ํ์ฑํํ๋ ค๋ฉด ์ฌ์ฉ์๋ ํ๋ จ ๋ช
๋ น ์ธ์์ `use_ipex`, `bf16`, `no_cuda`๋ฅผ ์ถ๊ฐํด์ผ ํฉ๋๋ค.
[Transformers ์ง๋ฌธ-์๋ต](https://github.com/huggingface/transformers/tree/main/examples/pytorch/question-answering)์ ์ฌ์ฉ ์ฌ๋ก๋ฅผ ์ดํด๋ณด๊ฒ ์ต๋๋ค.
- CPU์์ BF16 ์๋ ํผํฉ ์ ๋ฐ๋๋ฅผ ์ฌ์ฉํ์ฌ IPEX๋ก ํ๋ จํ๊ธฐ:
<pre> python run_qa.py \
--model_name_or_path google-bert/bert-base-uncased \
--dataset_name squad \
--do_train \
--do_eval \
--per_device_train_batch_size 12 \
--learning_rate 3e-5 \
--num_train_epochs 2 \
--max_seq_length 384 \
--doc_stride 128 \
--output_dir /tmp/debug_squad/ \
<b>--use_ipex \</b>
<b>--bf16 --no_cuda</b></pre>
### ์ค์ต ์์ [[practice-example]]
๋ธ๋ก๊ทธ: [Intel Sapphire Rapids๋ก PyTorch Transformers ๊ฐ์ํ](https://huggingface.co/blog/intel-sapphire-rapids) | 0 |
mavonic_private_repos/transformers/docs/source | mavonic_private_repos/transformers/docs/source/ko/model_summary.md | <!--Copyright 2020 The HuggingFace Team. All rights reserved.
Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
the License. You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
specific language governing permissions and limitations under the License.
โ ๏ธ Note that this file is in Markdown but contain specific syntax for our doc-builder (similar to MDX) that may not be
rendered properly in your Markdown viewer.
-->
# Transformer ๋ชจ๋ธ๊ตฐ[[the-transformer-model-family]]
2017๋
์ ์๊ฐ๋ [๊ธฐ๋ณธ Transformer](https://arxiv.org/abs/1706.03762) ๋ชจ๋ธ์ ์์ฐ์ด ์ฒ๋ฆฌ(NLP) ์์
์ ๋์ด ์๋กญ๊ณ ํฅ๋ฏธ๋ก์ด ๋ชจ๋ธ๋ค์ ์๊ฐ์ ์ฃผ์์ต๋๋ค. [๋จ๋ฐฑ์ง ์ ํ ๊ตฌ์กฐ ์์ธก](https://huggingface.co/blog/deep-learning-with-proteins), [์นํ์ ๋ฌ๋ฆฌ๊ธฐ ํ๋ จ](https://huggingface.co/blog/train-decision-transformers), [์๊ณ์ด ์์ธก](https://huggingface.co/blog/time-series-transformers) ๋ฑ์ ์ํ ๋ค์ํ ๋ชจ๋ธ์ด ์๊ฒจ๋ฌ์ต๋๋ค. Transformer์ ๋ณํ์ด ๋๋ฌด ๋ง์์, ํฐ ๊ทธ๋ฆผ์ ๋์น๊ธฐ ์ฝ์ต๋๋ค. ํ์ง๋ง ์ฌ๊ธฐ ์๋ ๋ชจ๋ ๋ชจ๋ธ์ ๊ณตํต์ ์ ๊ธฐ๋ณธ Trasnformer ์ํคํ
์ฒ๋ฅผ ๊ธฐ๋ฐ์ผ๋ก ํ๋ค๋ ์ ์
๋๋ค. ์ผ๋ถ ๋ชจ๋ธ์ ์ธ์ฝ๋ ๋๋ ๋์ฝ๋๋ง ์ฌ์ฉํ๊ณ , ๋ค๋ฅธ ๋ชจ๋ธ๋ค์ ์ธ์ฝ๋์ ๋์ฝ๋๋ฅผ ๋ชจ๋ ์ฌ์ฉํ๊ธฐ๋ ํฉ๋๋ค. ์ด๋ ๊ฒ Transformer ๋ชจ๋ธ๊ตฐ ๋ด ์์ ๋ ๋ฒจ์์์ ์ฐจ์ด์ ์ ๋ถ๋ฅํ๊ณ ๊ฒํ ํ๋ฉด ์ ์ฉํ ๋ถ๋ฅ ์ฒด๊ณ๋ฅผ ์ป์ ์ ์์ผ๋ฉฐ, ์ด์ ์ ์ ํด๋ณด์ง ๋ชปํ Transformer ๋ชจ๋ธ๋ค ๋ํ ์ดํดํ๋ ๋ฐ ๋์์ด ๋ ๊ฒ์
๋๋ค.
๊ธฐ๋ณธ Transformer ๋ชจ๋ธ์ ์ต์ํ์ง ์๊ฑฐ๋ ๋ณต์ต์ด ํ์ํ ๊ฒฝ์ฐ, Hugging Face ๊ฐ์์ [ํธ๋์คํฌ๋จธ๋ ์ด๋ป๊ฒ ๋์ํ๋์?](https://huggingface.co/course/chapter1/4?fw=pt) ์ฑํฐ๋ฅผ ํ์ธํ์ธ์.
<div align="center">
<iframe width="560" height="315" src="https://www.youtube.com/embed/H39Z_720T5s" title="YouTube video player"
frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope;
picture-in-picture" allowfullscreen></iframe>
</div>
## ์ปดํจํฐ ๋น์ [[computer-vision]]
<iframe style="border: 1px solid rgba(0, 0, 0, 0.1);" width="1000" height="450" src="https://www.figma.com/embed?embed_host=share&url=https%3A%2F%2Fwww.figma.com%2Ffile%2FacQBpeFBVvrDUlzFlkejoz%2FModelscape-timeline%3Fnode-id%3D0%253A1%26t%3Dm0zJ7m2BQ9oe0WtO-1" allowfullscreen></iframe>
### ํฉ์ฑ๊ณฑ ๋คํธ์ํฌ[[convolutional-network]]
[Vision Transformer](https://arxiv.org/abs/2010.11929)๊ฐ ํ์ฅ์ฑ๊ณผ ํจ์จ์ฑ์ ์
์ฆํ๊ธฐ ์ ๊น์ง ์ค๋ซ๋์ ํฉ์ฑ๊ณฑ ๋คํธ์ํฌ(CNN)๊ฐ ์ปดํจํฐ ๋น์ ์์
์ ์ง๋ฐฐ์ ์ธ ํจ๋ฌ๋ค์์ด์์ต๋๋ค. ๊ทธ๋ผ์๋ ๋ถ๊ตฌํ๊ณ , ์ด๋ ๋ถ๋ณ์ฑ(translation invariance)๊ณผ ๊ฐ์ CNN์ ์ฐ์ํ ๋ถ๋ถ์ด ๋๋๋ผ์ง๊ธฐ ๋๋ฌธ์ ๋ช๋ช (ํนํ ํน์ ๊ณผ์
์์์) Transformer ๋ชจ๋ธ์ ์ํคํ
์ฒ์ ํฉ์ฑ๊ณฑ์ ํตํฉํ๊ธฐ๋ ํ์ต๋๋ค. [ConvNeXt](model_doc/convnext)๋ ์ด๋ฐ ๊ด๋ก๋ฅผ ๋ค์ง์ด CNN์ ํ๋ํํ๊ธฐ ์ํด Transformer์ ๋์์ธ์ ์ฐจ์ฉํฉ๋๋ค. ์๋ฅผ ๋ค๋ฉด ConvNeXt๋ ๊ฒน์น์ง ์๋ ์ฌ๋ผ์ด๋ฉ ์ฐฝ(sliding window)์ ์ฌ์ฉํ์ฌ ์ด๋ฏธ์ง๋ฅผ ํจ์นํํ๊ณ , ๋ ํฐ ์ปค๋๋ก ์ ์ญ ์์ฉ ํ๋(global receptive field)๋ฅผ ํ์ฅ์ํต๋๋ค. ConvNeXt๋ ๋ํ ๋ฉ๋ชจ๋ฆฌ ํจ์จ์ ๋์ด๊ณ ์ฑ๋ฅ์ ํฅ์์ํค๊ธฐ ์ํด ์ฌ๋ฌ ๋ ์ด์ด ์ค๊ณ๋ฅผ ์ ํํ๊ธฐ ๋๋ฌธ์ Transformer์ ๊ฒฌ์ค๋งํฉ๋๋ค!
### ์ธ์ฝ๋[[cv-encoder]]
[Vision Transformer(ViT)](model_doc/vit)๋ ํฉ์ฑ๊ณฑ ์๋ ์ปดํจํฐ ๋น์ ์์
์ ๋ง์ ์ด์์ต๋๋ค. ViT๋ ํ์ค Transformer ์ธ์ฝ๋๋ฅผ ์ฌ์ฉํ์ง๋ง, ๊ฐ์ฅ ํฐ ํ์ ์ ์ด๋ฏธ์ง๋ฅผ ์ฒ๋ฆฌํ๋ ๋ฐฉ์์ด์์ต๋๋ค. ๋ฌธ์ฅ์ ํ ํฐ์ผ๋ก ๋ถํ ํ๋ ๊ฒ์ฒ๋ผ ์ด๋ฏธ์ง๋ฅผ ๊ณ ์ ๋ ํฌ๊ธฐ์ ํจ์น๋ก ๋ถํ ํ๊ณ , ์ด๋ฅผ ์ฌ์ฉํ์ฌ ์๋ฒ ๋ฉ์ ์์ฑํฉ๋๋ค. ViT๋ Transformer์ ํจ์จ์ ์ธ ์ํคํ
์ฒ๋ฅผ ํ์ฉํ์ฌ ํ๋ จ์ ๋ ์ ์ ์์์ ์ฌ์ฉํ๋ฉด์๋ ๋น์ CNN์ ๋น๊ฒฌํ๋ ๊ฒฐ๊ณผ๋ฅผ ์
์ฆํ์ต๋๋ค. ๊ทธ๋ฆฌ๊ณ ViT๋ฅผ ๋ค์ด์ด ๋ถํ (segmentation)๊ณผ ๊ฐ์ ๊ณ ๋ฐ๋ ๋น์ ์์
๊ณผ ํ์ง ์์
๋ ๋ค๋ฃฐ ์ ์๋ ๋ค๋ฅธ ๋น์ ๋ชจ๋ธ์ด ๋ฑ์ฅํ์ต๋๋ค.
์ด๋ฌํ ๋ชจ๋ธ ์ค ํ๋๊ฐ [Swin](model_doc/swin) Transformer์
๋๋ค. ์ด ๋ชจ๋ธ์ ์์ ํฌ๊ธฐ์ ํจ์น์์ ๊ณ์ธต์ ํน์ง ๋งต(CNN ๐๊ณผ ๊ฐ์ง๋ง ViT์๋ ๋ค๋ฆ)์ ๋ง๋ค๊ณ ๋ ๊น์ ๋ ์ด์ด์ ์ธ์ ํจ์น์ ๋ณํฉํฉ๋๋ค. ์ดํ
์
(Attention)์ ์ง์ญ ์๋์ฐ ๋ด์์๋ง ๊ณ์ฐ๋๋ฉฐ, ๋ชจ๋ธ์ด ๋ ์ ํ์ตํ ์ ์๋๋ก ์ดํ
์
๋ ์ด์ด ๊ฐ์ ์๋์ฐ๋ฅผ ์ด๋ํ๋ฉฐ ์ฐ๊ฒฐ์ ์์ฑํฉ๋๋ค. Swin Transformer๋ ๊ณ์ธต์ ํน์ง ๋งต์ ์์ฑํ ์ ์์ผ๋ฏ๋ก, ๋ถํ (segmentation)๊ณผ ํ์ง์ ๊ฐ์ ๊ณ ๋ฐ๋ ์์ธก ์์
์ ์ ํฉํฉ๋๋ค. [SegFormer](model_doc/segformer) ์ญ์ Transformer ์ธ์ฝ๋๋ฅผ ์ฌ์ฉํ์ฌ ๊ณ์ธต์ ํน์ง ๋งต์ ๊ตฌ์ถํ์ง๋ง, ์๋จ์ ๊ฐ๋จํ ๋ค์ธต ํผ์
ํธ๋ก (MLP) ๋์ฝ๋๋ฅผ ์ถ๊ฐํ์ฌ ๋ชจ๋ ํน์ง ๋งต์ ๊ฒฐํฉํ๊ณ ์์ธก์ ์ํํฉ๋๋ค.
BeIT์ ViTMAE์ ๊ฐ์ ๋ค๋ฅธ ๋น์ ๋ชจ๋ธ์ BERT์ ์ฌ์ ํ๋ จ ๋ชฉํ(objective)์์ ์๊ฐ์ ์ป์์ต๋๋ค. [BeIT](model_doc/beit)๋ *๋ง์คํฌ๋ ์ด๋ฏธ์ง ๋ชจ๋ธ๋ง(MIM)*์ผ๋ก ์ฌ์ ํ๋ จ๋๋ฉฐ, ์ด๋ฏธ์ง ํจ์น๋ ์์๋ก ๋ง์คํน๋๊ณ ์ด๋ฏธ์ง๋ ์๊ฐ์ ํ ํฐ์ผ๋ก ํ ํฐํ๋ฉ๋๋ค. BeIT๋ ๋ง์คํน๋ ํจ์น์ ํด๋นํ๋ ์๊ฐ์ ํ ํฐ์ ์์ธกํ๋๋ก ํ์ต๋ฉ๋๋ค. [ViTMAE](model_doc/vitmae)๋ ๋น์ทํ ์ฌ์ ํ๋ จ ๋ชฉํ๊ฐ ์์ง๋ง, ์๊ฐ์ ํ ํฐ ๋์ ํฝ์
์ ์์ธกํด์ผ ํ๋ค๋ ์ ์ด ๋ค๋ฆ
๋๋ค. ํน์ดํ ์ ์ ์ด๋ฏธ์ง ํจ์น์ 75%๊ฐ ๋ง์คํน๋์ด ์๋ค๋ ๊ฒ์
๋๋ค! ๋์ฝ๋๋ ๋ง์คํน๋ ํ ํฐ๊ณผ ์ธ์ฝ๋ฉ๋ ํจ์น์์ ํฝ์
์ ์ฌ๊ตฌ์ฑํฉ๋๋ค. ์ฌ์ ํ๋ จ์ด ๋๋๋ฉด ๋์ฝ๋๋ ํ๊ธฐ๋๊ณ ์ธ์ฝ๋๋ ๋ค์ด์คํธ๋ฆผ ์์
์ ์ฌ์ฉํ ์ค๋น๊ฐ ๋ฉ๋๋ค.
### ๋์ฝ๋[[cv-decoder]]
๋๋ถ๋ถ์ ๋น์ ๋ชจ๋ธ์ ์ธ์ฝ๋์ ์์กดํ์ฌ ์ด๋ฏธ์ง ํํ์ ํ์ตํ๊ธฐ ๋๋ฌธ์ ๋์ฝ๋ ์ ์ฉ ๋น์ ๋ชจ๋ธ์ ๋๋ญ
๋๋ค. ํ์ง๋ง ์ด๋ฏธ์ง ์์ฑ ๋ฑ์ ์ฌ๋ก์ ๊ฒฝ์ฐ, GPT-2์ ๊ฐ์ ํ
์คํธ ์์ฑ ๋ชจ๋ธ์์ ๋ณด์๋ฏ์ด ๋์ฝ๋๊ฐ ๊ฐ์ฅ ์ ํฉํฉ๋๋ค. [ImageGPT](model_doc/imagegpt)๋ GPT-2์ ๋์ผํ ์ํคํ
์ฒ๋ฅผ ์ฌ์ฉํ์ง๋ง, ์ํ์ค์ ๋ค์ ํ ํฐ์ ์์ธกํ๋ ๋์ ์ด๋ฏธ์ง์ ๋ค์ ํฝ์
์ ์์ธกํฉ๋๋ค. ImageGPT๋ ์ด๋ฏธ์ง ์์ฑ ๋ฟ๋ง ์๋๋ผ ์ด๋ฏธ์ง ๋ถ๋ฅ๋ฅผ ์ํด ๋ฏธ์ธ ์กฐ์ ํ ์๋ ์์ต๋๋ค.
### ์ธ์ฝ๋-๋์ฝ๋[[cv-encoder-decoder]]
๋น์ ๋ชจ๋ธ์ ์ผ๋ฐ์ ์ผ๋ก ์ธ์ฝ๋(๋ฐฑ๋ณธ์ผ๋ก๋ ์๋ ค์ง)๋ฅผ ์ฌ์ฉํ์ฌ ์ค์ํ ์ด๋ฏธ์ง ํน์ง์ ์ถ์ถํ ํ, ์ด๋ฅผ Transformer ๋์ฝ๋๋ก ์ ๋ฌํฉ๋๋ค. [DETR](model_doc/detr)์ ์ฌ์ ํ๋ จ๋ ๋ฐฑ๋ณธ์ด ์์ง๋ง, ๊ฐ์ฒด ํ์ง๋ฅผ ์ํด ์์ ํ Transformer ์ธ์ฝ๋-๋์ฝ๋ ์ํคํ
์ฒ๋ ์ฌ์ฉํฉ๋๋ค. ์ธ์ฝ๋๋ ์ด๋ฏธ์ง ํํ์ ํ์ตํ๊ณ ์ด๋ฅผ ๋์ฝ๋์์ ๊ฐ์ฒด ์ฟผ๋ฆฌ(๊ฐ ๊ฐ์ฒด ์ฟผ๋ฆฌ๋ ์ด๋ฏธ์ง์ ์์ญ ๋๋ ๊ฐ์ฒด์ ์ค์ ์ ๋๊ณ ํ์ต๋ ์๋ฒ ๋ฉ)์ ๊ฒฐํฉํฉ๋๋ค. DETR์ ๊ฐ ๊ฐ์ฒด ์ฟผ๋ฆฌ์ ๋ํ ๋ฐ์ด๋ฉ ๋ฐ์ค ์ขํ์ ํด๋์ค ๋ ์ด๋ธ์ ์์ธกํฉ๋๋ค.
## ์์ฐ์ด์ฒ๋ฆฌ[[natural-language-processing]]
<iframe style="border: 1px solid rgba(0, 0, 0, 0.1);" width="1000" height="450" src="https://www.figma.com/embed?embed_host=share&url=https%3A%2F%2Fwww.figma.com%2Ffile%2FUhbQAZDlpYW5XEpdFy6GoG%2Fnlp-model-timeline%3Fnode-id%3D0%253A1%26t%3D4mZMr4r1vDEYGJ50-1" allowfullscreen></iframe>
### ์ธ์ฝ๋[[nlp-encoder]]
[BERT](model_doc/bert)๋ ์ธ์ฝ๋ ์ ์ฉ Transformer๋ก, ๋ค๋ฅธ ํ ํฐ์ ๋ณด๊ณ ์์ "๋ถ์ ํ์"๋ฅผ ์ ์ง๋ฅด๋ ๊ฑธ ๋ง๊ธฐ ์ํด ์
๋ ฅ์์ ํน์ ํ ํฐ์ ์์๋ก ๋ง์คํนํฉ๋๋ค. ์ฌ์ ํ๋ จ์ ๋ชฉํ๋ ์ปจํ
์คํธ๋ฅผ ๊ธฐ๋ฐ์ผ๋ก ๋ง์คํน๋ ํ ํฐ์ ์์ธกํ๋ ๊ฒ์
๋๋ค. ์ด๋ฅผ ํตํด BERT๋ ์ผ์ชฝ๊ณผ ์ค๋ฅธ์ชฝ ์ปจํ
์คํธ๋ฅผ ์ถฉ๋ถํ ํ์ฉํ์ฌ ์
๋ ฅ์ ๋ํด ๋ ๊น๊ณ ํ๋ถํ ํํ์ ํ์ตํ ์ ์์ต๋๋ค. ๊ทธ๋ฌ๋ BERT์ ์ฌ์ ํ๋ จ ์ ๋ต์๋ ์ฌ์ ํ ๊ฐ์ ์ ์ฌ์ง๊ฐ ๋จ์ ์์์ต๋๋ค. [RoBERTa](model_doc/roberta)๋ ๋ ๊ธด ์๊ฐ ๋์ ๋ ํฐ ๋ฐฐ์น์ ๋ํ ํ๋ จ์ ํฌํจํ๊ณ , ์ ์ฒ๋ฆฌ ์ค์ ํ ๋ฒ๋ง ๋ง์คํนํ๋ ๊ฒ์ด ์๋๋ผ ๊ฐ ์ํญ์์ ํ ํฐ์ ์์๋ก ๋ง์คํนํ๊ณ , ๋ค์ ๋ฌธ์ฅ ์์ธก ๋ชฉํ๋ฅผ ์ ๊ฑฐํ๋ ์๋ก์ด ์ฌ์ ํ๋ จ ๋ฐฉ์์ ๋์
ํจ์ผ๋ก์จ ์ด๋ฅผ ๊ฐ์ ํ์ต๋๋ค.
์ฑ๋ฅ ๊ฐ์ ์ ์ํ ์ ๋ต์ผ๋ก ๋ชจ๋ธ ํฌ๊ธฐ๋ฅผ ํค์ฐ๋ ๊ฒ์ด ์ง๋ฐฐ์ ์
๋๋ค. ํ์ง๋ง ํฐ ๋ชจ๋ธ์ ํ๋ จํ๋ ค๋ฉด ๊ณ์ฐ ๋น์ฉ์ด ๋ง์ด ๋ญ๋๋ค. ๊ณ์ฐ ๋น์ฉ์ ์ค์ด๋ ํ ๊ฐ์ง ๋ฐฉ๋ฒ์ [DistilBERT](model_doc/distilbert)์ ๊ฐ์ด ์์ ๋ชจ๋ธ์ ์ฌ์ฉํ๋ ๊ฒ์
๋๋ค. DistilBERT๋ ์์ถ ๊ธฐ๋ฒ์ธ [์ง์ ์ฆ๋ฅ(knowledge distillation)](https://arxiv.org/abs/1503.02531)๋ฅผ ์ฌ์ฉํ์ฌ, ๊ฑฐ์ ๋ชจ๋ ์ธ์ด ์ดํด ๋ฅ๋ ฅ์ ์ ์งํ๋ฉด์ ๋ ์์ ๋ฒ์ ์ BERT๋ฅผ ๋ง๋ญ๋๋ค.
๊ทธ๋ฌ๋ ๋๋ถ๋ถ์ Transformer ๋ชจ๋ธ์ ๋ ๋ง์ ๋งค๊ฐ๋ณ์๋ฅผ ์ฌ์ฉํ๋ ๊ฒฝํฅ์ด ์ด์ด์ก๊ณ , ์ด์ ๋ฐ๋ผ ํ๋ จ ํจ์จ์ฑ์ ๊ฐ์ ํ๋ ๊ฒ์ ์ค์ ์ ๋ ์๋ก์ด ๋ชจ๋ธ์ด ๋ฑ์ฅํ์ต๋๋ค. [ALBERT](model_doc/albert)๋ ๋ ๊ฐ์ง ๋ฐฉ๋ฒ์ผ๋ก ๋งค๊ฐ๋ณ์ ์๋ฅผ ์ค์ฌ ๋ฉ๋ชจ๋ฆฌ ์ฌ์ฉ๋์ ์ค์์ต๋๋ค. ๋ฐ๋ก ํฐ ์ดํ๋ฅผ ๋ ๊ฐ์ ์์ ํ๋ ฌ๋ก ๋ถ๋ฆฌํ๋ ๊ฒ๊ณผ ๋ ์ด์ด๊ฐ ๋งค๊ฐ๋ณ์๋ฅผ ๊ณต์ ํ๋๋ก ํ๋ ๊ฒ์
๋๋ค. [DeBERTa](model_doc/deberta)๋ ๋จ์ด์ ๊ทธ ์์น๋ฅผ ๋ ๊ฐ์ ๋ฒกํฐ๋ก ๊ฐ๋ณ์ ์ผ๋ก ์ธ์ฝ๋ฉํ๋ ๋ถ๋ฆฌ๋(disentangled) ์ดํ
์
๋ฉ์ปค๋์ฆ์ ์ถ๊ฐํ์ต๋๋ค. ์ดํ
์
์ ๋จ์ด์ ์์น ์๋ฒ ๋ฉ์ ํฌํจํ๋ ๋จ์ผ ๋ฒกํฐ ๋์ ์ด ๋ณ๋์ ๋ฒกํฐ์์ ๊ณ์ฐ๋ฉ๋๋ค. [Longformer](model_doc/longformer)๋ ํนํ ์ํ์ค ๊ธธ์ด๊ฐ ๊ธด ๋ฌธ์๋ฅผ ์ฒ๋ฆฌํ ๋, ์ดํ
์
์ ๋ ํจ์จ์ ์ผ๋ก ๋ง๋๋ ๊ฒ์ ์ค์ ์ ๋์์ต๋๋ค. ์ง์ญ(local) ์๋์ฐ ์ดํ
์
(๊ฐ ํ ํฐ ์ฃผ๋ณ์ ๊ณ ์ ๋ ์๋์ฐ ํฌ๊ธฐ์์๋ง ๊ณ์ฐ๋๋ ์ดํ
์
)๊ณผ ์ ์ญ(global) ์ดํ
์
(๋ถ๋ฅ๋ฅผ ์ํด `[CLS]`์ ๊ฐ์ ํน์ ์์
ํ ํฐ์๋ง ํด๋น)์ ์กฐํฉ์ ์ฌ์ฉํ์ฌ ์ ์ฒด(full) ์ดํ
์
ํ๋ ฌ ๋์ ํฌ์(sparse) ์ดํ
์
ํ๋ ฌ์ ์์ฑํฉ๋๋ค.
### ๋์ฝ๋[[nlp-decoder]]
[GPT-2](model_doc/gpt2)๋ ์ํ์ค์์ ๋ค์ ๋จ์ด๋ฅผ ์์ธกํ๋ ๋์ฝ๋ ์ ์ฉ Transformer์
๋๋ค. ํ ํฐ์ ์ค๋ฅธ์ชฝ์ผ๋ก ๋ง์คํนํ์ฌ ๋ชจ๋ธ์ด ์ด์ ํ ํฐ์ ๋ณด๊ณ "๋ถ์ ํ์"๋ฅผ ํ์ง ๋ชปํ๋๋ก ํฉ๋๋ค. GPT-2๋ ๋ฐฉ๋ํ ํ
์คํธ์ ๋ํด ์ฌ์ ํ๋ จํ์ฌ ํ
์คํธ๊ฐ ์ผ๋ถ๋ง ์ ํํ๊ฑฐ๋ ์ฌ์ค์ธ ๊ฒฝ์ฐ์๋ ์๋นํ ๋ฅ์ํ๊ฒ ํ
์คํธ๋ฅผ ์์ฑํ ์ ์๊ฒ ๋์์ต๋๋ค. ํ์ง๋ง GPT-2๋ BERT๊ฐ ์ฌ์ ํ๋ จ์์ ๊ฐ๋ ์๋ฐฉํฅ ์ปจํ
์คํธ๊ฐ ๋ถ์กฑํ๊ธฐ ๋๋ฌธ์ ํน์ ์์
์ ์ ํฉํ์ง ์์์ต๋๋ค. [XLNET](model_doc/xlnet)์ ์๋ฐฉํฅ ํ๋ จ์ด ๊ฐ๋ฅํ permutation language modeling objective(PLM)๋ฅผ ์ฌ์ฉํ์ฌ BERT์ GPT-2์ ์ฌ์ ํ๋ จ ๋ชฉํ์ ๋ํ ์ฅ์ ์ ํจ๊ป ๊ฐ์ง๊ณ ์์ต๋๋ค.
GPT-2 ์ดํ, ์ธ์ด ๋ชจ๋ธ์ ๋์ฑ ๊ฑฐ๋ํด์ก๊ณ ํ์ฌ๋ *๋๊ท๋ชจ ์ธ์ด ๋ชจ๋ธ(LLM)*๋ก ์๋ ค์ ธ ์์ต๋๋ค. ์ถฉ๋ถํ ํฐ ๋ฐ์ดํฐ ์ธํธ๋ก ์ฌ์ ํ๋ จ๋ LLM์ ํจ์ท(few-shot) ๋๋ ์ ๋ก์ท(zero-shot) ํ์ต์ ์ํํฉ๋๋ค. [GPT-J](model_doc/gptj)๋ 6B ํฌ๊ธฐ์ ๋งค๊ฐ๋ณ์๊ฐ ์๊ณ 400B ํฌ๊ธฐ์ ํ ํฐ์ผ๋ก ํ๋ จ๋ LLM์
๋๋ค. GPT-J์ ์ด์ด ๋์ฝ๋ ์ ์ฉ ๋ชจ๋ธ๊ตฐ์ธ [OPT](model_doc/opt)๊ฐ ๋ฑ์ฅํ์ผ๋ฉฐ, ์ด ์ค ๊ฐ์ฅ ํฐ ๋ชจ๋ธ์ 175B ํฌ๊ธฐ์ด๊ณ 180B ํฌ๊ธฐ์ ํ ํฐ์ผ๋ก ํ๋ จ๋์์ต๋๋ค. [BLOOM](model_doc/bloom)์ ๋น์ทํ ์๊ธฐ์ ์ถ์๋์์ผ๋ฉฐ, ์ด ์ค ๊ฐ์ฅ ํฐ ๋ชจ๋ธ์ 176B ํฌ๊ธฐ์ ๋งค๊ฐ๋ณ์๊ฐ ์๊ณ 46๊ฐ์ ์ธ์ด์ 13๊ฐ์ ํ๋ก๊ทธ๋๋ฐ ์ธ์ด๋ก ๋ 366B ํฌ๊ธฐ์ ํ ํฐ์ผ๋ก ํ๋ จ๋์์ต๋๋ค.
### ์ธ์ฝ๋-๋์ฝ๋[[nlp-encoder-decoder]]
[BART](model_doc/bart)๋ ๊ธฐ๋ณธ Transformer ์ํคํ
์ฒ๋ฅผ ์ ์งํ์ง๋ง, ์ผ๋ถ ํ
์คํธ ์คํฌ(span)์ด ๋จ์ผ `๋ง์คํฌ` ํ ํฐ์ผ๋ก ๋์ฒด๋๋ *text infilling* ๋ณํ์ผ๋ก ์ฌ์ ํ๋ จ ๋ชฉํ๋ฅผ ์์ ํฉ๋๋ค. ๋์ฝ๋๋ ๋ณํ๋์ง ์์ ํ ํฐ(ํฅํ ํ ํฐ์ ๋ง์คํน๋จ)์ ์์ธกํ๊ณ ์ธ์ฝ๋์ ์๋ ์ํ๋ฅผ ์ฌ์ฉํ์ฌ ์ด ์์
์ ๋์ต๋๋ค. [Pegasus](model_doc/pegasus)๋ BART์ ์ ์ฌํ์ง๋ง, Pegasus๋ ํ
์คํธ ์คํฌ ๋์ ์ ์ฒด ๋ฌธ์ฅ์ ๋ง์คํนํฉ๋๋ค. Pegasus๋ ๋ง์คํฌ๋ ์ธ์ด ๋ชจ๋ธ๋ง ์ธ์๋ gap sentence generation(GSG)๋ก ์ฌ์ ํ๋ จ๋ฉ๋๋ค. GSG๋ ๋ฌธ์์ ์ค์ํ ๋ฌธ์ฅ ์ ์ฒด๋ฅผ ๋ง์คํนํ์ฌ `๋ง์คํฌ` ํ ํฐ์ผ๋ก ๋์ฒดํ๋ ๊ฒ์ ๋ชฉํ๋ก ํฉ๋๋ค. ๋์ฝ๋๋ ๋จ์ ๋ฌธ์ฅ์์ ์ถ๋ ฅ์ ์์ฑํด์ผ ํฉ๋๋ค. [T5](model_doc/t5)๋ ํน์ ์ ๋์ฌ๋ฅผ ์ฌ์ฉํ์ฌ ๋ชจ๋ NLP ์์
์ ํ
์คํธ ํฌ ํ
์คํธ ๋ฌธ์ ๋ก ๋ณํํ๋ ๋ ํน์ํ ๋ชจ๋ธ์
๋๋ค. ์๋ฅผ ๋ค์ด, ์ ๋์ฌ `Summarize:`์ ์์ฝ ์์
์ ๋ํ๋
๋๋ค. T5๋ ์ง๋(GLUE ๋ฐ SuperGLUE) ํ๋ จ๊ณผ ์๊ธฐ์ง๋ ํ๋ จ(ํ ํฐ์ 15%๋ฅผ ์์๋ก ์ํ๋งํ์ฌ ์ ๊ฑฐ)์ผ๋ก ์ฌ์ ํ๋ จ๋ฉ๋๋ค.
## ์ค๋์ค[[audio]]
<iframe style="border: 1px solid rgba(0, 0, 0, 0.1);" width="1000" height="450" src="https://www.figma.com/embed?embed_host=share&url=https%3A%2F%2Fwww.figma.com%2Ffile%2Fvrchl8jDV9YwNVPWu2W0kK%2Fspeech-and-audio-model-timeline%3Fnode-id%3D0%253A1%26t%3DmM4H8pPMuK23rClL-1" allowfullscreen></iframe>
### ์ธ์ฝ๋[[audio-encoder]]
[Wav2Vec2](model_doc/wav2vec2)๋ Transformer ์ธ์ฝ๋๋ฅผ ์ฌ์ฉํ์ฌ ์๋ณธ ์ค๋์ค ํํ(raw audio waveform)์์ ์ง์ ์์ฑ ํํ์ ํ์ตํฉ๋๋ค. ํ์ ์์ฑ ํํ ์ธํธ์์ ์ค์ ์์ฑ ํํ์ ํ๋ณํ๋ ๋์กฐ ์์
์ผ๋ก ์ฌ์ ํ๋ จ๋ฉ๋๋ค. [HuBERT](model_doc/hubert)๋ Wav2Vec2์ ์ ์ฌํ์ง๋ง ํ๋ จ ๊ณผ์ ์ด ๋ค๋ฆ
๋๋ค. ํ๊ฒ ๋ ์ด๋ธ์ด ์ ์ฌํ ์ค๋์ค ์ธ๊ทธ๋จผํธ๊ฐ ํด๋ฌ์คํฐ์ ํ ๋น๋์ด ์๋ ๋จ์(unit)๊ฐ ๋๋ ๊ตฐ์งํ(clustering) ๋จ๊ณ์์ ์์ฑ๋ฉ๋๋ค. ์๋ ๋จ์๋ ์์ธก์ ์ํ ์๋ฒ ๋ฉ์ ๋งคํ๋ฉ๋๋ค.
### ์ธ์ฝ๋-๋์ฝ๋[[audio-encoder-decoder]]
[Speech2Text](model_doc/speech_to_text)๋ ์๋ ์์ฑ ์ธ์(ASR) ๋ฐ ์์ฑ ๋ฒ์ญ์ ์ํด ๊ณ ์๋ ์์ฑ ๋ชจ๋ธ์
๋๋ค. ์ด ๋ชจ๋ธ์ ์ค๋์ค ํํ์์ ์ถ์ถํ log mel-filter bank ํน์ง์ ์ฑํํ๊ณ ์๊ธฐํ๊ท ๋ฐฉ์์ผ๋ก ์ฌ์ ํ๋ จํ์ฌ, ์ ์ฌ๋ณธ ๋๋ ๋ฒ์ญ์ ๋ง๋ญ๋๋ค. [Whisper](model_doc/whisper)์ ASR ๋ชจ๋ธ์ด์ง๋ง, ๋ค๋ฅธ ๋ง์ ์์ฑ ๋ชจ๋ธ๊ณผ ๋ฌ๋ฆฌ ์ ๋ก์ท ์ฑ๋ฅ์ ์ํด ๋๋์ โจ ๋ ์ด๋ธ์ด ์ง์ ๋ โจ ์ค๋์ค ์ ์ฌ ๋ฐ์ดํฐ์ ๋ํด ์ฌ์ ํ๋ จ๋ฉ๋๋ค. ๋ฐ์ดํฐ ์ธํธ์ ํฐ ๋ฌถ์์๋ ์์ด๊ฐ ์๋ ์ธ์ด๋ ํฌํจ๋์ด ์์ด์ ์์์ด ์ ์ ์ธ์ด์๋ Whisper๋ฅผ ์ฌ์ฉํ ์ ์์ต๋๋ค. ๊ตฌ์กฐ์ ์ผ๋ก, Whisper๋ Speech2Text์ ์ ์ฌํฉ๋๋ค. ์ค๋์ค ์ ํธ๋ ์ธ์ฝ๋์ ์ํด ์ธ์ฝ๋ฉ๋ log-mel spectrogram์ผ๋ก ๋ณํ๋ฉ๋๋ค. ๋์ฝ๋๋ ์ธ์ฝ๋์ ์๋ ์ํ์ ์ด์ ํ ํฐ์ผ๋ก๋ถํฐ ์๊ธฐํ๊ท ๋ฐฉ์์ผ๋ก ์ ์ฌ๋ฅผ ์์ฑํฉ๋๋ค.
## ๋ฉํฐ๋ชจ๋ฌ[[multimodal]]
<iframe style="border: 1px solid rgba(0, 0, 0, 0.1);" width="1000" height="450" src="https://www.figma.com/embed?embed_host=share&url=https%3A%2F%2Fwww.figma.com%2Ffile%2FcX125FQHXJS2gxeICiY93p%2Fmultimodal%3Fnode-id%3D0%253A1%26t%3DhPQwdx3HFPWJWnVf-1" allowfullscreen></iframe>
### ์ธ์ฝ๋[[mm-encoder]]
[VisualBERT](model_doc/visual_bert)๋ BERT ์ดํ์ ์ถ์๋ ๋น์ ์ธ์ด ์์
์ ์ํ ๋ฉํฐ๋ชจ๋ฌ ๋ชจ๋ธ์
๋๋ค. ์ด ๋ชจ๋ธ์ BERT์ ์ฌ์ ํ๋ จ๋ ๊ฐ์ฒด ํ์ง ์์คํ
์ ๊ฒฐํฉํ์ฌ ์ด๋ฏธ์ง ํน์ง์ ์๊ฐ ์๋ฒ ๋ฉ์ผ๋ก ์ถ์ถํ๊ณ , ํ
์คํธ ์๋ฒ ๋ฉ๊ณผ ํจ๊ป BERT๋ก ์ ๋ฌํฉ๋๋ค. VisualBERT๋ ๋ง์คํน๋์ง ์์ ํ
์คํธ์ ์๊ฐ ์๋ฒ ๋ฉ์ ๊ธฐ๋ฐ์ผ๋ก ๋ง์คํน๋ ํ
์คํธ๋ฅผ ์์ธกํ๊ณ , ํ
์คํธ๊ฐ ์ด๋ฏธ์ง์ ์ผ์นํ๋์ง ์์ธกํด์ผ ํฉ๋๋ค. ViT๊ฐ ์ด๋ฏธ์ง ์๋ฒ ๋ฉ์ ๊ตฌํ๋ ๋ฐฉ์์ด ๋ ์ฌ์ ๊ธฐ ๋๋ฌธ์, ViT๊ฐ ์ถ์๋ ํ [ViLT](model_doc/vilt)๋ ์ํคํ
์ฒ์ ViT๋ฅผ ์ฑํํ์ต๋๋ค. ์ด๋ฏธ์ง ์๋ฒ ๋ฉ์ ํ
์คํธ ์๋ฒ ๋ฉ๊ณผ ํจ๊ป ์ฒ๋ฆฌ๋ฉ๋๋ค. ์ฌ๊ธฐ์์, ViLT๋ ์ด๋ฏธ์ง ํ
์คํธ ๋งค์นญ, ๋ง์คํฌ๋ ์ธ์ด ๋ชจ๋ธ๋ง, ์ ์ฒด ๋จ์ด ๋ง์คํน์ ํตํด ์ฌ์ ํ๋ จ๋ฉ๋๋ค.
[CLIP](model_doc/clip)์ ๋ค๋ฅธ ์ ๊ทผ ๋ฐฉ์์ ์ฌ์ฉํ์ฌ (`์ด๋ฏธ์ง`, `ํ
์คํธ`)์ ์ ์์ธก์ ์ํํฉ๋๋ค. (`์ด๋ฏธ์ง`, `ํ
์คํธ`) ์์์์ ์ด๋ฏธ์ง์ ํ
์คํธ ์๋ฒ ๋ฉ ๊ฐ์ ์ ์ฌ๋๋ฅผ ์ต๋ํํ๊ธฐ ์ํด 4์ต ๊ฐ์ (`์ด๋ฏธ์ง`, `ํ
์คํธ`) ์ ๋ฐ์ดํฐ ์ธํธ์ ๋ํด ์ด๋ฏธ์ง ์ธ์ฝ๋(ViT)์ ํ
์คํธ ์ธ์ฝ๋(Transformer)๋ฅผ ํจ๊ป ํ๋ จํฉ๋๋ค. ์ฌ์ ํ๋ จ ํ, ์์ฐ์ด๋ฅผ ์ฌ์ฉํ์ฌ ์ด๋ฏธ์ง๊ฐ ์ฃผ์ด์ง ํ
์คํธ๋ฅผ ์์ธกํ๊ฑฐ๋ ๊ทธ ๋ฐ๋๋ก ์์ธกํ๋๋ก CLIP์ ์ง์ํ ์ ์์ต๋๋ค. [OWL-ViT](model_doc/owlvit)๋ CLIP์ ์ ๋ก์ท ๊ฐ์ฒด ํ์ง๋ฅผ ์ํ ๋ฐฑ๋ณธ(backbone)์ผ๋ก ์ฌ์ฉํ์ฌ CLIP ์์ ๊ตฌ์ถ๋ฉ๋๋ค. ์ฌ์ ํ๋ จ ํ, ๊ฐ์ฒด ํ์ง ํค๋๊ฐ ์ถ๊ฐ๋์ด (`ํด๋์ค`, `๋ฐ์ด๋ฉ ๋ฐ์ค`) ์์ ๋ํ ์งํฉ(set) ์์ธก์ ์ํํฉ๋๋ค.
### ์ธ์ฝ๋-๋์ฝ๋[[mm-encoder-decoder]]
๊ดํ ๋ฌธ์ ์ธ์(OCR)์ ์ด๋ฏธ์ง๋ฅผ ์ดํดํ๊ณ ํ
์คํธ๋ฅผ ์์ฑํ๊ธฐ ์ํด ๋ค์ํ ๊ตฌ์ฑ ์์๋ฅผ ํ์๋ก ํ๋ ์ ํต์ ์ธ ํ
์คํธ ์ธ์ ์์
์
๋๋ค. [TrOCR](model_doc/trocr)์ ์ข
๋จ๊ฐ(end-to-end) Transformer๋ฅผ ์ฌ์ฉํ์ฌ ์ด ํ๋ก์ธ์ค๋ฅผ ๊ฐ์ํํฉ๋๋ค. ์ธ์ฝ๋๋ ์ด๋ฏธ์ง ์ดํด๋ฅผ ์ํ ViT ๋ฐฉ์์ ๋ชจ๋ธ์ด๋ฉฐ ์ด๋ฏธ์ง๋ฅผ ๊ณ ์ ๋ ํฌ๊ธฐ์ ํจ์น๋ก ์ฒ๋ฆฌํฉ๋๋ค. ๋์ฝ๋๋ ์ธ์ฝ๋์ ์๋ ์ํ๋ฅผ ๋ฐ์์ ์๊ธฐํ๊ท ๋ฐฉ์์ผ๋ก ํ
์คํธ๋ฅผ ์์ฑํฉ๋๋ค. [Donut](model_doc/donut)์ OCR ๊ธฐ๋ฐ ์ ๊ทผ ๋ฐฉ์์ ์์กดํ์ง ์๋ ๋ ์ผ๋ฐ์ ์ธ ์๊ฐ ๋ฌธ์ ์ดํด ๋ชจ๋ธ์
๋๋ค. ์ด ๋ชจ๋ธ์ Swin Transformer๋ฅผ ์ธ์ฝ๋๋ก, ๋ค๊ตญ์ด BART๋ฅผ ๋์ฝ๋๋ก ์ฌ์ฉํฉ๋๋ค. Donut์ ์ด๋ฏธ์ง์ ํ
์คํธ ์ฃผ์์ ๊ธฐ๋ฐ์ผ๋ก ๋ค์ ๋จ์ด๋ฅผ ์์ธกํ์ฌ ํ
์คํธ๋ฅผ ์ฝ๋๋ก ์ฌ์ ํ๋ จ๋ฉ๋๋ค. ๋์ฝ๋๋ ํ๋กฌํํธ๊ฐ ์ฃผ์ด์ง๋ฉด ํ ํฐ ์ํ์ค๋ฅผ ์์ฑํฉ๋๋ค. ํ๋กฌํํธ๋ ๊ฐ ๋ค์ด์คํธ๋ฆผ ์์
์ ๋ํ ํน์ ํ ํฐ์ผ๋ก ํํ๋ฉ๋๋ค. ์๋ฅผ ๋ค์ด, ๋ฌธ์ ํ์ฑ(parsing)์๋ ์ธ์ฝ๋์ ์๋ ์ํ์ ๊ฒฐํฉ๋์ด ๋ฌธ์๋ฅผ ์ ํ ์ถ๋ ฅ ํ์(JSON)์ผ๋ก ํ์ฑํ๋ ํน์ `ํ์ฑ` ํ ํฐ์ด ์์ต๋๋ค.
## ๊ฐํ ํ์ต[[reinforcement-learning]]
<iframe style="border: 1px solid rgba(0, 0, 0, 0.1);" width="1000" height="450" src="https://www.figma.com/embed?embed_host=share&url=https%3A%2F%2Fwww.figma.com%2Ffile%2FiB3Y6RvWYki7ZuKO6tNgZq%2Freinforcement-learning%3Fnode-id%3D0%253A1%26t%3DhPQwdx3HFPWJWnVf-1" allowfullscreen></iframe>
### ๋์ฝ๋[[rl-decoder]]
Decision ๋ฐ Trajectory Transformer๋ ์ํ(state), ํ๋(action), ๋ณด์(reward)์ ์ํ์ค ๋ชจ๋ธ๋ง ๋ฌธ์ ๋ก ํํํฉ๋๋ค. [Decision Transformer](model_doc/decision_transformer)๋ ๊ธฐ๋ ๋ณด์(returns-to-go), ๊ณผ๊ฑฐ ์ํ ๋ฐ ํ๋์ ๊ธฐ๋ฐ์ผ๋ก ๋ฏธ๋์ ์ํ๋ ์์ต(return)์ผ๋ก ์ด์ด์ง๋ ์ผ๋ จ์ ํ๋์ ์์ฑํฉ๋๋ค. ๋ง์ง๋ง *K* ์๊ฐ ์คํ
(timestep)์ ๋ํด, ์ธ ๊ฐ์ง ๋ชจ๋ฌ๋ฆฌํฐ๋ ๊ฐ๊ฐ ํ ํฐ ์๋ฒ ๋ฉ์ผ๋ก ๋ณํ๋๊ณ GPT์ ๊ฐ์ ๋ชจ๋ธ์ ์ํด ์ฒ๋ฆฌ๋์ด ๋ฏธ๋์ ์ก์
ํ ํฐ์ ์์ธกํฉ๋๋ค. [Trajectory Transformer](model_doc/trajectory_transformer)๋ ์ํ, ํ๋, ๋ณด์์ ํ ํฐํํ์ฌ GPT ์ํคํ
์ฒ๋ก ์ฒ๋ฆฌํฉ๋๋ค. ๋ณด์ ์กฐ๊ฑด์ ์ค์ ์ ๋ Decision Transformer์ ๋ฌ๋ฆฌ Trajectory Transformer๋ ๋น ์์น(beam search)๋ก ๋ฏธ๋ ํ๋์ ์์ฑํฉ๋๋ค. | 0 |
mavonic_private_repos/transformers/docs/source | mavonic_private_repos/transformers/docs/source/ko/autoclass_tutorial.md | <!--Copyright 2022 The HuggingFace Team. All rights reserved.
Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
the License. You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
specific language governing permissions and limitations under the License.
โ ๏ธ Note that this file is in Markdown but contain specific syntax for our doc-builder (similar to MDX) that may not be
rendered properly in your Markdown viewer.
-->
# AutoClass๋ก ์ฌ์ ํ์ต๋ ์ธ์คํด์ค ๋ก๋[[load-pretrained-instances-with-an-autoclass]]
ํธ๋์คํฌ๋จธ ์ํคํ
์ฒ๊ฐ ๋งค์ฐ ๋ค์ํ๊ธฐ ๋๋ฌธ์ ์ฒดํฌํฌ์ธํธ์ ๋ง๋ ์ํคํ
์ฒ๋ฅผ ์์ฑํ๋ ๊ฒ์ด ์ด๋ ค์ธ ์ ์์ต๋๋ค. ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ฅผ ์ฝ๊ณ ๊ฐ๋จํ๋ฉฐ ์ ์ฐํ๊ฒ ์ฌ์ฉํ๊ธฐ ์ํ Transformer ํต์ฌ ์ฒ ํ์ ์ผํ์ผ๋ก, `AutoClass`๋ ์ฃผ์ด์ง ์ฒดํฌํฌ์ธํธ์์ ์ฌ๋ฐ๋ฅธ ์ํคํ
์ฒ๋ฅผ ์๋์ผ๋ก ์ถ๋ก ํ์ฌ ๋ก๋ํฉ๋๋ค. `from_pretrained()` ๋ฉ์๋๋ฅผ ์ฌ์ฉํ๋ฉด ๋ชจ๋ ์ํคํ
์ฒ์ ๋ํด ์ฌ์ ํ์ต๋ ๋ชจ๋ธ์ ๋น ๋ฅด๊ฒ ๋ก๋ํ ์ ์์ผ๋ฏ๋ก ๋ชจ๋ธ์ ์ฒ์๋ถํฐ ํ์ตํ๋ ๋ฐ ์๊ฐ๊ณผ ๋ฆฌ์์ค๋ฅผ ํฌ์
ํ ํ์๊ฐ ์์ต๋๋ค.
์ฒดํฌํฌ์ธํธ์ ๊ตฌ์ ๋ฐ์ง ์๋ ์ฝ๋๋ฅผ ์์ฑํ๋ค๋ ๊ฒ์ ์ฝ๋๊ฐ ํ ์ฒดํฌํฌ์ธํธ์์ ์๋ํ๋ฉด ์ํคํ
์ฒ๊ฐ ๋ค๋ฅด๋๋ผ๋ ๋ค๋ฅธ ์ฒดํฌํฌ์ธํธ(์ ์ฌํ ์์
์ ๋ํด ํ์ต๋ ๊ฒฝ์ฐ)์์๋ ์๋ํ๋ค๋ ๊ฒ์ ์๋ฏธํฉ๋๋ค.
<Tip>
์ํคํ
์ฒ๋ ๋ชจ๋ธ์ ๊ณจ๊ฒฉ์ ์๋ฏธํ๋ฉฐ ์ฒดํฌํฌ์ธํธ๋ ์ฃผ์ด์ง ์ํคํ
์ฒ์ ๋ํ ๊ฐ์ค์น์
๋๋ค. ์๋ฅผ ๋ค์ด, [BERT](https://huggingface.co/google-bert/bert-base-uncased)๋ ์ํคํ
์ฒ์ด๊ณ , `google-bert/bert-base-uncased`๋ ์ฒดํฌํฌ์ธํธ์
๋๋ค. ๋ชจ๋ธ์ ์ํคํ
์ฒ ๋๋ ์ฒดํฌํฌ์ธํธ๋ฅผ ์๋ฏธํ ์ ์๋ ์ผ๋ฐ์ ์ธ ์ฉ์ด์
๋๋ค.
</Tip>
์ด ํํ ๋ฆฌ์ผ์์๋ ๋ค์์ ํ์ตํฉ๋๋ค:
* ์ฌ์ ํ์ต๋ ํ ํฌ๋์ด์ ๋ก๋ํ๊ธฐ.
* ์ฌ์ ํ์ต๋ ์ด๋ฏธ์ง ํ๋ก์ธ์ ๋ก๋ํ๊ธฐ.
* ์ฌ์ ํ์ต๋ ํน์ง ์ถ์ถ๊ธฐ ๋ก๋ํ๊ธฐ.
* ์ฌ์ ํ๋ จ๋ ํ๋ก์ธ์ ๋ก๋ํ๊ธฐ.
* ์ฌ์ ํ์ต๋ ๋ชจ๋ธ ๋ก๋ํ๊ธฐ.
## AutoTokenizer[[autotokenizer]]
๊ฑฐ์ ๋ชจ๋ NLP ์์
์ ํ ํฌ๋์ด์ ๋ก ์์๋ฉ๋๋ค. ํ ํฌ๋์ด์ ๋ ์ฌ์ฉ์์ ์
๋ ฅ์ ๋ชจ๋ธ์์ ์ฒ๋ฆฌํ ์ ์๋ ํ์์ผ๋ก ๋ณํํฉ๋๋ค.
[`AutoTokenizer.from_pretrained`]๋ก ํ ํฌ๋์ด์ ๋ฅผ ๋ก๋ํฉ๋๋ค:
```py
>>> from transformers import AutoTokenizer
>>> tokenizer = AutoTokenizer.from_pretrained("google-bert/bert-base-uncased")
```
๊ทธ๋ฆฌ๊ณ ์๋์ ๊ฐ์ด ์
๋ ฅ์ ํ ํฐํํฉ๋๋ค:
```py
>>> sequence = "In a hole in the ground there lived a hobbit."
>>> print(tokenizer(sequence))
{'input_ids': [101, 1999, 1037, 4920, 1999, 1996, 2598, 2045, 2973, 1037, 7570, 10322, 4183, 1012, 102],
'token_type_ids': [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
'attention_mask': [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]}
```
## AutoImageProcessor[[autoimageprocessor]]
๋น์ ์์
์ ๊ฒฝ์ฐ ์ด๋ฏธ์ง ํ๋ก์ธ์๊ฐ ์ด๋ฏธ์ง๋ฅผ ์ฌ๋ฐ๋ฅธ ์
๋ ฅ ํ์์ผ๋ก ์ฒ๋ฆฌํฉ๋๋ค.
```py
>>> from transformers import AutoImageProcessor
>>> image_processor = AutoImageProcessor.from_pretrained("google/vit-base-patch16-224")
```
## AutoFeatureExtractor[[autofeatureextractor]]
์ค๋์ค ์์
์ ๊ฒฝ์ฐ ํน์ง ์ถ์ถ๊ธฐ๊ฐ ์ค๋์ค ์ ํธ๋ฅผ ์ฌ๋ฐ๋ฅธ ์
๋ ฅ ํ์์ผ๋ก ์ฒ๋ฆฌํฉ๋๋ค.
[`AutoFeatureExtractor.from_pretrained`]๋ก ํน์ง ์ถ์ถ๊ธฐ๋ฅผ ๋ก๋ํฉ๋๋ค:
```py
>>> from transformers import AutoFeatureExtractor
>>> feature_extractor = AutoFeatureExtractor.from_pretrained(
... "ehcalabres/wav2vec2-lg-xlsr-en-speech-emotion-recognition"
... )
```
## AutoProcessor[[autoprocessor]]
๋ฉํฐ๋ชจ๋ฌ ์์
์๋ ๋ ๊ฐ์ง ์ ํ์ ์ ์ฒ๋ฆฌ ๋๊ตฌ๋ฅผ ๊ฒฐํฉํ ํ๋ก์ธ์๊ฐ ํ์ํฉ๋๋ค. ์๋ฅผ ๋ค์ด LayoutLMV2 ๋ชจ๋ธ์๋ ์ด๋ฏธ์ง๋ฅผ ์ฒ๋ฆฌํ๋ ์ด๋ฏธ์ง ํ๋ก์ธ์์ ํ
์คํธ๋ฅผ ์ฒ๋ฆฌํ๋ ํ ํฌ๋์ด์ ๊ฐ ํ์ํ๋ฉฐ, ํ๋ก์ธ์๋ ์ด ๋ ๊ฐ์ง๋ฅผ ๊ฒฐํฉํฉ๋๋ค.
[`AutoProcessor.from_pretrained()`]๋ก ํ๋ก์ธ์๋ฅผ ๋ก๋ํฉ๋๋ค:
```py
>>> from transformers import AutoProcessor
>>> processor = AutoProcessor.from_pretrained("microsoft/layoutlmv2-base-uncased")
```
## AutoModel[[automodel]]
<frameworkcontent>
<pt>
๋ง์ง๋ง์ผ๋ก AutoModelForํด๋์ค๋ฅผ ์ฌ์ฉํ๋ฉด ์ฃผ์ด์ง ์์
์ ๋ํด ๋ฏธ๋ฆฌ ํ์ต๋ ๋ชจ๋ธ์ ๋ก๋ํ ์ ์์ต๋๋ค (์ฌ์ฉ ๊ฐ๋ฅํ ์์
์ ์ ์ฒด ๋ชฉ๋ก์ [์ฌ๊ธฐ](model_doc/auto)๋ฅผ ์ฐธ์กฐํ์ธ์). ์๋ฅผ ๋ค์ด, [`AutoModelForSequenceClassification.from_pretrained`]๋ฅผ ์ฌ์ฉํ์ฌ ์ํ์ค ๋ถ๋ฅ์ฉ ๋ชจ๋ธ์ ๋ก๋ํ ์ ์์ต๋๋ค:
```py
>>> from transformers import AutoModelForSequenceClassification
>>> model = AutoModelForSequenceClassification.from_pretrained("distilbert/distilbert-base-uncased")
```
๋์ผํ ์ฒดํฌํฌ์ธํธ๋ฅผ ์ฝ๊ฒ ์ฌ์ฌ์ฉํ์ฌ ๋ค๋ฅธ ์์
์ ์ํคํ
์ฒ๋ฅผ ๋ก๋ํ ์ ์์ต๋๋ค:
```py
>>> from transformers import AutoModelForTokenClassification
>>> model = AutoModelForTokenClassification.from_pretrained("distilbert/distilbert-base-uncased")
```
<Tip warning={true}>
PyTorch๋ชจ๋ธ์ ๊ฒฝ์ฐ `from_pretrained()` ๋ฉ์๋๋ ๋ด๋ถ์ ์ผ๋ก ํผํด์ ์ฌ์ฉํ์ฌ ์์ ํ์ง ์์ ๊ฒ์ผ๋ก ์๋ ค์ง `torch.load()`๋ฅผ ์ฌ์ฉํฉ๋๋ค.
์ผ๋ฐ์ ์ผ๋ก ์ ๋ขฐํ ์ ์๋ ์์ค์์ ๊ฐ์ ธ์๊ฑฐ๋ ๋ณ์กฐ๋์์ ์ ์๋ ๋ชจ๋ธ์ ๋ก๋ํ์ง ๋ง์ธ์. ํ๊น
ํ์ด์ค ํ๋ธ์์ ํธ์คํ
๋๋ ๊ณต๊ฐ ๋ชจ๋ธ์ ๊ฒฝ์ฐ ์ด๋ฌํ ๋ณด์ ์ํ์ด ๋ถ๋ถ์ ์ผ๋ก ์ํ๋๋ฉฐ, ๊ฐ ์ปค๋ฐ ์ ๋ฉ์จ์ด๋ฅผ [๊ฒ์ฌํฉ๋๋ค](https://huggingface.co/docs/hub/security-malware). GPG๋ฅผ ์ฌ์ฉํด ์๋ช
๋ [์ปค๋ฐ ๊ฒ์ฆ](https://huggingface.co/docs/hub/security-gpg#signing-commits-with-gpg)๊ณผ ๊ฐ์ ๋ชจ๋ฒ์ฌ๋ก๋ [๋ฌธ์](https://huggingface.co/docs/hub/security)๋ฅผ ์ฐธ์กฐํ์ธ์.
ํ
์ํ๋ก์ฐ์ Flax ์ฒดํฌํฌ์ธํธ๋ ์ํฅ์ ๋ฐ์ง ์์ผ๋ฉฐ, `from_pretrained`๋ฉ์๋์ `from_tf` ์ `from_flax` ํค์๋ ๊ฐ๋ณ ์ธ์๋ฅผ ์ฌ์ฉํ์ฌ ์ด ๋ฌธ์ ๋ฅผ ์ฐํํ ์ ์์ต๋๋ค.
</Tip>
์ผ๋ฐ์ ์ผ๋ก AutoTokenizer ํด๋์ค์ AutoModelFor ํด๋์ค๋ฅผ ์ฌ์ฉํ์ฌ ๋ฏธ๋ฆฌ ํ์ต๋ ๋ชจ๋ธ ์ธ์คํด์ค๋ฅผ ๋ก๋ํ๋ ๊ฒ์ด ์ข์ต๋๋ค. ์ด๋ ๊ฒ ํ๋ฉด ๋งค๋ฒ ์ฌ๋ฐ๋ฅธ ์ํคํ
์ฒ๋ฅผ ๋ก๋ํ ์ ์์ต๋๋ค. ๋ค์ [ํํ ๋ฆฌ์ผ](preprocessing)์์๋ ์๋กญ๊ฒ ๋ก๋ํ ํ ํฌ๋์ด์ , ์ด๋ฏธ์ง ํ๋ก์ธ์, ํน์ง ์ถ์ถ๊ธฐ๋ฅผ ์ฌ์ฉํ์ฌ ๋ฏธ์ธ ํ๋์ฉ ๋ฐ์ดํฐ ์ธํธ๋ฅผ ์ ์ฒ๋ฆฌํ๋ ๋ฐฉ๋ฒ์ ๋ํด ์์๋ด
๋๋ค.
</pt>
<tf>
๋ง์ง๋ง์ผ๋ก `TFAutoModelFor` ํด๋์ค๋ฅผ ์ฌ์ฉํ๋ฉด ์ฃผ์ด์ง ์์
์ ๋ํด ์ฌ์ ํ๋ จ๋ ๋ชจ๋ธ์ ๋ก๋ํ ์ ์์ต๋๋ค. (์ฌ์ฉ ๊ฐ๋ฅํ ์์
์ ์ ์ฒด ๋ชฉ๋ก์ [์ฌ๊ธฐ](model_doc/auto)๋ฅผ ์ฐธ์กฐํ์ธ์. ์๋ฅผ ๋ค์ด, [`TFAutoModelForSequenceClassification.from_pretrained`]๋ก ์ํ์ค ๋ถ๋ฅ๋ฅผ ์ํ ๋ชจ๋ธ์ ๋ก๋ํฉ๋๋ค:
```py
>>> from transformers import TFAutoModelForSequenceClassification
>>> model = TFAutoModelForSequenceClassification.from_pretrained("distilbert/distilbert-base-uncased")
```
์ฝ๊ฒ ๋์ผํ ์ฒดํฌํฌ์ธํธ๋ฅผ ์ฌ์ฌ์ฉํ์ฌ ๋ค๋ฅธ ์์
์ ์ํคํ
์ฒ๋ฅผ ๋ก๋ํ ์ ์์ต๋๋ค:
```py
>>> from transformers import TFAutoModelForTokenClassification
>>> model = TFAutoModelForTokenClassification.from_pretrained("distilbert/distilbert-base-uncased")
```
์ผ๋ฐ์ ์ผ๋ก, `AutoTokenizer`ํด๋์ค์ `TFAutoModelFor` ํด๋์ค๋ฅผ ์ฌ์ฉํ์ฌ ๋ฏธ๋ฆฌ ํ์ต๋ ๋ชจ๋ธ ์ธ์คํด์ค๋ฅผ ๋ก๋ํ๋ ๊ฒ์ด ์ข์ต๋๋ค. ์ด๋ ๊ฒ ํ๋ฉด ๋งค๋ฒ ์ฌ๋ฐ๋ฅธ ์ํคํ
์ฒ๋ฅผ ๋ก๋ํ ์ ์์ต๋๋ค. ๋ค์ [ํํ ๋ฆฌ์ผ](preprocessing)์์๋ ์๋กญ๊ฒ ๋ก๋ํ ํ ํฌ๋์ด์ , ์ด๋ฏธ์ง ํ๋ก์ธ์, ํน์ง ์ถ์ถ๊ธฐ๋ฅผ ์ฌ์ฉํ์ฌ ๋ฏธ์ธ ํ๋์ฉ ๋ฐ์ดํฐ ์ธํธ๋ฅผ ์ ์ฒ๋ฆฌํ๋ ๋ฐฉ๋ฒ์ ๋ํด ์์๋ด
๋๋ค.
</tf>
</frameworkcontent>
| 0 |
mavonic_private_repos/transformers/docs/source | mavonic_private_repos/transformers/docs/source/ko/multilingual.md | <!--Copyright 2022 The HuggingFace Team. All rights reserved.
Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
the License. You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
specific language governing permissions and limitations under the License.
โ ๏ธ Note that this file is in Markdown but contain specific syntax for our doc-builder (similar to MDX) that may not be
rendered properly in your Markdown viewer.
-->
# ๋ค๊ตญ์ด ๋ชจ๋ธ ์ถ๋ก ํ๊ธฐ[[multilingual-models-for-inference]]
[[open-in-colab]]
๐ค Transformers์๋ ์ฌ๋ฌ ์ข
๋ฅ์ ๋ค๊ตญ์ด(multilingual) ๋ชจ๋ธ์ด ์์ผ๋ฉฐ, ๋จ์ผ ์ธ์ด(monolingual) ๋ชจ๋ธ๊ณผ ์ถ๋ก ์ ์ฌ์ฉ๋ฒ์ด ๋ค๋ฆ
๋๋ค.
๊ทธ๋ ๋ค๊ณ ํด์ *๋ชจ๋ * ๋ค๊ตญ์ด ๋ชจ๋ธ์ ์ฌ์ฉ๋ฒ์ด ๋ค๋ฅธ ๊ฒ์ ์๋๋๋ค.
[google-bert/bert-base-multilingual-uncased](https://huggingface.co/google-bert/bert-base-multilingual-uncased)์ ๊ฐ์ ๋ช๋ช ๋ชจ๋ธ์ ๋จ์ผ ์ธ์ด ๋ชจ๋ธ์ฒ๋ผ ์ฌ์ฉํ ์ ์์ต๋๋ค.
์ด๋ฒ ๊ฐ์ด๋์์ ๋ค๊ตญ์ด ๋ชจ๋ธ์ ์ถ๋ก ์ ์ฌ์ฉ ๋ฐฉ๋ฒ์ ์์๋ณผ ๊ฒ์
๋๋ค.
## XLM[[xlm]]
XLM์๋ 10๊ฐ์ง ์ฒดํฌํฌ์ธํธ(checkpoint)๊ฐ ์๋๋ฐ, ์ด ์ค ํ๋๋ง ๋จ์ผ ์ธ์ด์
๋๋ค.
๋๋จธ์ง ์ฒดํฌํฌ์ธํธ 9๊ฐ๋ ์ธ์ด ์๋ฒ ๋ฉ์ ์ฌ์ฉํ๋ ์ฒดํฌํฌ์ธํธ์ ๊ทธ๋ ์ง ์์ ์ฒดํฌํฌ์ธํธ์ ๋ ๊ฐ์ง ๋ฒ์ฃผ๋ก ๋๋ ์ ์์ต๋๋ค.
### ์ธ์ด ์๋ฒ ๋ฉ์ ์ฌ์ฉํ๋ XLM[[xlm-with-language-embeddings]]
๋ค์ XLM ๋ชจ๋ธ์ ์ถ๋ก ์์ ์ธ์ด ์๋ฒ ๋ฉ์ ์ฌ์ฉํฉ๋๋ค:
- `FacebookAI/xlm-mlm-ende-1024` (๋ง์คํน๋ ์ธ์ด ๋ชจ๋ธ๋ง, ์์ด-๋
์ผ์ด)
- `FacebookAI/xlm-mlm-enfr-1024` (๋ง์คํน๋ ์ธ์ด ๋ชจ๋ธ๋ง, ์์ด-ํ๋์ค์ด)
- `FacebookAI/xlm-mlm-enro-1024` (๋ง์คํน๋ ์ธ์ด ๋ชจ๋ธ๋ง, ์์ด-๋ฃจ๋ง๋์์ด)
- `FacebookAI/xlm-mlm-xnli15-1024` (๋ง์คํน๋ ์ธ์ด ๋ชจ๋ธ๋ง, XNLI ๋ฐ์ดํฐ ์ธํธ์์ ์ ๊ณตํ๋ 15๊ฐ ๊ตญ์ด)
- `FacebookAI/xlm-mlm-tlm-xnli15-1024` (๋ง์คํน๋ ์ธ์ด ๋ชจ๋ธ๋ง + ๋ฒ์ญ, XNLI ๋ฐ์ดํฐ ์ธํธ์์ ์ ๊ณตํ๋ 15๊ฐ ๊ตญ์ด)
- `FacebookAI/xlm-clm-enfr-1024` (Causal language modeling, ์์ด-ํ๋์ค์ด)
- `FacebookAI/xlm-clm-ende-1024` (Causal language modeling, ์์ด-๋
์ผ์ด)
์ธ์ด ์๋ฒ ๋ฉ์ ๋ชจ๋ธ์ ์ ๋ฌ๋ `input_ids`์ ๋์ผํ shape์ ํ
์๋ก ํํ๋ฉ๋๋ค.
์ด๋ฌํ ํ
์์ ๊ฐ์ ์ฌ์ฉ๋ ์ธ์ด์ ๋ฐ๋ผ ๋ค๋ฅด๋ฉฐ ํ ํฌ๋์ด์ ์ `lang2id` ๋ฐ `id2lang` ์์ฑ์ ์ํด ์๋ณ๋ฉ๋๋ค.
๋ค์ ์์ ์์๋ `FacebookAI/xlm-clm-enfr-1024` ์ฒดํฌํฌ์ธํธ(์ฝ์ ์ธ์ด ๋ชจ๋ธ๋ง(causal language modeling), ์์ด-ํ๋์ค์ด)๋ฅผ ๊ฐ์ ธ์ต๋๋ค:
```py
>>> import torch
>>> from transformers import XLMTokenizer, XLMWithLMHeadModel
>>> tokenizer = XLMTokenizer.from_pretrained("FacebookAI/xlm-clm-enfr-1024")
>>> model = XLMWithLMHeadModel.from_pretrained("FacebookAI/xlm-clm-enfr-1024")
```
ํ ํฌ๋์ด์ ์ `lang2id` ์์ฑ์ ๋ชจ๋ธ์ ์ธ์ด์ ํด๋น ID๋ฅผ ํ์ํฉ๋๋ค:
```py
>>> print(tokenizer.lang2id)
{'en': 0, 'fr': 1}
```
๋ค์์ผ๋ก, ์์ ์
๋ ฅ์ ๋ง๋ญ๋๋ค:
```py
>>> input_ids = torch.tensor([tokenizer.encode("Wikipedia was used to")]) # ๋ฐฐ์น ํฌ๊ธฐ๋ 1์
๋๋ค
```
์ธ์ด ID๋ฅผ `"en"`์ผ๋ก ์ค์ ํด ์ธ์ด ์๋ฒ ๋ฉ์ ์ ์ํฉ๋๋ค.
์ธ์ด ์๋ฒ ๋ฉ์ ์์ด์ ์ธ์ด ID์ธ `0`์ผ๋ก ์ฑ์์ง ํ
์์
๋๋ค.
์ด ํ
์๋ `input_ids`์ ๊ฐ์ ํฌ๊ธฐ์ฌ์ผ ํฉ๋๋ค.
```py
>>> language_id = tokenizer.lang2id["en"] # 0
>>> langs = torch.tensor([language_id] * input_ids.shape[1]) # torch.tensor([0, 0, 0, ..., 0])
>>> # (batch_size, sequence_length) shape์ ํ
์๊ฐ ๋๋๋ก ๋ง๋ญ๋๋ค.
>>> langs = langs.view(1, -1) # ์ด์ [1, sequence_length] shape์ด ๋์์ต๋๋ค(๋ฐฐ์น ํฌ๊ธฐ๋ 1์
๋๋ค)
```
์ด์ `input_ids`์ ์ธ์ด ์๋ฒ ๋ฉ์ ๋ชจ๋ธ๋ก ์ ๋ฌํฉ๋๋ค:
```py
>>> outputs = model(input_ids, langs=langs)
```
[run_generation.py](https://github.com/huggingface/transformers/tree/main/examples/pytorch/text-generation/run_generation.py) ์คํฌ๋ฆฝํธ๋ก `xlm-clm` ์ฒดํฌํฌ์ธํธ๋ฅผ ์ฌ์ฉํด ํ
์คํธ์ ์ธ์ด ์๋ฒ ๋ฉ์ ์์ฑํ ์ ์์ต๋๋ค.
### ์ธ์ด ์๋ฒ ๋ฉ์ ์ฌ์ฉํ์ง ์๋ XLM[[xlm-without-language-embeddings]]
๋ค์ XLM ๋ชจ๋ธ์ ์ถ๋ก ์์ ์ธ์ด ์๋ฒ ๋ฉ์ด ํ์ํ์ง ์์ต๋๋ค:
- `FacebookAI/xlm-mlm-17-1280` (๋ง์คํน๋ ์ธ์ด ๋ชจ๋ธ๋ง, 17๊ฐ ๊ตญ์ด)
- `FacebookAI/xlm-mlm-100-1280` (๋ง์คํน๋ ์ธ์ด ๋ชจ๋ธ๋ง, 100๊ฐ ๊ตญ์ด)
์ด์ ์ XLM ์ฒดํฌํฌ์ธํธ์ ๋ฌ๋ฆฌ ์ด ๋ชจ๋ธ์ ์ผ๋ฐ ๋ฌธ์ฅ ํํ์ ์ฌ์ฉ๋ฉ๋๋ค.
## BERT[[bert]]
๋ค์ BERT ๋ชจ๋ธ์ ๋ค๊ตญ์ด ํ์คํฌ์ ์ฌ์ฉํ ์ ์์ต๋๋ค:
- `google-bert/bert-base-multilingual-uncased` (๋ง์คํน๋ ์ธ์ด ๋ชจ๋ธ๋ง + ๋ค์ ๋ฌธ์ฅ ์์ธก, 102๊ฐ ๊ตญ์ด)
- `google-bert/bert-base-multilingual-cased` (๋ง์คํน๋ ์ธ์ด ๋ชจ๋ธ๋ง + ๋ค์ ๋ฌธ์ฅ ์์ธก, 104๊ฐ ๊ตญ์ด)
์ด๋ฌํ ๋ชจ๋ธ์ ์ถ๋ก ์์ ์ธ์ด ์๋ฒ ๋ฉ์ด ํ์ํ์ง ์์ต๋๋ค.
๋ฌธ๋งฅ์์ ์ธ์ด๋ฅผ ์๋ณํ๊ณ , ์๋ณ๋ ์ธ์ด๋ก ์ถ๋ก ํฉ๋๋ค.
## XLM-RoBERTa[[xlmroberta]]
๋ค์ XLM-RoBERTa ๋ํ ๋ค๊ตญ์ด ๋ค๊ตญ์ด ํ์คํฌ์ ์ฌ์ฉํ ์ ์์ต๋๋ค:
- `FacebookAI/xlm-roberta-base` (๋ง์คํน๋ ์ธ์ด ๋ชจ๋ธ๋ง, 100๊ฐ ๊ตญ์ด)
- `FacebookAI/xlm-roberta-large` (๋ง์คํน๋ ์ธ์ด ๋ชจ๋ธ๋ง, 100๊ฐ ๊ตญ์ด)
XLM-RoBERTa๋ 100๊ฐ ๊ตญ์ด์ ๋ํด ์๋ก ์์ฑ๋๊ณ ์ ์ ๋ 2.5TB ๊ท๋ชจ์ CommonCrawl ๋ฐ์ดํฐ๋ก ํ์ต๋์์ต๋๋ค.
์ด์ ์ ๊ณต๊ฐ๋ mBERT๋ XLM๊ณผ ๊ฐ์ ๋ค๊ตญ์ด ๋ชจ๋ธ์ ๋นํด ๋ถ๋ฅ, ์ํ์ค ๋ผ๋ฒจ๋ง, ์ง์ ์๋ต๊ณผ ๊ฐ์ ๋ค์ด์คํธ๋ฆผ(downstream) ์์
์์ ์ด์ ์ด ์์ต๋๋ค.
## M2M100[[m2m100]]
๋ค์ M2M100 ๋ชจ๋ธ ๋ํ ๋ค๊ตญ์ด ๋ค๊ตญ์ด ํ์คํฌ์ ์ฌ์ฉํ ์ ์์ต๋๋ค:
- `facebook/m2m100_418M` (๋ฒ์ญ)
- `facebook/m2m100_1.2B` (๋ฒ์ญ)
์ด ์์ ์์๋ `facebook/m2m100_418M` ์ฒดํฌํฌ์ธํธ๋ฅผ ๊ฐ์ ธ์์ ์ค๊ตญ์ด๋ฅผ ์์ด๋ก ๋ฒ์ญํฉ๋๋ค.
ํ ํฌ๋์ด์ ์์ ๋ฒ์ญ ๋์ ์ธ์ด(source language)๋ฅผ ์ค์ ํ ์ ์์ต๋๋ค:
```py
>>> from transformers import M2M100ForConditionalGeneration, M2M100Tokenizer
>>> en_text = "Do not meddle in the affairs of wizards, for they are subtle and quick to anger."
>>> chinese_text = "ไธ่ฆๆๆๅทซๅธซ็ไบๅ, ๅ ็บไปๅๆฏๅพฎๅฆ็, ๅพๅฟซๅฐฑๆ็ผๆ."
>>> tokenizer = M2M100Tokenizer.from_pretrained("facebook/m2m100_418M", src_lang="zh")
>>> model = M2M100ForConditionalGeneration.from_pretrained("facebook/m2m100_418M")
```
๋ฌธ์ฅ์ ํ ํฐํํฉ๋๋ค:
```py
>>> encoded_zh = tokenizer(chinese_text, return_tensors="pt")
```
M2M100์ ๋ฒ์ญ์ ์งํํ๊ธฐ ์ํด ์ฒซ ๋ฒ์งธ๋ก ์์ฑ๋๋ ํ ํฐ์ ๋ฒ์ญํ ์ธ์ด(target language) ID๋ก ๊ฐ์ ์ง์ ํฉ๋๋ค.
์์ด๋ก ๋ฒ์ญํ๊ธฐ ์ํด `generate` ๋ฉ์๋์์ `forced_bos_token_id`๋ฅผ `en`์ผ๋ก ์ค์ ํฉ๋๋ค:
```py
>>> generated_tokens = model.generate(**encoded_zh, forced_bos_token_id=tokenizer.get_lang_id("en"))
>>> tokenizer.batch_decode(generated_tokens, skip_special_tokens=True)
'Do not interfere with the matters of the witches, because they are delicate and will soon be angry.'
```
## MBart[[mbart]]
๋ค์ MBart ๋ชจ๋ธ ๋ํ ๋ค๊ตญ์ด ํ์คํฌ์ ์ฌ์ฉํ ์ ์์ต๋๋ค:
- `facebook/mbart-large-50-one-to-many-mmt` (์ผ๋๋ค ๋ค๊ตญ์ด ๋ฒ์ญ, 50๊ฐ ๊ตญ์ด)
- `facebook/mbart-large-50-many-to-many-mmt` (๋ค๋๋ค ๋ค๊ตญ์ด ๋ฒ์ญ, 50๊ฐ ๊ตญ์ด)
- `facebook/mbart-large-50-many-to-one-mmt` (๋ค๋์ผ ๋ค๊ตญ์ด ๋ฒ์ญ, 50๊ฐ ๊ตญ์ด)
- `facebook/mbart-large-50` (๋ค๊ตญ์ด ๋ฒ์ญ, 50๊ฐ ๊ตญ์ด)
- `facebook/mbart-large-cc25`
์ด ์์ ์์๋ ํ๋๋์ด๋ฅผ ์์ด๋ก ๋ฒ์ญํ๊ธฐ ์ํด `facebook/mbart-large-50-many-to-many-mmt` ์ฒดํฌํฌ์ธํธ๋ฅผ ๊ฐ์ ธ์ต๋๋ค.
ํ ํฌ๋์ด์ ์์ ๋ฒ์ญ ๋์ ์ธ์ด(source language)๋ฅผ ์ค์ ํ ์ ์์ต๋๋ค:
```py
>>> from transformers import AutoTokenizer, AutoModelForSeq2SeqLM
>>> en_text = "Do not meddle in the affairs of wizards, for they are subtle and quick to anger."
>>> fi_text = "รlรค sekaannu velhojen asioihin, sillรค ne ovat hienovaraisia ja nopeasti vihaisia."
>>> tokenizer = AutoTokenizer.from_pretrained("facebook/mbart-large-50-many-to-many-mmt", src_lang="fi_FI")
>>> model = AutoModelForSeq2SeqLM.from_pretrained("facebook/mbart-large-50-many-to-many-mmt")
```
๋ฌธ์ฅ์ ํ ํฐํํฉ๋๋ค:
```py
>>> encoded_en = tokenizer(en_text, return_tensors="pt")
```
MBart๋ ๋ฒ์ญ์ ์งํํ๊ธฐ ์ํด ์ฒซ ๋ฒ์งธ๋ก ์์ฑ๋๋ ํ ํฐ์ ๋ฒ์ญํ ์ธ์ด(target language) ID๋ก ๊ฐ์ ์ง์ ํฉ๋๋ค.
์์ด๋ก ๋ฒ์ญํ๊ธฐ ์ํด `generate` ๋ฉ์๋์์ `forced_bos_token_id`๋ฅผ `en`์ผ๋ก ์ค์ ํฉ๋๋ค:
```py
>>> generated_tokens = model.generate(**encoded_en, forced_bos_token_id=tokenizer.lang_code_to_id("en_XX"))
>>> tokenizer.batch_decode(generated_tokens, skip_special_tokens=True)
"Don't interfere with the wizard's affairs, because they are subtle, will soon get angry."
```
`facebook/mbart-large-50-many-to-one-mmt` ์ฒดํฌํฌ์ธํธ๋ฅผ ์ฌ์ฉํ๊ณ ์๋ค๋ฉด, ์ฒซ ๋ฒ์งธ๋ก ์์ฑ๋๋ ํ ํฐ์ ๋ฒ์ญํ ์ธ์ด(target language) ID๋ก ๊ฐ์ ์ง์ ํ ํ์๋ ์์ต๋๋ค.
| 0 |
mavonic_private_repos/transformers/docs/source | mavonic_private_repos/transformers/docs/source/ko/model_sharing.md | <!--Copyright 2022 The HuggingFace Team. All rights reserved.
Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
the License. You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
specific language governing permissions and limitations under the License.
โ ๏ธ Note that this file is in Markdown but contain specific syntax for our doc-builder (similar to MDX) that may not be
rendered properly in your Markdown viewer.
-->
# ๋ชจ๋ธ ๊ณต์ ํ๊ธฐ[[share-a-model]]
์ง๋ ๋ ํํ ๋ฆฌ์ผ์์ ๋ถ์ฐ ์ค์ ์ ์ํด PyTorch, Keras ๋ฐ ๐ค Accelerate๋ฅผ ์ฌ์ฉํ์ฌ ๋ชจ๋ธ์ ๋ฏธ์ธ ์กฐ์ ํ๋ ๋ฐฉ๋ฒ์ ๋ณด์์ต๋๋ค. ๋ค์ ๋จ๊ณ๋ ๋ชจ๋ธ์ ์ปค๋ฎค๋ํฐ์ ๊ณต์ ํ๋ ๊ฒ์
๋๋ค! Hugging Face๋ ์ธ๊ณต์ง๋ฅ์ ๋ฏผ์ฃผํ๋ฅผ ์ํด ๋ชจ๋์๊ฒ ์ง์๊ณผ ์์์ ๊ณต๊ฐ์ ์ผ๋ก ๊ณต์ ํด์ผ ํ๋ค๊ณ ๋ฏฟ์ต๋๋ค. ๋ค๋ฅธ ์ฌ๋๋ค์ด ์๊ฐ๊ณผ ์์์ ์ ์ฝํ ์ ์๋๋ก ์ปค๋ฎค๋ํฐ์ ๋ชจ๋ธ์ ๊ณต์ ํ๋ ๊ฒ์ ๊ณ ๋ คํด ๋ณด์ธ์.
์ด ํํ ๋ฆฌ์ผ์์ [Model Hub](https://huggingface.co/models)์์ ํ๋ จ๋๊ฑฐ๋ ๋ฏธ์ธ ์กฐ์ ๋ชจ๋ธ์ ๊ณต์ ํ๋ ๋ ๊ฐ์ง ๋ฐฉ๋ฒ์ ๋ํด ์์๋ด
์๋ค:
- API๋ฅผ ํตํด ํ์ผ์ Hub์ ํธ์ํฉ๋๋ค.
- ์น์ฌ์ดํธ๋ฅผ ํตํด ํ์ผ์ Hub๋ก ๋์ด๋ค ๋์ต๋๋ค.
<iframe width="560" height="315" src="https://www.youtube.com/embed/XvSGPZFEjDY" title="YouTube video player"
frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope;
picture-in-picture" allowfullscreen></iframe>
<Tip>
์ปค๋ฎค๋ํฐ์ ๋ชจ๋ธ์ ๊ณต์ ํ๋ ค๋ฉด, [huggingface.co](https://huggingface.co/join)์ ๊ณ์ ์ด ํ์ํฉ๋๋ค. ๊ธฐ์กด ์กฐ์ง์ ๊ฐ์
ํ๊ฑฐ๋ ์๋ก ๋ง๋ค ์๋ ์์ต๋๋ค.
</Tip>
## ์ ์ฅ์ ํน์ง[[repository-features]]
๋ชจ๋ธ ํ๋ธ์ ๊ฐ ์ ์ฅ์๋ ์ผ๋ฐ์ ์ธ GitHub ์ ์ฅ์์ฒ๋ผ ์๋ํฉ๋๋ค. ์ ์ฅ์๋ ๋ฒ์ ๊ด๋ฆฌ, ์ปค๋ฐ ๊ธฐ๋ก, ์ฐจ์ด์ ์๊ฐํ ๊ธฐ๋ฅ์ ์ ๊ณตํฉ๋๋ค.
๋ชจ๋ธ ํ๋ธ์ ๋ด์ฅ๋ ๋ฒ์ ๊ด๋ฆฌ๋ git ๋ฐ [git-lfs](https://git-lfs.github.com/)๋ฅผ ๊ธฐ๋ฐ์ผ๋ก ํฉ๋๋ค. ์ฆ, ํ๋์ ๋ชจ๋ธ์ ํ๋์ ์ ์ฅ์๋ก ์ทจ๊ธํ์ฌ ์ ๊ทผ ์ ์ด ๋ฐ ํ์ฅ์ฑ์ด ํฅ์๋ฉ๋๋ค. ๋ฒ์ ์ ์ด๋ ์ปค๋ฐ ํด์, ํ๊ทธ ๋๋ ๋ธ๋์น๋ก ๋ชจ๋ธ์ ํน์ ๋ฒ์ ์ ๊ณ ์ ํ๋ ๋ฐฉ๋ฒ์ธ *revision*์ ํ์ฉํฉ๋๋ค.
๋ฐ๋ผ์ `revision` ๋งค๊ฐ๋ณ์๋ฅผ ์ฌ์ฉํ์ฌ ํน์ ๋ชจ๋ธ ๋ฒ์ ์ ๊ฐ์ ธ์ฌ ์ ์์ต๋๋ค:
```py
>>> model = AutoModel.from_pretrained(
... "julien-c/EsperBERTo-small", revision="v2.0.1" # tag name, or branch name, or commit hash
... )
```
๋ํ ์ ์ฅ์์์ ํ์ผ์ ์ฝ๊ฒ ํธ์งํ ์ ์์ผ๋ฉฐ, ์ปค๋ฐ ๊ธฐ๋ก๊ณผ ์ฐจ์ด๋ฅผ ๋ณผ ์ ์์ต๋๋ค:
## ์ค์ [[setup]]
๋ชจ๋ธ์ ํ๋ธ์ ๊ณต์ ํ๊ธฐ ์ ์ Hugging Face ์๊ฒฉ ์ฆ๋ช
์ด ํ์ํฉ๋๋ค. ํฐ๋ฏธ๋์ ์ก์ธ์คํ ์ ์๋ ๊ฒฝ์ฐ, ๐ค Transformers๊ฐ ์ค์น๋ ๊ฐ์ ํ๊ฒฝ์์ ๋ค์ ๋ช
๋ น์ ์คํํฉ๋๋ค. ๊ทธ๋ฌ๋ฉด Hugging Face ์บ์ ํด๋(๊ธฐ๋ณธ์ ์ผ๋ก `~/.cache/`)์ ์ก์ธ์ค ํ ํฐ์ ์ ์ฅํฉ๋๋ค:
```bash
huggingface-cli login
```
Jupyter ๋๋ Colaboratory์ ๊ฐ์ ๋
ธํธ๋ถ์ ์ฌ์ฉ ์ค์ธ ๊ฒฝ์ฐ, [`huggingface_hub`](https://huggingface.co/docs/hub/adding-a-library) ๋ผ์ด๋ธ๋ฌ๋ฆฌ๊ฐ ์ค์น๋์๋์ง ํ์ธํ์ธ์. ์ด ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ฅผ ์ฌ์ฉํ๋ฉด API๋ก ํ๋ธ์ ์ํธ ์์ฉํ ์ ์์ต๋๋ค.
```bash
pip install huggingface_hub
```
๊ทธ๋ฐ ๋ค์ `notebook_login`๋ก ํ๋ธ์ ๋ก๊ทธ์ธํ๊ณ , [์ฌ๊ธฐ](https://huggingface.co/settings/token) ๋งํฌ์์ ๋ก๊ทธ์ธํ ํ ํฐ์ ์์ฑํฉ๋๋ค:
```py
>>> from huggingface_hub import notebook_login
>>> notebook_login()
```
## ํ๋ ์์ํฌ ๊ฐ ๋ชจ๋ธ ๋ณํํ๊ธฐ[[convert-a-model-for-all-frameworks]]
๋ค๋ฅธ ํ๋ ์์ํฌ๋ก ์์
ํ๋ ์ฌ์ฉ์๊ฐ ๋ชจ๋ธ์ ์ฌ์ฉํ ์ ์๋๋ก ํ๋ ค๋ฉด, PyTorch ๋ฐ TensorFlow ์ฒดํฌํฌ์ธํธ๋ฅผ ๋ชจ๋ ์ฌ์ฉํ์ฌ ๋ชจ๋ธ์ ๋ณํํ๊ณ ์
๋ก๋ํ๋ ๊ฒ์ด ์ข์ต๋๋ค. ์ด ๋จ๊ณ๋ฅผ ๊ฑด๋๋ฐ์ด๋ ์ฌ์ฉ์๋ ๋ค๋ฅธ ํ๋ ์์ํฌ์์ ๋ชจ๋ธ์ ๊ฐ์ ธ์ฌ ์ ์์ง๋ง, ๐ค Transformers๊ฐ ์ฒดํฌํฌ์ธํธ๋ฅผ ์ฆ์์์ ๋ณํํด์ผ ํ๋ฏ๋ก ์๋๊ฐ ๋๋ ค์ง ์ ์์ต๋๋ค.
์ฒดํฌํฌ์ธํธ๋ฅผ ๋ค๋ฅธ ํ๋ ์์ํฌ๋ก ๋ณํํ๋ ๊ฒ์ ์ฝ์ต๋๋ค. PyTorch ๋ฐ TensorFlow๊ฐ ์ค์น๋์ด ์๋์ง ํ์ธํ ๋ค์(์ค์น ์ง์นจ์ [์ฌ๊ธฐ](installation) ์ฐธ์กฐ) ๋ค๋ฅธ ํ๋ ์์ํฌ์์ ์์
์ ๋ํ ํน์ ๋ชจ๋ธ์ ์ฐพ์ต๋๋ค.
<frameworkcontent>
<pt>
์ฒดํฌํฌ์ธํธ๋ฅผ TensorFlow์์ PyTorch๋ก ๋ณํํ๋ ค๋ฉด `from_tf=True`๋ฅผ ์ง์ ํ์ธ์:
```py
>>> pt_model = DistilBertForSequenceClassification.from_pretrained("path/to/awesome-name-you-picked", from_tf=True)
>>> pt_model.save_pretrained("path/to/awesome-name-you-picked")
```
</pt>
<tf>
์ฒดํฌํฌ์ธํธ๋ฅผ PyTorch์์ TensorFlow๋ก ๋ณํํ๋ ค๋ฉด `from_pt=True`๋ฅผ ์ง์ ํ์ธ์:
```py
>>> tf_model = TFDistilBertForSequenceClassification.from_pretrained("path/to/awesome-name-you-picked", from_pt=True)
```
๊ทธ๋ฐ ๋ค์ ์๋ก์ด ์ฒดํฌํฌ์ธํธ์ ํจ๊ป ์๋ก์ด TensorFlow ๋ชจ๋ธ์ ์ ์ฅํ ์ ์์ต๋๋ค:
```py
>>> tf_model.save_pretrained("path/to/awesome-name-you-picked")
```
</tf>
<jax>
Flax์์ ๋ชจ๋ธ์ ์ฌ์ฉํ๋ ๊ฒฝ์ฐ, PyTorch์์ Flax๋ก ์ฒดํฌํฌ์ธํธ๋ฅผ ๋ณํํ ์๋ ์์ต๋๋ค:
```py
>>> flax_model = FlaxDistilBertForSequenceClassification.from_pretrained(
... "path/to/awesome-name-you-picked", from_pt=True
... )
```
</jax>
</frameworkcontent>
## ํ๋ จ ์ค ๋ชจ๋ธ ํธ์ํ๊ธฐ[[push-a-model-during-training]]
<frameworkcontent>
<pt>
<Youtube id="Z1-XMy-GNLQ"/>
๋ชจ๋ธ์ ํ๋ธ์ ๊ณต์ ํ๋ ๊ฒ์ ์ถ๊ฐ ๋งค๊ฐ๋ณ์๋ ์ฝ๋ฐฑ์ ์ถ๊ฐํ๋ ๊ฒ๋งํผ ๊ฐ๋จํฉ๋๋ค. [๋ฏธ์ธ ์กฐ์ ํํ ๋ฆฌ์ผ](training)์์ [`TrainingArguments`] ํด๋์ค๋ ํ์ดํผํ๋ผ๋ฏธํฐ์ ์ถ๊ฐ ํ๋ จ ์ต์
์ ์ง์ ํ๋ ๊ณณ์ด๋ผ๋ ๊ฒ์ ๊ธฐ์ตํ์ธ์. ์ด๋ฌํ ํ๋ จ ์ต์
์ค ํ๋๋ ๋ชจ๋ธ์ ํ๋ธ๋ก ์ง์ ํธ์ํ๋ ๊ธฐ๋ฅ์ ํฌํจํฉ๋๋ค. [`TrainingArguments`]์์ `push_to_hub=True`๋ฅผ ์ค์ ํ์ธ์:
```py
>>> training_args = TrainingArguments(output_dir="my-awesome-model", push_to_hub=True)
```
ํ์์ ๊ฐ์ด ํ๋ จ ์ธ์๋ฅผ [`Trainer`]์ ์ ๋ฌํฉ๋๋ค:
```py
>>> trainer = Trainer(
... model=model,
... args=training_args,
... train_dataset=small_train_dataset,
... eval_dataset=small_eval_dataset,
... compute_metrics=compute_metrics,
... )
```
๋ชจ๋ธ์ ๋ฏธ์ธ ์กฐ์ ํ ํ, [`Trainer`]์์ [`~transformers.Trainer.push_to_hub`]๋ฅผ ํธ์ถํ์ฌ ํ๋ จ๋ ๋ชจ๋ธ์ ํ๋ธ๋ก ํธ์ํ์ธ์. ๐ค Transformers๋ ํ๋ จ ํ์ดํผํ๋ผ๋ฏธํฐ, ํ๋ จ ๊ฒฐ๊ณผ ๋ฐ ํ๋ ์์ํฌ ๋ฒ์ ์ ๋ชจ๋ธ ์นด๋์ ์๋์ผ๋ก ์ถ๊ฐํฉ๋๋ค!
```py
>>> trainer.push_to_hub()
```
</pt>
<tf>
[`PushToHubCallback`]์ ์ฌ์ฉํ์ฌ ๋ชจ๋ธ์ ํ๋ธ์ ๊ณต์ ํ๋ ค๋ฉด, [`PushToHubCallback`]์ ๋ค์ ์ธ์๋ฅผ ์ ์ํ์ธ์:
- ์ถ๋ ฅ๋ ๋ชจ๋ธ์ ํ์ผ ๊ฒฝ๋ก
- ํ ํฌ๋์ด์
- `{Hub ์ฌ์ฉ์ ์ด๋ฆ}/{๋ชจ๋ธ ์ด๋ฆ}` ํ์์ `hub_model_id`
```py
>>> from transformers import PushToHubCallback
>>> push_to_hub_callback = PushToHubCallback(
... output_dir="./your_model_save_path", tokenizer=tokenizer, hub_model_id="your-username/my-awesome-model"
... )
```
[`fit`](https://keras.io/api/models/model_training_apis/)์ ์ฝ๋ฐฑ์ ์ถ๊ฐํ๋ฉด, ๐ค Transformers๊ฐ ํ๋ จ๋ ๋ชจ๋ธ์ ํ๋ธ๋ก ํธ์ํฉ๋๋ค:
```py
>>> model.fit(tf_train_dataset, validation_data=tf_validation_dataset, epochs=3, callbacks=push_to_hub_callback)
```
</tf>
</frameworkcontent>
## `push_to_hub` ํจ์ ์ฌ์ฉํ๊ธฐ[[use-the-pushtohub-function]]
๋ชจ๋ธ์์ ์ง์ `push_to_hub`๋ฅผ ํธ์ถํ์ฌ ํ๋ธ์ ์
๋ก๋ํ ์๋ ์์ต๋๋ค.
`push_to_hub`์ ๋ชจ๋ธ ์ด๋ฆ์ ์ง์ ํ์ธ์:
```py
>>> pt_model.push_to_hub("my-awesome-model")
```
์ด๋ ๊ฒ ํ๋ฉด ์ฌ์ฉ์ ์ด๋ฆ ์๋์ ๋ชจ๋ธ ์ด๋ฆ `my-awesome-model`๋ก ์ ์ฅ์๊ฐ ์์ฑ๋ฉ๋๋ค. ์ด์ ์ฌ์ฉ์๋ `from_pretrained` ํจ์๋ฅผ ์ฌ์ฉํ์ฌ ๋ชจ๋ธ์ ๊ฐ์ ธ์ฌ ์ ์์ต๋๋ค:
```py
>>> from transformers import AutoModel
>>> model = AutoModel.from_pretrained("your_username/my-awesome-model")
```
์กฐ์ง์ ์ํ๊ณ ๋ชจ๋ธ์ ์กฐ์ง ์ด๋ฆ์ผ๋ก ๋์ ํธ์ํ๋ ค๋ฉด `repo_id`์ ์ถ๊ฐํ์ธ์:
```py
>>> pt_model.push_to_hub("my-awesome-org/my-awesome-model")
```
`push_to_hub` ํจ์๋ ๋ชจ๋ธ ์ ์ฅ์์ ๋ค๋ฅธ ํ์ผ์ ์ถ๊ฐํ๋ ๋ฐ์๋ ์ฌ์ฉํ ์ ์์ต๋๋ค. ์๋ฅผ ๋ค์ด ๋ชจ๋ธ ์ ์ฅ์์ ํ ํฌ๋์ด์ ๋ฅผ ์ถ๊ฐํ ์ ์์ต๋๋ค:
```py
>>> tokenizer.push_to_hub("my-awesome-model")
```
๋๋ ๋ฏธ์ธ ์กฐ์ ๋ PyTorch ๋ชจ๋ธ์ TensorFlow ๋ฒ์ ์ ์ถ๊ฐํ ์๋ ์์ต๋๋ค:
```py
>>> tf_model.push_to_hub("my-awesome-model")
```
์ด์ Hugging Face ํ๋กํ๋ก ์ด๋ํ๋ฉด, ์๋ก ์์ฑํ ๋ชจ๋ธ ์ ์ฅ์๊ฐ ํ์๋ฉ๋๋ค. **Files** ํญ์ ํด๋ฆญํ๋ฉด ์ ์ฅ์์ ์
๋ก๋ํ ๋ชจ๋ ํ์ผ์ด ํ์๋ฉ๋๋ค.
์ ์ฅ์์ ํ์ผ์ ๋ง๋ค๊ณ ์
๋ก๋ํ๋ ๋ฐฉ๋ฒ์ ๋ํ ์์ธํ ๋ด์ฉ์ ํ๋ธ ์ค๋ช
์ [์ฌ๊ธฐ](https://huggingface.co/docs/hub/how-to-upstream)๋ฅผ ์ฐธ์กฐํ์ธ์.
## ์น ์ธํฐํ์ด์ค๋ก ์
๋ก๋ํ๊ธฐ[[upload-with-the-web-interface]]
์ฝ๋ ์๋ ์ ๊ทผ ๋ฐฉ์์ ์ ํธํ๋ ์ฌ์ฉ์๋ ํ๋ธ์ ์น ์ธํฐํ์ด์ค๋ฅผ ํตํด ๋ชจ๋ธ์ ์
๋ก๋ํ ์ ์์ต๋๋ค. [huggingface.co/new](https://huggingface.co/new)๋ฅผ ๋ฐฉ๋ฌธํ์ฌ ์๋ก์ด ์ ์ฅ์๋ฅผ ์์ฑํ์ธ์:
์ฌ๊ธฐ์ ๋ชจ๋ธ์ ๋ํ ๋ช ๊ฐ์ง ์ ๋ณด๋ฅผ ์ถ๊ฐํ์ธ์:
- ์ ์ฅ์์ **์์ ์**๋ฅผ ์ ํํฉ๋๋ค. ์ด๋ ์ฌ์ฉ์ ๋๋ ์ฌ์ฉ์๊ฐ ์ํ ์กฐ์ง์ผ ์ ์์ต๋๋ค.
- ์ ์ฅ์ ์ด๋ฆ์ด ๋ ๋ชจ๋ธ์ ์ด๋ฆ์ ์ ํํฉ๋๋ค.
- ๋ชจ๋ธ์ด ๊ณต๊ฐ์ธ์ง ๋น๊ณต๊ฐ์ธ์ง ์ ํํฉ๋๋ค.
- ๋ชจ๋ธ์ ๋ผ์ด์ผ์ค ์ฌ์ฉ์ ์ง์ ํฉ๋๋ค.
์ด์ **Files** ํญ์ ํด๋ฆญํ๊ณ **Add file** ๋ฒํผ์ ํด๋ฆญํ์ฌ ์๋ก์ด ํ์ผ์ ์ ์ฅ์์ ์
๋ก๋ํฉ๋๋ค. ๊ทธ๋ฐ ๋ค์ ์
๋ก๋ํ ํ์ผ์ ๋์ด๋ค ๋๊ณ ์ปค๋ฐ ๋ฉ์์ง๋ฅผ ์ถ๊ฐํ์ธ์.
## ๋ชจ๋ธ ์นด๋ ์ถ๊ฐํ๊ธฐ[[add-a-model-card]]
์ฌ์ฉ์๊ฐ ๋ชจ๋ธ์ ๊ธฐ๋ฅ, ์ ํ, ์ ์ฌ์ ํธํฅ ๋ฐ ์ค๋ฆฌ์ ๊ณ ๋ ค ์ฌํญ์ ์ดํดํ ์ ์๋๋ก ์ ์ฅ์์ ๋ชจ๋ธ ์นด๋๋ฅผ ์ถ๊ฐํ์ธ์. ๋ชจ๋ธ ์นด๋๋ `README.md` ํ์ผ์ ์ ์๋์ด ์์ต๋๋ค. ๋ค์ ๋ฐฉ๋ฒ์ผ๋ก ๋ชจ๋ธ ์นด๋๋ฅผ ์ถ๊ฐํ ์ ์์ต๋๋ค:
* `README.md` ํ์ผ์ ์๋์ผ๋ก ์์ฑํ์ฌ ์
๋ก๋ํฉ๋๋ค.
* ๋ชจ๋ธ ์ ์ฅ์์์ **Edit model card** ๋ฒํผ์ ํด๋ฆญํฉ๋๋ค.
๋ชจ๋ธ ์นด๋์ ํฌํจํ ์ ๋ณด ์ ํ์ ๋ํ ์ข์ ์๋ DistilBert [๋ชจ๋ธ ์นด๋](https://huggingface.co/distilbert/distilbert-base-uncased)๋ฅผ ์ฐธ์กฐํ์ธ์. ๋ชจ๋ธ์ ํ์ ๋ฐ์๊ตญ์ด๋ ์์ ฏ ์์ ๋ฑ `README.md` ํ์ผ์์ ์ ์ดํ ์ ์๋ ๋ค๋ฅธ ์ต์
์ ๋ํ ์์ธํ ๋ด์ฉ์ [์ฌ๊ธฐ](https://huggingface.co/docs/hub/models-cards) ๋ฌธ์๋ฅผ ์ฐธ์กฐํ์ธ์.
| 0 |
mavonic_private_repos/transformers/docs/source | mavonic_private_repos/transformers/docs/source/ko/custom_models.md | <!--Copyright 2020 The HuggingFace Team. All rights reserved.
Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
the License. You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
specific language governing permissions and limitations under the License.
โ ๏ธ Note that this file is in Markdown but contain specific syntax for our doc-builder (similar to MDX) that may not be
rendered properly in your Markdown viewer.
-->
# ์ฌ์ฉ์ ์ ์ ๋ชจ๋ธ ๊ณต์ ํ๊ธฐ[[sharing-custom-models]]
๐ค Transformers ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ ์ฝ๊ฒ ํ์ฅํ ์ ์๋๋ก ์ค๊ณ๋์์ต๋๋ค.
๋ชจ๋ ๋ชจ๋ธ์ ์ถ์ํ ์์ด ์ ์ฅ์์ ์ง์ ๋ ํ์ ํด๋์ ์์ ํ ์ฝ๋ฉ๋์ด ์์ผ๋ฏ๋ก, ์์ฝ๊ฒ ๋ชจ๋ธ๋ง ํ์ผ์ ๋ณต์ฌํ๊ณ ํ์์ ๋ฐ๋ผ ์กฐ์ ํ ์ ์์ต๋๋ค.
์์ ํ ์๋ก์ด ๋ชจ๋ธ์ ๋ง๋๋ ๊ฒฝ์ฐ์๋ ์ฒ์๋ถํฐ ์์ํ๋ ๊ฒ์ด ๋ ์ฌ์ธ ์ ์์ต๋๋ค.
์ด ํํ ๋ฆฌ์ผ์์๋ Transformers ๋ด์์ ์ฌ์ฉํ ์ ์๋๋ก ์ฌ์ฉ์ ์ ์ ๋ชจ๋ธ๊ณผ ๊ตฌ์ฑ์ ์์ฑํ๋ ๋ฐฉ๋ฒ๊ณผ
๐ค Transformers ๋ผ์ด๋ธ๋ฌ๋ฆฌ์ ์๋ ๊ฒฝ์ฐ์๋ ๋๊ตฌ๋ ์ฌ์ฉํ ์ ์๋๋ก (์์กด์ฑ๊ณผ ํจ๊ป) ์ปค๋ฎค๋ํฐ์ ๊ณต์ ํ๋ ๋ฐฉ๋ฒ์ ๋ฐฐ์ธ ์ ์์ต๋๋ค.
[timm ๋ผ์ด๋ธ๋ฌ๋ฆฌ](https://github.com/rwightman/pytorch-image-models)์ ResNet ํด๋์ค๋ฅผ [`PreTrainedModel`]๋ก ๋ํํ ResNet ๋ชจ๋ธ์ ์๋ก ๋ชจ๋ ๊ฒ์ ์ค๋ช
ํฉ๋๋ค.
## ์ฌ์ฉ์ ์ ์ ๊ตฌ์ฑ ์์ฑํ๊ธฐ[[writing-a-custom-configuration]]
๋ชจ๋ธ์ ๋ค์ด๊ฐ๊ธฐ ์ ์ ๋จผ์ ๊ตฌ์ฑ์ ์์ฑํด๋ณด๋๋ก ํ๊ฒ ์ต๋๋ค.
๋ชจ๋ธ์ `configuration`์ ๋ชจ๋ธ์ ๋ง๋ค๊ธฐ ์ํด ํ์ํ ๋ชจ๋ ์ค์ํ ๊ฒ๋ค์ ํฌํจํ๊ณ ์๋ ๊ฐ์ฒด์
๋๋ค.
๋ค์ ์น์
์์ ๋ณผ ์ ์๋ฏ์ด, ๋ชจ๋ธ์ `config`๋ฅผ ์ฌ์ฉํด์๋ง ์ด๊ธฐํํ ์ ์๊ธฐ ๋๋ฌธ์ ์๋ฒฝํ ๊ตฌ์ฑ์ด ํ์ํฉ๋๋ค.
์๋ ์์์์๋ ResNet ํด๋์ค์ ์ธ์(argument)๋ฅผ ์กฐ์ ํด๋ณด๊ฒ ์ต๋๋ค.
๋ค๋ฅธ ๊ตฌ์ฑ์ ๊ฐ๋ฅํ ResNet ์ค ๋ค๋ฅธ ์ ํ์ ์ ๊ณตํฉ๋๋ค.
๊ทธ๋ฐ ๋ค์ ๋ช ๊ฐ์ง ์ ํจ์ฑ์ ํ์ธํ ํ ํด๋น ์ธ์๋ฅผ ์ ์ฅํฉ๋๋ค.
```python
from transformers import PretrainedConfig
from typing import List
class ResnetConfig(PretrainedConfig):
model_type = "resnet"
def __init__(
self,
block_type="bottleneck",
layers: List[int] = [3, 4, 6, 3],
num_classes: int = 1000,
input_channels: int = 3,
cardinality: int = 1,
base_width: int = 64,
stem_width: int = 64,
stem_type: str = "",
avg_down: bool = False,
**kwargs,
):
if block_type not in ["basic", "bottleneck"]:
raise ValueError(f"`block_type` must be 'basic' or bottleneck', got {block_type}.")
if stem_type not in ["", "deep", "deep-tiered"]:
raise ValueError(f"`stem_type` must be '', 'deep' or 'deep-tiered', got {stem_type}.")
self.block_type = block_type
self.layers = layers
self.num_classes = num_classes
self.input_channels = input_channels
self.cardinality = cardinality
self.base_width = base_width
self.stem_width = stem_width
self.stem_type = stem_type
self.avg_down = avg_down
super().__init__(**kwargs)
```
์ฌ์ฉ์ ์ ์ `configuration`์ ์์ฑํ ๋ ๊ธฐ์ตํด์ผ ํ ์ธ ๊ฐ์ง ์ค์ํ ์ฌํญ์ ๋ค์๊ณผ ๊ฐ์ต๋๋ค:
- `PretrainedConfig`์ ์์ํด์ผ ํฉ๋๋ค.
- `PretrainedConfig`์ `__init__`์ ๋ชจ๋ kwargs๋ฅผ ํ์ฉํด์ผ ํ๊ณ ,
- ์ด๋ฌํ `kwargs`๋ ์์ ํด๋์ค `__init__`์ ์ ๋ฌ๋์ด์ผ ํฉ๋๋ค.
์์์ ๐ค Transformers ๋ผ์ด๋ธ๋ฌ๋ฆฌ์์ ๋ชจ๋ ๊ธฐ๋ฅ์ ๊ฐ์ ธ์ค๋ ๊ฒ์
๋๋ค.
์ด๋ฌํ ์ ์ผ๋ก๋ถํฐ ๋น๋กฏ๋๋ ๋ ๊ฐ์ง ์ ์ฝ ์กฐ๊ฑด์ `PretrainedConfig`์ ์ค์ ํ๋ ๊ฒ๋ณด๋ค ๋ ๋ง์ ํ๋๊ฐ ์์ต๋๋ค.
`from_pretrained` ๋ฉ์๋๋ก ๊ตฌ์ฑ์ ๋ค์ ๋ก๋ํ ๋ ํด๋น ํ๋๋ ๊ตฌ์ฑ์์ ์๋ฝํ ํ ์์ ํด๋์ค๋ก ๋ณด๋ด์ผ ํฉ๋๋ค.
๋ชจ๋ธ์ auto ํด๋์ค์ ๋ฑ๋กํ์ง ์๋ ํ, `configuration`์์ `model_type`์ ์ ์(์ฌ๊ธฐ์ `model_type="resnet"`)ํ๋ ๊ฒ์ ํ์ ์ฌํญ์ด ์๋๋๋ค (๋ง์ง๋ง ์น์
์ฐธ์กฐ).
์ด๋ ๊ฒ ํ๋ฉด ๋ผ์ด๋ธ๋ฌ๋ฆฌ์ ๋ค๋ฅธ ๋ชจ๋ธ ๊ตฌ์ฑ๊ณผ ๋ง์ฐฌ๊ฐ์ง๋ก ๊ตฌ์ฑ์ ์ฝ๊ฒ ๋ง๋ค๊ณ ์ ์ฅํ ์ ์์ต๋๋ค.
๋ค์์ resnet50d ๊ตฌ์ฑ์ ์์ฑํ๊ณ ์ ์ฅํ๋ ๋ฐฉ๋ฒ์
๋๋ค:
```py
resnet50d_config = ResnetConfig(block_type="bottleneck", stem_width=32, stem_type="deep", avg_down=True)
resnet50d_config.save_pretrained("custom-resnet")
```
์ด๋ ๊ฒ ํ๋ฉด `custom-resnet` ํด๋ ์์ `config.json`์ด๋ผ๋ ํ์ผ์ด ์ ์ฅ๋ฉ๋๋ค.
๊ทธ๋ฐ ๋ค์ `from_pretrained` ๋ฉ์๋๋ฅผ ์ฌ์ฉํ์ฌ ๊ตฌ์ฑ์ ๋ค์ ๋ก๋ํ ์ ์์ต๋๋ค.
```py
resnet50d_config = ResnetConfig.from_pretrained("custom-resnet")
```
๊ตฌ์ฑ์ Hub์ ์ง์ ์
๋ก๋ํ๊ธฐ ์ํด [`PretrainedConfig`] ํด๋์ค์ [`~PretrainedConfig.push_to_hub`]์ ๊ฐ์ ๋ค๋ฅธ ๋ฉ์๋๋ฅผ ์ฌ์ฉํ ์ ์์ต๋๋ค.
## ์ฌ์ฉ์ ์ ์ ๋ชจ๋ธ ์์ฑํ๊ธฐ[[writing-a-custom-model]]
์ด์ ResNet ๊ตฌ์ฑ์ด ์์ผ๋ฏ๋ก ๋ชจ๋ธ์ ์์ฑํ ์ ์์ต๋๋ค.
์ค์ ๋ก๋ ๋ ๊ฐ๋ฅผ ์์ฑํ ๊ฒ์
๋๋ค. ํ๋๋ ์ด๋ฏธ์ง ๋ฐฐ์น์์ hidden features๋ฅผ ์ถ์ถํ๋ ๊ฒ([`BertModel`]๊ณผ ๊ฐ์ด), ๋ค๋ฅธ ํ๋๋ ์ด๋ฏธ์ง ๋ถ๋ฅ์ ์ ํฉํ ๊ฒ์
๋๋ค([`BertForSequenceClassification`]๊ณผ ๊ฐ์ด).
์ด์ ์ ์ธ๊ธํ๋ฏ์ด ์ด ์์ ์์๋ ๋จ์ํ๊ฒ ํ๊ธฐ ์ํด ๋ชจ๋ธ์ ๋์จํ ๋ํผ(loose wrapper)๋ง ์์ฑํ ๊ฒ์
๋๋ค.
์ด ํด๋์ค๋ฅผ ์์ฑํ๊ธฐ ์ ์ ๋ธ๋ก ์ ํ๊ณผ ์ค์ ๋ธ๋ก ํด๋์ค ๊ฐ์ ๋งคํ ์์
๋ง ํ๋ฉด ๋ฉ๋๋ค.
๊ทธ๋ฐ ๋ค์ `ResNet` ํด๋์ค๋ก ์ ๋ฌ๋์ด `configuration`์ ํตํด ๋ชจ๋ธ์ด ์ ์ธ๋ฉ๋๋ค:
```py
from transformers import PreTrainedModel
from timm.models.resnet import BasicBlock, Bottleneck, ResNet
from .configuration_resnet import ResnetConfig
BLOCK_MAPPING = {"basic": BasicBlock, "bottleneck": Bottleneck}
class ResnetModel(PreTrainedModel):
config_class = ResnetConfig
def __init__(self, config):
super().__init__(config)
block_layer = BLOCK_MAPPING[config.block_type]
self.model = ResNet(
block_layer,
config.layers,
num_classes=config.num_classes,
in_chans=config.input_channels,
cardinality=config.cardinality,
base_width=config.base_width,
stem_width=config.stem_width,
stem_type=config.stem_type,
avg_down=config.avg_down,
)
def forward(self, tensor):
return self.model.forward_features(tensor)
```
์ด๋ฏธ์ง ๋ถ๋ฅ ๋ชจ๋ธ์ ๋ง๋ค๊ธฐ ์ํด์๋ forward ๋ฉ์๋๋ง ๋ณ๊ฒฝํ๋ฉด ๋ฉ๋๋ค:
```py
import torch
class ResnetModelForImageClassification(PreTrainedModel):
config_class = ResnetConfig
def __init__(self, config):
super().__init__(config)
block_layer = BLOCK_MAPPING[config.block_type]
self.model = ResNet(
block_layer,
config.layers,
num_classes=config.num_classes,
in_chans=config.input_channels,
cardinality=config.cardinality,
base_width=config.base_width,
stem_width=config.stem_width,
stem_type=config.stem_type,
avg_down=config.avg_down,
)
def forward(self, tensor, labels=None):
logits = self.model(tensor)
if labels is not None:
loss = torch.nn.cross_entropy(logits, labels)
return {"loss": loss, "logits": logits}
return {"logits": logits}
```
๋ ๊ฒฝ์ฐ ๋ชจ๋ `PreTrainedModel`๋ฅผ ์์๋ฐ๊ณ , `config`๋ฅผ ํตํด ์์ ํด๋์ค ์ด๊ธฐํ๋ฅผ ํธ์ถํ๋ค๋ ์ ์ ๊ธฐ์ตํ์ธ์ (์ผ๋ฐ์ ์ธ `torch.nn.Module`์ ์์ฑํ ๋์ ๋น์ทํจ).
๋ชจ๋ธ์ auto ํด๋์ค์ ๋ฑ๋กํ๊ณ ์ถ์ ๊ฒฝ์ฐ์๋ `config_class`๋ฅผ ์ค์ ํ๋ ๋ถ๋ถ์ด ํ์์
๋๋ค (๋ง์ง๋ง ์น์
์ฐธ์กฐ).
<Tip>
๋ผ์ด๋ธ๋ฌ๋ฆฌ์ ์กด์ฌํ๋ ๋ชจ๋ธ๊ณผ ๊ต์ฅํ ์ ์ฌํ๋ค๋ฉด, ๋ชจ๋ธ์ ์์ฑํ ๋ ๊ตฌ์ฑ์ ์ฐธ์กฐํด ์ฌ์ฌ์ฉํ ์ ์์ต๋๋ค.
</Tip>
์ํ๋ ๊ฒ์ ๋ชจ๋ธ์ด ๋ฐํํ๋๋ก ํ ์ ์์ง๋ง, `ResnetModelForImageClassification`์์ ํ๋ ๊ฒ ์ฒ๋ผ
๋ ์ด๋ธ์ ํต๊ณผ์์ผฐ์ ๋ ์์ค๊ณผ ํจ๊ป ์ฌ์ ํํ๋ก ๋ฐํํ๋ ๊ฒ์ด [`Trainer`] ํด๋์ค ๋ด์์ ์ง์ ๋ชจ๋ธ์ ์ฌ์ฉํ๊ธฐ์ ์ ์ฉํฉ๋๋ค.
์์ ๋ง์ ํ์ต ๋ฃจํ ๋๋ ๋ค๋ฅธ ํ์ต ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ฅผ ์ฌ์ฉํ ๊ณํ์ด๋ผ๋ฉด ๋ค๋ฅธ ์ถ๋ ฅ ํ์์ ์ฌ์ฉํด๋ ์ข์ต๋๋ค.
์ด์ ๋ชจ๋ธ ํด๋์ค๊ฐ ์์ผ๋ฏ๋ก ํ๋ ์์ฑํด ๋ณด๊ฒ ์ต๋๋ค:
```py
resnet50d = ResnetModelForImageClassification(resnet50d_config)
```
๋ค์ ๋งํ์ง๋ง, [`~PreTrainedModel.save_pretrained`]๋๋ [`~PreTrainedModel.push_to_hub`]์ฒ๋ผ [`PreTrainedModel`]์ ์ํ๋ ๋ชจ๋ ๋ฉ์๋๋ฅผ ์ฌ์ฉํ ์ ์์ต๋๋ค.
๋ค์ ์น์
์์ ๋ ๋ฒ์งธ ๋ฉ์๋๋ฅผ ์ฌ์ฉํด ๋ชจ๋ธ ์ฝ๋์ ๋ชจ๋ธ ๊ฐ์ค์น๋ฅผ ์
๋ก๋ํ๋ ๋ฐฉ๋ฒ์ ์ดํด๋ณด๊ฒ ์ต๋๋ค.
๋จผ์ , ๋ชจ๋ธ ๋ด๋ถ์ ์ฌ์ ํ๋ จ๋ ๊ฐ์ค์น๋ฅผ ๋ก๋ํด ๋ณด๊ฒ ์ต๋๋ค.
์ด ์์ ๋ฅผ ํ์ฉํ ๋๋, ์ฌ์ฉ์ ์ ์ ๋ชจ๋ธ์ ์์ ๋ง์ ๋ฐ์ดํฐ๋ก ํ์ต์ํฌ ๊ฒ์
๋๋ค.
์ด ํํ ๋ฆฌ์ผ์์๋ ๋น ๋ฅด๊ฒ ์งํํ๊ธฐ ์ํด ์ฌ์ ํ๋ จ๋ resnet50d๋ฅผ ์ฌ์ฉํ๊ฒ ์ต๋๋ค.
์๋ ๋ชจ๋ธ์ resnet50d์ ๋ํผ์ด๊ธฐ ๋๋ฌธ์, ๊ฐ์ค์น๋ฅผ ์ฝ๊ฒ ๋ก๋ํ ์ ์์ต๋๋ค.
```py
import timm
pretrained_model = timm.create_model("resnet50d", pretrained=True)
resnet50d.model.load_state_dict(pretrained_model.state_dict())
```
์ด์ [`~PreTrainedModel.save_pretrained`] ๋๋ [`~PreTrainedModel.push_to_hub`]๋ฅผ ์ฌ์ฉํ ๋ ๋ชจ๋ธ ์ฝ๋๊ฐ ์ ์ฅ๋๋์ง ํ์ธํด๋ด
์๋ค.
## Hub๋ก ์ฝ๋ ์
๋ก๋ํ๊ธฐ[[sending-the-code-to-the-hub]]
<Tip warning={true}>
์ด API๋ ์คํ์ ์ด๋ฉฐ ๋ค์ ๋ฆด๋ฆฌ์ค์์ ์ฝ๊ฐ์ ๋ณ๊ฒฝ ์ฌํญ์ด ์์ ์ ์์ต๋๋ค.
</Tip>
๋จผ์ ๋ชจ๋ธ์ด `.py` ํ์ผ์ ์์ ํ ์ ์๋์ด ์๋์ง ํ์ธํ์ธ์.
๋ชจ๋ ํ์ผ์ด ๋์ผํ ์์
๊ฒฝ๋ก์ ์๊ธฐ ๋๋ฌธ์ ์๋๊ฒฝ๋ก ์ํฌํธ(relative import)์ ์์กดํ ์ ์์ต๋๋ค (transformers์์๋ ์ด ๊ธฐ๋ฅ์ ๋ํ ํ์ ๋ชจ๋์ ์ง์ํ์ง ์์ต๋๋ค).
์ด ์์์์๋ ์์
๊ฒฝ๋ก ์์ `resnet_model`์์ `modeling_resnet.py` ํ์ผ๊ณผ `configuration_resnet.py` ํ์ผ์ ์ ์ํฉ๋๋ค.
๊ตฌ์ฑ ํ์ผ์๋ `ResnetConfig`์ ๋ํ ์ฝ๋๊ฐ ์๊ณ ๋ชจ๋ธ๋ง ํ์ผ์๋ `ResnetModel` ๋ฐ `ResnetModelForImageClassification`์ ๋ํ ์ฝ๋๊ฐ ์์ต๋๋ค.
```
.
โโโ resnet_model
โโโ __init__.py
โโโ configuration_resnet.py
โโโ modeling_resnet.py
```
Python์ด `resnet_model`์ ๋ชจ๋๋ก ์ฌ์ฉํ ์ ์๋๋ก ๊ฐ์งํ๋ ๋ชฉ์ ์ด๊ธฐ ๋๋ฌธ์ `__init__.py`๋ ๋น์ด ์์ ์ ์์ต๋๋ค.
<Tip warning={true}>
๋ผ์ด๋ธ๋ฌ๋ฆฌ์์ ๋ชจ๋ธ๋ง ํ์ผ์ ๋ณต์ฌํ๋ ๊ฒฝ์ฐ,
๋ชจ๋ ํ์ผ ์๋จ์ ์๋ ์๋ ๊ฒฝ๋ก ์ํฌํธ(relative import) ๋ถ๋ถ์ `transformers` ํจํค์ง์์ ์ํฌํธ ํ๋๋ก ๋ณ๊ฒฝํด์ผ ํฉ๋๋ค.
</Tip>
๊ธฐ์กด ๊ตฌ์ฑ์ด๋ ๋ชจ๋ธ์ ์ฌ์ฌ์ฉ(๋๋ ์๋ธ ํด๋์คํ)ํ ์ ์์ต๋๋ค.
์ปค๋ฎค๋ํฐ์ ๋ชจ๋ธ์ ๊ณต์ ํ๊ธฐ ์ํด์๋ ๋ค์ ๋จ๊ณ๋ฅผ ๋ฐ๋ผ์ผ ํฉ๋๋ค:
๋จผ์ , ์๋ก ๋ง๋ ํ์ผ์ ResNet ๋ชจ๋ธ๊ณผ ๊ตฌ์ฑ์ ์ํฌํธํฉ๋๋ค:
```py
from resnet_model.configuration_resnet import ResnetConfig
from resnet_model.modeling_resnet import ResnetModel, ResnetModelForImageClassification
```
๋ค์์ผ๋ก `save_pretrained` ๋ฉ์๋๋ฅผ ์ฌ์ฉํด ํด๋น ๊ฐ์ฒด์ ์ฝ๋ ํ์ผ์ ๋ณต์ฌํ๊ณ ,
๋ณต์ฌํ ํ์ผ์ Auto ํด๋์ค๋ก ๋ฑ๋กํ๊ณ (๋ชจ๋ธ์ธ ๊ฒฝ์ฐ) ์คํํฉ๋๋ค:
```py
ResnetConfig.register_for_auto_class()
ResnetModel.register_for_auto_class("AutoModel")
ResnetModelForImageClassification.register_for_auto_class("AutoModelForImageClassification")
```
`configuration`์ ๋ํ auto ํด๋์ค๋ฅผ ์ง์ ํ ํ์๋ ์์ง๋ง(`configuration` ๊ด๋ จ auto ํด๋์ค๋ AutoConfig ํด๋์ค ํ๋๋ง ์์), ๋ชจ๋ธ์ ๊ฒฝ์ฐ์๋ ์ง์ ํด์ผ ํฉ๋๋ค.
์ฌ์ฉ์ ์ง์ ๋ชจ๋ธ์ ๋ค์ํ ์์
์ ์ ํฉํ ์ ์์ผ๋ฏ๋ก, ๋ชจ๋ธ์ ๋ง๋ auto ํด๋์ค๋ฅผ ์ง์ ํด์ผ ํฉ๋๋ค.
๋ค์์ผ๋ก, ์ด์ ์ ์์
ํ๋ ๊ฒ๊ณผ ๋ง์ฐฌ๊ฐ์ง๋ก ๊ตฌ์ฑ๊ณผ ๋ชจ๋ธ์ ์์ฑํฉ๋๋ค:
```py
resnet50d_config = ResnetConfig(block_type="bottleneck", stem_width=32, stem_type="deep", avg_down=True)
resnet50d = ResnetModelForImageClassification(resnet50d_config)
pretrained_model = timm.create_model("resnet50d", pretrained=True)
resnet50d.model.load_state_dict(pretrained_model.state_dict())
```
์ด์ ๋ชจ๋ธ์ Hub๋ก ์
๋ก๋ํ๊ธฐ ์ํด ๋ก๊ทธ์ธ ์ํ์ธ์ง ํ์ธํ์ธ์.
ํฐ๋ฏธ๋์์ ๋ค์ ์ฝ๋๋ฅผ ์คํํด ํ์ธํ ์ ์์ต๋๋ค:
```bash
huggingface-cli login
```
์ฃผํผํฐ ๋
ธํธ๋ถ์ ๊ฒฝ์ฐ์๋ ๋ค์๊ณผ ๊ฐ์ต๋๋ค:
```py
from huggingface_hub import notebook_login
notebook_login()
```
๊ทธ๋ฐ ๋ค์ ์ด๋ ๊ฒ ์์ ์ ๋ค์์คํ์ด์ค(๋๋ ์์ ์ด ์ํ ์กฐ์ง)์ ์
๋ก๋ํ ์ ์์ต๋๋ค:
```py
resnet50d.push_to_hub("custom-resnet50d")
```
On top of the modeling weights and the configuration in json format, this also copied the modeling and
configuration `.py` files in the folder `custom-resnet50d` and uploaded the result to the Hub. You can check the result
in this [model repo](https://huggingface.co/sgugger/custom-resnet50d).
json ํ์์ ๋ชจ๋ธ๋ง ๊ฐ์ค์น์ ๊ตฌ์ฑ ์ธ์๋ `custom-resnet50d` ํด๋ ์์ ๋ชจ๋ธ๋ง๊ณผ ๊ตฌ์ฑ `.py` ํ์ผ์ ๋ณต์ฌํํด Hub์ ์
๋ก๋ํฉ๋๋ค.
[๋ชจ๋ธ ์ ์ฅ์](https://huggingface.co/sgugger/custom-resnet50d)์์ ๊ฒฐ๊ณผ๋ฅผ ํ์ธํ ์ ์์ต๋๋ค.
[sharing tutorial](model_sharing) ๋ฌธ์์ `push_to_hub` ๋ฉ์๋์์ ์์ธํ ๋ด์ฉ์ ํ์ธํ ์ ์์ต๋๋ค.
## ์ฌ์ฉ์ ์ ์ ์ฝ๋๋ก ๋ชจ๋ธ ์ฌ์ฉํ๊ธฐ[[using-a-model-with-custom-code]]
auto ํด๋์ค์ `from_pretrained` ๋ฉ์๋๋ฅผ ์ฌ์ฉํ์ฌ ์ฌ์ฉ์ ์ง์ ์ฝ๋ ํ์ผ๊ณผ ํจ๊ป ๋ชจ๋ ๊ตฌ์ฑ, ๋ชจ๋ธ, ํ ํฌ๋์ด์ ๋ฅผ ์ฌ์ฉํ ์ ์์ต๋๋ค.
Hub์ ์
๋ก๋๋ ๋ชจ๋ ํ์ผ ๋ฐ ์ฝ๋๋ ๋ฉ์จ์ด๊ฐ ์๋์ง ๊ฒ์ฌ๋์ง๋ง (์์ธํ ๋ด์ฉ์ [Hub ๋ณด์](https://huggingface.co/docs/hub/security#malware-scanning) ์ค๋ช
์ฐธ์กฐ),
์์ ์ ์ปดํจํฐ์์ ๋ชจ๋ธ ์ฝ๋์ ์์ฑ์๊ฐ ์
์ฑ ์ฝ๋๋ฅผ ์คํํ์ง ์๋์ง ํ์ธํด์ผ ํฉ๋๋ค.
์ฌ์ฉ์ ์ ์ ์ฝ๋๋ก ๋ชจ๋ธ์ ์ฌ์ฉํ๋ ค๋ฉด `trust_remote_code=True`๋ก ์ค์ ํ์ธ์:
```py
from transformers import AutoModelForImageClassification
model = AutoModelForImageClassification.from_pretrained("sgugger/custom-resnet50d", trust_remote_code=True)
```
๋ชจ๋ธ ์์ฑ์๊ฐ ์
์์ ์ผ๋ก ์ฝ๋๋ฅผ ์
๋ฐ์ดํธํ์ง ์์๋ค๋ ์ ์ ํ์ธํ๊ธฐ ์ํด, ์ปค๋ฐ ํด์(commit hash)๋ฅผ `revision`์ผ๋ก ์ ๋ฌํ๋ ๊ฒ๋ ๊ฐ๋ ฅํ ๊ถ์ฅ๋ฉ๋๋ค (๋ชจ๋ธ ์์ฑ์๋ฅผ ์์ ํ ์ ๋ขฐํ์ง ์๋ ๊ฒฝ์ฐ).
```py
commit_hash = "ed94a7c6247d8aedce4647f00f20de6875b5b292"
model = AutoModelForImageClassification.from_pretrained(
"sgugger/custom-resnet50d", trust_remote_code=True, revision=commit_hash
)
```
Hub์์ ๋ชจ๋ธ ์ ์ฅ์์ ์ปค๋ฐ ๊ธฐ๋ก์ ์ฐพ์๋ณผ ๋, ๋ชจ๋ ์ปค๋ฐ์ ์ปค๋ฐ ํด์๋ฅผ ์ฝ๊ฒ ๋ณต์ฌํ ์ ์๋ ๋ฒํผ์ด ์์ต๋๋ค.
## ์ฌ์ฉ์ ์ ์ ์ฝ๋๋ก ๋ง๋ ๋ชจ๋ธ์ auto ํด๋์ค๋ก ๋ฑ๋กํ๊ธฐ[[registering-a-model-with-custom-code-to-the-auto-classes]]
๐ค Transformers๋ฅผ ์์ํ๋ ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ฅผ ์์ฑํ๋ ๊ฒฝ์ฐ ์ฌ์ฉ์ ์ ์ ๋ชจ๋ธ์ auto ํด๋์ค์ ์ถ๊ฐํ ์ ์์ต๋๋ค.
์ฌ์ฉ์ ์ ์ ๋ชจ๋ธ์ ์ฌ์ฉํ๊ธฐ ์ํด ํด๋น ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ฅผ ์ํฌํธํด์ผ ํ๊ธฐ ๋๋ฌธ์, ์ด๋ Hub๋ก ์ฝ๋๋ฅผ ์
๋ก๋ํ๋ ๊ฒ๊ณผ ๋ค๋ฆ
๋๋ค (Hub์์ ์๋์ ์ผ๋ก ๋ชจ๋ธ ์ฝ๋๋ฅผ ๋ค์ด๋ก๋ ํ๋ ๊ฒ๊ณผ ๋ฐ๋).
๊ตฌ์ฑ์ ๊ธฐ์กด ๋ชจ๋ธ ์ ํ๊ณผ ๋ค๋ฅธ `model_type` ์์ฑ์ด ์๊ณ ๋ชจ๋ธ ํด๋์ค์ ์ฌ๋ฐ๋ฅธ `config_class` ์์ฑ์ด ์๋ ํ,
๋ค์๊ณผ ๊ฐ์ด auto ํด๋์ค์ ์ถ๊ฐํ ์ ์์ต๋๋ค:
```py
from transformers import AutoConfig, AutoModel, AutoModelForImageClassification
AutoConfig.register("resnet", ResnetConfig)
AutoModel.register(ResnetConfig, ResnetModel)
AutoModelForImageClassification.register(ResnetConfig, ResnetModelForImageClassification)
```
์ฌ์ฉ์ ์ ์ ๊ตฌ์ฑ์ [`AutoConfig`]์ ๋ฑ๋กํ ๋ ์ฌ์ฉ๋๋ ์ฒซ ๋ฒ์งธ ์ธ์๋ ์ฌ์ฉ์ ์ ์ ๊ตฌ์ฑ์ `model_type`๊ณผ ์ผ์นํด์ผ ํฉ๋๋ค.
๋ํ, ์ฌ์ฉ์ ์ ์ ๋ชจ๋ธ์ auto ํด๋์ค์ ๋ฑ๋กํ ๋ ์ฌ์ฉ๋๋ ์ฒซ ๋ฒ์งธ ์ธ์๋ ํด๋น ๋ชจ๋ธ์ `config_class`์ ์ผ์นํด์ผ ํฉ๋๋ค. | 0 |
mavonic_private_repos/transformers/docs/source | mavonic_private_repos/transformers/docs/source/ko/perf_infer_cpu.md | <!--Copyright 2022 The HuggingFace Team. All rights reserved.
Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
the License. You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
โ ๏ธ Note that this file is in Markdown but contain specific syntax for our doc-builder (similar to MDX) that may not be
rendered properly in your Markdown viewer.
-->
# CPU์์ ํจ์จ์ ์ธ ์ถ๋ก ํ๊ธฐ [[efficient-inference-on-cpu]]
์ด ๊ฐ์ด๋๋ CPU์์ ๋๊ท๋ชจ ๋ชจ๋ธ์ ํจ์จ์ ์ผ๋ก ์ถ๋ก ํ๋ ๋ฐฉ๋ฒ์ ์ค์ ์ ๋๊ณ ์์ต๋๋ค.
## ๋ ๋น ๋ฅธ ์ถ๋ก ์ ์ํ `BetterTransformer` [[bettertransformer-for-faster-inference]]
์ฐ๋ฆฌ๋ ์ต๊ทผ CPU์์ ํ
์คํธ, ์ด๋ฏธ์ง ๋ฐ ์ค๋์ค ๋ชจ๋ธ์ ๋น ๋ฅธ ์ถ๋ก ์ ์ํด `BetterTransformer`๋ฅผ ํตํฉํ์ต๋๋ค. ์ด ํตํฉ์ ๋ํ ๋ ์์ธํ ๋ด์ฉ์ [์ด ๋ฌธ์](https://huggingface.co/docs/optimum/bettertransformer/overview)๋ฅผ ์ฐธ์กฐํ์ธ์.
## PyTorch JIT ๋ชจ๋ (TorchScript) [[pytorch-jitmode-torchscript]]
TorchScript๋ PyTorch ์ฝ๋์์ ์ง๋ ฌํ์ ์ต์ ํ๊ฐ ๊ฐ๋ฅํ ๋ชจ๋ธ์ ์์ฑํ ๋ ์ฐ์
๋๋ค. TorchScript๋ก ๋ง๋ค์ด์ง ํ๋ก๊ทธ๋จ์ ๊ธฐ์กด Python ํ๋ก์ธ์ค์์ ์ ์ฅํ ๋ค, ์ข
์์ฑ์ด ์๋ ์๋ก์ด ํ๋ก์ธ์ค๋ก ๊ฐ์ ธ์ฌ ์ ์์ต๋๋ค. PyTorch์ ๊ธฐ๋ณธ ์ค์ ์ธ `eager` ๋ชจ๋์ ๋น๊ตํ์๋, `jit` ๋ชจ๋๋ ์ฐ์ฐ์ ๊ฒฐํฉ๊ณผ ๊ฐ์ ์ต์ ํ ๋ฐฉ๋ฒ๋ก ์ ํตํด ๋ชจ๋ธ ์ถ๋ก ์์ ๋๋ถ๋ถ ๋ ๋์ ์ฑ๋ฅ์ ์ ๊ณตํฉ๋๋ค.
TorchScript์ ๋ํ ์น์ ํ ์๊ฐ๋ [PyTorch TorchScript ํํ ๋ฆฌ์ผ](https://pytorch.org/tutorials/beginner/Intro_to_TorchScript_tutorial.html#tracing-modules)์ ์ฐธ์กฐํ์ธ์.
### JIT ๋ชจ๋์ ํจ๊ปํ๋ IPEX ๊ทธ๋ํ ์ต์ ํ [[ipex-graph-optimization-with-jitmode]]
Intelยฎ Extension for PyTorch(IPEX)๋ Transformers ๊ณ์ด ๋ชจ๋ธ์ jit ๋ชจ๋์์ ์ถ๊ฐ์ ์ธ ์ต์ ํ๋ฅผ ์ ๊ณตํฉ๋๋ค. jit ๋ชจ๋์ ๋๋ถ์ด Intelยฎ Extension for PyTorch(IPEX)๋ฅผ ํ์ฉํ์๊ธธ ๊ฐ๋ ฅํ ๊ถ์ฅ๋๋ฆฝ๋๋ค. Transformers ๋ชจ๋ธ์์ ์์ฃผ ์ฌ์ฉ๋๋ ์ผ๋ถ ์ฐ์ฐ์ ํจํด์ ์ด๋ฏธ jit ๋ชจ๋ ์ฐ์ฐ์ ๊ฒฐํฉ(operator fusion)์ ํํ๋ก Intelยฎ Extension for PyTorch(IPEX)์์ ์ง์๋๊ณ ์์ต๋๋ค. Multi-head-attention, Concat Linear, Linear+Add, Linear+Gelu, Add+LayerNorm ๊ฒฐํฉ ํจํด ๋ฑ์ด ์ด์ฉ ๊ฐ๋ฅํ๋ฉฐ ํ์ฉํ์ ๋ ์ฑ๋ฅ์ด ์ฐ์ํฉ๋๋ค. ์ฐ์ฐ์ ๊ฒฐํฉ์ ์ด์ ์ ์ฌ์ฉ์์๊ฒ ๊ณ ์ค๋ํ ์ ๋ฌ๋ฉ๋๋ค. ๋ถ์์ ๋ฐ๋ฅด๋ฉด, ์ง์ ์๋ต, ํ
์คํธ ๋ถ๋ฅ ๋ฐ ํ ํฐ ๋ถ๋ฅ์ ๊ฐ์ ๊ฐ์ฅ ์ธ๊ธฐ ์๋ NLP ํ์คํฌ ์ค ์ฝ 70%๊ฐ ์ด๋ฌํ ๊ฒฐํฉ ํจํด์ ์ฌ์ฉํ์ฌ Float32 ์ ๋ฐ๋์ BFloat16 ํผํฉ ์ ๋ฐ๋ ๋ชจ๋์์ ์ฑ๋ฅ์์ ์ด์ ์ ์ป์ ์ ์์ต๋๋ค.
[IPEX ๊ทธ๋ํ ์ต์ ํ](https://intel.github.io/intel-extension-for-pytorch/cpu/latest/tutorials/features/graph_optimization.html)์ ๋ํ ์์ธํ ์ ๋ณด๋ฅผ ํ์ธํ์ธ์.
#### IPEX ์ค์น: [[ipex-installation]]
IPEX ๋ฐฐํฌ ์ฃผ๊ธฐ๋ PyTorch๋ฅผ ๋ฐ๋ผ์ ์ด๋ฃจ์ด์ง๋๋ค. ์์ธํ ์ ๋ณด๋ [IPEX ์ค์น ๋ฐฉ๋ฒ](https://intel.github.io/intel-extension-for-pytorch/)์ ํ์ธํ์ธ์.
### JIT ๋ชจ๋ ์ฌ์ฉ๋ฒ [[usage-of-jitmode]]
ํ๊ฐ ๋๋ ์์ธก์ ์ํด Trainer์์ JIT ๋ชจ๋๋ฅผ ์ฌ์ฉํ๋ ค๋ฉด Trainer์ ๋ช
๋ น ์ธ์์ `jit_mode_eval`์ ์ถ๊ฐํด์ผ ํฉ๋๋ค.
<Tip warning={true}>
PyTorch์ ๋ฒ์ ์ด 1.14.0 ์ด์์ด๋ผ๋ฉด, jit ๋ชจ๋๋ jit.trace์์ dict ์
๋ ฅ์ด ์ง์๋๋ฏ๋ก, ๋ชจ๋ ๋ชจ๋ธ์ ์์ธก๊ณผ ํ๊ฐ๊ฐ ๊ฐ์ ๋ ์ ์์ต๋๋ค.
PyTorch์ ๋ฒ์ ์ด 1.14.0 ๋ฏธ๋ง์ด๋ผ๋ฉด, ์ง์ ์๋ต ๋ชจ๋ธ๊ณผ ๊ฐ์ด forward ๋งค๊ฐ๋ณ์์ ์์๊ฐ jit.trace์ ํํ ์
๋ ฅ ์์์ ์ผ์นํ๋ ๋ชจ๋ธ์ ๋์ด ๋ ์ ์์ต๋๋ค. ํ
์คํธ ๋ถ๋ฅ ๋ชจ๋ธ๊ณผ ๊ฐ์ด forward ๋งค๊ฐ๋ณ์ ์์๊ฐ jit.trace์ ํํ ์
๋ ฅ ์์์ ๋ค๋ฅธ ๊ฒฝ์ฐ, jit.trace๊ฐ ์คํจํ๋ฉฐ ์์ธ๊ฐ ๋ฐ์ํฉ๋๋ค. ์ด๋ ์์ธ์ํฉ์ ์ฌ์ฉ์์๊ฒ ์๋ฆฌ๊ธฐ ์ํด Logging์ด ์ฌ์ฉ๋ฉ๋๋ค.
</Tip>
[Transformers ์ง์ ์๋ต](https://github.com/huggingface/transformers/tree/main/examples/pytorch/question-answering)์ ์ฌ์ฉ ์ฌ๋ก ์์๋ฅผ ์ฐธ์กฐํ์ธ์.
- CPU์์ jit ๋ชจ๋๋ฅผ ์ฌ์ฉํ ์ถ๋ก :
<pre>python run_qa.py \
--model_name_or_path csarron/bert-base-uncased-squad-v1 \
--dataset_name squad \
--do_eval \
--max_seq_length 384 \
--doc_stride 128 \
--output_dir /tmp/ \
--no_cuda \
<b>--jit_mode_eval </b></pre>
- CPU์์ IPEX์ ํจ๊ป jit ๋ชจ๋๋ฅผ ์ฌ์ฉํ ์ถ๋ก :
<pre>python run_qa.py \
--model_name_or_path csarron/bert-base-uncased-squad-v1 \
--dataset_name squad \
--do_eval \
--max_seq_length 384 \
--doc_stride 128 \
--output_dir /tmp/ \
--no_cuda \
<b>--use_ipex \</b>
<b>--jit_mode_eval</b></pre>
| 0 |
mavonic_private_repos/transformers/docs/source | mavonic_private_repos/transformers/docs/source/ko/perplexity.md | <!--Copyright 2020 The HuggingFace Team. All rights reserved.
Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
the License. You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
specific language governing permissions and limitations under the License.
-->
# ๊ณ ์ ๊ธธ์ด ๋ชจ๋ธ์ ํํ๋ ์ํฐ(Perplexity)[[perplexity-of-fixedlength-models]]
[[open-in-colab]]
ํํ๋ ์ํฐ(Perplexity, PPL)๋ ๊ฐ์ฅ ์ผ๋ฐ์ ์ธ ์ธ์ด ๋ชจ๋ธ ํ๊ฐ์งํ ์ค ํ๋์
๋๋ค.
์์ธํ ์์๋ณด๊ธฐ ์ ์ ์ด ํ๊ฐ์งํ๋ ๊ณ ์ ์ ์ธ ์ธ์ด ๋ชจ๋ธ(์๊ธฐํ๊ท ๋๋ ์ธ๊ณผ์ ์ธ์ด ๋ชจ๋ธ์ด๋ผ๊ณ ๋ ํจ)์๋ง ์ ์ฉ๋๋ฉฐ BERT์ ๊ฐ์ ๋ง์คํน๋ ์ธ์ด ๋ชจ๋ธ์๋ ์ ์ ์ฉํ์ง ์์ต๋๋ค (BERT๋ [summary of the models](../en/model_summary) ๋ฌธ์๋ฅผ ์ฐธ๊ณ ํ์ธ์).
ํํ๋ ์ํฐ๋ ์ํ์ค์ ์์ ๋ก๊ทธ ์ฐ๋(negative log-likelihood, NLL) ๊ฐ์ ํ๊ท ์ ์ง์(exponentiate)๋ฅผ ์ทจํ ๊ฐ์ผ๋ก ์ ์๋ฉ๋๋ค.
ํ ํฐํ๋ ์ํ์ค \\(X = (x_0, x_1, \dots, x_t)\\) ๊ฐ ์์ ๋, \\(X\\) ์ ํํ๋ ์ํฐ๋ ์๋ ์์๊ณผ ๊ฐ์ด ๊ตฌํ ์ ์์ต๋๋ค.
$$\text{PPL}(X) = \exp \left\{ {-\frac{1}{t}\sum_i^t \log p_\theta (x_i|x_{<i}) } \right\}$$
\\(\log p_\theta (x_i|x_{<i})\\) ๋ ๋ชจ๋ธ์ i๋ฒ์งธ ์ด์ ๊น์ง ํ ํฐ์ด ์ฃผ์ด์ก์ ๋ i๋ฒ์งธ ํ ํฐ์ ๋ก๊ทธ ์ฐ๋๊ฐ์
๋๋ค.
์ง๊ด์ ์ผ๋ก ๋ง๋ญ์น์์ ์ง์ ๋ ํ ํฐ ์งํฉ์ ๊ท ์ผํ๊ฒ ์์ธกํ๋ ๋ชจ๋ธ์ ๋ฅ๋ ฅ์ ๋ํ ํ๊ฐ๋ก ์๊ฐํ ์ ์์ต๋๋ค.
์ค์ํ ์ ์ ํ ํฐํ ๊ณผ์ ์ด ๋ชจ๋ธ์ ํํ๋ ์ํฐ์ ์ง์ ์ ์ธ ์ํฅ์ ๋ฏธ์น๋ฏ๋ก ์๋ก ๋ค๋ฅธ ๋ชจ๋ธ์ ๋น๊ตํ ๋ ํญ์ ์ด๋ฅผ ๊ณ ๋ คํด์ผ ํฉ๋๋ค.
์ด๋ ๋ฐ์ดํฐ์ ๋ชจ๋ธ ์์ธก ๊ฐ์ cross-entropy ๊ฐ์ ์ง์๋ฅผ ์ทจํ ๊ฒ๊ณผ ๋์ผํฉ๋๋ค.
ํํ๋ ์ํฐ์ ๋ฌธ์๋น ๋นํธ ์(BPC) ๋ฐ ๋ฐ์ดํฐ ์์ถ๊ณผ์ ๊ด๊ณ์ ๋ํด ๋ ์ง๊ด์ ์ธ ์ดํด๋ฅผ ์ํ์ ๋ค๋ฉด ๋ค์ ๊ธ
[fantastic blog post on The Gradient](https://thegradient.pub/understanding-evaluation-metrics-for-language-models/)์ ํ์ธํ์ธ์.
## ๊ณ ์ ๊ธธ์ด ๋ชจ๋ธ์ ํํ๋ ์ํฐ(PPL) ๊ณ์ฐํ๊ธฐ[[calculating-ppl-with-fixedlength-models]]
๋ชจ๋ธ์ ์ปจํ
์คํธ ํฌ๊ธฐ๊ฐ ์ ํด์ ธ์์ง ์๋ค๋ฉด,
์๋์ ๊ฐ์ด ์ํ์ค๋ฅผ ์๋ ํ๊ท์ ์ผ๋ก ๋ถํดํ๊ณ ๊ฐ ๋จ๊ณ์์ ์ ํ ํ๋ ์ ์ฒด ์ํ์ค๋ฅผ ์กฐ๊ฑด๋ถ ํ๋ฅ ์ ๋ฃ์ด ๋ชจ๋ธ์ ํํ๋ ์ํฐ๋ฅผ ๊ณ์ฐํ ๊ฒ์
๋๋ค.
<img width="600" alt="Full decomposition of a sequence with unlimited context length" src="https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/ppl_full.gif"/>
๊ทธ๋ฌ๋ ๋ชจ๋ธ์ ๊ทผ์ฌ์น๋ฅผ ๊ตฌํ ๋๋ ์ผ๋ฐ์ ์ผ๋ก ๋ชจ๋ธ์ด ์ฒ๋ฆฌํ ์ ์๋ ํ ํฐ ์์ ์ ํ์ด ์์ต๋๋ค.
์๋ฅผ ๋ค์ด, ๊ฐ์ฅ ํฐ ๋ฒ์ ์ [GPT-2](model_doc/gpt2)๋ ํ ํฐ์ ๊ธธ์ด๊ฐ 1024๋ก ๊ณ ์ ๋์ด ์์ต๋๋ค.
๋ฐ๋ผ์ \\(t\\) ๊ฐ 1024๋ณด๋ค ํฐ ๊ฒฝ์ฐ์ \\(p_\theta(x_t|x_{<t})\\) ์ ๊ณ์ฐํ ์ ์์ต๋๋ค.
๋์ ์ํ์ค๋ ์ผ๋ฐ์ ์ผ๋ก ๋ชจ๋ธ์ ์ต๋ ์
๋ ฅ ํฌ๊ธฐ์ ๋์ผํ ๊ธธ์ด๋ ๊ฐ์ง๋ ๋ถ๋ถ ์ํ์ค๋ก ์ชผ๊ฐญ๋๋ค.
๋ง์ฝ ๋ชจ๋ธ์ ์ต๋ ์
๋ ฅ ๊ธธ์ด๊ฐ \\(k\\) ๋ผ๋ฉด,
ํ ํฐ \\(x_t\\) ์ ์ฐ๋ ๊ฐ์ ๊ณ์ฐํ ๋ ์ด์ ํ ํฐ์ ๋ชจ๋ ์ฌ์ฉํ์ง ์๊ณ , \\(k-1\\) ํ ํฐ๊น์ง ์ฌ์ฉํด ๋๋ต์ ์ธ ์ฐ๋ ๊ฐ์ ์ถ์ ํฉ๋๋ค.
๋ชจ๋ธ์ ์ํ์ค์ ๋ํ ํํ๋ ์ํฐ๋ฅผ ๊ณ์ฐํ ๋,
์์ํ์ง๋ง ์ฐจ์ ์ฑ
์ ์ํ์ค๋ฅผ ์ฒญํฌ๋ก ์ชผ๊ฐ๊ณ ๋ถํด๋ ๊ฐ ๋ถ๋ถ์ ๋ก๊ทธ ์ฐ๋ ๊ฐ์ ๋
๋ฆฝ์ ์ผ๋ก ํฉ์ฐํ๋ ๊ฒ์
๋๋ค.
<img width="600" alt="Suboptimal PPL not taking advantage of full available context" src="https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/ppl_chunked.gif"/>
์ด ๋ฐฉ๋ฒ์ ๊ฐ ๋ถ๋ถ์ ํํ๋ ์ํฐ๋ฅผ ํ ๋ฒ์ ํฌ์๋ ํจ์ค๋ก ๊ณ์ฐํ ์ ์์ด ๋น ๋ฅด์ง๋ง ์ผ๋ฐ์ ์ผ๋ก ๋ ๋์(๋ ๋์) PPL์ ์ฐ์ถํฉ๋๋ค.
์๋ํ๋ฉด ๋๋ถ๋ถ์ ์์ธก ๋จ๊ณ์์ ๋ชจ๋ธ์ ์ปจํ
์คํธ๊ฐ ์ ๊ธฐ ๋๋ฌธ์
๋๋ค.
๋์ , ๊ณ ์ ๊ธธ์ด ๋ชจ๋ธ์ PPL์ ์ฌ๋ผ์ด๋ฉ ์๋์ฐ ์ ๋ต์ผ๋ก ํ๊ฐํด์ผ ํฉ๋๋ค.
์ด ์ ๋ต์๋ ์ปจํ
์คํธ ์๋์ฐ์ ๋ฐ๋ณต์ ์ผ๋ก ์ฌ๋ผ์ด๋ฉํด ๋ชจ๋ธ์ด ๊ฐ ์์ธก์ ์ํํ ๋ ๋ ๋ง์ ์ปจํ
์คํธ๋ฅผ ๊ฐ๋๋ก ํ๋ ์์
์ด ํฌํจ๋ฉ๋๋ค.
<img width="600" alt="Sliding window PPL taking advantage of all available context" src="https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/ppl_sliding.gif"/>
์ด๋ ์ํ์ค ํ๋ฅ ์ ์ค์ ๋ถํด์ ๋ ๊ฐ๊น์ด ๊ทผ์ฌ์น์ด๋ฉฐ ์ผ๋ฐ์ ์ผ๋ก ๋ ์ ๋ฆฌํ ์ ์๋ฅผ ์ฐ์ถํฉ๋๋ค.
๋จ์ ์ ๋ง๋ญ์น์ ๊ฐ ํ ํฐ์ ๋ํด ๋ณ๋์ ํฌ์๋ ํจ์ค๊ฐ ํ์ํ๋ค๋ ๊ฒ์
๋๋ค.
ํ์ค์ ์ผ๋ก ์ข์ ์ ์ถฉ์์ ํ ๋ฒ์ ํ ํ ํฐ์ฉ ์ฌ๋ผ์ด๋ฉํ๋ ๊ฒ์ด ์๋๋ผ ๋ ํฐ ๊ฐ๊ฒฉ์ผ๋ก ์ปจํ
์คํธ๋ฅผ ์ด๋ํ๋ ์คํธ๋ผ์ด๋๊ฐ ์ ์ฉ๋ ์ฌ๋ผ์ด๋ฉ ์๋์ฐ์ ์ฌ์ฉํ๋ ๊ฒ์
๋๋ค.
์ด๋ ๊ฒ ํ๋ฉด ๊ณ์ฐ์ ํจ์ฌ ๋ ๋น ๋ฅด๊ฒ ์งํํ๋ฉด์๋ ๋ชจ๋ธ์ ๊ฐ ๋จ๊ณ์์ ์์ธก์ ์ํํ ์ ์๋ ๊ธด ์ปจํ
์คํธ๋ฅผ ์ ๊ณตํ ์ ์์ต๋๋ค.
## ์์ : ๐ค Transformers์์ GPT-2๋ก ํํ๋ ์ํฐ(perplexity) ๊ณ์ฐํ๊ธฐ[[example-calculating-perplexity-with-gpt2-in-transformers]]
์ด์ GPT-2๋ก ์์ ๊ณผ์ ์ ์์ฐํด ๋ณด๊ฒ ์ต๋๋ค.
```python
from transformers import GPT2LMHeadModel, GPT2TokenizerFast
device = "cuda"
model_id = "openai-community/gpt2-large"
model = GPT2LMHeadModel.from_pretrained(model_id).to(device)
tokenizer = GPT2TokenizerFast.from_pretrained(model_id)
```
WikiText-2 ๋ฐ์ดํฐ ์ธํธ๋ฅผ ๊ฐ์ ธ์ค๊ณ ๋ช ๊ฐ์ง ์ฌ๋ผ์ด๋ฉ ์๋์ฐ ์ ๋ต์ ์ฌ์ฉํด ํํ๋ ์ํฐ๋ฅผ ๊ณ์ฐํด๋ณด๊ฒ ์ต๋๋ค.
์ด ๋ฐ์ดํฐ ์ธํธ๋ ํฌ๊ธฐ๊ฐ ์๊ณ ํฌ์๋ ํจ์ค ํ ๋ฒ๋ง ์ํํ๊ธฐ ๋๋ฌธ์ ์ ์ฒด ๋ฐ์ดํฐ ์ธํธ๋ฅผ ๋ฉ๋ชจ๋ฆฌ์ ๊ฐ์ ธ์ค๊ณ ์ธ์ฝ๋ฉํ ์ ์์ต๋๋ค.
```python
from datasets import load_dataset
test = load_dataset("wikitext", "wikitext-2-raw-v1", split="test")
encodings = tokenizer("\n\n".join(test["text"]), return_tensors="pt")
```
๐ค Transformers๋ฅผ ์ฌ์ฉํ๋ฉด ๋ชจ๋ธ์ `labels`๋ก `input_ids`๋ฅผ ์ ๋ฌํด ๊ฐ ํ ํฐ์ ๋ํ ํ๊ท ์์ ์ฐ๋ ๊ฐ์ ์์ค๋ก ๋ฐํํ ์ ์์ต๋๋ค.
ํ์ง๋ง ์ฌ๋ผ์ด๋ฉ ์๋์ฐ ๋ฐฉ์์ ์ฌ์ฉํ๋ฉด ๊ฐ ๋ฐ๋ณต๋ง๋ค ๋ชจ๋ธ์ ์ ๋ฌํ๋ ํ ํฐ์ด ๊ฒน์นฉ๋๋ค.
์ปจํ
์คํธ๋ก ์ฒ๋ฆฌํ๋ ํ ํฐ์ ๋ํ ๋ก๊ทธ ์ฐ๋ ๊ฐ์ด ์์ค์ ํฌํจ๋๋ ๊ฒ์ ์ํ์ง ์๊ธฐ ๋๋ฌธ์ ์ด๋ฌํ ํ ํฐ์ `input_ids`๋ฅผ `-100`์ผ๋ก ์ค์ ํ์ฌ ๋ฌด์ํ ์ ์์ต๋๋ค.
๋ค์์ ์คํธ๋ผ์ด๋(stride)๋ฅผ `512`๋ก ์ฌ์ฉํ ์์์
๋๋ค.
์ฆ, ๋ชจ๋ธ์ด ํ ํ ํฐ์ ์กฐ๊ฑด๋ถ ์ฐ๋ ๊ฐ์ ๊ณ์ฐํ ๋ ์ปจํ
์คํธ์ ์ต์ํ 512๊ฐ์ ํ ํฐ์ด ํฌํจ๋์ด์๋ค๋ ์๋ฏธ์
๋๋ค (ํด๋น ํ ํฐ ์์ 512๊ฐ์ ํ ํฐ์ด ์๋ ๊ฒฝ์ฐ).
```python
import torch
from tqdm import tqdm
max_length = model.config.n_positions
stride = 512
seq_len = encodings.input_ids.size(1)
nlls = []
prev_end_loc = 0
for begin_loc in tqdm(range(0, seq_len, stride)):
end_loc = min(begin_loc + max_length, seq_len)
trg_len = end_loc - prev_end_loc # ๋ง์ง๋ง ๋ฃจํ์ ์คํธ๋ผ์ด๋ ๊ฐ๊ณผ ๋ค๋ฅผ ์ ์์
input_ids = encodings.input_ids[:, begin_loc:end_loc].to(device)
target_ids = input_ids.clone()
target_ids[:, :-trg_len] = -100
with torch.no_grad():
outputs = model(input_ids, labels=target_ids)
# ์์ค์ ๋ชจ๋ ์ ํจํ ๋ ์ด๋ธ์ ๋ํ ํ๊ท ๊ฐ์ ๊ตฌํ๋ ๊ต์ฐจ ์ํธ๋กํผ(cross entropy)๋ก ๊ณ์ฐ๋ฉ๋๋ค.
# ๋์ด๋ธ ๋ฒ ์ด์ง์ ๋ชจ๋ธ์ ๋ด๋ถ์ ์ผ๋ก ๋ ์ด๋ธ์ ์ผ์ชฝ์ผ๋ก 1๊ฐ์ฉ ๋ฐ๊ธฐ ๋๋ฌธ์, (ํ์ผ - 1)๊ฐ ๋งํผ์ ๋ ์ด๋ธ์ ๋ํด ์์ค์ ๊ณ์ฐํฉ๋๋ค.
neg_log_likelihood = outputs.loss
nlls.append(neg_log_likelihood)
prev_end_loc = end_loc
if end_loc == seq_len:
break
ppl = torch.exp(torch.stack(nlls).mean())
```
์คํธ๋ผ์ด๋๋ฅผ ์ต๋ ์
๋ ฅ ๊ธธ์ด์ ๋์ผํ๊ฒ ์ค์ ํ๋ฉด ์์์ ์ค๋ช
ํ ์ฐจ์ ์ฑ
์ธ ๋น์ฌ๋ผ์ด๋ฉ ์๋์ฐ ์ ๋ต๊ณผ ๋์ผํฉ๋๋ค.
์ผ๋ฐ์ ์ผ๋ก ์คํธ๋ผ์ด๋๊ฐ ์์์๋ก ๋ชจ๋ธ์ด ๊ฐ ์์ธก์ ํ ๋ ๋ ๋ง์ ์ปจํ
์คํธ๋ฅผ ๋ณผ ์ ์๊ฒ ๋์ด ํํ๋ ์ํฐ ๊ฐ์ด ์ข์์ง๋๋ค.
์์ ๊ณ์ฐ์ ํ ํฐ์ด ๊ฒน์น์ง ์๋๋ก `stride = 1024`๋ก ์ค์ ํ๋ฉด PPL์ `19.44`๋ก GPT-2 ๋
ผ๋ฌธ์์ ๋ณด๊ณ ๋ `19.93`๊ณผ ๊ฑฐ์ ๋์ผํฉ๋๋ค.
`stride = 512`๋ก ์ฌ๋ผ์ด๋ฉ ์๋์ฐ ์ ๋ต์ ์ฌ์ฉํ๋ฉด PPL์ `16.45`๋ก ๋จ์ด์ง๋๋ค.
์ด๋ ๋ ์ข์ ์ ์์ผ ๋ฟ๋ง ์๋๋ผ ์ํ์ค ํ๋ฅ ์ ์ค์ ์๋ ํ๊ท ๋ถํด์ ๋ ๊ฐ๊น์ด ๋ฐฉ์์ผ๋ก ๊ณ์ฐ๋ฉ๋๋ค. | 0 |
mavonic_private_repos/transformers/docs/source | mavonic_private_repos/transformers/docs/source/ko/perf_train_cpu_many.md | <!--Copyright 2022 The HuggingFace Team. All rights reserved.
Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
the License. You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
โ ๏ธ Note that this file is in Markdown but contain specific syntax for our doc-builder (similar to MDX) that may not be
rendered properly in your Markdown viewer.
-->
# ๋ค์ค CPU์์ ํจ์จ์ ์ผ๋ก ํ๋ จํ๊ธฐ [[efficient-training-on-multiple-cpus]]
ํ๋์ CPU์์ ํ๋ จํ๋ ๊ฒ์ด ๋๋ฌด ๋๋ฆด ๋๋ ๋ค์ค CPU๋ฅผ ์ฌ์ฉํ ์ ์์ต๋๋ค. ์ด ๊ฐ์ด๋๋ PyTorch ๊ธฐ๋ฐ์ DDP๋ฅผ ์ฌ์ฉํ์ฌ ๋ถ์ฐ CPU ํ๋ จ์ ํจ์จ์ ์ผ๋ก ์ํํ๋ ๋ฐฉ๋ฒ์ ๋ํด ์ค๋ช
ํฉ๋๋ค.
## PyTorch์ฉ Intelยฎ oneCCL ๋ฐ์ธ๋ฉ [[intel-oneccl-bindings-for-pytorch]]
[Intelยฎ oneCCL](https://github.com/oneapi-src/oneCCL) (collective communications library)์ allreduce, allgather, alltoall๊ณผ ๊ฐ์ ์งํฉ ํต์ (collective communications)์ ๊ตฌํํ ํจ์จ์ ์ธ ๋ถ์ฐ ๋ฅ๋ฌ๋ ํ๋ จ์ ์ํ ๋ผ์ด๋ธ๋ฌ๋ฆฌ์
๋๋ค. oneCCL์ ๋ํ ์์ธํ ์ ๋ณด๋ [oneCCL ๋ฌธ์](https://spec.oneapi.com/versions/latest/elements/oneCCL/source/index.html)์ [oneCCL ์ฌ์](https://spec.oneapi.com/versions/latest/elements/oneCCL/source/index.html)์ ์ฐธ์กฐํ์ธ์.
`oneccl_bindings_for_pytorch` ๋ชจ๋ (`torch_ccl`์ ๋ฒ์ 1.12 ์ด์ ์ ์ฌ์ฉ)์ PyTorch C10D ProcessGroup API๋ฅผ ๊ตฌํํ๋ฉฐ, ์ธ๋ถ ProcessGroup๋ก ๋์ ์ผ๋ก ๊ฐ์ ธ์ฌ ์ ์์ผ๋ฉฐ ํ์ฌ Linux ํ๋ซํผ์์๋ง ์๋ํฉ๋๋ค.
[oneccl_bind_pt](https://github.com/intel/torch-ccl)์์ ๋ ์์ธํ ์ ๋ณด๋ฅผ ํ์ธํ์ธ์.
### PyTorch์ฉ Intelยฎ oneCCL ๋ฐ์ธ๋ฉ ์ค์น: [[intel-oneccl-bindings-for-pytorch-installation]]
๋ค์ Python ๋ฒ์ ์ ๋ํ Wheel ํ์ผ์ ์ฌ์ฉํ ์ ์์ต๋๋ค.
| Extension Version | Python 3.6 | Python 3.7 | Python 3.8 | Python 3.9 | Python 3.10 |
| :---------------: | :--------: | :--------: | :--------: | :--------: | :---------: |
| 1.13.0 | | โ | โ | โ | โ |
| 1.12.100 | | โ | โ | โ | โ |
| 1.12.0 | | โ | โ | โ | โ |
| 1.11.0 | | โ | โ | โ | โ |
| 1.10.0 | โ | โ | โ | โ | |
```bash
pip install oneccl_bind_pt=={pytorch_version} -f https://developer.intel.com/ipex-whl-stable-cpu
```
`{pytorch_version}`์ 1.13.0๊ณผ ๊ฐ์ด PyTorch ๋ฒ์ ์ ๋ํ๋
๋๋ค.
[oneccl_bind_pt ์ค์น](https://github.com/intel/torch-ccl)์ ๋ํ ๋ ๋ง์ ์ ๊ทผ ๋ฐฉ๋ฒ์ ํ์ธํด ๋ณด์ธ์.
oneCCL๊ณผ PyTorch์ ๋ฒ์ ์ ์ผ์นํด์ผ ํฉ๋๋ค.
<Tip warning={true}>
oneccl_bindings_for_pytorch 1.12.0 ๋ฒ์ ์ ๋ฏธ๋ฆฌ ๋น๋๋ Wheel ํ์ผ์ PyTorch 1.12.1๊ณผ ํธํ๋์ง ์์ต๋๋ค(PyTorch 1.12.0์ฉ์
๋๋ค).
PyTorch 1.12.1์ oneccl_bindings_for_pytorch 1.12.10 ๋ฒ์ ๊ณผ ํจ๊ป ์ฌ์ฉํด์ผ ํฉ๋๋ค.
</Tip>
## Intelยฎ MPI ๋ผ์ด๋ธ๋ฌ๋ฆฌ [[intel-mpi-library]]
์ด ํ์ค ๊ธฐ๋ฐ MPI ๊ตฌํ์ ์ฌ์ฉํ์ฌ Intelยฎ ์ํคํ
์ฒ์์ ์ ์ฐํ๊ณ ํจ์จ์ ์ด๋ฉฐ ํ์ฅ ๊ฐ๋ฅํ ํด๋ฌ์คํฐ ๋ฉ์์ง์ ์ ๊ณตํ์ธ์. ์ด ๊ตฌ์ฑ ์์๋ Intelยฎ oneAPI HPC Toolkit์ ์ผ๋ถ์
๋๋ค.
oneccl_bindings_for_pytorch๋ MPI ๋๊ตฌ ์ธํธ์ ํจ๊ป ์ค์น๋ฉ๋๋ค. ์ฌ์ฉํ๊ธฐ ์ ์ ํ๊ฒฝ์ ์์ค๋ก ์ง์ ํด์ผ ํฉ๋๋ค.
Intelยฎ oneCCL ๋ฒ์ 1.12.0 ์ด์์ธ ๊ฒฝ์ฐ
```bash
oneccl_bindings_for_pytorch_path=$(python -c "from oneccl_bindings_for_pytorch import cwd; print(cwd)")
source $oneccl_bindings_for_pytorch_path/env/setvars.sh
```
Intelยฎ oneCCL ๋ฒ์ ์ด 1.12.0 ๋ฏธ๋ง์ธ ๊ฒฝ์ฐ
```bash
torch_ccl_path=$(python -c "import torch; import torch_ccl; import os; print(os.path.abspath(os.path.dirname(torch_ccl.__file__)))")
source $torch_ccl_path/env/setvars.sh
```
#### IPEX ์ค์น: [[ipex-installation]]
IPEX๋ Float32์ BFloat16์ ๋ชจ๋ ์ฌ์ฉํ๋ CPU ํ๋ จ์ ์ํ ์ฑ๋ฅ ์ต์ ํ๋ฅผ ์ ๊ณตํฉ๋๋ค. [single CPU section](./perf_train_cpu)์ ์ฐธ์กฐํ์ธ์.
์ด์ด์ ๋์ค๋ "Trainer์์์ ์ฌ์ฉ"์ Intelยฎ MPI ๋ผ์ด๋ธ๋ฌ๋ฆฌ์ mpirun์ ์๋ก ๋ค์์ต๋๋ค.
## Trainer์์์ ์ฌ์ฉ [[usage-in-trainer]]
Trainer์์ ccl ๋ฐฑ์๋๋ฅผ ์ฌ์ฉํ์ฌ ๋ฉํฐ CPU ๋ถ์ฐ ํ๋ จ์ ํ์ฑํํ๋ ค๋ฉด ๋ช
๋ น ์ธ์์ **`--ddp_backend ccl`**์ ์ถ๊ฐํด์ผ ํฉ๋๋ค.
[์ง์ ์๋ต ์์ ](https://github.com/huggingface/transformers/tree/main/examples/pytorch/question-answering)๋ฅผ ์ฌ์ฉํ ์๋ฅผ ์ดํด๋ณด๊ฒ ์ต๋๋ค.
๋ค์ ๋ช
๋ น์ ํ Xeon ๋
ธ๋์์ 2๊ฐ์ ํ๋ก์ธ์ค๋ก ํ๋ จ์ ํ์ฑํํ๋ฉฐ, ๊ฐ ์์ผ๋น ํ๋์ ํ๋ก์ธ์ค๊ฐ ์คํ๋ฉ๋๋ค. OMP_NUM_THREADS/CCL_WORKER_COUNT ๋ณ์๋ ์ต์ ์ ์ฑ๋ฅ์ ์ํด ์กฐ์ ํ ์ ์์ต๋๋ค.
```shell script
export CCL_WORKER_COUNT=1
export MASTER_ADDR=127.0.0.1
mpirun -n 2 -genv OMP_NUM_THREADS=23 \
python3 run_qa.py \
--model_name_or_path google-bert/bert-large-uncased \
--dataset_name squad \
--do_train \
--do_eval \
--per_device_train_batch_size 12 \
--learning_rate 3e-5 \
--num_train_epochs 2 \
--max_seq_length 384 \
--doc_stride 128 \
--output_dir /tmp/debug_squad/ \
--no_cuda \
--ddp_backend ccl \
--use_ipex
```
๋ค์ ๋ช
๋ น์ ๋ ๊ฐ์ Xeon(๋
ธ๋0 ๋ฐ ๋
ธ๋1, ์ฃผ ํ๋ก์ธ์ค๋ก ๋
ธ๋0์ ์ฌ์ฉ)์์ ์ด 4๊ฐ์ ํ๋ก์ธ์ค๋ก ํ๋ จ์ ํ์ฑํํ๋ฉฐ, ๊ฐ ์์ผ๋น ํ๋์ ํ๋ก์ธ์ค๊ฐ ์คํ๋ฉ๋๋ค. OMP_NUM_THREADS/CCL_WORKER_COUNT ๋ณ์๋ ์ต์ ์ ์ฑ๋ฅ์ ์ํด ์กฐ์ ํ ์ ์์ต๋๋ค.
๋
ธ๋0์์๋ ๊ฐ ๋
ธ๋์ IP ์ฃผ์๋ฅผ ํฌํจํ๋ ๊ตฌ์ฑ ํ์ผ(์: hostfile)์ ์์ฑํ๊ณ ํด๋น ๊ตฌ์ฑ ํ์ผ ๊ฒฝ๋ก๋ฅผ ์ธ์๋ก ์ ๋ฌํด์ผ ํฉ๋๋ค.
```shell script
cat hostfile
xxx.xxx.xxx.xxx #node0 ip
xxx.xxx.xxx.xxx #node1 ip
```
์ด์ ๋
ธ๋0์์ ๋ค์ ๋ช
๋ น์ ์คํํ๋ฉด **4DDP**๊ฐ ๋
ธ๋0 ๋ฐ ๋
ธ๋1์์ BF16 ์๋ ํผํฉ ์ ๋ฐ๋๋ก ํ์ฑํ๋ฉ๋๋ค.
```shell script
export CCL_WORKER_COUNT=1
export MASTER_ADDR=xxx.xxx.xxx.xxx #node0 ip
mpirun -f hostfile -n 4 -ppn 2 \
-genv OMP_NUM_THREADS=23 \
python3 run_qa.py \
--model_name_or_path google-bert/bert-large-uncased \
--dataset_name squad \
--do_train \
--do_eval \
--per_device_train_batch_size 12 \
--learning_rate 3e-5 \
--num_train_epochs 2 \
--max_seq_length 384 \
--doc_stride 128 \
--output_dir /tmp/debug_squad/ \
--no_cuda \
--ddp_backend ccl \
--use_ipex \
--bf16
```
| 0 |
mavonic_private_repos/transformers/docs/source | mavonic_private_repos/transformers/docs/source/ko/perf_train_gpu_many.md | <!--Copyright 2022 The HuggingFace Team. All rights reserved.
Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
the License. You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
โ ๏ธ Note that this file is in Markdown but contain specific syntax for our doc-builder (similar to MDX) that may not be
rendered properly in your Markdown viewer.
-->
# ๋ค์ค GPU์์ ํจ์จ์ ์ธ ํ๋ จ [[efficient-training-on-multiple-gpus]]
๋จ์ผ GPU์์์ ํ๋ จ์ด ๋๋ฌด ๋๋ฆฌ๊ฑฐ๋ ๋ชจ๋ธ ๊ฐ์ค์น๊ฐ ๋จ์ผ GPU์ ๋ฉ๋ชจ๋ฆฌ์ ๋ง์ง ์๋ ๊ฒฝ์ฐ, ๋ค์ค-GPU ์ค์ ์ ์ฌ์ฉํฉ๋๋ค. ๋จ์ผ GPU์์ ๋ค์ค GPU๋ก ์ ํํ๊ธฐ ์ํด์๋ ์์
์ ๋ถ์ฐํด์ผ ํฉ๋๋ค. ๋ฐ์ดํฐ, ํ
์ ๋๋ ํ์ดํ๋ผ์ธ๊ณผ ๊ฐ์ ๋ณ๋ ฌํ ๊ธฐ๋ฒ์ ์ฌ์ฉํ์ฌ ์์
์ ๋ณ๋ ฌ๋ก ์ฒ๋ฆฌํ ์ ์์ต๋๋ค. ๊ทธ๋ฌ๋ ์ด๋ฌํ ์ค์ ์ ๋ชจ๋์๊ฒ ์ ์ฉํ ์ ์๋ ์๋ฒฝํ ํด๊ฒฐ์ฑ
์ ์์ผ๋ฉฐ, ์ด๋ค ์ค์ ์ด ๊ฐ์ฅ ์ ํฉํ์ง๋ ์ฌ์ฉํ๋ ํ๋์จ์ด์ ๋ฐ๋ผ ๋ฌ๋ผ์ง๋๋ค. ์ด ๋ฌธ์๋ ์ฃผ๋ก PyTorch ๊ธฐ๋ฐ์ ๊ตฌํ์ ์ค์ฌ์ผ๋ก ์ค๋ช
ํ๋ฉฐ, ๋๋ถ๋ถ์ ๊ฐ๋
์ ๋ค๋ฅธ ํ๋ ์์ํฌ์๋ ์ ์ฉ๋ ์ ์์ ๊ฒ์ผ๋ก ์์๋ฉ๋๋ค.
<Tip>
์ฐธ๊ณ : [๋จ์ผ GPU ์น์
](perf_train_gpu_one)์์ ์๊ฐ๋ ์ ๋ต(ํผํฉ ์ ๋ฐ๋ ํ๋ จ ๋๋ ๊ทธ๋๋์ธํธ ๋์ ๋ฑ)์ ์ผ๋ฐ์ ์ผ๋ก ๋ชจ๋ธ ํ๋ จ์ ์ ์ฉ๋๋ฉฐ, ๋ค์ค-GPU ๋๋ CPU ํ๋ จ๊ณผ ๊ฐ์ ๋ค์ ์น์
์ผ๋ก ์ง์
ํ๊ธฐ ์ ์ ํด๋น ์น์
์ ์ฐธ๊ณ ํ๋ ๊ฒ์ด ์ข์ต๋๋ค.
</Tip>
๋จผ์ 1D ๋ณ๋ ฌํ ๊ธฐ์ ์ ๋ํด ์์ธํ ๋
ผ์ํ ํ, ์ด๋ฌํ ๊ธฐ์ ์ ๊ฒฐํฉํ์ฌ 2D ๋ฐ 3D ๋ณ๋ ฌํ๋ฅผ ๊ตฌํํ์ฌ ๋ ๋น ๋ฅธ ํ๋ จ๊ณผ ๋ ํฐ ๋ชจ๋ธ์ ์ง์ํ๋ ๋ฐฉ๋ฒ์ ์ดํด๋ณผ ๊ฒ์
๋๋ค. ๋ํ ๋ค๋ฅธ ํจ๊ณผ์ ์ธ ๋์ ๋ฐฉ์๋ ์๊ฐ๋ ์์ ์
๋๋ค.
## ๊ฐ๋
[[concepts]]
๋ค์์ ์ด ๋ฌธ์์์ ์์ธํ ์ค๋ช
๋ ์ฃผ์ ๊ฐ๋
์ ๋ํ ๊ฐ๋จํ ์ค๋ช
์
๋๋ค.
1. **DataParallel (DP)** - ๋์ผํ ์ค์ ์ด ์ฌ๋ฌ ๋ฒ ๋ณต์ ๋๊ณ , ๊ฐ ์ค์ ์ ๋ฐ์ดํฐ ์ผ๋ถ๋ฅผ ๋ฐ์ต๋๋ค. ์ฒ๋ฆฌ๋ ๋ณ๋ ฌ๋ก ์ํ๋๋ฉฐ ๋ชจ๋ ์ค์ ์ ๊ฐ ํ๋ จ ๋จ๊ณ์ ๋๋ ๋ ๋๊ธฐํ๋ฉ๋๋ค.
2. **TensorParallel (TP)** - ๊ฐ ํ
์๋ ์ฌ๋ฌ ๊ฐ์ ๋ฌถ์์ผ๋ก ๋ถํ ๋๊ธฐ์, ์ ์ฒด ํ
์๊ฐ ๋จ์ผ GPU์ ์์ฃผํ๋ ๋์ ํ
์์ ๊ฐ ์ค๋๊ฐ ์ง์ ๋ GPU์ ์์ฃผํฉ๋๋ค. ์ฒ๋ฆฌํ๋ ๋์ ๊ฐ ์ค๋๋ ์๋ก ๋ค๋ฅธ GPU์์ ๊ฐ๋ณ์ ์ผ๋ก ๋ณ๋ ฌ ์ฒ๋ฆฌ๋๋ฉฐ ๊ฒฐ๊ณผ๋ ๋จ๊ณ๊ฐ ๋๋ ๋ ๋๊ธฐํ๋ฉ๋๋ค. ๋ถํ ์ด ์ํ ์์ค์์ ์ด๋ฃจ์ด์ง๊ธฐ ๋๋ฌธ์ ์ด๋ฅผ ์ํ ๋ณ๋ ฌ ์ฒ๋ฆฌ๋ผ๊ณ ๋ถ๋ฅผ ์ ์์ต๋๋ค.
3. **PipelineParallel (PP)** - ๋ชจ๋ธ์ด ์์ง์ผ๋ก (๋ ์ด์ด ์์ค) ์ฌ๋ฌ GPU์ ๋ถํ ๋์ด ๋ชจ๋ธ์ ๋จ์ผ GPU์๋ ํ๋ ๋๋ ์ฌ๋ฌ ๋ ์ด์ด๊ฐ ๋ฐฐ์น๋ฉ๋๋ค. ๊ฐ GPU๋ ํ์ดํ๋ผ์ธ์ ์๋ก ๋ค๋ฅธ ๋จ๊ณ๋ฅผ ๋ณ๋ ฌ๋ก ์ฒ๋ฆฌํ๋ฉฐ ์์ ๋ฐฐ์น ๋ฌถ์์์ ์๋ํฉ๋๋ค.
4. **Zero Redundancy Optimizer (ZeRO)** - TP์ ์ ์ฌํ๊ฒ ํ
์๋ฅผ ์ค๋ฉํ์ง๋ง, ์ ์ฒด ํ
์๋ ์๋ฐฉํฅ ๋๋ ์ญ๋ฐฉํฅ ๊ณ์ฐ์ ์ํด ์ฌ๊ตฌ์ฑ๋๋ฏ๋ก ๋ชจ๋ธ์ ์์ ํ ํ์๊ฐ ์์ต๋๋ค. ๋ํ ์ ํ๋ GPU ๋ฉ๋ชจ๋ฆฌ๋ฅผ ๋ณด์ํ๊ธฐ ์ํด ๋ค์ํ ์คํ๋ก๋ ๊ธฐ์ ์ ์ง์ํฉ๋๋ค.
5. **Sharded DDP** - ZeRO์ ๊ธฐ๋ณธ ๊ฐ๋
์ผ๋ก ๋ค๋ฅธ ZeRO ๊ตฌํ์์๋ ์ฌ์ฉ๋๋ ์ฉ์ด์
๋๋ค.
๊ฐ ๊ฐ๋
์ ๊ตฌ์ฒด์ ์ธ ๋ด์ฉ์ ๋ํด ์์ธํ ๋ค์ด๊ฐ๊ธฐ ์ ์ ๋๊ท๋ชจ ์ธํ๋ผ์์ ๋๊ท๋ชจ ๋ชจ๋ธ์ ํ๋ จํ๋ ๊ฒฝ์ฐ์ ๋๋ต์ ์ธ ๊ฒฐ์ ๊ณผ์ ์ ์ดํด๋ณด๊ฒ ์ต๋๋ค.
## ํ์ฅ์ฑ ์ ๋ต [[scalability-strategy]]
**โจ ๋จ์ผ ๋
ธ๋ / ๋ค์ค-GPU**
* ๋ชจ๋ธ์ด ๋จ์ผ GPU์ ๋ง๋ ๊ฒฝ์ฐ:
1. DDP - ๋ถ์ฐ DP
2. ZeRO - ์ํฉ๊ณผ ๊ตฌ์ฑ์ ๋ฐ๋ผ ๋ ๋น ๋ฅผ ์๋ ์๊ณ ๊ทธ๋ ์ง ์์ ์๋ ์์
* ๋ชจ๋ธ์ด ๋จ์ผ GPU์ ๋ง์ง ์๋ ๊ฒฝ์ฐ:
1. PP
2. ZeRO
3. TP
๋
ธ๋ ๋ด ์ฐ๊ฒฐ ์๋๊ฐ ๋งค์ฐ ๋น ๋ฅธ NVLINK ๋๋ NVSwitch์ ๊ฒฝ์ฐ ์ธ ๊ฐ์ง ๋ฐฉ๋ฒ์ ๋๋ถ๋ถ ๋น์ทํ ์ฑ๋ฅ์ ๋ณด์ฌ์ผ ํ๋ฉฐ, PP๊ฐ ์๋ ๊ฒฝ์ฐ TP ๋๋ ZeRO๋ณด๋ค ๋น ๋ฅผ ๊ฒ์
๋๋ค. TP์ ์ ๋๋ ์ฐจ์ด๋ฅผ ๋ง๋ค ์ ์์ต๋๋ค. ํน์ ์ค์ ์์ ์น์๋ฅผ ์ฐพ๊ธฐ ์ํด ์คํํ๋ ๊ฒ์ด ๊ฐ์ฅ ์ข์ต๋๋ค.
TP๋ ๊ฑฐ์ ํญ์ ๋จ์ผ ๋
ธ๋ ๋ด์์ ์ฌ์ฉ๋ฉ๋๋ค. ์ฆ, TP ํฌ๊ธฐ <= ๋
ธ๋๋น GPU ์์
๋๋ค.
* ๊ฐ์ฅ ํฐ ๋ ์ด์ด๊ฐ ๋จ์ผ GPU์ ๋ง์ง ์๋ ๊ฒฝ์ฐ:
1. ZeRO๋ฅผ ์ฌ์ฉํ์ง ์๋ ๊ฒฝ์ฐ - PP๋ง์ผ๋ก๋ ๋ง์ง ์์ผ๋ฏ๋ก TP๋ฅผ ๋ฐ๋์ ์ฌ์ฉํด์ผ ํจ
2. ZeRO๋ฅผ ์ฌ์ฉํ๋ ๊ฒฝ์ฐ์๋ ์์ "๋จ์ผ GPU" ํญ๋ชฉ๊ณผ ๋์ผ
**โจ ๋ค์ค ๋
ธ๋ / ๋ค์ค GPU**
* ๋
ธ๋ ๊ฐ ์ฐ๊ฒฐ ์๋๊ฐ ๋น ๋ฅธ ๊ฒฝ์ฐ:
1. ZeRO - ๋ชจ๋ธ์ ๋๋ถ๋ถ์ ์์ ์ ํ์๋ก ํ์ง ์์
2. PP+TP+DP - ํต์ ์ด ์ ์ง๋ง ๋ชจ๋ธ์ ๋๋์ ์ธ ๋ณ๊ฒฝ์ด ํ์ํจ
* ๋
ธ๋ ๊ฐ ์ฐ๊ฒฐ ์๋๊ฐ ๋๋ฆฌ๋ฉฐ, GPU ๋ฉ๋ชจ๋ฆฌ๊ฐ ์ฌ์ ํ ๋ถ์กฑํ ๊ฒฝ์ฐ:
1. DP+PP+TP+ZeRO-1
## ๋ฐ์ดํฐ ๋ณ๋ ฌํ [[data-parallelism]]
2๊ฐ์ GPU๋ง์ผ๋ก๋ ๋๋ถ๋ถ์ ์ฌ์ฉ์๋ค์ `DataParallel` (DP)๊ณผ `DistributedDataParallel` (DDP)์ ํตํด ํฅ์๋ ํ๋ จ ์๋๋ฅผ ๋๋ฆด ์ ์์ต๋๋ค. ์ด๋ PyTorch์ ๋ด์ฅ ๊ธฐ๋ฅ์
๋๋ค. ์ผ๋ฐ์ ์ผ๋ก DDP๋ฅผ ์ฌ์ฉํ๋ ๊ฒ์ด ์ข์ผ๋ฉฐ, DP๋ ์ผ๋ถ ๋ชจ๋ธ์์ ์๋ํ์ง ์์ ์ ์์ผ๋ฏ๋ก ์ฃผ์ํด์ผ ํฉ๋๋ค. [PyTorch ๋ฌธ์](https://pytorch.org/docs/master/generated/torch.nn.DataParallel.html)์์๋ DDP์ ์ฌ์ฉ์ ๊ถ์ฅํฉ๋๋ค.
### DP vs DDP [[dp-vs-ddp]]
`DistributedDataParallel` (DDP)์ ์ผ๋ฐ์ ์ผ๋ก `DataParallel` (DP)๋ณด๋ค ๋น ๋ฅด์ง๋ง, ํญ์ ๊ทธ๋ ์ง๋ ์์ต๋๋ค:
* DP๋ ํ์ด์ฌ ์ค๋ ๋ ๊ธฐ๋ฐ์ธ ๋ฐ๋ฉด, DDP๋ ๋ค์ค ํ๋ก์ธ์ค ๊ธฐ๋ฐ์ด๊ธฐ ๋๋ฌธ์ GIL๊ณผ ๊ฐ์ ํ์ด์ฌ ์ค๋ ๋ ์ ํ์ด ์์ต๋๋ค.
* ๊ทธ๋ฌ๋ GPU ์นด๋ ๊ฐ์ ๋๋ฆฐ ์ํธ ์ฐ๊ฒฐ์ฑ์ DDP๋ก ์ธํด ์ค์ ๋ก ๋๋ฆฐ ๊ฒฐ๊ณผ๋ฅผ ๋ผ ์ ์์ต๋๋ค.
์ด ๋ ๋ชจ๋ ๊ฐ์ GPU ๊ฐ ํต์ ์ค๋ฒํค๋์ ์ฃผ์ ์ฐจ์ด์ ์ ๋ค์๊ณผ ๊ฐ์ต๋๋ค:
[DDP](https://pytorch.org/docs/master/notes/ddp.html):
- ์์ํ ๋, ์ฃผ ํ๋ก์ธ์ค๊ฐ ๋ชจ๋ธ์ gpu 0์์ ๋ค๋ฅธ ๋ชจ๋ gpu๋ก ๋ณต์ ํฉ๋๋ค.
- ๊ทธ๋ฐ ๋ค์ ๊ฐ ๋ฐฐ์น์ ๋ํด:
1. ๊ฐ gpu๋ ์์ฒด ๋ฏธ๋ ๋ฐฐ์น ๋ฐ์ดํฐ๋ฅผ ์ง์ ์ฌ์ฉํฉ๋๋ค.
2. `backward` ๋์ ๋ก์ปฌ ๊ทธ๋๋์ธํธ๊ฐ ์ค๋น๋๋ฉด, ๋ชจ๋ ํ๋ก์ธ์ค์ ํ๊ท ํ๋ฉ๋๋ค.
[DP](https://pytorch.org/docs/master/generated/torch.nn.DataParallel.html):
๊ฐ ๋ฐฐ์น์ ๋ํด:
1. gpu 0์ ๋ฐ์ดํฐ ๋ฐฐ์น๋ฅผ ์ฝ๊ณ ๊ฐ gpu์ ๋ฏธ๋ ๋ฐฐ์น๋ฅผ ๋ณด๋
๋๋ค.
2. ์
๋ฐ์ดํธ๋ ๋ชจ๋ธ์ gpu 0์์ ๊ฐ gpu๋ก ๋ณต์ ํฉ๋๋ค.
3. `forward`๋ฅผ ์คํํ๊ณ ๊ฐ gpu์ ์ถ๋ ฅ์ gpu 0์ผ๋ก ๋ณด๋ด๊ณ ์์ค์ ๊ณ์ฐํฉ๋๋ค.
4. gpu 0์์ ๋ชจ๋ gpu๋ก ์์ค์ ๋ถ์ฐํ๊ณ `backward`๋ฅผ ์คํํฉ๋๋ค.
5. ๊ฐ gpu์์ ๊ทธ๋๋์ธํธ๋ฅผ gpu 0์ผ๋ก ๋ณด๋ด๊ณ ์ด๋ฅผ ํ๊ท ํํฉ๋๋ค.
DDP๋ ๊ฐ ๋ฐฐ์น๋ง๋ค ๊ทธ๋๋์ธํธ๋ฅผ ๋ณด๋ด๋ ํต์ ๋ง์ ์ํํ๋ฉฐ, DP๋ ๋ฐฐ์น๋ง๋ค 5๊ฐ์ ๋ค๋ฅธ ๋ฐ์ดํฐ ๊ตํ์ ์ํํฉ๋๋ค.
DP๋ ํ์ด์ฌ ์ค๋ ๋๋ฅผ ํตํด ํ๋ก์ธ์ค ๋ด์์ ๋ฐ์ดํฐ๋ฅผ ๋ณต์ ํ๋ฉฐ, DDP๋ [torch.distributed](https://pytorch.org/docs/master/distributed.html)๋ฅผ ํตํด ๋ฐ์ดํฐ๋ฅผ ๋ณต์ ํฉ๋๋ค.
DP์์๋ gpu 0์ด ๋ค๋ฅธ gpu๋ณด๋ค ํจ์ฌ ๋ ๋ง์ ์์
์ ์ํํ๋ฏ๋ก, gpu์ ํ์ฉ๋๊ฐ ๋ฎ์์ง๋๋ค.
DDP๋ ์ฌ๋ฌ ๋์ ์ปดํจํฐ์์ ์ฌ์ฉํ ์ ์์ง๋ง, DP์ ๊ฒฝ์ฐ๋ ๊ทธ๋ ์ง ์์ต๋๋ค.
DP์ DDP ์ฌ์ด์๋ ๋ค๋ฅธ ์ฐจ์ด์ ์ด ์์ง๋ง, ์ด ํ ๋ก ๊ณผ๋ ๊ด๋ จ์ด ์์ต๋๋ค.
์ด 2๊ฐ์ง ๋ชจ๋๋ฅผ ๊น๊ฒ ์ดํดํ๊ณ ์ถ๋ค๋ฉด, [์ด ๋ฌธ์](https://www.telesens.co/2019/04/04/distributed-data-parallel-training-using-pytorch-on-aws/)๋ฅผ ๊ฐ๋ ฅํ ์ถ์ฒํฉ๋๋ค. ์ด ๋ฌธ์๋ ๋ฉ์ง ๋ค์ด์ด๊ทธ๋จ์ ํฌํจํ๊ณ ์์ผ๋ฉฐ, ๋ค์ํ ํ๋์จ์ด์์ ์ฌ๋ฌ ๋ฒค์น๋งํฌ์ ํ๋กํ์ผ๋ฌ ์ถ๋ ฅ์ ์ค๋ช
ํ์ฌ ํ์ํ ์ธ๋ถ ์ฌํญ์ ๋ชจ๋ ์ค๋ช
ํฉ๋๋ค.
์ค์ ๋ฒค์น๋งํฌ๋ฅผ ์ดํด๋ณด๊ฒ ์ต๋๋ค:
| Type | NVlink | Time |
| :----- | ----- | ---: |
| 2:DP | Y | 110s |
| 2:DDP | Y | 101s |
| 2:DDP | N | 131s |
๋ถ์:
์ฌ๊ธฐ์ DP๋ NVlink๊ฐ ์๋ DDP๋ณด๋ค ์ฝ 10% ๋๋ฆฝ๋๋ค. ๊ทธ๋ฌ๋ NVlink๊ฐ ์๋ DDP๋ณด๋ค ์ฝ 15% ๋น ๋ฆ
๋๋ค.
์ค์ ์ฐจ์ด๋ ๊ฐ GPU๊ฐ ๋ค๋ฅธ GPU์ ๋๊ธฐํํด์ผ ํ๋ ๋ฐ์ดํฐ ์์ ๋ฐ๋ผ ๋ฌ๋ผ์ง ๊ฒ์
๋๋ค. ๋๊ธฐํํ ๋ฐ์ดํฐ๊ฐ ๋ง์์๋ก ๋๋ฆฐ ๋งํฌ๊ฐ ์ด ์คํ ์๊ฐ์ ๋ฆ์ถ ์ ์์ต๋๋ค.
๋ค์์ ์ ์ฒด ๋ฒค์น๋งํฌ ์ฝ๋์ ์ถ๋ ฅ์
๋๋ค:
ํด๋น ๋ฒค์น๋งํฌ์์ `NCCL_P2P_DISABLE=1`์ ์ฌ์ฉํ์ฌ NVLink ๊ธฐ๋ฅ์ ๋นํ์ฑํํ์ต๋๋ค.
```bash
# DP
rm -r /tmp/test-clm; CUDA_VISIBLE_DEVICES=0,1 \
python examples/pytorch/language-modeling/run_clm.py \
--model_name_or_path openai-community/gpt2 --dataset_name wikitext --dataset_config_name wikitext-2-raw-v1 \
--do_train --output_dir /tmp/test-clm --per_device_train_batch_size 4 --max_steps 200
{'train_runtime': 110.5948, 'train_samples_per_second': 1.808, 'epoch': 0.69}
# DDP w/ NVlink
rm -r /tmp/test-clm; CUDA_VISIBLE_DEVICES=0,1 \
torchrun --nproc_per_node 2 examples/pytorch/language-modeling/run_clm.py \
--model_name_or_path openai-community/gpt2 --dataset_name wikitext --dataset_config_name wikitext-2-raw-v1 \
--do_train --output_dir /tmp/test-clm --per_device_train_batch_size 4 --max_steps 200
{'train_runtime': 101.9003, 'train_samples_per_second': 1.963, 'epoch': 0.69}
# DDP w/o NVlink
rm -r /tmp/test-clm; NCCL_P2P_DISABLE=1 CUDA_VISIBLE_DEVICES=0,1 \
torchrun --nproc_per_node 2 examples/pytorch/language-modeling/run_clm.py \
--model_name_or_path openai-community/gpt2 --dataset_name wikitext --dataset_config_name wikitext-2-raw-v1 \
--do_train --output_dir /tmp/test-clm --per_device_train_batch_size 4 --max_steps 200
{'train_runtime': 131.4367, 'train_samples_per_second': 1.522, 'epoch': 0.69}
```
ํ๋์จ์ด: ๊ฐ๊ฐ 24GB์ TITAN RTX 2๊ฐ + NVlink๊ณผ 2๊ฐ์ NVLink (`nvidia-smi topo -m`์์ `NV2`์
๋๋ค.)
์ํํธ์จ์ด: `pytorch-1.8-to-be` + `cuda-11.0` / `transformers==4.3.0.dev0`
## ZeRO ๋ฐ์ดํฐ ๋ณ๋ ฌํ [[zero-data-parallelism]]
ZeRO๋ฅผ ๊ธฐ๋ฐ์ผ๋ก ํ ๋ฐ์ดํฐ ๋ณ๋ ฌํ (ZeRO-DP)๋ ๋ค์ [๋ธ๋ก๊ทธ ๊ธ](https://www.microsoft.com/en-us/research/blog/zero-deepspeed-new-system-optimizations-enable-training-models-with-over-100-billion-parameters/)์ ๋ค์ ๋ค์ด์ด๊ทธ๋จ์์ ์ค๋ช
๋๊ณ ์์ต๋๋ค.
์ด ๊ฐ๋
์ ์ดํดํ๊ธฐ ์ด๋ ค์ธ ์ ์์ง๋ง, ์ค์ ๋ก๋ ๋งค์ฐ ๊ฐ๋จํ ๊ฐ๋
์
๋๋ค. ์ด๋ ์ผ๋ฐ์ ์ธ `DataParallel` (DP)๊ณผ ๋์ผํ์ง๋ง, ์ ์ฒด ๋ชจ๋ธ ๋งค๊ฐ๋ณ์, ๊ทธ๋๋์ธํธ ๋ฐ ์ตํฐ๋ง์ด์ ์ํ๋ฅผ ๋ณต์ ํ๋ ๋์ ๊ฐ GPU๋ ๊ทธ ์ค ์ผ๋ถ๋ง ์ ์ฅํฉ๋๋ค. ๊ทธ๋ฆฌ๊ณ ์คํ ์๊ฐ์๋ ์ฃผ์ด์ง ๋ ์ด์ด์ ๋ํด ์ ์ฒด ๋ ์ด์ด ๋งค๊ฐ๋ณ์๊ฐ ํ์ํ ๋ ๊ฐ GPU๊ฐ ์๋ก์๊ฒ ํ์ํ ๋ถ๋ถ์ ์ ๊ณตํ๊ธฐ ์ํด ๋๊ธฐํ๋ฉ๋๋ค - ๊ทธ๊ฒ ์ ๋ถ์
๋๋ค.
๊ฐ๊ฐ 3๊ฐ์ ๋ ์ด์ด์ 3๊ฐ์ ๋งค๊ฐ๋ณ์๊ฐ ์๋ ๊ฐ๋จํ ๋ชจ๋ธ์ ์๊ฐํด ๋ด
์๋ค:
```
La | Lb | Lc
---|----|---
a0 | b0 | c0
a1 | b1 | c1
a2 | b2 | c2
```
๋ ์ด์ด La์๋ ๊ฐ์ค์น a0, a1 ๋ฐ a2๊ฐ ์์ต๋๋ค.
3๊ฐ์ GPU๊ฐ ์๋ ๊ฒฝ์ฐ, Sharded DDP (= Zero-DP)๋ ๋ค์๊ณผ ๊ฐ์ด ๋ชจ๋ธ์ 3๊ฐ์ GPU์ ๋ถํ ํฉ๋๋ค:
```
GPU0:
La | Lb | Lc
---|----|---
a0 | b0 | c0
GPU1:
La | Lb | Lc
---|----|---
a1 | b1 | c1
GPU2:
La | Lb | Lc
---|----|---
a2 | b2 | c2
```
์ผ๋ฐ์ ์ธ DNN ๋ค์ด์ด๊ทธ๋จ์ ์์ํด๋ณด๋ฉด ์ด๋ ํ
์ ๋ณ๋ ฌ ์ฒ๋ฆฌ์ ๊ฐ์ ์ํ ์ฌ๋ผ์ด์ฑ์
๋๋ค. ์์ง ์ฌ๋ผ์ด์ฑ์ ์ ์ฒด ๋ ์ด์ด ๊ทธ๋ฃน์ ๋ค๋ฅธ GPU์ ๋ฐฐ์นํ๋ ๊ฒ์
๋๋ค. ์ด๋ ์์์ ๋ถ๊ณผํฉ๋๋ค.
์ด์ ์ด๋ฌํ ๊ฐ๊ฐ์ GPU๋ DP์์ ์๋ํ๋ ๊ฒ๊ณผ ๋ง์ฐฌ๊ฐ์ง๋ก ์ผ๋ฐ์ ์ธ ๋ฏธ๋ ๋ฐฐ์น๋ฅผ ๋ฐ์ต๋๋ค:
```
x0 => GPU0
x1 => GPU1
x2 => GPU2
```
์
๋ ฅ์ ์์ ๋์ง ์์ ์ํ๋ก ์ผ๋ฐ ๋ชจ๋ธ์ ์ํด ์ฒ๋ฆฌ๋ ๊ฒ์ผ๋ก ๊ฐ์ฃผํฉ๋๋ค.
๋จผ์ , ์
๋ ฅ์ ๋ ์ด์ด La์ ๋๋ฌํฉ๋๋ค.
GPU0์๋ง ์ง์คํด ๋ณด๊ฒ ์ต๋๋ค. x0์ ์๋ฐฉํฅ ๊ฒฝ๋ก๋ฅผ ์ํํ๊ธฐ ์ํด a0, a1, a2 ํ๋ผ๋ฏธํฐ๊ฐ ํ์ํ์ง๋ง GPU0์๋ a0๋ง ์์ต๋๋ค. GPU1์์ a1์, GPU2์์ a2๋ฅผ ์ ์ก๋ฐ์ ๋ชจ๋ธ์ ๋ชจ๋ ์กฐ๊ฐ์ ํ๋๋ก ๋ชจ์๋๋ค.
๋ณ๋ ฌ์ ์ผ๋ก, GPU1์ ๋ฏธ๋ ๋ฐฐ์น x1์ ๋ฐ๊ณ a1๋ง ๊ฐ์ง๊ณ ์์ง๋ง, a0 ๋ฐ a2 ๋งค๊ฐ๋ณ์๊ฐ ํ์ํฉ๋๋ค. ๋ฐ๋ผ์ GPU0 ๋ฐ GPU2์์ ์ด๋ฅผ ๊ฐ์ ธ์ต๋๋ค.
GPU2๋ ๋์ผํ ์์
์ ์ํํฉ๋๋ค. ์
๋ ฅ x2๋ฅผ ๋ฐ๊ณ GPU0 ๋ฐ GPU1์์ ๊ฐ๊ฐ a0๊ณผ a1์, ๊ทธ๋ฆฌ๊ณ ์์ ์ a2์ ํจ๊ป ์ ์ฒด ํ
์๋ฅผ ๋ณต์ํฉ๋๋ค.
3๊ฐ์ GPU๋ ๋ณต์๋ ์ ์ฒด ํ
์๋ฅผ ๋ฐ๊ณ forward๊ฐ ์ํ๋ฉ๋๋ค.
๊ณ์ฐ์ด ์๋ฃ๋๋ฉด ๋ ์ด์ ํ์ํ์ง ์์ ๋ฐ์ดํฐ๋ ์ญ์ ๋๊ณ , ํด๋น ๋ฐ์ดํฐ๋ ๊ณ์ฐ ์ค์๋ง ์ฌ์ฉ๋ฉ๋๋ค. ๋ณต์์ ์ฌ์ ํจ์น๋ฅผ ํตํด ํจ์จ์ ์ผ๋ก ์ํ๋ฉ๋๋ค.
๊ทธ๋ฆฌ๊ณ ์ ์ฒด ํ๋ก์ธ์ค๋ ๋ ์ด์ด Lb์ ๋ํด ๋ฐ๋ณต๋๊ณ , ๊ทธ ๋ค์ Lc๋ก ์๋ฐฉํฅ์ผ๋ก, ๊ทธ๋ค์์ ์ญ๋ฐฉํฅ์ผ๋ก Lc -> Lb -> La๋ก ๋ฐ๋ณต๋ฉ๋๋ค.
๊ฐ์ธ์ ์ผ๋ก ์ด๊ฒ์ ํจ์จ์ ์ธ ๊ทธ๋ฃน ๋ฐฐ๋ญ ์ฌํ์์ ์ค๋ ๋ถ๋ฐฐ ์ ๋ต์ฒ๋ผ ๋ค๋ฆฝ๋๋ค:
1. ์ฌ๋ A๊ฐ ํ
ํธ๋ฅผ ์ด๋ฐํฉ๋๋ค.
2. ์ฌ๋ B๊ฐ ๋๋ก๋ฅผ ์ด๋ฐํฉ๋๋ค.
3. ์ฌ๋ C๊ฐ ๋๋ผ๋ฅผ ์ด๋ฐํฉ๋๋ค.
์ด์ ๋งค์ผ ๋ฐค ๊ฐ์ ๊ฐ์ง ๊ฒ์ ๋ค๋ฅธ ์ฌ๋๋ค๊ณผ ๊ณต์ ํ๊ณ , ๊ฐ์ง์ง ์์ ๊ฒ์ ๋ค๋ฅธ ์ฌ๋๋ค๋ก๋ถํฐ ๋ฐ๊ณ , ์์นจ์๋ ํ ๋น๋ ์ ํ์ ์ฅ๋น๋ฅผ ์ธ๊ณ ๊ณ์ํด์ ์ฌํ์ ์งํํฉ๋๋ค. ์ด๊ฒ์ด Sharded DDP / Zero DP์
๋๋ค.
์ด ์ ๋ต์ ๊ฐ๊ฐ ์์ ์ ํ
ํธ, ๋๋ก ๋ฐ ๋๋ผ๋ฅผ ๊ฐ๋ณ์ ์ผ๋ก ์ด๋ฐํด์ผ ํ๋ ๋จ์ํ ์ ๋ต๊ณผ ๋น๊ตํด๋ณด๋ฉด ํจ์ฌ ๋นํจ์จ์ ์ผ ๊ฒ์
๋๋ค. ์ด๊ฒ์ด Pytorch์ DataParallel (DP ๋ฐ DDP)์
๋๋ค.
์ด ์ฃผ์ ์ ๋ํด ๋
ผ๋ฌธ์ ์ฝ์ ๋ ๋ค์ ๋์์ด๋ฅผ ๋ง๋ ์ ์์ต๋๋ค: Sharded, Partitioned.
ZeRO๊ฐ ๋ชจ๋ธ ๊ฐ์ค์น๋ฅผ ๋ถํ ํ๋ ๋ฐฉ์์ ์์ธํ ์ดํด๋ณด๋ฉด, ํ
์ ๋ณ๋ ฌํ์ ๋งค์ฐ ์ ์ฌํ ๊ฒ์ ์ ์ ์์ต๋๋ค. ์ด๋ ์ดํ์ ์ค๋ช
๋ ์์ง ๋ชจ๋ธ ๋ณ๋ ฌํ์๋ ๋ฌ๋ฆฌ ๊ฐ ๋ ์ด์ด์ ๊ฐ์ค์น๋ฅผ ๋ถํ /๋ถํ ํ๊ธฐ ๋๋ฌธ์
๋๋ค.
๊ตฌํ:
- [DeepSpeed](https://www.deepspeed.ai/tutorials/zero/)๋ 1๋จ๊ณ + 2๋จ๊ณ + 3๋จ๊ณ์ ZeRO-DP๋ฅผ ์ ๊ณตํฉ๋๋ค.
- [Fairscale](https://github.com/facebookresearch/fairscale/#optimizer-state-sharding-zero)์ 1๋จ๊ณ + 2๋จ๊ณ + 3๋จ๊ณ์ ZeRO-DP๋ฅผ ์ ๊ณตํฉ๋๋ค.
- [`transformers` ํตํฉ](main_classes/trainer#trainer-integrations)
## ๋ค์ดํฐ๋ธ ๋ชจ๋ธ ๋ณ๋ ฌ ์ฒ๋ฆฌ(์์ง์ ) ๋ฐ ํ์ดํ๋ผ์ธ ๋ณ๋ ฌ ์ฒ๋ฆฌ[[naive-model-parallelism-vertical-and-pipeline-parallelism]]
Naive Model Parallelism (MP)์ ๋ชจ๋ธ ๋ ์ด์ด ๊ทธ๋ฃน์ ๋ค์ค GPU์ ๋ถ์ฐํ๋ ๋ฐฉ์์
๋๋ค. ๋ฉ์ปค๋์ฆ์ ์๋์ ์ผ๋ก ๊ฐ๋จํฉ๋๋ค. ์ํ๋ ๋ ์ด์ด๋ฅผ `.to()`๋ฅผ ์ฌ์ฉํ์ฌ ์ํ๋ ์ฅ์น๋ก ์ ํํ๋ฉด ๋ฐ์ดํฐ๊ฐ ํด๋น ๋ ์ด์ด๋ก ๋ค์ด์ค๊ณ ๋๊ฐ ๋ ๋ฐ์ดํฐ๋ ๋ ์ด์ด์ ๋์ผํ ์ฅ์น๋ก ์ ํ๋๊ณ ๋๋จธ์ง๋ ์์ ๋์ง ์์ต๋๋ค.
๋๋ถ๋ถ์ ๋ชจ๋ธ์ด ๊ทธ๋ ค์ง๋ ๋ฐฉ์์ด ๋ ์ด์ด๋ฅผ ์ธ๋ก๋ก ์ฌ๋ผ์ด์คํ๊ธฐ ๋๋ฌธ์ ์ด๋ฅผ ์์ง ๋ชจ๋ธ ๋ณ๋ ฌํ๋ผ๊ณ ๋ถ๋ฆ
๋๋ค. ์๋ฅผ ๋ค์ด ๋ค์ ๋ค์ด์ด๊ทธ๋จ์ 8๋ ์ด์ด ๋ชจ๋ธ์ ๋ณด์ฌ์ค๋๋ค:
```
=================== ===================
| 0 | 1 | 2 | 3 | | 4 | 5 | 6 | 7 |
=================== ===================
gpu0 gpu1
```
์ฐ๋ฆฌ๋ ๋ชจ๋ธ์ ์์ง์ผ๋ก 2๊ฐ๋ก ๋ถํ ํ์ฌ ๋ ์ด์ด 0-3์ GPU0์ ๋ฐฐ์นํ๊ณ ๋ ์ด์ด 4-7์ GPU1์ ๋ฐฐ์นํ์ต๋๋ค.
์ด์ ๋ฐ์ดํฐ๊ฐ ๋ ์ด์ด 0์์ 1๋ก, 1์์ 2๋ก, 2์์ 3์ผ๋ก ์ด๋ํ๋ ๋์์๋ ์ผ๋ฐ์ ์ธ ๋ชจ๋ธ์
๋๋ค. ๊ทธ๋ฌ๋ ๋ฐ์ดํฐ๊ฐ ๋ ์ด์ด 3์์ ๋ ์ด์ด 4๋ก ์ ๋ฌ๋์ด์ผ ํ ๋๋ GPU0์์ GPU1๋ก ์ด๋ํด์ผ ํ๋ฏ๋ก ํต์ ์ค๋ฒํค๋๊ฐ ๋ฐ์ํฉ๋๋ค. ์ฐธ์ฌํ๋ GPU๊ฐ ๋์ผํ ์ปดํจํ
๋
ธ๋(์: ๋์ผํ ๋ฌผ๋ฆฌ์ ์ธ ๊ธฐ๊ณ)์ ์๋ ๊ฒฝ์ฐ ์ด ๋ณต์ฌ๋ ๋งค์ฐ ๋น ๋ฆ
๋๋ค. ๊ทธ๋ฌ๋ GPU๊ฐ ์๋ก ๋ค๋ฅธ ์ปดํจํ
๋
ธ๋(์: ์ฌ๋ฌ ๊ธฐ๊ณ)์ ์์นํ ๊ฒฝ์ฐ ํต์ ์ค๋ฒํค๋๋ ์๋นํ ํฌ๊ฒ ๋ ์ ์์ต๋๋ค.
๊ทธ๋ฐ ๋ค์ ๋ ์ด์ด 4๋ถํฐ 5๋ก, 6์ผ๋ก, 7๋ก ์งํ๋๋ ๊ฒ์ ์ผ๋ฐ์ ์ธ ๋ชจ๋ธ๊ณผ ๋์ผํ๊ฒ ์งํ๋๊ณ , 7๋ฒ์งธ ๋ ์ด์ด๊ฐ ์๋ฃ๋๋ฉด ๋ฐ์ดํฐ๋ฅผ ๋ค์ ๋ ์ด์ด 0์ผ๋ก ๋ณด๋ด๊ฑฐ๋ ๋๋ ๋ ์ด๋ธ์ ๋ง์ง๋ง ๋ ์ด์ด๋ก ๋ณด๋ด์ผ ํ ํ์๊ฐ ์์ต๋๋ค. ์ด์ ์์ค์ ๊ณ์ฐํ๊ณ ์ตํฐ๋ง์ด์ ๊ฐ ์๋ํ ์ ์์ต๋๋ค.
๋ฌธ์ ์ :
- ์ด ๋ฐฉ์์ "naive" MP๋ผ๊ณ ๋ถ๋ฅด๋ ์ด์ ๋ ์ฃผ์ด์ง ์ํฉ์ ํ๋์ GPU๋ฅผ ์ ์ธํ ๋ชจ๋ GPU๊ฐ ์ ํด ์ํ๋ผ๋ ์ ์
๋๋ค. ๋ฐ๋ผ์ 4๊ฐ์ GPU๋ฅผ ์ฌ์ฉํ๋ ๊ฒฝ์ฐ ๋จ์ผ GPU์ ๋ฉ๋ชจ๋ฆฌ ์์ 4๋ฐฐ๋ก ๋๋ฆฌ๊ณ ๋๋จธ์ง ํ๋์จ์ด๋ ๋ฌด์ํ๋ ๊ฒ๊ณผ ๊ฑฐ์ ๋์ผํฉ๋๋ค. ๋ํ ์ฅ์น ๊ฐ ๋ฐ์ดํฐ ๋ณต์ฌ์ ์ค๋ฒํค๋๋ ์์ต๋๋ค. ๋ฐ๋ผ์ 4๊ฐ์ 6GB ์นด๋๋ naive MP๋ฅผ ์ฌ์ฉํ์ฌ 1๊ฐ์ 24GB ์นด๋์ ๋์ผํ ํฌ๊ธฐ๋ฅผ ์์ฉํ ์ ์์ง๋ง, ํ์๋ ๋ฐ์ดํฐ ๋ณต์ฌ์ ์ค๋ฒํค๋๊ฐ ์์ผ๋ฏ๋ก ํ๋ จ์ ๋ ๋นจ๋ฆฌ ์๋ฃํฉ๋๋ค. ๊ทธ๋ฌ๋ ์๋ฅผ ๋ค์ด 40GB ์นด๋๊ฐ ์๊ณ 45GB ๋ชจ๋ธ์ ๋ง์ถ์ด์ผ ํ ๊ฒฝ์ฐ 4๊ฐ์ 40GB ์นด๋๋ก ๋ง์ถ ์ ์์ต๋๋ค (ํ์ง๋ง ๊ทธ๋๋์ธํธ์ ์ตํฐ๋ง์ด์ ์ํ ๋๋ฌธ์ ๊ฐ๊น์ค๋ก ๊ฐ๋ฅํฉ๋๋ค).
- ๊ณต์ ์๋ฒ ๋ฉ์ GPU ๊ฐ์ ๋ณต์ฌํด์ผ ํ ์๋ ์์ต๋๋ค.
ํ์ดํ๋ผ์ธ ๋ณ๋ ฌํ (PP)์ ๊ฑฐ์ naive MP์ ๋์ผํ์ง๋ง GPU ์ ํด ์ํ ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ๊ธฐ ์ํด ๋ค์ด์ค๋ ๋ฐฐ์น๋ฅผ ๋ง์ดํฌ๋ก ๋ฐฐ์น๋ก ๋๋๊ณ ์ธ๊ณต์ ์ผ๋ก ํ์ดํ๋ผ์ธ์ ์์ฑํ์ฌ ์๋ก ๋ค๋ฅธ GPU๊ฐ ๋์์ ๊ณ์ฐ์ ์ฐธ์ฌํ ์ ์๊ฒ ํฉ๋๋ค.
[GPipe ๋
ผ๋ฌธ](https://ai.googleblog.com/2019/03/introducing-gpipe-open-source-library.html)์์ ๊ฐ์ ธ์จ ๊ทธ๋ฆผ์ ์๋จ์ naive MP๋ฅผ, ํ๋จ์๋ PP๋ฅผ ๋ณด์ฌ์ค๋๋ค:
ํ๋จ ๋ค์ด์ด๊ทธ๋จ์์ PP๊ฐ ์ ํด ์์ญ์ด ์ ์ ๊ฒ์ ์ฝ๊ฒ ๋ณผ ์ ์์ต๋๋ค. ์ ํด ๋ถ๋ถ์ "bubble"์ด๋ผ๊ณ ํฉ๋๋ค.
๋ค์ด์ด๊ทธ๋จ์ ์์ชฝ ๋ถ๋ถ์ ์ฐธ์ฌํ๋ GPU๊ฐ 4๊ฐ์ธ ๋ณ๋ ฌ์ฑ์ ๋ณด์ฌ์ค๋๋ค. ์ฆ, 4๊ฐ์ GPU๊ฐ ํ์ดํ๋ผ์ธ์ ์ฐธ์ฌํฉ๋๋ค. ๋ฐ๋ผ์ 4๊ฐ์ ํ์ดํ ๋จ๊ณ F0, F1, F2 ๋ฐ F3์ ์๋ฐฉํฅ ๊ฒฝ๋ก์ B3, B2, B1 ๋ฐ B0์ ์ญ๋ฐฉํฅ ๊ฒฝ๋ก๊ฐ ์์ต๋๋ค.
PP๋ ์กฐ์ ํด์ผ ํ ์๋ก์ด ํ์ดํผํ๋ผ๋ฏธํฐ์ธ `chunks`๋ฅผ ๋์
ํฉ๋๋ค. ์ด๋ ๋์ผํ ํ์ดํ ๋จ๊ณ๋ฅผ ํตํด ์ผ๋ จ์ ๋ฐ์ดํฐ๋ฅผ ๋ฌถ์ด์ ๋ณด๋ด๋ ๋ฐฉ์์ ์ ์ํฉ๋๋ค. ์๋ฅผ ๋ค์ด, ์๋ ๋ค์ด์ด๊ทธ๋จ์์ `chunks=4`๋ฅผ ๋ณผ ์ ์์ต๋๋ค. GPU0์ 0, 1, 2 ๋ฐ 3 (F0,0, F0,1, F0,2, F0,3) ๋ฌถ์์์ ๋์ผํ ์๋ฐฉํฅ ๊ฒฝ๋ก๋ฅผ ์ํํ๊ณ , ๋ค๋ฅธ GPU๊ฐ ์์
์ ์ํํ๊ธฐ ์์ํ๊ณ ์๋ฃ๊ฐ ์์๋ ๋๋ง GPU0์ด ๋ฌถ์์ ์ญ์์ผ๋ก 3, 2, 1 ๋ฐ 0 (B0,3, B0,2, B0,1, B0,0) ๊ฒฝ๋ก๋ฅผ ์ํํฉ๋๋ค.
๊ฐ๋
์ ์ผ๋ก ์ด๋ ๊ทธ๋๋์ธํธ ๋์ ๋จ๊ณ (GAS)์ ๋์ผํ ๊ฐ๋
์
๋๋ค. ํ์ดํ ์น์์๋ `chunks`๋ฅผ ์ฌ์ฉํ๊ณ DeepSpeed์์๋ ๋์ผํ ํ์ดํผํ๋ผ๋ฏธํฐ๋ฅผ GAS๋ก ์ฐธ์กฐํฉ๋๋ค.
๋ฌถ์์ผ๋ก ์ธํด PP๋ ๋ง์ดํฌ๋ก ๋ฐฐ์น (MBS)์ ๊ฐ๋
์ ๋์
ํฉ๋๋ค. DP๋ ์ ์ญ ๋ฐ์ดํฐ ๋ฐฐ์น ํฌ๊ธฐ๋ฅผ ๋ฏธ๋ ๋ฐฐ์น๋ก ๋๋๋๋ค. ๋ฐ๋ผ์ DP ์ฐจ์๊ฐ 4์ด๊ณ ์ ์ญ ๋ฐฐ์น ํฌ๊ธฐ๊ฐ 1024์ด๋ฉด 256์ฉ 4๊ฐ์ ๋ฏธ๋ ๋ฐฐ์น๋ก ๋ถํ ๋ฉ๋๋ค (1024/4). ๊ทธ๋ฆฌ๊ณ `chunks` (๋๋ GAS)์ ์๊ฐ 32์ด๋ฉด ๋ง์ดํฌ๋ก ๋ฐฐ์น ํฌ๊ธฐ๋ 8์ด ๋ฉ๋๋ค (256/32). ๊ฐ ํ์ดํ๋ผ์ธ ๋จ๊ณ๋ ํ ๋ฒ์ ํ๋์ ๋ง์ดํฌ๋ก ๋ฐฐ์น์ ํจ๊ป ์๋ํฉ๋๋ค.
DP + PP ์ค์ ์ ์ ์ญ ๋ฐฐ์น ํฌ๊ธฐ๋ฅผ ๊ณ์ฐํ๋ ค๋ฉด `mbs*chunks*dp_degree` (`8*32*4=1024`)๋ฅผ ์ํํฉ๋๋ค.
๋ค์ด์ด๊ทธ๋จ์ผ๋ก ๋์๊ฐ ๋ณด๊ฒ ์ต๋๋ค.
`chunks=1`๋ก ์ค์ ํ๋ฉด ๋งค์ฐ ๋นํจ์จ์ ์ธ naive MP๊ฐ ์์ฑ๋๋ฉฐ, ๋งค์ฐ ํฐ `chunks` ๊ฐ์ผ๋ก ์ค์ ํ๋ฉด ์์ฃผ ์์ ๋ง์ดํฌ๋ก ๋ฐฐ์น ํฌ๊ธฐ๊ฐ ์์ฑ๋์ด ํจ์จ์ ์ด์ง ์์ ์ ์์ต๋๋ค. ๋ฐ๋ผ์ ๊ฐ์ฅ ํจ์จ์ ์ธ GPU ํ์ฉ์ ์ํด ์ด๋ค ๊ฐ์ด ๊ฐ์ฅ ์ ์ ํ์ง ์คํ์ ํด์ผ ํฉ๋๋ค.
๋ค์ด์ด๊ทธ๋จ์์ ๋ณด์ด๋ ๊ฒ์ฒ๋ผ "dead" ์๊ฐ์ ๋ฒ๋ธ์ด ์กด์ฌํ์ฌ ๋ง์ง๋ง `forward` ๋จ๊ณ๊ฐ `backward` ๋จ๊ณ๊ฐ ํ์ดํ๋ผ์ธ์ ์๋ฃํ๊ธฐ๋ฅผ ๊ธฐ๋ค๋ ค์ผ ํ๋ ์ํฉ์ด ๋ฐ์ํ์ง๋ง, `chunks`์ ๊ฐ์ฅ ์ ์ ํ ๊ฐ์ ์ฐพ๋ ๊ฒ์ ๋ชฉ์ ์ ๋ชจ๋ ์ฐธ์ฌํ๋ GPU์์ ๋์์ ๊ณ ๋๋ก ํ์ฉ๋๋ GPU ํ์ฉ์ ๊ฐ๋ฅํ๊ฒ ํ์ฌ ๋ฒ๋ธ์ ํฌ๊ธฐ๋ฅผ ์ต์ํํ๋ ๊ฒ์
๋๋ค.
ํด๊ฒฐ์ฑ
์ ์ ํต์ ์ธ ํ์ดํ๋ผ์ธ API์ ๋ ํ๋์ ์ธ ์๋ฃจ์
์ผ๋ก ๋๋ฉ๋๋ค. ์ ํต์ ์ธ ํ์ดํ๋ผ์ธ API ์๋ฃจ์
๊ณผ ํ๋์ ์ธ ์๋ฃจ์
์ ๋ํด ์์๋ณด๊ฒ ์ต๋๋ค.
์ ํต์ ์ธ ํ์ดํ๋ผ์ธ API ์๋ฃจ์
:
- ํ์ดํ ์น
- FairScale
- DeepSpeed
- Megatron-LM
ํ๋์ ์ธ ์๋ฃจ์
:
- Varuna
- Sagemaker
์ ํต์ ์ธ ํ์ดํ๋ผ์ธ API ์๋ฃจ์
์ ๋ฌธ์ ์ :
- ๋ชจ๋ธ์ ์๋นํ ์์ ํด์ผ ํ๋ค๋ ์ ์ด ๋ฌธ์ ์
๋๋ค. ํ์ดํ๋ผ์ธ์ ๋ชจ๋์ ์ ์์ ์ธ ํ๋ฆ์ `nn.Sequential` ์ํ์ค๋ก ๋ค์ ์์ฑํด์ผ ํ๋ฏ๋ก ๋ชจ๋ธ์ ์ค๊ณ๋ฅผ ๋ณ๊ฒฝํด์ผ ํ ์ ์์ต๋๋ค.
- ํ์ฌ ํ์ดํ๋ผ์ธ API๋ ๋งค์ฐ ์ ํ์ ์
๋๋ค. ํ์ดํ๋ผ์ธ์ ๋งค์ฐ ์ฒซ ๋ฒ์งธ ๋จ๊ณ์์ ์ ๋ฌ๋๋ ๋ง์ ํ์ด์ฌ ๋ณ์๊ฐ ์๋ ๊ฒฝ์ฐ ์ด๋ฅผ ํด๊ฒฐํด์ผ ํฉ๋๋ค. ํ์ฌ ํ์ดํ๋ผ์ธ ์ธํฐํ์ด์ค๋ ํ๋์ ํ
์ ๋๋ ํ
์์ ํํ์ ์ ์ผํ ์
๋ ฅ ๋ฐ ์ถ๋ ฅ์ผ๋ก ์๊ตฌํฉ๋๋ค. ์ด๋ฌํ ํ
์๋ ๋ง์ดํฌ๋ก ๋ฐฐ์น๋ก ๋ฏธ๋ ๋ฐฐ์น๋ก ๋ฌถ์ ๊ฒ์ด๋ฏ๋ก ์ฒซ ๋ฒ์งธ ์ฐจ์์ผ๋ก ๋ฐฐ์น ํฌ๊ธฐ๊ฐ ์์ด์ผ ํฉ๋๋ค. ๊ฐ๋ฅํ ๊ฐ์ ์ฌํญ์ ์ฌ๊ธฐ์์ ๋
ผ์๋๊ณ ์์ต๋๋ค. https://github.com/pytorch/pytorch/pull/50693
- ํ์ดํ ๋จ๊ณ ์์ค์์ ์กฐ๊ฑด๋ถ ์ ์ด ํ๋ฆ์ ๋ถ๊ฐ๋ฅํฉ๋๋ค. ์๋ฅผ ๋ค์ด, T5์ ๊ฐ์ ์ธ์ฝ๋-๋์ฝ๋ ๋ชจ๋ธ์ ์กฐ๊ฑด๋ถ ์ธ์ฝ๋ ๋จ๊ณ๋ฅผ ์ฒ๋ฆฌํ๊ธฐ ์ํด ํน๋ณํ ํด๊ฒฐ์ฑ
์ด ํ์ํฉ๋๋ค.
- ๊ฐ ๋ ์ด์ด๋ฅผ ์ ๋ ฌํ์ฌ ํ๋์ ๋ชจ๋ธ์ ์ถ๋ ฅ์ด ๋ค๋ฅธ ๋ชจ๋ธ์ ์
๋ ฅ์ด ๋๋๋กํด์ผ ํฉ๋๋ค.
์ฐ๋ฆฌ๋ ์์ง Varuna์ SageMaker๋ก ์คํํ์ง ์์์ง๋ง, ํด๋น ๋
ผ๋ฌธ๋ค์ ์์์ ์ธ๊ธํ ๋ฌธ์ ๋ค์ ๋ชฉ๋ก์ ๊ทน๋ณตํ๊ณ ์ฌ์ฉ์์ ๋ชจ๋ธ์ ๋ํ ๋ณ๊ฒฝ ์ฌํญ์ด ํจ์ฌ ์ ๊ฒ ํ์ํ๋ค๊ณ ๋ณด๊ณ ํ๊ณ ์์ต๋๋ค.
๊ตฌํ:
- [ํ์ดํ ์น](https://pytorch.org/docs/stable/pipeline.html) (ํ์ดํ ์น-1.8์์ ์ด๊ธฐ ์ง์, 1.9์์ ์ ์ง์ ์ผ๋ก ๊ฐ์ ๋๊ณ 1.10์์ ๋ ๊ฐ์ ๋จ). [์์ ](https://github.com/pytorch/pytorch/blob/master/benchmarks/distributed/pipeline/pipe.py)๋ ์ฐธ๊ณ ํ์ธ์.
- [FairScale](https://fairscale.readthedocs.io/en/latest/tutorials/pipe.html)
- [DeepSpeed](https://www.deepspeed.ai/tutorials/pipeline/)
- [Megatron-LM](https://github.com/NVIDIA/Megatron-LM)์ ๋ด๋ถ ๊ตฌํ์ ๊ฐ์ง๊ณ ์์ต๋๋ค - API ์์.
- [Varuna](https://github.com/microsoft/varuna)
- [SageMaker](https://arxiv.org/abs/2111.05972) - ์ด๋ AWS์์๋ง ์ฌ์ฉํ ์ ์๋ ์์ ์๋ฃจ์
์
๋๋ค.
- [OSLO](https://github.com/tunib-ai/oslo) - ์ด๋ Hugging Face Transformers๋ฅผ ๊ธฐ๋ฐ์ผ๋ก ๊ตฌํ๋ ํ์ดํ๋ผ์ธ ๋ณ๋ ฌํ์
๋๋ค.
๐ค Transformers ์ํ: ์ด ์์ฑ ์์ ์์ ๋ชจ๋ธ ์ค ์ด๋ ๊ฒ๋ ์์ ํ PP๋ฅผ ์ง์ํ์ง ์์ต๋๋ค. GPT2์ T5 ๋ชจ๋ธ์ naive MP๋ฅผ ์ง์ํฉ๋๋ค. ์ฃผ์ ์ฅ์ ๋ฌผ์ ๋ชจ๋ธ์ `nn.Sequential`๋ก ๋ณํํ๊ณ ๋ชจ๋ ์
๋ ฅ์ ํ
์๋ก ๊ฐ์ ธ์์ผ ํ๋ ๊ฒ์ ์ฒ๋ฆฌํ ์ ์๊ธฐ ๋๋ฌธ์
๋๋ค. ํ์ฌ ๋ชจ๋ธ์๋ ์ด๋ฌํ ๋ณํ์ ๋งค์ฐ ๋ณต์กํ๊ฒ ๋ง๋๋ ๋ง์ ๊ธฐ๋ฅ์ด ํฌํจ๋์ด ์์ด ์ ๊ฑฐํด์ผ ํฉ๋๋ค.
๊ธฐํ ์ ๊ทผ ๋ฐฉ๋ฒ:
DeepSpeed, Varuna ๋ฐ SageMaker๋ [๊ต์ฐจ ํ์ดํ๋ผ์ธ(Interleaved Pipeline)](https://docs.aws.amazon.com/sagemaker/latest/dg/model-parallel-core-features.html) ๊ฐ๋
์ ์ฌ์ฉํฉ๋๋ค.
์ฌ๊ธฐ์๋ ๋ฒ๋ธ(์ ํด ์๊ฐ)์ ์ญ๋ฐฉํฅ ํจ์ค์ ์ฐ์ ์์๋ฅผ ๋ถ์ฌํ์ฌ ์ต์ํํฉ๋๋ค.
Varuna๋ ๊ฐ์ฅ ํจ์จ์ ์ธ ์ค์ผ์ค๋ง์ ์ฐพ๊ธฐ ์ํด ์๋ฎฌ๋ ์ด์
์ ์ฌ์ฉํ์ฌ ์ค์ผ์ค์ ๊ฐ์ ํ๋ ค๊ณ ํฉ๋๋ค.
OSLO๋ `nn.Sequential`๋ก ๋ณํํ์ง ์๊ณ Transformers๋ฅผ ๊ธฐ๋ฐ์ผ๋ก ํ ํ์ดํ๋ผ์ธ ๋ณ๋ ฌํ๋ฅผ ๊ตฌํํ์ต๋๋ค.
## ํ
์ ๋ณ๋ ฌ ์ฒ๋ฆฌ [[tensor-parallelism]]
ํ
์ ๋ณ๋ ฌ ์ฒ๋ฆฌ์์๋ ๊ฐ GPU๊ฐ ํ
์์ ์ผ๋ถ๋ถ๋ง ์ฒ๋ฆฌํ๊ณ ์ ์ฒด ํ
์๊ฐ ํ์ํ ์ฐ์ฐ์ ๋ํด์๋ง ์ ์ฒด ํ
์๋ฅผ ์ง๊ณํฉ๋๋ค.
์ด ์น์
์์๋ [Megatron-LM](https://github.com/NVIDIA/Megatron-LM) ๋
ผ๋ฌธ์ธ [Efficient Large-Scale Language Model Training on GPU Clusters](https://arxiv.org/abs/2104.04473)์์์ ๊ฐ๋
๊ณผ ๋ค์ด์ด๊ทธ๋จ์ ์ฌ์ฉํฉ๋๋ค.
Transformer์ ์ฃผ์ ๊ตฌ์ฑ ์์๋ fully connected `nn.Linear`์ ๋น์ ํ ํ์ฑํ ํจ์์ธ `GeLU`์
๋๋ค.
Megatron ๋
ผ๋ฌธ์ ํ๊ธฐ๋ฒ์ ๋ฐ๋ผ ํ๋ ฌ์ ์ ๊ณฑ ๋ถ๋ถ์ `Y = GeLU(XA)`๋ก ํํํ ์ ์์ต๋๋ค. ์ฌ๊ธฐ์ `X`์ `Y`๋ ์
๋ ฅ ๋ฐ ์ถ๋ ฅ ๋ฒกํฐ์ด๊ณ `A`๋ ๊ฐ์ค์น ํ๋ ฌ์
๋๋ค.
ํ๋ ฌ ํํ๋ก ๊ณ์ฐ์ ์ดํด๋ณด๋ฉด, ํ๋ ฌ ๊ณฑ์
์ ๋ค์ค GPU๋ก ๋ถํ ํ ์ ์๋ ๋ฐฉ๋ฒ์ ์ฝ๊ฒ ์ ์ ์์ต๋๋ค:
๊ฐ์ค์น ํ๋ ฌ `A`๋ฅผ `N`๊ฐ์ GPU์ ๋ํด ์ด๋ณ๋ก ๋ถํ ํ๊ณ ๋ณ๋ ฌ๋ก ํ๋ ฌ ๊ณฑ์
`XA_1`์์ `XA_n`๊น์ง ์ํํ๋ฉด `N`๊ฐ์ ์ถ๋ ฅ ๋ฒกํฐ `Y_1, Y_2, ..., Y_n`๊ฐ ์์ฑ๋๋ฉฐ ๋
๋ฆฝ์ ์ผ๋ก `GeLU`์ ์ ๋ฌ๋ ์ ์์ต๋๋ค:
์ด ์๋ฆฌ๋ฅผ ์ฌ์ฉํ์ฌ ๋๊ธฐํ๊ฐ ํ์ํ์ง ์์ GPU ๊ฐ์ ์์ ๊น์ด์ MLP๋ฅผ ์
๋ฐ์ดํธํ ์ ์์ต๋๋ค. ๊ทธ๋ฌ๋ ๊ฒฐ๊ณผ ๋ฒกํฐ๋ฅผ ์ค๋๋ก๋ถํฐ ์ฌ๊ตฌ์ฑํด์ผ ํ๋ ๋ง์ง๋ง ๋จ๊ณ๊น์ง๋ GPU ๊ฐ์ ๋๊ธฐํ๊ฐ ํ์ํฉ๋๋ค. Megatron-LM ๋
ผ๋ฌธ์ ์ ์๋ค์ ์ด์ ๋ํ ์ ์ฉํ ๊ทธ๋ฆผ์ ์ ๊ณตํฉ๋๋ค:
๋ค์ค ํค๋ ์ดํ
์
๋ ์ด์ด์ ๋ณ๋ ฌํ๋ ๋์ฑ ๊ฐ๋จํฉ๋๋ค. ์ด๋ฏธ ๋
๋ฆฝ์ ์ธ ๋ค์ค ํค๋๋ฅผ ๊ฐ์ง๊ณ ์๊ธฐ ๋๋ฌธ์ ์ด๋ฏธ ๋ณ๋ ฌํ๋์ด ์์ต๋๋ค!
ํน๋ณ ๊ณ ๋ ค์ฌํญ: TP๋ ๋งค์ฐ ๋น ๋ฅธ ๋คํธ์ํฌ๊ฐ ํ์ํ๋ฏ๋ก ํ ๊ฐ ์ด์์ ๋
ธ๋์์ TP๋ฅผ ์ํํ๋ ๊ฒ์ ๊ถ์ฅ๋์ง ์์ต๋๋ค. ์ค์ ๋ก ๋
ธ๋์ 4๊ฐ์ GPU๊ฐ ์๋ ๊ฒฝ์ฐ TP์ ์ต๋ ์ฐจ์๋ 4์
๋๋ค. TP ์ฐจ์๊ฐ 8์ธ ๊ฒฝ์ฐ ์ต์ํ 8๊ฐ์ GPU๊ฐ ์๋ ๋
ธ๋๋ฅผ ์ฌ์ฉํด์ผ ํฉ๋๋ค.
์ด ์น์
์ ์๋์ [๋ ์์ธํ TP ๊ฐ์](https://github.com/huggingface/transformers/issues/10321#issuecomment-783543530)๋ฅผ ๊ธฐ๋ฐ์ผ๋ก ํฉ๋๋ค.
์์ฑ์๋ [@anton-l](https://github.com/anton-l)์
๋๋ค.
SageMaker๋ ๋ ํจ์จ์ ์ธ ์ฒ๋ฆฌ๋ฅผ ์ํด TP์ DP๋ฅผ ๊ฒฐํฉํฉ๋๋ค.
๋์ฒด ์ด๋ฆ:
- DeepSpeed๋ ์ด๋ฅผ [ํ
์ ์ฌ๋ผ์ด์ฑ](https://www.deepspeed.ai/training/#model-parallelism)์ด๋ผ๊ณ ๋ถ๋ฆ
๋๋ค.
๊ตฌํ:
- [Megatron-LM](https://github.com/NVIDIA/Megatron-LM)์ ๋ด๋ถ ๊ตฌํ์ ๊ฐ์ง๊ณ ์์ผ๋ฏ๋ก ๋ชจ๋ธ์ ๋งค์ฐ ํนํ๋์ด ์์ต๋๋ค.
- [parallelformers](https://github.com/tunib-ai/parallelformers) (ํ์ฌ๋ ์ถ๋ก ์๋ง ํด๋น)
- [SageMaker](https://arxiv.org/abs/2111.05972) - ์ด๋ AWS์์๋ง ์ฌ์ฉํ ์ ์๋ ์์ ์๋ฃจ์
์
๋๋ค.
- [OSLO](https://github.com/tunib-ai/oslo)์ Transformers๋ฅผ ๊ธฐ๋ฐ์ผ๋ก ํ ํ
์ ๋ณ๋ ฌ ์ฒ๋ฆฌ ๊ตฌํ์ ๊ฐ์ง๊ณ ์์ต๋๋ค.
๐ค Transformers ํํฉ:
- core: ์์ง ํต์ฌ ๋ถ๋ถ์ ๊ตฌํ๋์ง ์์
- ๊ทธ๋ฌ๋ ์ถ๋ก ์ ํ๋ ค๋ฉด [parallelformers](https://github.com/tunib-ai/parallelformers)๊ฐ ๋๋ถ๋ถ์ ๋ชจ๋ธ์ ์ง์ํฉ๋๋ค. ๋ฐ๋ผ์ ํต์ฌ ๋ถ๋ถ์ ๊ตฌํ๋๊ธฐ ์ ๊น์ง ๊ทธ๋ค์ ๊ฒ์ ์ฌ์ฉํ ์ ์์ต๋๋ค. ๊ทธ๋ฆฌ๊ณ ํ๋ จ ๋ชจ๋๋ ์ง์๋ ์์ ์
๋๋ค.
- Deepspeed-Inference๋ CUDA ์ปค๋์ ๊ธฐ๋ฐ์ผ๋ก ํ๋ ๋งค์ฐ ๋น ๋ฅธ ์ถ๋ก ๋ชจ๋์์ BERT, GPT-2 ๋ฐ GPT-Neo ๋ชจ๋ธ์ ์ง์ํฉ๋๋ค. ์์ธํ ๋ด์ฉ์ [์ฌ๊ธฐ](https://www.deepspeed.ai/tutorials/inference-tutorial/)๋ฅผ ์ฐธ์กฐํ์ธ์.
## DP+PP [[dppp]]
DeepSpeed [pipeline tutorial](https://www.deepspeed.ai/tutorials/pipeline/)์์ ๋ค์ ๋ค์ด์ด๊ทธ๋จ์ DP์ PP๋ฅผ ๊ฒฐํฉํ๋ ๋ฐฉ๋ฒ์ ๋ณด์ฌ์ค๋๋ค.
์ฌ๊ธฐ์ DP ๋ญํฌ 0์ GPU2๋ฅผ ๋ณด์ง ๋ชปํ๊ณ , DP ๋ญํฌ 1์ GPU3์ ๋ณด์ง ๋ชปํ๋ ๊ฒ์ด ์ค์ํฉ๋๋ค. DP์๊ฒ๋ ๋ฑ 2๊ฐ์ GPU์ธ ๊ฒ์ฒ๋ผ ๋ฐ์ดํฐ๋ฅผ ๊ณต๊ธํฉ๋๋ค. GPU0์ PP๋ฅผ ์ฌ์ฉํ์ฌ GPU2์๊ฒ ์ผ๋ถ ์์
์ "๋น๋ฐ๋ฆฌ์" ํ ๋นํฉ๋๋ค. ๊ทธ๋ฆฌ๊ณ GPU1๋ GPU3์ ๋์์ผ๋ก ์ผ์ ๊ฐ์ ๋ฐฉ์์ผ๋ก ์์
ํฉ๋๋ค.
๊ฐ ์ฐจ์๋ง๋ค ์ ์ด๋ 2๊ฐ์ GPU๊ฐ ํ์ํ๋ฏ๋ก ์ต์ํ 4๊ฐ์ GPU๊ฐ ํ์ํฉ๋๋ค.
๊ตฌํ:
- [DeepSpeed](https://github.com/microsoft/DeepSpeed)
- [Megatron-LM](https://github.com/NVIDIA/Megatron-LM)
- [Varuna](https://github.com/microsoft/varuna)
- [SageMaker](https://arxiv.org/abs/2111.05972)
- [OSLO](https://github.com/tunib-ai/oslo)
๐ค Transformers ํํฉ: ์์ง ๊ตฌํ๋์ง ์์
## DP+PP+TP [[dppptp]]
๋ ํจ์จ์ ์ธ ํ๋ จ์ ์ํด PP์ TP ๋ฐ DP๋ฅผ ๊ฒฐํฉํ์ฌ 3D ๋ณ๋ ฌ ์ฒ๋ฆฌ๋ฅผ ์ฌ์ฉํฉ๋๋ค. ๋ค์ ๋ค์ด์ด๊ทธ๋จ์์ ์ด๋ฅผ ํ์ธํ ์ ์์ต๋๋ค.
์ด ๋ค์ด์ด๊ทธ๋จ์ [3D parallelism: Scaling to trillion-parameter models](https://www.microsoft.com/en-us/research/blog/deepspeed-extreme-scale-model-training-for-everyone/)์ด๋ผ๋ ๋ธ๋ก๊ทธ ๊ธ์์ ํ์ธํ ์ ์์ต๋๋ค.
๊ฐ ์ฐจ์๋ง๋ค ์ ์ด๋ 2๊ฐ์ GPU๊ฐ ํ์ํ๋ฏ๋ก ์ต์ํ 8๊ฐ์ GPU๊ฐ ํ์ํฉ๋๋ค.
๊ตฌํ:
- [DeepSpeed](https://github.com/microsoft/DeepSpeed) - DeepSpeed๋ ๋์ฑ ํจ์จ์ ์ธ DP์ธ ZeRO-DP๋ผ๊ณ ๋ ๋ถ๋ฆ
๋๋ค.
- [Megatron-LM](https://github.com/NVIDIA/Megatron-LM)
- [Varuna](https://github.com/microsoft/varuna)
- [SageMaker](https://arxiv.org/abs/2111.05972)
- [OSLO](https://github.com/tunib-ai/oslo)
๐ค Transformers ํํฉ: ์์ง ๊ตฌํ๋์ง ์์. PP์ TP๊ฐ ์๊ธฐ ๋๋ฌธ์
๋๋ค.
## ZeRO DP+PP+TP [[zero-dppptp]]
DeepSpeed์ ์ฃผ์ ๊ธฐ๋ฅ ์ค ํ๋๋ DP์ ํ์ฅ์ธ ZeRO์
๋๋ค. ZeRO-DP์ ๋ํด ์ด๋ฏธ [ZeRO Data Parallelism](#zero-data-parallelism)์์ ๋
ผ์๋์์ต๋๋ค. ์ผ๋ฐ์ ์ผ๋ก ์ด๋ PP๋ TP๋ฅผ ํ์๋กํ์ง ์๋ ๋
๋ฆฝ์ ์ธ ๊ธฐ๋ฅ์
๋๋ค. ๊ทธ๋ฌ๋ PP์ TP์ ๊ฒฐํฉํ ์๋ ์์ต๋๋ค.
ZeRO-DP๊ฐ PP์ (์ ํ์ ์ผ๋ก TP์) ๊ฒฐํฉ๋๋ฉด ์ผ๋ฐ์ ์ผ๋ก ZeRO ๋จ๊ณ 1(์ตํฐ๋ง์ด์ ๋ถํ )๋ง ํ์ฑํ๋ฉ๋๋ค.
์ด๋ก ์ ์ผ๋ก๋ ZeRO ๋จ๊ณ 2(๊ทธ๋ผ๋์ธํธ ๋ถํ )๋ฅผ ํ์ดํ๋ผ์ธ ๋ณ๋ ฌ ์ฒ๋ฆฌ์ ํจ๊ป ์ฌ์ฉํ ์๋ ์์ง๋ง, ์ด๋ ์ฑ๋ฅ์ ๋์ ์ํฅ์ ๋ฏธ์น ๊ฒ์
๋๋ค. ๊ฐ ๋ง์ดํฌ๋ก ๋ฐฐ์น๋ง๋ค ๊ทธ๋ผ๋์ธํธ๋ฅผ ์ค๋ฉํ๊ธฐ ์ ์ ์ถ๊ฐ์ ์ธ ๋ฆฌ๋์ค-์ค์บํฐ ์ปฌ๋ ํฐ๋ธ๊ฐ ํ์ํ๋ฉฐ, ์ด๋ ์ ์ฌ์ ์ผ๋ก ์๋นํ ํต์ ์ค๋ฒํค๋๋ฅผ ์ถ๊ฐํฉ๋๋ค. ํ์ดํ๋ผ์ธ ๋ณ๋ ฌ ์ฒ๋ฆฌ์ ํน์ฑ์ ์์ ๋ง์ดํฌ๋ก ๋ฐฐ์น๊ฐ ์ฌ์ฉ๋๋ฉฐ, ์ฐ์ ์ฐ์ฐ ๊ฐ๋(๋ง์ดํฌ๋ก ๋ฐฐ์น ํฌ๊ธฐ)๋ฅผ ๊ท ํ ์๊ฒ ์ ์งํ๋ฉด์ ํ์ดํ๋ผ์ธ ๋ฒ๋ธ(๋ง์ดํฌ๋ก ๋ฐฐ์น ์)์ ์ต์ํํ๋ ๊ฒ์ ์ค์ ์ ๋ก๋๋ค. ๋ฐ๋ผ์ ํด๋น ํต์ ๋น์ฉ์ ๋ฌธ์ ๊ฐ ๋ ๊ฒ์
๋๋ค.
๋ํ, PP๋ก ์ธํด ์ ์๋ณด๋ค ์ ์ ์์ ๋ ์ด์ด๊ฐ ์์ผ๋ฏ๋ก ๋ฉ๋ชจ๋ฆฌ ์ ์ฝ์ ํฌ์ง ์์ ๊ฒ์
๋๋ค. PP๋ ์ด๋ฏธ ๊ทธ๋๋์ธํธ ํฌ๊ธฐ๋ฅผ ``1/PP``๋ก ์ค์ด๊ธฐ ๋๋ฌธ์ ๊ทธ๋๋์ธํธ ์ค๋ฉ์ ์ ์ฝ ํจ๊ณผ๋ ์์ DP๋ณด๋ค๋ ๋ฏธ๋ฏธํฉ๋๋ค.
ZeRO ๋จ๊ณ 3๋ ๊ฐ์ ์ด์ ๋ก ์ข์ ์ ํ์ด ์๋๋๋ค - ๋ ๋ง์ ๋
ธ๋ ๊ฐ ํต์ ์ด ํ์ํฉ๋๋ค.
๊ทธ๋ฆฌ๊ณ ZeRO๊ฐ ์๊ธฐ ๋๋ฌธ์ ๋ค๋ฅธ ์ด์ ์ ZeRO-Offload์
๋๋ค. ์ด๋ ๋จ๊ณ 1์ด๋ฏ๋ก ์ตํฐ๋ง์ด์ ์ํ๋ฅผ CPU๋ก ์คํ๋ก๋ํ ์ ์์ต๋๋ค.
๊ตฌํ:
- [Megatron-DeepSpeed](https://github.com/microsoft/Megatron-DeepSpeed) ๋ฐ [BigScience์ Megatron-Deepspeed](https://github.com/bigscience-workshop/Megatron-DeepSpeed), ์ด์ ์ ์ฅ์์ ํฌํฌ์
๋๋ค.
- [OSLO](https://github.com/tunib-ai/oslo)
์ค์ํ ๋
ผ๋ฌธ:
- [Using DeepSpeed and Megatron to Train Megatron-Turing NLG 530B, A Large-Scale Generative Language Model](
https://arxiv.org/abs/2201.11990)
๐ค Transformers ํํฉ: ์์ง ๊ตฌํ๋์ง ์์, PP์ TP๊ฐ ์๊ธฐ ๋๋ฌธ์
๋๋ค.
## FlexFlow [[flexflow]]
[FlexFlow](https://github.com/flexflow/FlexFlow)๋ ์ฝ๊ฐ ๋ค๋ฅธ ๋ฐฉ์์ผ๋ก ๋ณ๋ ฌํ ๋ฌธ์ ๋ฅผ ํด๊ฒฐํฉ๋๋ค.
๋
ผ๋ฌธ: ["Beyond Data and Model Parallelism for Deep Neural Networks" by Zhihao Jia, Matei Zaharia, Alex Aiken](https://arxiv.org/abs/1807.05358)
์ด๋ Sample-Operator-Attribute-Parameter๋ฅผ ๊ธฐ๋ฐ์ผ๋ก ํ๋ ์ผ์ข
์ 4D ๋ณ๋ ฌํ๋ฅผ ์ํํฉ๋๋ค.
1. Sample = ๋ฐ์ดํฐ ๋ณ๋ ฌํ (์ํ๋ณ ๋ณ๋ ฌ)
2. Operator = ๋จ์ผ ์ฐ์ฐ์ ์ฌ๋ฌ ํ์ ์ฐ์ฐ์ผ๋ก ๋ณ๋ ฌํ
3. Attribute = ๋ฐ์ดํฐ ๋ณ๋ ฌํ (๊ธธ์ด๋ณ ๋ณ๋ ฌ)
4. Parameter = ๋ชจ๋ธ ๋ณ๋ ฌํ (์ํ ๋๋ ์์ง๊ณผ ๊ด๊ณ์์ด)
์์:
* Sample
512 ๊ธธ์ด์ 10๊ฐ์ ๋ฐฐ์น๋ฅผ ๊ฐ์ ํด ๋ด
์๋ค. ์ด๋ฅผ sample ์ฐจ์์ผ๋ก 2๊ฐ์ ์ฅ์น์ ๋ณ๋ ฌํํ๋ฉด, 10 x 512๋ 5 x 2 x 512๊ฐ ๋ฉ๋๋ค.
* Operator
๋ ์ด์ด ์ ๊ทํ๋ฅผ ์ํํ๋ค๋ฉด, ์ฐ์ std๋ฅผ ๊ณ์ฐํ๊ณ ๋ ๋ฒ์งธ๋ก mean์ ๊ณ์ฐํ ๋ค์ ๋ฐ์ดํฐ๋ฅผ ์ ๊ทํํ ์ ์์ต๋๋ค. Operator ๋ณ๋ ฌํ๋ std์ mean์ ๋ณ๋ ฌ๋ก ๊ณ์ฐํ ์ ์๋๋ก ํฉ๋๋ค. ๋ฐ๋ผ์ operator ์ฐจ์์ผ๋ก 2๊ฐ์ ์ฅ์น (cuda:0, cuda:1)์ ๋ณ๋ ฌํํ๋ฉด, ๋จผ์ ์
๋ ฅ ๋ฐ์ดํฐ๋ฅผ ๋ ์ฅ์น๋ก ๋ณต์ฌํ ๋ค์ cuda:0์์ std๋ฅผ ๊ณ์ฐํ๊ณ cuda:1์์ ๋์์ mean์ ๊ณ์ฐํฉ๋๋ค.
* Attribute
512 ๊ธธ์ด์ 10๊ฐ์ ๋ฐฐ์น๊ฐ ์์ต๋๋ค. ์ด๋ฅผ attribute ์ฐจ์์ผ๋ก 2๊ฐ์ ์ฅ์น์ ๋ณ๋ ฌํํ๋ฉด, 10 x 512๋ 10 x 2 x 256์ด ๋ฉ๋๋ค.
* Parameter
์ด๋ tensor ๋ชจ๋ธ ๋ณ๋ ฌํ ๋๋ naive layer-wise ๋ชจ๋ธ ๋ณ๋ ฌํ์ ์ ์ฌํฉ๋๋ค.
์ด ํ๋ ์์ํฌ์ ์ค์ํ ์ ์ (1) GPU/TPU/CPU ๋ (2) RAM/DRAM ๋ (3) ๋น ๋ฅธ ์ธํธ๋ผ-์ปค๋ฅํธ ๋ ๋๋ฆฐ ์ธํฐ-์ปค๋ฅํธ์ ๊ฐ์ ๋ฆฌ์์ค๋ฅผ ๊ณ ๋ คํ์ฌ ์ด๋์์ ์ด๋ค ๋ณ๋ ฌํ๋ฅผ ์ฌ์ฉํ ์ง๋ฅผ ์๊ณ ๋ฆฌ์ฆ์ ์ผ๋ก ์๋์ผ๋ก ์ต์ ํํ๋ค๋ ๊ฒ์
๋๋ค.
ํ๋ ๋งค์ฐ ์ค์ํ ์ธก๋ฉด์ FlexFlow๊ฐ ์ ์ ์ด๊ณ ๊ณ ์ ๋ ์ํฌ๋ก๋๋ฅผ ๊ฐ์ง ๋ชจ๋ธ์ ๋ํ DNN ๋ณ๋ ฌํ๋ฅผ ์ต์ ํํ๊ธฐ ์ํด ์ค๊ณ๋์๋ค๋ ๊ฒ์
๋๋ค. ๋์ ์ธ ๋์์ ๊ฐ์ง ๋ชจ๋ธ์ ๋ฐ๋ณต๋ง๋ค ๋ค๋ฅธ ๋ณ๋ ฌํ ์ ๋ต์ ์ ํธํ ์ ์์ต๋๋ค.
๋ฐ๋ผ์ ์ด ํ๋ ์์ํฌ์ ์ฅ์ ์ ์ ํํ ํด๋ฌ์คํฐ์์ 30๋ถ ๋์ ์๋ฎฌ๋ ์ด์
์ ์คํํ๊ณ ์ด ํน์ ํ๊ฒฝ์ ์ต์ ์ผ๋ก ํ์ฉํ๊ธฐ ์ํ ์ต์์ ์ ๋ต์ ์ ์ํ๋ค๋ ๊ฒ์
๋๋ค. ๋ถํ์ ์ถ๊ฐ/์ ๊ฑฐ/๊ต์ฒดํ๋ฉด ์คํํ๊ณ ๊ทธ์ ๋ํ ๊ณํ์ ๋ค์ ์ต์ ํํ ํ ํ๋ จํ ์ ์์ต๋๋ค. ๋ค๋ฅธ ์ค์ ์ ์์ฒด์ ์ธ ์ฌ์ฉ์ ์ ์ ์ต์ ํ๋ฅผ ๊ฐ์ง ์ ์์ต๋๋ค.
๐ค Transformers ํํฉ: ์์ง ํตํฉ๋์ง ์์. ์ด๋ฏธ [transformers.utils.fx](https://github.com/huggingface/transformers/blob/master/src/transformers/utils/fx.py)๋ฅผ ํตํด ๋ชจ๋ธ์ FX-์ถ์ ํ ์ ์์ผ๋ฉฐ, ์ด๋ FlexFlow์ ์ ํ ์กฐ๊ฑด์
๋๋ค. ๋ฐ๋ผ์ ์ด๋ค ์์
์ ์ํํด์ผ FlexFlow๊ฐ ์ฐ๋ฆฌ์ ๋ชจ๋ธ๊ณผ ํจ๊ป ์๋ํ ์ ์๋์ง ํ์
ํด์ผ ํฉ๋๋ค.
## ์ด๋ค ์ ๋ต์ ์ฌ์ฉํด์ผ ํ ๊น์? [[which-strategy-to-use-when]]
๋ค์์ ์ด๋ค ๋ณ๋ ฌํ ์ ๋ต์ ์ธ์ ์ฌ์ฉํด์ผ ํ๋์ง์ ๋ํ ๋งค์ฐ ๋๋ต์ ์ธ ๊ฐ์์
๋๋ค. ๊ฐ ๋ชฉ๋ก์ ์ฒซ ๋ฒ์งธ ์ ๋ต์ด ์ผ๋ฐ์ ์ผ๋ก ๋ ๋น ๋ฆ
๋๋ค.
**โจ ๋จ์ผ GPU**
* ๋ชจ๋ธ์ด ๋จ์ผ GPU์ ๋ง๋ ๊ฒฝ์ฐ:
1. ์ผ๋ฐ์ ์ธ ์ฌ์ฉ
* ๋ชจ๋ธ์ด ๋จ์ผ GPU์ ๋ง์ง ์๋ ๊ฒฝ์ฐ:
1. ZeRO + CPU ๋ฐ ์ต์
์ผ๋ก NVMe ์ธ๋ก๋
2. ์์ ๋์ผํ๊ฒ ์ฌ์ฉํ๋, ๊ฐ์ฅ ํฐ ๋ ์ด์ด๊ฐ ๋จ์ผ GPU์ ๋ง์ง ์๋ ๊ฒฝ์ฐ Memory Centric Tiling(์์ธํ ๋ด์ฉ์ ์๋ ์ฐธ์กฐ)์ ์ถ๊ฐ์ ์ผ๋ก ์ฌ์ฉ
* ๊ฐ์ฅ ํฐ ๋ ์ด์ด๊ฐ ๋จ์ผ GPU์ ๋ง์ง ์๋ ๊ฒฝ์ฐ:
1. ZeRO - [Memory Centric Tiling](https://deepspeed.readthedocs.io/en/latest/zero3.html#memory-centric-tiling) (MCT) ํ์ฑํ. ์ด๋ฅผ ํตํด ํฌ๊ธฐ๊ฐ ๋งค์ฐ ํฐ ๋ ์ด์ด๋ฅผ ์์๋ก ๋ถํ ํ์ฌ ์์ฐจ์ ์ผ๋ก ์คํํ ์ ์์ต๋๋ค. MCT๋ GPU์ ํ์ฑํ๋ ๋งค๊ฐ๋ณ์์ ์๋ฅผ ์ค์ด์ง๋ง ํ์ฑํ ๋ฉ๋ชจ๋ฆฌ์๋ ์ํฅ์ ์ฃผ์ง ์์ต๋๋ค. ํ์ฌ ์์ฑ ๊ธฐ์ค์ผ๋ก ์ด ์๊ตฌ์ฌํญ์ ๋งค์ฐ ๋๋ฌผ๊ธฐ ๋๋ฌธ์ ์ฌ์ฉ์๊ฐ `torch.nn.Linear`๋ฅผ ์๋์ผ๋ก ์์ ํด์ผ ํฉ๋๋ค.
**โจ ๋จ์ผ ๋
ธ๋ / ๋ค์ค GPU**
* ๋ชจ๋ธ์ด ๋จ์ผ GPU์ ๋ง๋ ๊ฒฝ์ฐ:
1. DDP - ๋ถ์ฐ DP
2. ZeRO - ์ํฉ๊ณผ ๊ตฌ์ฑ์ ๋ฐ๋ผ ๋น ๋ฅผ ์๋ ์๊ณ ๊ทธ๋ ์ง ์์ ์๋ ์์ต๋๋ค.
* ๋ชจ๋ธ์ด ๋จ์ผ GPU์ ๋ง์ง ์๋ ๊ฒฝ์ฐ:
1. PP
2. ZeRO
3. TP
NVLINK ๋๋ NVSwitch๋ฅผ ํตํ ๋งค์ฐ ๋น ๋ฅธ ์ธํธ๋ผ-๋
ธ๋ ์ฐ๊ฒฐ์ด ์๋ ๊ฒฝ์ฐ ์ด ์ธ ๊ฐ์ง ๋ฐฉ๋ฒ์ ๊ฑฐ์ ๋๋ฑํ ๊ฒ์ด๋ฉฐ, ์ด๋ฌํ ์ฐ๊ฒฐ์ด ์๋ ๊ฒฝ์ฐ PP๊ฐ TP๋ ZeRO๋ณด๋ค ๋น ๋ฅผ ๊ฒ์
๋๋ค. ๋ํ TP์ ์ฐจ์๋ ์ํฅ์ ์ค ์ ์์ต๋๋ค. ํน์ ์ค์ ์์ ์ฐ์น์๋ฅผ ์ฐพ๊ธฐ ์ํด ์คํํ๋ ๊ฒ์ด ๊ฐ์ฅ ์ข์ต๋๋ค.
TP๋ ๊ฑฐ์ ํญ์ ๋จ์ผ ๋
ธ๋ ๋ด์์ ์ฌ์ฉ๋ฉ๋๋ค. ์ฆ, TP ํฌ๊ธฐ <= ๋
ธ๋๋น GPU ์์
๋๋ค.
* ๊ฐ์ฅ ํฐ ๋ ์ด์ด๊ฐ ๋จ์ผ GPU์ ๋ง์ง ์๋ ๊ฒฝ์ฐ:
1. ZeRO๋ฅผ ์ฌ์ฉํ์ง ์์ ๊ฒฝ์ฐ - PP๋ง ์ฌ์ฉํ ์ ์์ผ๋ฏ๋ก TP๋ฅผ ์ฌ์ฉํด์ผ ํฉ๋๋ค.
2. ZeRO๋ฅผ ์ฌ์ฉํ ๊ฒฝ์ฐ, "๋จ์ผ GPU"์ ํญ๋ชฉ๊ณผ ๋์ผํ ํญ๋ชฉ ์ฐธ์กฐ
**โจ ๋ค์ค ๋
ธ๋ / ๋ค์ค GPU**
* ๋น ๋ฅธ ๋
ธ๋ ๊ฐ ์ฐ๊ฒฐ์ด ์๋ ๊ฒฝ์ฐ:
1. ZeRO - ๋ชจ๋ธ์ ๋ํ ์์ ์ด ๊ฑฐ์ ํ์ํ์ง ์์ต๋๋ค.
2. PP+TP+DP - ํต์ ์ด ์ ์ง๋ง ๋ชจ๋ธ์ ๋ํ ๋๊ท๋ชจ ๋ณ๊ฒฝ์ด ํ์ํฉ๋๋ค.
* ๋๋ฆฐ ๋
ธ๋ ๊ฐ ์ฐ๊ฒฐ ๋ฐ GPU ๋ฉ๋ชจ๋ฆฌ ๋ถ์กฑํ ๊ฒฝ์ฐ:
1. DP+PP+TP+ZeRO-1
| 0 |
mavonic_private_repos/transformers/docs/source | mavonic_private_repos/transformers/docs/source/ko/generation_strategies.md | <!--Copyright 2023 The HuggingFace Team. All rights reserved.
Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
the License. You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
specific language governing permissions and limitations under the License.
โ ๏ธ Note that this file is in Markdown but contain specific syntax for our doc-builder (similar to MDX) that may not be
rendered properly in your Markdown viewer.
-->
# Text generation strategies[[text-generation-strategies]]
ํ
์คํธ ์์ฑ์ ๊ฐ๋ฐฉํ ํ
์คํธ ์์ฑ, ์์ฝ, ๋ฒ์ญ ๋ฑ ๋ค์ํ ์์ฐ์ด ์ฒ๋ฆฌ(NLP) ์์
์ ํ์์ ์
๋๋ค. ์ด๋ ๋ํ ์์ฑ-ํ
์คํธ ๋ณํ, ์๊ฐ-ํ
์คํธ ๋ณํ๊ณผ ๊ฐ์ด ํ
์คํธ๋ฅผ ์ถ๋ ฅ์ผ๋ก ํ๋ ์ฌ๋ฌ ํผํฉ ๋ชจ๋ฌ๋ฆฌํฐ ์์ฉ ํ๋ก๊ทธ๋จ์์๋ ์ค์ํ ์ญํ ์ ํฉ๋๋ค. ํ
์คํธ ์์ฑ์ ๊ฐ๋ฅํ๊ฒ ํ๋ ๋ช๋ช ๋ชจ๋ธ๋ก๋ GPT2, XLNet, OpenAI GPT, CTRL, TransformerXL, XLM, Bart, T5, GIT, Whisper ๋ฑ์ด ์์ต๋๋ค.
[`~generation.GenerationMixin.generate`] ๋ฉ์๋๋ฅผ ํ์ฉํ์ฌ ๋ค์๊ณผ ๊ฐ์ ๋ค์ํ ์์
๋ค์ ๋ํด ํ
์คํธ ๊ฒฐ๊ณผ๋ฌผ์ ์์ฑํ๋ ๋ช ๊ฐ์ง ์์๋ฅผ ์ดํด๋ณด์ธ์:
* [ํ
์คํธ ์์ฝ](./tasks/summarization#inference)
* [์ด๋ฏธ์ง ์บก์
๋](./model_doc/git#transformers.GitForCausalLM.forward.example)
* [์ค๋์ค ์ ์ฌ](./model_doc/whisper#transformers.WhisperForConditionalGeneration.forward.example)
generate ๋ฉ์๋์ ์
๋ ฅ๋๋ ๊ฐ๋ค์ ๋ชจ๋ธ์ ๋ฐ์ดํฐ ํํ์ ๋ฐ๋ผ ๋ฌ๋ผ์ง๋๋ค. ์ด ๊ฐ๋ค์ AutoTokenizer๋ AutoProcessor์ ๊ฐ์ ๋ชจ๋ธ์ ์ ์ฒ๋ฆฌ ํด๋์ค์ ์ํด ๋ฐํ๋ฉ๋๋ค. ๋ชจ๋ธ์ ์ ์ฒ๋ฆฌ ์ฅ์น๊ฐ ํ๋ ์ด์์ ์
๋ ฅ ์ ํ์ ์์ฑํ๋ ๊ฒฝ์ฐ, ๋ชจ๋ ์
๋ ฅ์ generate()์ ์ ๋ฌํด์ผ ํฉ๋๋ค. ๊ฐ ๋ชจ๋ธ์ ์ ์ฒ๋ฆฌ ์ฅ์น์ ๋ํด์๋ ํด๋น ๋ชจ๋ธ์ ๋ฌธ์์์ ์์ธํ ์์๋ณผ ์ ์์ต๋๋ค.
ํ
์คํธ๋ฅผ ์์ฑํ๊ธฐ ์ํด ์ถ๋ ฅ ํ ํฐ์ ์ ํํ๋ ๊ณผ์ ์ ๋์ฝ๋ฉ์ด๋ผ๊ณ ํ๋ฉฐ, `generate()` ๋ฉ์๋๊ฐ ์ฌ์ฉํ ๋์ฝ๋ฉ ์ ๋ต์ ์ฌ์ฉ์๊ฐ ์ปค์คํฐ๋ง์ด์งํ ์ ์์ต๋๋ค. ๋์ฝ๋ฉ ์ ๋ต์ ์์ ํ๋ ๊ฒ์ ํ๋ จ ๊ฐ๋ฅํ ๋งค๊ฐ๋ณ์์ ๊ฐ๋ค์ ๋ณ๊ฒฝํ์ง ์์ง๋ง, ์์ฑ๋ ์ถ๋ ฅ์ ํ์ง์ ๋์ ๋๋ ์ํฅ์ ์ค ์ ์์ต๋๋ค. ์ด๋ ํ
์คํธ์์ ๋ฐ๋ณต์ ์ค์ด๊ณ , ๋ ์ผ๊ด์ฑ ์๊ฒ ๋ง๋๋ ๋ฐ ๋์์ ์ค ์ ์์ต๋๋ค.
์ด ๊ฐ์ด๋์์๋ ๋ค์๊ณผ ๊ฐ์ ๋ด์ฉ์ ๋ค๋ฃน๋๋ค:
* ๊ธฐ๋ณธ ์์ฑ ์ค์
* ์ผ๋ฐ์ ์ธ ๋์ฝ๋ฉ ์ ๋ต๊ณผ ์ฃผ์ ํ๋ผ๋ฏธํฐ
* ๐ค Hub์์ ๋ฏธ์ธ ์กฐ์ ๋ ๋ชจ๋ธ๊ณผ ํจ๊ป ์ฌ์ฉ์ ์ ์ ์์ฑ ์ค์ ์ ์ ์ฅํ๊ณ ๊ณต์ ํ๋ ๋ฐฉ๋ฒ
## ๊ธฐ๋ณธ ํ
์คํธ ์์ฑ ์ค์ [[default-text-generation-configuration]]
๋ชจ๋ธ์ ๋์ฝ๋ฉ ์ ๋ต์ ์์ฑ ์ค์ ์์ ์ ์๋ฉ๋๋ค. ์ฌ์ ํ๋ จ๋ ๋ชจ๋ธ์ [`pipeline`] ๋ด์์ ์ถ๋ก ์ ์ฌ์ฉํ ๋, ๋ชจ๋ธ์ ๋ด๋ถ์ ์ผ๋ก ๊ธฐ๋ณธ ์์ฑ ์ค์ ์ ์ ์ฉํ๋ `PreTrainedModel.generate()` ๋ฉ์๋๋ฅผ ํธ์ถํฉ๋๋ค. ์ฌ์ฉ์๊ฐ ๋ชจ๋ธ๊ณผ ํจ๊ป ์ฌ์ฉ์ ์ ์ ์ค์ ์ ์ ์ฅํ์ง ์์์ ๊ฒฝ์ฐ์๋ ๊ธฐ๋ณธ ์ค์ ์ด ์ฌ์ฉ๋ฉ๋๋ค.
๋ชจ๋ธ์ ๋ช
์์ ์ผ๋ก ๋ก๋ํ ๋, `model.generation_config`์ ํตํด ์ ๊ณต๋๋ ์์ฑ ์ค์ ์ ๊ฒ์ฌํ ์ ์์ต๋๋ค.
```python
>>> from transformers import AutoModelForCausalLM
>>> model = AutoModelForCausalLM.from_pretrained("distilbert/distilgpt2")
>>> model.generation_config
GenerationConfig {
"bos_token_id": 50256,
"eos_token_id": 50256,
}
```
`model.generation_config`๋ฅผ ์ถ๋ ฅํ๋ฉด ๊ธฐ๋ณธ ์ค์ ๊ณผ ๋ค๋ฅธ ๊ฐ๋ค๋ง ํ์๋๊ณ , ๊ธฐ๋ณธ๊ฐ๋ค์ ๋์ด๋์ง ์์ต๋๋ค.
๊ธฐ๋ณธ ์์ฑ ์ค์ ์ ์
๋ ฅ ํ๋กฌํํธ์ ์ถ๋ ฅ์ ํฉ์น ์ต๋ ํฌ๊ธฐ๋ฅผ 20 ํ ํฐ์ผ๋ก ์ ํํ์ฌ ๋ฆฌ์์ค ๋ถ์กฑ์ ๋ฐฉ์งํฉ๋๋ค. ๊ธฐ๋ณธ ๋์ฝ๋ฉ ์ ๋ต์ ํ์ ํ์(greedy search)์ผ๋ก, ๋ค์ ํ ํฐ์ผ๋ก ๊ฐ์ฅ ๋์ ํ๋ฅ ์ ๊ฐ์ง ํ ํฐ์ ์ ํํ๋ ๊ฐ์ฅ ๋จ์ํ ๋์ฝ๋ฉ ์ ๋ต์
๋๋ค. ๋ง์ ์์
๊ณผ ์์ ์ถ๋ ฅ ํฌ๊ธฐ์ ๋ํด์๋ ์ด ๋ฐฉ๋ฒ์ด ์ ์๋ํ์ง๋ง, ๋ ๊ธด ์ถ๋ ฅ์ ์์ฑํ ๋ ์ฌ์ฉํ๋ฉด ๋งค์ฐ ๋ฐ๋ณต์ ์ธ ๊ฒฐ๊ณผ๋ฅผ ์์ฑํ๊ฒ ๋ ์ ์์ต๋๋ค.
## ํ
์คํธ ์์ฑ ์ฌ์ฉ์ ์ ์[[customize-text-generation]]
ํ๋ผ๋ฏธํฐ์ ํด๋น ๊ฐ์ [`generate`] ๋ฉ์๋์ ์ง์ ์ ๋ฌํ์ฌ `generation_config`์ ์ฌ์ ์ํ ์ ์์ต๋๋ค:
```python
>>> my_model.generate(**inputs, num_beams=4, do_sample=True) # doctest: +SKIP
```
๊ธฐ๋ณธ ๋์ฝ๋ฉ ์ ๋ต์ด ๋๋ถ๋ถ์ ์์
์ ์ ์๋ํ๋ค ํ๋๋ผ๋, ์กฐ์ ํ ์ ์๋ ๋ช ๊ฐ์ง ํ๋ผ๋ฏธํฐ๊ฐ ์์ต๋๋ค. ์ผ๋ฐ์ ์ผ๋ก ์กฐ์ ๋๋ ํ๋ผ๋ฏธํฐ์๋ ๋ค์๊ณผ ๊ฐ์ ๊ฒ๋ค์ด ํฌํจ๋ฉ๋๋ค:
- `max_new_tokens`: ์์ฑํ ์ต๋ ํ ํฐ ์์
๋๋ค. ์ฆ, ํ๋กฌํํธ์ ์๋ ํ ํฐ์ ์ ์ธํ ์ถ๋ ฅ ์ํ์ค์ ํฌ๊ธฐ์
๋๋ค. ์ถ๋ ฅ์ ๊ธธ์ด๋ฅผ ์ค๋จ ๊ธฐ์ค์ผ๋ก ์ฌ์ฉํ๋ ๋์ , ์ ์ฒด ์์ฑ๋ฌผ์ด ์ผ์ ์๊ฐ์ ์ด๊ณผํ ๋ ์์ฑ์ ์ค๋จํ๊ธฐ๋ก ์ ํํ ์๋ ์์ต๋๋ค. ๋ ์์๋ณด๋ ค๋ฉด [`StoppingCriteria`]๋ฅผ ํ์ธํ์ธ์.
- `num_beams`: 1๋ณด๋ค ํฐ ์์ ๋น์ ์ง์ ํจ์ผ๋ก์จ, ํ์ ํ์(greedy search)์์ ๋น ํ์(beam search)์ผ๋ก ์ ํํ๊ฒ ๋ฉ๋๋ค. ์ด ์ ๋ต์ ๊ฐ ์๊ฐ ๋จ๊ณ์์ ์ฌ๋ฌ ๊ฐ์ค์ ํ๊ฐํ๊ณ ๊ฒฐ๊ตญ ์ ์ฒด ์ํ์ค์ ๋ํด ๊ฐ์ฅ ๋์ ํ๋ฅ ์ ๊ฐ์ง ๊ฐ์ค์ ์ ํํฉ๋๋ค. ์ด๋ ์ด๊ธฐ ํ ํฐ์ ํ๋ฅ ์ด ๋ฎ์ ํ์ ํ์์ ์ํด ๋ฌด์๋์์ ๋์ ํ๋ฅ ์ ์ํ์ค๋ฅผ ์๋ณํ ์ ์๋ ์ฅ์ ์ ๊ฐ์ง๋๋ค.
- `do_sample`: ์ด ๋งค๊ฐ๋ณ์๋ฅผ `True`๋ก ์ค์ ํ๋ฉด, ๋คํญ ์ํ๋ง, ๋น ํ์ ๋คํญ ์ํ๋ง, Top-K ์ํ๋ง ๋ฐ Top-p ์ํ๋ง๊ณผ ๊ฐ์ ๋์ฝ๋ฉ ์ ๋ต์ ํ์ฑํํฉ๋๋ค. ์ด๋ฌํ ์ ๋ต๋ค์ ์ ์ฒด ์ดํ์ ๋ํ ํ๋ฅ ๋ถํฌ์์ ๋ค์ ํ ํฐ์ ์ ํํ๋ฉฐ, ์ ๋ต๋ณ๋ก ํน์ ์กฐ์ ์ด ์ ์ฉ๋ฉ๋๋ค.
- `num_return_sequences`: ๊ฐ ์
๋ ฅ์ ๋ํด ๋ฐํํ ์ํ์ค ํ๋ณด์ ์์
๋๋ค. ์ด ์ต์
์ ๋น ํ์(beam search)์ ๋ณํ๊ณผ ์ํ๋ง๊ณผ ๊ฐ์ด ์ฌ๋ฌ ์ํ์ค ํ๋ณด๋ฅผ ์ง์ํ๋ ๋์ฝ๋ฉ ์ ๋ต์๋ง ์ฌ์ฉํ ์ ์์ต๋๋ค. ํ์ ํ์(greedy search)๊ณผ ๋์กฐ ํ์(contrastive search) ๊ฐ์ ๋์ฝ๋ฉ ์ ๋ต์ ๋จ์ผ ์ถ๋ ฅ ์ํ์ค๋ฅผ ๋ฐํํฉ๋๋ค.
## ๋ชจ๋ธ์ ์ฌ์ฉ์ ์ ์ ๋์ฝ๋ฉ ์ ๋ต ์ ์ฅ[[save-a-custom-decoding-strategy-with-your-model]]
ํน์ ์์ฑ ์ค์ ์ ๊ฐ์ง ๋ฏธ์ธ ์กฐ์ ๋ ๋ชจ๋ธ์ ๊ณต์ ํ๊ณ ์ ํ ๋, ๋ค์ ๋จ๊ณ๋ฅผ ๋ฐ๋ฅผ ์ ์์ต๋๋ค:
* [`GenerationConfig`] ํด๋์ค ์ธ์คํด์ค๋ฅผ ์์ฑํฉ๋๋ค.
* ๋์ฝ๋ฉ ์ ๋ต ํ๋ผ๋ฏธํฐ๋ฅผ ์ค์ ํฉ๋๋ค.
* ์์ฑ ์ค์ ์ [`GenerationConfig.save_pretrained`]๋ฅผ ์ฌ์ฉํ์ฌ ์ ์ฅํ๋ฉฐ, `config_file_name` ์ธ์๋ ๋น์๋ก๋๋ค.
* ๋ชจ๋ธ์ ์ ์ฅ์์ ์ค์ ์ ์
๋ก๋ํ๊ธฐ ์ํด `push_to_hub`๋ฅผ `True`๋ก ์ค์ ํฉ๋๋ค.
```python
>>> from transformers import AutoModelForCausalLM, GenerationConfig
>>> model = AutoModelForCausalLM.from_pretrained("my_account/my_model") # doctest: +SKIP
>>> generation_config = GenerationConfig(
... max_new_tokens=50, do_sample=True, top_k=50, eos_token_id=model.config.eos_token_id
... )
>>> generation_config.save_pretrained("my_account/my_model", push_to_hub=True) # doctest: +SKIP
```
๋จ์ผ ๋๋ ํ ๋ฆฌ์ ์ฌ๋ฌ ์์ฑ ์ค์ ์ ์ ์ฅํ ์ ์์ผ๋ฉฐ, ์ด๋ [`GenerationConfig.save_pretrained`]์ `config_file_name` ์ธ์๋ฅผ ์ฌ์ฉํฉ๋๋ค. ๋์ค์ [`GenerationConfig.from_pretrained`]๋ก ์ด๋ค์ ์ธ์คํด์คํํ ์ ์์ต๋๋ค. ์ด๋ ๋จ์ผ ๋ชจ๋ธ์ ๋ํด ์ฌ๋ฌ ์์ฑ ์ค์ ์ ์ ์ฅํ๊ณ ์ถ์ ๋ ์ ์ฉํฉ๋๋ค(์: ์ํ๋ง์ ์ด์ฉํ ์ฐฝ์์ ํ
์คํธ ์์ฑ์ ์ํ ํ๋, ๋น ํ์์ ์ด์ฉํ ์์ฝ์ ์ํ ๋ค๋ฅธ ํ๋ ๋ฑ). ๋ชจ๋ธ์ ์ค์ ํ์ผ์ ์ถ๊ฐํ๊ธฐ ์ํด ์ ์ ํ Hub ๊ถํ์ ๊ฐ์ง๊ณ ์์ด์ผ ํฉ๋๋ค.
```python
>>> from transformers import AutoModelForSeq2SeqLM, AutoTokenizer, GenerationConfig
>>> tokenizer = AutoTokenizer.from_pretrained("google-t5/t5-small")
>>> model = AutoModelForSeq2SeqLM.from_pretrained("google-t5/t5-small")
>>> translation_generation_config = GenerationConfig(
... num_beams=4,
... early_stopping=True,
... decoder_start_token_id=0,
... eos_token_id=model.config.eos_token_id,
... pad_token=model.config.pad_token_id,
... )
>>> # ํ: Hub์ pushํ๋ ค๋ฉด `push_to_hub=True`๋ฅผ ์ถ๊ฐ
>>> translation_generation_config.save_pretrained("/tmp", "translation_generation_config.json")
>>> # ๋ช
๋ช
๋ ์์ฑ ์ค์ ํ์ผ์ ์ฌ์ฉํ์ฌ ์์ฑ์ ๋งค๊ฐ๋ณ์ํํ ์ ์์ต๋๋ค.
>>> generation_config = GenerationConfig.from_pretrained("/tmp", "translation_generation_config.json")
>>> inputs = tokenizer("translate English to French: Configuration files are easy to use!", return_tensors="pt")
>>> outputs = model.generate(**inputs, generation_config=generation_config)
>>> print(tokenizer.batch_decode(outputs, skip_special_tokens=True))
['Les fichiers de configuration sont faciles ร utiliser!']
```
## ์คํธ๋ฆฌ๋ฐ[[streaming]]
`generate()` ๋ฉ์๋๋ `streamer` ์
๋ ฅ์ ํตํด ์คํธ๋ฆฌ๋ฐ์ ์ง์ํฉ๋๋ค. `streamer` ์
๋ ฅ์ `put()`๊ณผ `end()` ๋ฉ์๋๋ฅผ ๊ฐ์ง ํด๋์ค์ ์ธ์คํด์ค์ ํธํ๋ฉ๋๋ค. ๋ด๋ถ์ ์ผ๋ก, `put()`์ ์ ํ ํฐ์ ์ถ๊ฐํ๋ ๋ฐ ์ฌ์ฉ๋๋ฉฐ, `end()`๋ ํ
์คํธ ์์ฑ์ ๋์ ํ์ํ๋ ๋ฐ ์ฌ์ฉ๋ฉ๋๋ค.
<Tip warning={true}>
์คํธ๋ฆฌ๋จธ ํด๋์ค์ API๋ ์์ง ๊ฐ๋ฐ ์ค์ด๋ฉฐ, ํฅํ ๋ณ๊ฒฝ๋ ์ ์์ต๋๋ค.
</Tip>
์ค์ ๋ก ๋ค์ํ ๋ชฉ์ ์ ์ํด ์์ฒด ์คํธ๋ฆฌ๋ฐ ํด๋์ค๋ฅผ ๋ง๋ค ์ ์์ต๋๋ค! ๋ํ, ๊ธฐ๋ณธ์ ์ธ ์คํธ๋ฆฌ๋ฐ ํด๋์ค๋ค๋ ์ค๋น๋์ด ์์ด ๋ฐ๋ก ์ฌ์ฉํ ์ ์์ต๋๋ค. ์๋ฅผ ๋ค์ด, [`TextStreamer`] ํด๋์ค๋ฅผ ์ฌ์ฉํ์ฌ `generate()`์ ์ถ๋ ฅ์ ํ๋ฉด์ ํ ๋จ์ด์ฉ ์คํธ๋ฆฌ๋ฐํ ์ ์์ต๋๋ค:
```python
>>> from transformers import AutoModelForCausalLM, AutoTokenizer, TextStreamer
>>> tok = AutoTokenizer.from_pretrained("openai-community/gpt2")
>>> model = AutoModelForCausalLM.from_pretrained("openai-community/gpt2")
>>> inputs = tok(["An increasing sequence: one,"], return_tensors="pt")
>>> streamer = TextStreamer(tok)
>>> # ์คํธ๋ฆฌ๋จธ๋ ํ์์ ๊ฐ์ ์ถ๋ ฅ๊ฐ์ ๋ฐํํ ๋ฟ๋ง ์๋๋ผ ์์ฑ๋ ํ
์คํธ๋ ํ์ค ์ถ๋ ฅ(stdout)์ผ๋ก ์ถ๋ ฅํฉ๋๋ค.
>>> _ = model.generate(**inputs, streamer=streamer, max_new_tokens=20)
An increasing sequence: one, two, three, four, five, six, seven, eight, nine, ten, eleven,
```
## ๋์ฝ๋ฉ ์ ๋ต[[decoding-strategies]]
`generate()` ๋งค๊ฐ๋ณ์์ ๊ถ๊ทน์ ์ผ๋ก `generation_config`์ ํน์ ์กฐํฉ์ ์ฌ์ฉํ์ฌ ํน์ ๋์ฝ๋ฉ ์ ๋ต์ ํ์ฑํํ ์ ์์ต๋๋ค. ์ด ๊ฐ๋
์ด ์ฒ์์ด๋ผ๋ฉด, ํํ ์ฌ์ฉ๋๋ ๋์ฝ๋ฉ ์ ๋ต์ด ์ด๋ป๊ฒ ์๋ํ๋์ง ์ค๋ช
ํ๋ [์ด ๋ธ๋ก๊ทธ ํฌ์คํธ](https://huggingface.co/blog/how-to-generate)๋ฅผ ์ฝ์ด๋ณด๋ ๊ฒ์ ์ถ์ฒํฉ๋๋ค.
์ฌ๊ธฐ์๋ ๋์ฝ๋ฉ ์ ๋ต์ ์ ์ดํ๋ ๋ช ๊ฐ์ง ๋งค๊ฐ๋ณ์๋ฅผ ๋ณด์ฌ์ฃผ๊ณ , ์ด๋ฅผ ์ด๋ป๊ฒ ์ฌ์ฉํ ์ ์๋์ง ์ค๋ช
ํ๊ฒ ์ต๋๋ค.
### ํ์ ํ์(Greedy Search)[[greedy-search]]
[`generate`]๋ ๊ธฐ๋ณธ์ ์ผ๋ก ํ์ ํ์ ๋์ฝ๋ฉ์ ์ฌ์ฉํ๋ฏ๋ก ์ด๋ฅผ ํ์ฑํํ๊ธฐ ์ํด ๋ณ๋์ ๋งค๊ฐ๋ณ์๋ฅผ ์ง์ ํ ํ์๊ฐ ์์ต๋๋ค. ์ด๋ `num_beams`๊ฐ 1๋ก ์ค์ ๋๊ณ `do_sample=False`๋ก ๋์ด ์๋ค๋ ์๋ฏธ์
๋๋ค."
```python
>>> from transformers import AutoModelForCausalLM, AutoTokenizer
>>> prompt = "I look forward to"
>>> checkpoint = "distilbert/distilgpt2"
>>> tokenizer = AutoTokenizer.from_pretrained(checkpoint)
>>> inputs = tokenizer(prompt, return_tensors="pt")
>>> model = AutoModelForCausalLM.from_pretrained(checkpoint)
>>> outputs = model.generate(**inputs)
>>> tokenizer.batch_decode(outputs, skip_special_tokens=True)
['I look forward to seeing you all again!\n\n\n\n\n\n\n\n\n\n\n']
```
### ๋์กฐ ํ์(Contrastive search)[[contrastive-search]]
2022๋
๋
ผ๋ฌธ [A Contrastive Framework for Neural Text Generation](https://arxiv.org/abs/2202.06417)์์ ์ ์๋ ๋์กฐ ํ์ ๋์ฝ๋ฉ ์ ๋ต์ ๋ฐ๋ณต๋์ง ์์ผ๋ฉด์๋ ์ผ๊ด๋ ๊ธด ์ถ๋ ฅ์ ์์ฑํ๋ ๋ฐ ์์ด ์ฐ์ํ ๊ฒฐ๊ณผ๋ฅผ ๋ณด์์ต๋๋ค. ๋์กฐ ํ์์ด ์๋ํ๋ ๋ฐฉ์์ ์์๋ณด๋ ค๋ฉด [์ด ๋ธ๋ก๊ทธ ํฌ์คํธ](https://huggingface.co/blog/introducing-csearch)๋ฅผ ํ์ธํ์ธ์. ๋์กฐ ํ์์ ๋์์ ๊ฐ๋ฅํ๊ฒ ํ๊ณ ์ ์ดํ๋ ๋ ๊ฐ์ง ์ฃผ์ ๋งค๊ฐ๋ณ์๋ `penalty_alpha`์ `top_k`์
๋๋ค:
```python
>>> from transformers import AutoTokenizer, AutoModelForCausalLM
>>> checkpoint = "openai-community/gpt2-large"
>>> tokenizer = AutoTokenizer.from_pretrained(checkpoint)
>>> model = AutoModelForCausalLM.from_pretrained(checkpoint)
>>> prompt = "Hugging Face Company is"
>>> inputs = tokenizer(prompt, return_tensors="pt")
>>> outputs = model.generate(**inputs, penalty_alpha=0.6, top_k=4, max_new_tokens=100)
>>> tokenizer.batch_decode(outputs, skip_special_tokens=True)
['Hugging Face Company is a family owned and operated business. We pride ourselves on being the best
in the business and our customer service is second to none.\n\nIf you have any questions about our
products or services, feel free to contact us at any time. We look forward to hearing from you!']
```
### ๋คํญ ์ํ๋ง(Multinomial sampling)[[multinomial-sampling]]
ํ์ ํ์(greedy search)์ด ํญ์ ๊ฐ์ฅ ๋์ ํ๋ฅ ์ ๊ฐ์ง ํ ํฐ์ ๋ค์ ํ ํฐ์ผ๋ก ์ ํํ๋ ๊ฒ๊ณผ ๋ฌ๋ฆฌ, ๋คํญ ์ํ๋ง(multinomial sampling, ์กฐ์ ์ํ๋ง(ancestral sampling)์ด๋ผ๊ณ ๋ ํจ)์ ๋ชจ๋ธ์ด ์ ๊ณตํ๋ ์ ์ฒด ์ดํ์ ๋ํ ํ๋ฅ ๋ถํฌ๋ฅผ ๊ธฐ๋ฐ์ผ๋ก ๋ค์ ํ ํฐ์ ๋ฌด์์๋ก ์ ํํฉ๋๋ค. 0์ด ์๋ ํ๋ฅ ์ ๊ฐ์ง ๋ชจ๋ ํ ํฐ์ ์ ํ๋ ๊ธฐํ๊ฐ ์์ผ๋ฏ๋ก, ๋ฐ๋ณต์ ์ํ์ ์ค์ผ ์ ์์ต๋๋ค.
๋คํญ ์ํ๋ง์ ํ์ฑํํ๋ ค๋ฉด `do_sample=True` ๋ฐ `num_beams=1`์ ์ค์ ํ์ธ์.
```python
>>> from transformers import AutoTokenizer, AutoModelForCausalLM, set_seed
>>> set_seed(0) # ์ฌํ์ฑ์ ์ํด
>>> checkpoint = "openai-community/gpt2-large"
>>> tokenizer = AutoTokenizer.from_pretrained(checkpoint)
>>> model = AutoModelForCausalLM.from_pretrained(checkpoint)
>>> prompt = "Today was an amazing day because"
>>> inputs = tokenizer(prompt, return_tensors="pt")
>>> outputs = model.generate(**inputs, do_sample=True, num_beams=1, max_new_tokens=100)
>>> tokenizer.batch_decode(outputs, skip_special_tokens=True)
['Today was an amazing day because when you go to the World Cup and you don\'t, or when you don\'t get invited,
that\'s a terrible feeling."']
```
### ๋น ํ์(Beam-search) ๋์ฝ๋ฉ[[beam-search-decoding]]
ํ์ ๊ฒ์(greedy search)๊ณผ ๋ฌ๋ฆฌ, ๋น ํ์(beam search) ๋์ฝ๋ฉ์ ๊ฐ ์๊ฐ ๋จ๊ณ์์ ์ฌ๋ฌ ๊ฐ์ค์ ์ ์งํ๊ณ ๊ฒฐ๊ตญ ์ ์ฒด ์ํ์ค์ ๋ํด ๊ฐ์ฅ ๋์ ํ๋ฅ ์ ๊ฐ์ง ๊ฐ์ค์ ์ ํํฉ๋๋ค. ์ด๋ ๋ฎ์ ํ๋ฅ ์ ์ด๊ธฐ ํ ํฐ์ผ๋ก ์์ํ๊ณ ๊ทธ๋ฆฌ๋ ๊ฒ์์์ ๋ฌด์๋์์ ๊ฐ๋ฅ์ฑ์ด ๋์ ์ํ์ค๋ฅผ ์๋ณํ๋ ์ด์ ์ด ์์ต๋๋ค.
์ด ๋์ฝ๋ฉ ์ ๋ต์ ํ์ฑํํ๋ ค๋ฉด `num_beams` (์ถ์ ํ ๊ฐ์ค ์๋ผ๊ณ ๋ ํจ)๋ฅผ 1๋ณด๋ค ํฌ๊ฒ ์ง์ ํ์ธ์.
```python
>>> from transformers import AutoModelForCausalLM, AutoTokenizer
>>> prompt = "It is astonishing how one can"
>>> checkpoint = "openai-community/gpt2-medium"
>>> tokenizer = AutoTokenizer.from_pretrained(checkpoint)
>>> inputs = tokenizer(prompt, return_tensors="pt")
>>> model = AutoModelForCausalLM.from_pretrained(checkpoint)
>>> outputs = model.generate(**inputs, num_beams=5, max_new_tokens=50)
>>> tokenizer.batch_decode(outputs, skip_special_tokens=True)
['It is astonishing how one can have such a profound impact on the lives of so many people in such a short period of
time."\n\nHe added: "I am very proud of the work I have been able to do in the last few years.\n\n"I have']
```
### ๋น ํ์ ๋คํญ ์ํ๋ง(Beam-search multinomial sampling)[[beam-search-multinomial-sampling]]
์ด ๋์ฝ๋ฉ ์ ๋ต์ ์ด๋ฆ์์ ์ ์ ์๋ฏ์ด ๋น ํ์๊ณผ ๋คํญ ์ํ๋ง์ ๊ฒฐํฉํ ๊ฒ์
๋๋ค. ์ด ๋์ฝ๋ฉ ์ ๋ต์ ์ฌ์ฉํ๊ธฐ ์ํด์๋ `num_beams`๋ฅผ 1๋ณด๋ค ํฐ ๊ฐ์ผ๋ก ์ค์ ํ๊ณ , `do_sample=True`๋ก ์ค์ ํด์ผ ํฉ๋๋ค.
```python
>>> from transformers import AutoTokenizer, AutoModelForSeq2SeqLM, set_seed
>>> set_seed(0) # ์ฌํ์ฑ์ ์ํด
>>> prompt = "translate English to German: The house is wonderful."
>>> checkpoint = "google-t5/t5-small"
>>> tokenizer = AutoTokenizer.from_pretrained(checkpoint)
>>> inputs = tokenizer(prompt, return_tensors="pt")
>>> model = AutoModelForSeq2SeqLM.from_pretrained(checkpoint)
>>> outputs = model.generate(**inputs, num_beams=5, do_sample=True)
>>> tokenizer.decode(outputs[0], skip_special_tokens=True)
'Das Haus ist wunderbar.'
```
### ๋ค์ํ ๋น ํ์ ๋์ฝ๋ฉ(Diverse beam search decoding)[[diverse-beam-search-decoding]]
๋ค์ํ ๋น ํ์(Decoding) ์ ๋ต์ ์ ํํ ์ ์๋ ๋ ๋ค์ํ ๋น ์ํ์ค ์งํฉ์ ์์ฑํ ์ ์๊ฒ ํด์ฃผ๋ ๋น ํ์ ์ ๋ต์ ํ์ฅ์
๋๋ค. ์ด ๋ฐฉ๋ฒ์ ์ด๋ป๊ฒ ์๋ํ๋์ง ์์๋ณด๋ ค๋ฉด, [๋ค์ํ ๋น ํ์: ์ ๊ฒฝ ์ํ์ค ๋ชจ๋ธ์์ ๋ค์ํ ์๋ฃจ์
๋์ฝ๋ฉํ๊ธฐ](https://arxiv.org/pdf/1610.02424.pdf)๋ฅผ ์ฐธ์กฐํ์ธ์. ์ด ์ ๊ทผ ๋ฐฉ์์ ์ธ ๊ฐ์ง ์ฃผ์ ๋งค๊ฐ๋ณ์๋ฅผ ๊ฐ์ง๊ณ ์์ต๋๋ค: `num_beams`, `num_beam_groups`, ๊ทธ๋ฆฌ๊ณ `diversity_penalty`. ๋ค์์ฑ ํจ๋ํฐ๋ ๊ทธ๋ฃน ๊ฐ์ ์ถ๋ ฅ์ด ์๋ก ๋ค๋ฅด๊ฒ ํ๊ธฐ ์ํ ๊ฒ์ด๋ฉฐ, ๊ฐ ๊ทธ๋ฃน ๋ด์์ ๋น ํ์์ด ์ฌ์ฉ๋ฉ๋๋ค.
```python
>>> from transformers import AutoTokenizer, AutoModelForSeq2SeqLM
>>> checkpoint = "google/pegasus-xsum"
>>> prompt = (
... "The Permaculture Design Principles are a set of universal design principles "
... "that can be applied to any location, climate and culture, and they allow us to design "
... "the most efficient and sustainable human habitation and food production systems. "
... "Permaculture is a design system that encompasses a wide variety of disciplines, such "
... "as ecology, landscape design, environmental science and energy conservation, and the "
... "Permaculture design principles are drawn from these various disciplines. Each individual "
... "design principle itself embodies a complete conceptual framework based on sound "
... "scientific principles. When we bring all these separate principles together, we can "
... "create a design system that both looks at whole systems, the parts that these systems "
... "consist of, and how those parts interact with each other to create a complex, dynamic, "
... "living system. Each design principle serves as a tool that allows us to integrate all "
... "the separate parts of a design, referred to as elements, into a functional, synergistic, "
... "whole system, where the elements harmoniously interact and work together in the most "
... "efficient way possible."
... )
>>> tokenizer = AutoTokenizer.from_pretrained(checkpoint)
>>> inputs = tokenizer(prompt, return_tensors="pt")
>>> model = AutoModelForSeq2SeqLM.from_pretrained(checkpoint)
>>> outputs = model.generate(**inputs, num_beams=5, num_beam_groups=5, max_new_tokens=30, diversity_penalty=1.0)
>>> tokenizer.decode(outputs[0], skip_special_tokens=True)
'The Design Principles are a set of universal design principles that can be applied to any location, climate and
culture, and they allow us to design the'
```
์ด ๊ฐ์ด๋์์๋ ๋ค์ํ ๋์ฝ๋ฉ ์ ๋ต์ ๊ฐ๋ฅํ๊ฒ ํ๋ ์ฃผ์ ๋งค๊ฐ๋ณ์๋ฅผ ๋ณด์ฌ์ค๋๋ค. [`generate`] ๋ฉ์๋์ ๋ํ ๊ณ ๊ธ ๋งค๊ฐ๋ณ์๊ฐ ์กด์ฌํ๋ฏ๋ก [`generate`] ๋ฉ์๋์ ๋์์ ๋์ฑ ์ธ๋ถ์ ์ผ๋ก ์ ์ดํ ์ ์์ต๋๋ค. ์ฌ์ฉ ๊ฐ๋ฅํ ๋งค๊ฐ๋ณ์์ ์ ์ฒด ๋ชฉ๋ก์ [API ๋ฌธ์](./main_classes/text_generation.md)๋ฅผ ์ฐธ์กฐํ์ธ์.
### ์ถ๋ก ๋์ฝ๋ฉ(Speculative Decoding)[[speculative-decoding]]
์ถ๋ก ๋์ฝ๋ฉ(๋ณด์กฐ ๋์ฝ๋ฉ(assisted decoding)์ผ๋ก๋ ์๋ ค์ง)์ ๋์ผํ ํ ํฌ๋์ด์ ๋ฅผ ์ฌ์ฉํ๋ ํจ์ฌ ์์ ๋ณด์กฐ ๋ชจ๋ธ์ ํ์ฉํ์ฌ ๋ช ๊ฐ์ง ํ๋ณด ํ ํฐ์ ์์ฑํ๋ ์์ ๋ชจ๋ธ์ ๋์ฝ๋ฉ ์ ๋ต์ ์์ ํ ๊ฒ์
๋๋ค. ์ฃผ ๋ชจ๋ธ์ ๋จ์ผ ์ ๋ฐฉ ํต๊ณผ๋ก ํ๋ณด ํ ํฐ์ ๊ฒ์ฆํจ์ผ๋ก์จ ๋์ฝ๋ฉ ๊ณผ์ ์ ๊ฐ์ํํฉ๋๋ค. `do_sample=True`์ผ ๊ฒฝ์ฐ, [์ถ๋ก ๋์ฝ๋ฉ ๋
ผ๋ฌธ](https://arxiv.org/pdf/2211.17192.pdf)์ ์๊ฐ๋ ํ ํฐ ๊ฒ์ฆ๊ณผ ์ฌ์ํ๋ง ๋ฐฉ์์ด ์ฌ์ฉ๋ฉ๋๋ค.
ํ์ฌ, ํ์ ๊ฒ์(greedy search)๊ณผ ์ํ๋ง๋ง์ด ์ง์๋๋ ๋ณด์กฐ ๋์ฝ๋ฉ(assisted decoding) ๊ธฐ๋ฅ์ ํตํด, ๋ณด์กฐ ๋์ฝ๋ฉ์ ๋ฐฐ์น ์
๋ ฅ์ ์ง์ํ์ง ์์ต๋๋ค. ๋ณด์กฐ ๋์ฝ๋ฉ์ ๋ํด ๋ ์๊ณ ์ถ๋ค๋ฉด, [์ด ๋ธ๋ก๊ทธ ํฌ์คํธ](https://huggingface.co/blog/assisted-generation)๋ฅผ ํ์ธํด ์ฃผ์ธ์.
๋ณด์กฐ ๋์ฝ๋ฉ์ ํ์ฑํํ๋ ค๋ฉด ๋ชจ๋ธ๊ณผ ํจ๊ป `assistant_model` ์ธ์๋ฅผ ์ค์ ํ์ธ์.
```python
>>> from transformers import AutoModelForCausalLM, AutoTokenizer
>>> prompt = "Alice and Bob"
>>> checkpoint = "EleutherAI/pythia-1.4b-deduped"
>>> assistant_checkpoint = "EleutherAI/pythia-160m-deduped"
>>> tokenizer = AutoTokenizer.from_pretrained(checkpoint)
>>> inputs = tokenizer(prompt, return_tensors="pt")
>>> model = AutoModelForCausalLM.from_pretrained(checkpoint)
>>> assistant_model = AutoModelForCausalLM.from_pretrained(assistant_checkpoint)
>>> outputs = model.generate(**inputs, assistant_model=assistant_model)
>>> tokenizer.batch_decode(outputs, skip_special_tokens=True)
['Alice and Bob are sitting in a bar. Alice is drinking a beer and Bob is drinking a']
```
์ํ๋ง ๋ฐฉ๋ฒ๊ณผ ํจ๊ป ๋ณด์กฐ ๋์ฝ๋ฉ์ ์ฌ์ฉํ๋ ๊ฒฝ์ฐ ๋คํญ ์ํ๋ง๊ณผ ๋ง์ฐฌ๊ฐ์ง๋ก `temperature` ์ธ์๋ฅผ ์ฌ์ฉํ์ฌ ๋ฌด์์์ฑ์ ์ ์ดํ ์ ์์ต๋๋ค. ๊ทธ๋ฌ๋ ๋ณด์กฐ ๋์ฝ๋ฉ์์๋ `temperature`๋ฅผ ๋ฎ์ถ๋ฉด ๋๊ธฐ ์๊ฐ์ ๊ฐ์ ํ๋ ๋ฐ ๋์์ด ๋ ์ ์์ต๋๋ค.
```python
>>> from transformers import AutoModelForCausalLM, AutoTokenizer, set_seed
>>> set_seed(42) # ์ฌํ์ฑ์ ์ํด
>>> prompt = "Alice and Bob"
>>> checkpoint = "EleutherAI/pythia-1.4b-deduped"
>>> assistant_checkpoint = "EleutherAI/pythia-160m-deduped"
>>> tokenizer = AutoTokenizer.from_pretrained(checkpoint)
>>> inputs = tokenizer(prompt, return_tensors="pt")
>>> model = AutoModelForCausalLM.from_pretrained(checkpoint)
>>> assistant_model = AutoModelForCausalLM.from_pretrained(assistant_checkpoint)
>>> outputs = model.generate(**inputs, assistant_model=assistant_model, do_sample=True, temperature=0.5)
>>> tokenizer.batch_decode(outputs, skip_special_tokens=True)
['Alice and Bob are going to the same party. It is a small party, in a small']
```
| 0 |
mavonic_private_repos/transformers/docs/source | mavonic_private_repos/transformers/docs/source/ko/pipeline_tutorial.md | <!--Copyright 2022 The HuggingFace Team. All rights reserved.
Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
the License. You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
specific language governing permissions and limitations under the License.
โ ๏ธ Note that this file is in Markdown but contain specific syntax for our doc-builder (similar to MDX) that may not be
rendered properly in your Markdown viewer.
-->
# ์ถ๋ก ์ ์ํ Pipeline[[pipelines-for-inference]]
[`pipeline`]์ ์ฌ์ฉํ๋ฉด ์ธ์ด, ์ปดํจํฐ ๋น์ , ์ค๋์ค ๋ฐ ๋ฉํฐ๋ชจ๋ฌ ํ์คํฌ์ ๋ํ ์ถ๋ก ์ ์ํด [Hub](https://huggingface.co/models)์ ์ด๋ค ๋ชจ๋ธ์ด๋ ์ฝ๊ฒ ์ฌ์ฉํ ์ ์์ต๋๋ค. ํน์ ๋ถ์ผ์ ๋ํ ๊ฒฝํ์ด ์๊ฑฐ๋, ๋ชจ๋ธ์ ์ด๋ฃจ๋ ์ฝ๋๊ฐ ์ต์ํ์ง ์์ ๊ฒฝ์ฐ์๋ [`pipeline`]์ ์ฌ์ฉํด์ ์ถ๋ก ํ ์ ์์ด์! ์ด ํํ ๋ฆฌ์ผ์์๋ ๋ค์์ ๋ฐฐ์๋ณด๊ฒ ์ต๋๋ค.
* ์ถ๋ก ์ ์ํด [`pipeline`]์ ์ฌ์ฉํ๋ ๋ฐฉ๋ฒ
* ํน์ ํ ํฌ๋์ด์ ๋๋ ๋ชจ๋ธ์ ์ฌ์ฉํ๋ ๋ฐฉ๋ฒ
* ์ธ์ด, ์ปดํจํฐ ๋น์ , ์ค๋์ค ๋ฐ ๋ฉํฐ๋ชจ๋ฌ ํ์คํฌ์์ [`pipeline`]์ ์ฌ์ฉํ๋ ๋ฐฉ๋ฒ
<Tip>
์ง์ํ๋ ๋ชจ๋ ํ์คํฌ์ ์ธ ์ ์๋ ๋งค๊ฐ๋ณ์๋ฅผ ๋ด์ ๋ชฉ๋ก์ [`pipeline`] ์ค๋ช
์๋ฅผ ์ฐธ๊ณ ํด์ฃผ์ธ์.
</Tip>
## Pipeline ์ฌ์ฉํ๊ธฐ[[pipeline-usage]]
๊ฐ ํ์คํฌ๋ง๋ค ๊ณ ์ ์ [`pipeline`]์ด ์์ง๋ง, ๊ฐ๋ณ ํ์ดํ๋ผ์ธ์ ๋ด๊ณ ์๋ ์ถ์ํ๋ [`pipeline`]๋ฅผ ์ฌ์ฉํ๋ ๊ฒ์ด ์ผ๋ฐ์ ์ผ๋ก ๋ ๊ฐ๋จํฉ๋๋ค. [`pipeline`]์ ํ์คํฌ์ ์๋ง๊ฒ ์ถ๋ก ์ด ๊ฐ๋ฅํ ๊ธฐ๋ณธ ๋ชจ๋ธ๊ณผ ์ ์ฒ๋ฆฌ ํด๋์ค๋ฅผ ์๋์ผ๋ก ๋ก๋ํฉ๋๋ค.
1. ๋จผ์ [`pipeline`]์ ์์ฑํ๊ณ ํ์คํฌ๋ฅผ ์ง์ ํ์ธ์.
```py
>>> from transformers import pipeline
>>> generator = pipeline(task="automatic-speech-recognition")
```
2. ๊ทธ๋ฆฌ๊ณ [`pipeline`]์ ์
๋ ฅ์ ๋ฃ์ด์ฃผ์ธ์.
```py
>>> generator("https://huggingface.co/datasets/Narsil/asr_dummy/resolve/main/mlk.flac")
{'text': 'I HAVE A DREAM BUT ONE DAY THIS NATION WILL RISE UP LIVE UP THE TRUE MEANING OF ITS TREES'}
```
๊ธฐ๋ํ๋ ๊ฒฐ๊ณผ๊ฐ ์๋๊ฐ์? Hub์์ [๊ฐ์ฅ ๋ง์ด ๋ค์ด๋ก๋๋ ์๋ ์์ฑ ์ธ์ ๋ชจ๋ธ](https://huggingface.co/models?pipeline_tag=automatic-speech-recognition&sort=downloads)๋ก ๋ ๋์ ๊ฒฐ๊ณผ๋ฅผ ์ป์ ์ ์๋์ง ํ์ธํด๋ณด์ธ์.
๋ค์์ [openai/whisper-large](https://huggingface.co/openai/whisper-large)๋ก ์๋ํด๋ณด๊ฒ ์ต๋๋ค.
```py
>>> generator = pipeline(model="openai/whisper-large")
>>> generator("https://huggingface.co/datasets/Narsil/asr_dummy/resolve/main/mlk.flac")
{'text': ' I have a dream that one day this nation will rise up and live out the true meaning of its creed.'}
```
ํจ์ฌ ๋ ๋์์ก๊ตฐ์!
Hub์ ๋ชจ๋ธ๋ค์ ์ฌ๋ฌ ๋ค์ํ ์ธ์ด์ ์ ๋ฌธ๋ถ์ผ๋ฅผ ์์ฐ๋ฅด๊ธฐ ๋๋ฌธ์ ๊ผญ ์์ ์ ์ธ์ด๋ ๋ถ์ผ์ ํนํ๋ ๋ชจ๋ธ์ ์ฐพ์๋ณด์๊ธฐ ๋ฐ๋๋๋ค.
๋ธ๋ผ์ฐ์ ๋ฅผ ๋ฒ์ด๋ ํ์์์ด Hub์์ ์ง์ ๋ชจ๋ธ์ ์ถ๋ ฅ์ ํ์ธํ๊ณ ๋ค๋ฅธ ๋ชจ๋ธ๊ณผ ๋น๊ตํด์ ์์ ์ ์ํฉ์ ๋ ์ ํฉํ์ง, ์ ๋งคํ ์
๋ ฅ์ ๋ ์ ์ฒ๋ฆฌํ๋์ง๋ ํ์ธํ ์ ์์ต๋๋ค.
๋ง์ฝ ์ํฉ์ ์๋ง๋ ๋ชจ๋ธ์ ์๋ค๋ฉด ์ธ์ ๋ ์ง์ [ํ๋ จ](training)์ํฌ ์ ์์ต๋๋ค!
์
๋ ฅ์ด ์ฌ๋ฌ ๊ฐ ์๋ ๊ฒฝ์ฐ, ๋ฆฌ์คํธ ํํ๋ก ์ ๋ฌํ ์ ์์ต๋๋ค.
```py
generator(
[
"https://huggingface.co/datasets/Narsil/asr_dummy/resolve/main/mlk.flac",
"https://huggingface.co/datasets/Narsil/asr_dummy/resolve/main/1.flac",
]
)
```
์ ์ฒด ๋ฐ์ดํฐ์ธํธ์ ์ํํ๊ฑฐ๋ ์น์๋ฒ์ ์ฌ๋ ค๋์ด ์ถ๋ก ์ ์ฌ์ฉํ๊ณ ์ถ๋ค๋ฉด, ๊ฐ ์์ธ ํ์ด์ง๋ฅผ ์ฐธ์กฐํ์ธ์.
[๋ฐ์ดํฐ์ธํธ์์ Pipeline ์ฌ์ฉํ๊ธฐ](#using-pipelines-on-a-dataset)
[์น์๋ฒ์์ Pipeline ์ฌ์ฉํ๊ธฐ](./pipeline_webserver)
## ๋งค๊ฐ๋ณ์[[parameters]]
[`pipeline`]์ ๋ง์ ๋งค๊ฐ๋ณ์๋ฅผ ์ง์ํฉ๋๋ค. ํน์ ํ์คํฌ์ฉ์ธ ๊ฒ๋ ์๊ณ , ๋ฒ์ฉ์ธ ๊ฒ๋ ์์ต๋๋ค.
์ผ๋ฐ์ ์ผ๋ก ์ํ๋ ์์น์ ์ด๋๋ ๋งค๊ฐ๋ณ์๋ฅผ ๋ฃ์ ์ ์์ต๋๋ค.
```py
generator(model="openai/whisper-large", my_parameter=1)
out = generate(...) # This will use `my_parameter=1`.
out = generate(..., my_parameter=2) # This will override and use `my_parameter=2`.
out = generate(...) # This will go back to using `my_parameter=1`.
```
์ค์ํ 3๊ฐ์ง ๋งค๊ฐ๋ณ์๋ฅผ ์ดํด๋ณด๊ฒ ์ต๋๋ค.
### ๊ธฐ๊ธฐ(device)[[device]]
`device=n`์ฒ๋ผ ๊ธฐ๊ธฐ๋ฅผ ์ง์ ํ๋ฉด ํ์ดํ๋ผ์ธ์ด ์๋์ผ๋ก ํด๋น ๊ธฐ๊ธฐ์ ๋ชจ๋ธ์ ๋ฐฐ์นํฉ๋๋ค.
ํ์ดํ ์น์์๋ ํ
์ํ๋ก์ฐ์์๋ ๋ชจ๋ ์๋ํฉ๋๋ค.
```py
generator(model="openai/whisper-large", device=0)
```
๋ชจ๋ธ์ด GPU ํ๋์ ๋์๊ฐ๊ธฐ ๋ฒ๊ฒ๋ค๋ฉด, `device_map="auto"`๋ฅผ ์ง์ ํด์ ๐ค [Accelerate](https://huggingface.co/docs/accelerate)๊ฐ ๋ชจ๋ธ ๊ฐ์ค์น๋ฅผ ์ด๋ป๊ฒ ๋ก๋ํ๊ณ ์ ์ฅํ ์ง ์๋์ผ๋ก ๊ฒฐ์ ํ๋๋ก ํ ์ ์์ต๋๋ค.
```py
#!pip install accelerate
generator(model="openai/whisper-large", device_map="auto")
```
### ๋ฐฐ์น ์ฌ์ด์ฆ[[batch-size]]
๊ธฐ๋ณธ์ ์ผ๋ก ํ์ดํ๋ผ์ธ์ [์ฌ๊ธฐ](https://huggingface.co/docs/transformers/main_classes/pipelines#pipeline-batching)์ ๋์จ ์ด์ ๋ก ์ถ๋ก ์ ์ผ๊ด ์ฒ๋ฆฌํ์ง ์์ต๋๋ค. ๊ฐ๋จํ ์ค๋ช
ํ์๋ฉด ์ผ๊ด ์ฒ๋ฆฌ๊ฐ ๋ฐ๋์ ๋ ๋น ๋ฅด์ง ์๊ณ ์คํ๋ ค ๋ ๋๋ ค์ง ์๋ ์๊ธฐ ๋๋ฌธ์
๋๋ค.
ํ์ง๋ง ์์ ์ ์ํฉ์ ์ ํฉํ๋ค๋ฉด, ์ด๋ ๊ฒ ์ฌ์ฉํ์ธ์.
```py
generator(model="openai/whisper-large", device=0, batch_size=2)
audio_filenames = [f"audio_{i}.flac" for i in range(10)]
texts = generator(audio_filenames)
```
ํ์ดํ๋ผ์ธ ์ ์ ๊ณต๋ 10๊ฐ์ ์ค๋์ค ํ์ผ์ ์ถ๊ฐ๋ก ์ฒ๋ฆฌํ๋ ์ฝ๋ ์์ด (์ผ๊ด ์ฒ๋ฆฌ์ ๋ณด๋ค ํจ๊ณผ์ ์ธ GPU ์) ๋ชจ๋ธ์ 2๊ฐ์ฉ ์ ๋ฌํฉ๋๋ค.
์ถ๋ ฅ์ ์ผ๊ด ์ฒ๋ฆฌํ์ง ์์์ ๋์ ๋๊ฐ์์ผ ํฉ๋๋ค. ํ์ดํ๋ผ์ธ์์ ์๋๋ฅผ ๋ ๋ผ ์๋ ์๋ ๋ฐฉ๋ฒ ์ค ํ๋์ผ ๋ฟ์
๋๋ค.
ํ์ดํ๋ผ์ธ์ ์ผ๊ด ์ฒ๋ฆฌ์ ๋ณต์กํ ๋ถ๋ถ์ ์ค์ฌ์ฃผ๊ธฐ๋ ํฉ๋๋ค. (์๋ฅผ ๋ค์ด ๊ธด ์ค๋์ค ํ์ผ์ฒ๋ผ) ์ฌ๋ฌ ๋ถ๋ถ์ผ๋ก ๋๋ ์ผ ๋ชจ๋ธ์ด ์ฒ๋ฆฌํ ์ ์๋ ๊ฒ์ [*chunk batching*](./main_classes/pipelines#pipeline-chunk-batching)์ด๋ผ๊ณ ํ๋๋ฐ, ํ์ดํ๋ผ์ธ์ ์ฌ์ฉํ๋ฉด ์๋์ผ๋ก ๋๋ ์ค๋๋ค.
### ํน์ ํ์คํฌ์ฉ ๋งค๊ฐ๋ณ์[[task-specific-parameters]]
๊ฐ ํ์คํฌ๋ง๋ค ๊ตฌํํ ๋ ์ ์ฐ์ฑ๊ณผ ์ต์
์ ์ ๊ณตํ๊ธฐ ์ํด ํ์คํฌ์ฉ ๋งค๊ฐ๋ณ์๊ฐ ์์ต๋๋ค.
์๋ฅผ ๋ค์ด [`transformers.AutomaticSpeechRecognitionPipeline.__call__`] ๋ฉ์๋์๋ ๋์์์ ์๋ง์ ๋ฃ์ ๋ ์ ์ฉํ ๊ฒ ๊ฐ์ `return_timestamps` ๋งค๊ฐ๋ณ์๊ฐ ์์ต๋๋ค.
```py
>>> # Not using whisper, as it cannot provide timestamps.
>>> generator = pipeline(model="facebook/wav2vec2-large-960h-lv60-self", return_timestamps="word")
>>> generator("https://huggingface.co/datasets/Narsil/asr_dummy/resolve/main/mlk.flac")
{'text': 'I HAVE A DREAM BUT ONE DAY THIS NATION WILL RISE UP AND LIVE OUT THE TRUE MEANING OF ITS CREED', 'chunks': [{'text': 'I', 'timestamp': (1.22, 1.24)}, {'text': 'HAVE', 'timestamp': (1.42, 1.58)}, {'text': 'A', 'timestamp': (1.66, 1.68)}, {'text': 'DREAM', 'timestamp': (1.76, 2.14)}, {'text': 'BUT', 'timestamp': (3.68, 3.8)}, {'text': 'ONE', 'timestamp': (3.94, 4.06)}, {'text': 'DAY', 'timestamp': (4.16, 4.3)}, {'text': 'THIS', 'timestamp': (6.36, 6.54)}, {'text': 'NATION', 'timestamp': (6.68, 7.1)}, {'text': 'WILL', 'timestamp': (7.32, 7.56)}, {'text': 'RISE', 'timestamp': (7.8, 8.26)}, {'text': 'UP', 'timestamp': (8.38, 8.48)}, {'text': 'AND', 'timestamp': (10.08, 10.18)}, {'text': 'LIVE', 'timestamp': (10.26, 10.48)}, {'text': 'OUT', 'timestamp': (10.58, 10.7)}, {'text': 'THE', 'timestamp': (10.82, 10.9)}, {'text': 'TRUE', 'timestamp': (10.98, 11.18)}, {'text': 'MEANING', 'timestamp': (11.26, 11.58)}, {'text': 'OF', 'timestamp': (11.66, 11.7)}, {'text': 'ITS', 'timestamp': (11.76, 11.88)}, {'text': 'CREED', 'timestamp': (12.0, 12.38)}]}
```
๋ณด์๋ค์ํผ ๋ชจ๋ธ์ด ํ
์คํธ๋ฅผ ์ถ๋ก ํ ๋ฟ๋ง ์๋๋ผ ๊ฐ ๋จ์ด๋ฅผ ๋งํ ์์ ๊น์ง๋ ์ถ๋ ฅํ์ต๋๋ค.
ํ์คํฌ๋ง๋ค ๋ค์ํ ๋งค๊ฐ๋ณ์๋ฅผ ๊ฐ์ง๊ณ ์๋๋ฐ์. ์ํ๋ ํ์คํฌ์ API๋ฅผ ์ฐธ์กฐํด์ ๋ฐ๊ฟ๋ณผ ์ ์๋ ์ฌ๋ฌ ๋งค๊ฐ๋ณ์๋ฅผ ์ดํด๋ณด์ธ์!
์ง๊ธ๊น์ง ๋ค๋ค๋ณธ [`~transformers.AutomaticSpeechRecognitionPipeline`]์๋ `chunk_length_s` ๋งค๊ฐ๋ณ์๊ฐ ์์ต๋๋ค. ์ํ๋ 1์๊ฐ ๋ถ๋์ ๋์์์ ์๋ง ์์
์ ํ ๋์ฒ๋ผ, ์ผ๋ฐ์ ์ผ๋ก ๋ชจ๋ธ์ด ์์ฒด์ ์ผ๋ก ์ฒ๋ฆฌํ ์ ์๋ ๋งค์ฐ ๊ธด ์ค๋์ค ํ์ผ์ ์ฒ๋ฆฌํ ๋ ์ ์ฉํ์ฃ .
๋์์ด ๋ ๋งํ ๋งค๊ฐ๋ณ์๋ฅผ ์ฐพ์ง ๋ชปํ๋ค๋ฉด ์ธ์ ๋ ์ง [์์ฒญ](https://github.com/huggingface/transformers/issues/new?assignees=&labels=feature&template=feature-request.yml)ํด์ฃผ์ธ์!
## ๋ฐ์ดํฐ์ธํธ์์ Pipeline ์ฌ์ฉํ๊ธฐ[[using-pipelines-on-a-dataset]]
ํ์ดํ๋ผ์ธ์ ๋๊ท๋ชจ ๋ฐ์ดํฐ์ธํธ์์๋ ์ถ๋ก ์์
์ ํ ์ ์์ต๋๋ค. ์ด๋ ์ดํฐ๋ ์ดํฐ๋ฅผ ์ฌ์ฉํ๋ ๊ฑธ ์ถ์ฒ๋๋ฆฝ๋๋ค.
```py
def data():
for i in range(1000):
yield f"My example {i}"
pipe = pipe(model="openai-community/gpt2", device=0)
generated_characters = 0
for out in pipe(data()):
generated_characters += len(out["generated_text"])
```
์ดํฐ๋ ์ดํฐ `data()`๋ ๊ฐ ๊ฒฐ๊ณผ๋ฅผ ํธ์ถ๋ง๋ค ์์ฑํ๊ณ , ํ์ดํ๋ผ์ธ์ ์
๋ ฅ์ด ์ํํ ์ ์๋ ์๋ฃ๊ตฌ์กฐ์์ ์๋์ผ๋ก ์ธ์ํ์ฌ GPU์์ ๊ธฐ์กด ๋ฐ์ดํฐ๊ฐ ์ฒ๋ฆฌ๋๋ ๋์ ์๋ก์ด ๋ฐ์ดํฐ๋ฅผ ๊ฐ์ ธ์ค๊ธฐ ์์ํฉ๋๋ค.(์ด๋ ๋ด๋ถ์ ์ผ๋ก [DataLoader](https://pytorch.org/docs/stable/data.html#torch.utils.data.DataLoader)๋ฅผ ์ฌ์ฉํด์.) ์ด ๊ณผ์ ์ ์ ์ฒด ๋ฐ์ดํฐ์ธํธ๋ฅผ ๋ฉ๋ชจ๋ฆฌ์ ์ ์ฌํ์ง ์๊ณ ๋ GPU์ ์ต๋ํ ๋น ๋ฅด๊ฒ ์๋ก์ด ์์
์ ๊ณต๊ธํ ์ ์๊ธฐ ๋๋ฌธ์ ์ค์ํฉ๋๋ค.
๊ทธ๋ฆฌ๊ณ ์ผ๊ด ์ฒ๋ฆฌ๊ฐ ๋ ๋น ๋ฅผ ์ ์๊ธฐ ๋๋ฌธ์, `batch_size` ๋งค๊ฐ๋ณ์๋ฅผ ์กฐ์ ํด๋ด๋ ์ข์์.
๋ฐ์ดํฐ์ธํธ๋ฅผ ์ํํ๋ ๊ฐ์ฅ ๊ฐ๋จํ ๋ฐฉ๋ฒ์ ๐ค [Datasets](https://github.com/huggingface/datasets/)๋ฅผ ํ์ฉํ๋ ๊ฒ์ธ๋ฐ์.
```py
# KeyDataset is a util that will just output the item we're interested in.
from transformers.pipelines.pt_utils import KeyDataset
pipe = pipeline(model="hf-internal-testing/tiny-random-wav2vec2", device=0)
dataset = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation[:10]")
for out in pipe(KeyDataset(dataset["audio"])):
print(out)
```
## ์น์๋ฒ์์ Pipeline ์ฌ์ฉํ๊ธฐ[[using-pipelines-for-a-webserver]]
<Tip>
์ถ๋ก ์์ง์ ๋ง๋๋ ๊ณผ์ ์ ๋ฐ๋ก ํ์ด์ง๋ฅผ ์์ฑํ ๋งํ ๋ณต์กํ ์ฃผ์ ์
๋๋ค.
</Tip>
[Link](./pipeline_webserver)
## ๋น์ Pipeline[[vision-pipeline]]
๋น์ ํ์คํฌ๋ฅผ ์ํด [`pipeline`]์ ์ฌ์ฉํ๋ ์ผ์ ๊ฑฐ์ ๋์ผํฉ๋๋ค.
ํ์คํฌ๋ฅผ ์ง์ ํ๊ณ ์ด๋ฏธ์ง๋ฅผ ๋ถ๋ฅ๊ธฐ์ ์ ๋ฌํ๋ฉด ๋ฉ๋๋ค. ์ด๋ฏธ์ง๋ ์ธํฐ๋ท ๋งํฌ ๋๋ ๋ก์ปฌ ๊ฒฝ๋ก์ ํํ๋ก ์ ๋ฌํด์ฃผ์ธ์. ์๋ฅผ ๋ค์ด ์๋์ ํ์๋ ๊ณ ์์ด๋ ์ด๋ค ์ข
์ธ๊ฐ์?
```py
>>> from transformers import pipeline
>>> vision_classifier = pipeline(model="google/vit-base-patch16-224")
>>> preds = vision_classifier(
... images="https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/pipeline-cat-chonk.jpeg"
... )
>>> preds = [{"score": round(pred["score"], 4), "label": pred["label"]} for pred in preds]
>>> preds
[{'score': 0.4335, 'label': 'lynx, catamount'}, {'score': 0.0348, 'label': 'cougar, puma, catamount, mountain lion, painter, panther, Felis concolor'}, {'score': 0.0324, 'label': 'snow leopard, ounce, Panthera uncia'}, {'score': 0.0239, 'label': 'Egyptian cat'}, {'score': 0.0229, 'label': 'tiger cat'}]
```
### ํ
์คํธ Pipeline[[text-pipeline]]
NLP ํ์คํฌ๋ฅผ ์ํด [`pipeline`]์ ์ฌ์ฉํ๋ ์ผ๋ ๊ฑฐ์ ๋์ผํฉ๋๋ค.
```py
>>> from transformers import pipeline
>>> # This model is a `zero-shot-classification` model.
>>> # It will classify text, except you are free to choose any label you might imagine
>>> classifier = pipeline(model="facebook/bart-large-mnli")
>>> classifier(
... "I have a problem with my iphone that needs to be resolved asap!!",
... candidate_labels=["urgent", "not urgent", "phone", "tablet", "computer"],
... )
{'sequence': 'I have a problem with my iphone that needs to be resolved asap!!', 'labels': ['urgent', 'phone', 'computer', 'not urgent', 'tablet'], 'scores': [0.504, 0.479, 0.013, 0.003, 0.002]}
```
### ๋ฉํฐ๋ชจ๋ฌ Pipeline[[multimodal-pipeline]]
[`pipeline`]์ ์ฌ๋ฌ ๋ชจ๋ฌ๋ฆฌํฐ(์ญ์ฃผ: ์ค๋์ค, ๋น๋์ค, ํ
์คํธ์ ๊ฐ์ ๋ฐ์ดํฐ ํํ)๋ฅผ ์ง์ํฉ๋๋ค. ์์๋ก ์๊ฐ์ ์ง์์๋ต(VQA; Visual Question Answering) ํ์คํฌ๋ ํ
์คํธ์ ์ด๋ฏธ์ง๋ฅผ ๋ชจ๋ ์ฌ์ฉํฉ๋๋ค. ๊ทธ ์ด๋ค ์ด๋ฏธ์ง ๋งํฌ๋ ๋ฌป๊ณ ์ถ์ ์ง๋ฌธ๋ ์์ ๋กญ๊ฒ ์ ๋ฌํ ์ ์์ต๋๋ค. ์ด๋ฏธ์ง๋ URL ๋๋ ๋ก์ปฌ ๊ฒฝ๋ก์ ํํ๋ก ์ ๋ฌํด์ฃผ์ธ์.
์๋ฅผ ๋ค์ด ์ด [๊ฑฐ๋๋ช
์ธ์ ์ฌ์ง](https://huggingface.co/spaces/impira/docquery/resolve/2359223c1837a7587402bda0f2643382a6eefeab/invoice.png)์์ ๊ฑฐ๋๋ช
์ธ์ ๋ฒํธ๋ฅผ ๋ฌป๊ณ ์ถ๋ค๋ฉด,
```py
>>> from transformers import pipeline
>>> vqa = pipeline(model="impira/layoutlm-document-qa")
>>> vqa(
... image="https://huggingface.co/spaces/impira/docquery/resolve/2359223c1837a7587402bda0f2643382a6eefeab/invoice.png",
... question="What is the invoice number?",
... )
[{'score': 0.42514941096305847, 'answer': 'us-001', 'start': 16, 'end': 16}]
```
| 0 |
mavonic_private_repos/transformers/docs/source | mavonic_private_repos/transformers/docs/source/ko/add_new_pipeline.md | <!--Copyright 2020 The HuggingFace Team. All rights reserved.
Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
the License. You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
โ ๏ธ Note that this file is in Markdown but contain specific syntax for our doc-builder (similar to MDX) that may not be
rendered properly in your Markdown viewer.
-->
# ์ด๋ป๊ฒ ์ฌ์ฉ์ ์ ์ ํ์ดํ๋ผ์ธ์ ์์ฑํ๋์? [[how-to-create-a-custom-pipeline]]
์ด ๊ฐ์ด๋์์๋ ์ฌ์ฉ์ ์ ์ ํ์ดํ๋ผ์ธ์ ์ด๋ป๊ฒ ์์ฑํ๊ณ [ํ๋ธ](https://hf.co/models)์ ๊ณต์ ํ๊ฑฐ๋ ๐ค Transformers ๋ผ์ด๋ธ๋ฌ๋ฆฌ์ ์ถ๊ฐํ๋ ๋ฐฉ๋ฒ์ ์ดํด๋ณด๊ฒ ์ต๋๋ค.
๋จผ์ ํ์ดํ๋ผ์ธ์ด ์์ฉํ ์ ์๋ ์์ ์
๋ ฅ์ ๊ฒฐ์ ํด์ผ ํฉ๋๋ค.
๋ฌธ์์ด, ์์ ๋ฐ์ดํธ, ๋์
๋๋ฆฌ ๋๋ ๊ฐ์ฅ ์ํ๋ ์
๋ ฅ์ผ ๊ฐ๋ฅ์ฑ์ด ๋์ ๊ฒ์ด๋ฉด ๋ฌด์์ด๋ ๊ฐ๋ฅํฉ๋๋ค.
์ด ์
๋ ฅ์ ๊ฐ๋ฅํ ํ ์์ํ Python ํ์์ผ๋ก ์ ์งํด์ผ (JSON์ ํตํด ๋ค๋ฅธ ์ธ์ด์๋) ํธํ์ฑ์ด ์ข์์ง๋๋ค.
์ด๊ฒ์ด ์ ์ฒ๋ฆฌ(`preprocess`) ํ์ดํ๋ผ์ธ์ ์
๋ ฅ(`inputs`)์ด ๋ ๊ฒ์
๋๋ค.
๊ทธ๋ฐ ๋ค์ `outputs`๋ฅผ ์ ์ํ์ธ์.
`inputs`์ ๊ฐ์ ์ ์ฑ
์ ๋ฐ๋ฅด๊ณ , ๊ฐ๋จํ ์๋ก ์ข์ต๋๋ค.
์ด๊ฒ์ด ํ์ฒ๋ฆฌ(`postprocess`) ๋ฉ์๋์ ์ถ๋ ฅ์ด ๋ ๊ฒ์
๋๋ค.
๋จผ์ 4๊ฐ์ ๋ฉ์๋(`preprocess`, `_forward`, `postprocess` ๋ฐ `_sanitize_parameters`)๋ฅผ ๊ตฌํํ๊ธฐ ์ํด ๊ธฐ๋ณธ ํด๋์ค `Pipeline`์ ์์ํ์ฌ ์์ํฉ๋๋ค.
```python
from transformers import Pipeline
class MyPipeline(Pipeline):
def _sanitize_parameters(self, **kwargs):
preprocess_kwargs = {}
if "maybe_arg" in kwargs:
preprocess_kwargs["maybe_arg"] = kwargs["maybe_arg"]
return preprocess_kwargs, {}, {}
def preprocess(self, inputs, maybe_arg=2):
model_input = Tensor(inputs["input_ids"])
return {"model_input": model_input}
def _forward(self, model_inputs):
# model_inputs == {"model_input": model_input}
outputs = self.model(**model_inputs)
# Maybe {"logits": Tensor(...)}
return outputs
def postprocess(self, model_outputs):
best_class = model_outputs["logits"].softmax(-1)
return best_class
```
์ด ๋ถํ ๊ตฌ์กฐ๋ CPU/GPU์ ๋ํ ๋น๊ต์ ์ํํ ์ง์์ ์ ๊ณตํ๋ ๋์์, ๋ค๋ฅธ ์ค๋ ๋์์ CPU์ ๋ํ ์ฌ์ /์ฌํ ์ฒ๋ฆฌ๋ฅผ ์ํํ ์ ์๊ฒ ์ง์ํ๋ ๊ฒ์
๋๋ค.
`preprocess`๋ ์๋ ์ ์๋ ์
๋ ฅ์ ๊ฐ์ ธ์ ๋ชจ๋ธ์ ๊ณต๊ธํ ์ ์๋ ํ์์ผ๋ก ๋ณํํฉ๋๋ค.
๋ ๋ง์ ์ ๋ณด๋ฅผ ํฌํจํ ์ ์์ผ๋ฉฐ ์ผ๋ฐ์ ์ผ๋ก `Dict` ํํ์
๋๋ค.
`_forward`๋ ๊ตฌํ ์ธ๋ถ ์ฌํญ์ด๋ฉฐ ์ง์ ํธ์ถํ ์ ์์ต๋๋ค.
`forward`๋ ์์ ์ฅ์น์์ ๋ชจ๋ ๊ฒ์ด ์๋ํ๋์ง ํ์ธํ๊ธฐ ์ํ ์์ ์ฅ์น๊ฐ ํฌํจ๋์ด ์์ด ์ ํธ๋๋ ํธ์ถ ๋ฉ์๋์
๋๋ค.
์ค์ ๋ชจ๋ธ๊ณผ ๊ด๋ จ๋ ๊ฒ์ `_forward` ๋ฉ์๋์ ์ํ๋ฉฐ, ๋๋จธ์ง๋ ์ ์ฒ๋ฆฌ/ํ์ฒ๋ฆฌ ๊ณผ์ ์ ์์ต๋๋ค.
`postprocess` ๋ฉ์๋๋ `_forward`์ ์ถ๋ ฅ์ ๊ฐ์ ธ์ ์ด์ ์ ๊ฒฐ์ ํ ์ต์ข
์ถ๋ ฅ ํ์์ผ๋ก ๋ณํํฉ๋๋ค.
`_sanitize_parameters`๋ ์ด๊ธฐํ ์๊ฐ์ `pipeline(...., maybe_arg=4)`์ด๋ ํธ์ถ ์๊ฐ์ `pipe = pipeline(...); output = pipe(...., maybe_arg=4)`๊ณผ ๊ฐ์ด, ์ฌ์ฉ์๊ฐ ์ํ๋ ๊ฒฝ์ฐ ์ธ์ ๋ ์ง ๋งค๊ฐ๋ณ์๋ฅผ ์ ๋ฌํ ์ ์๋๋ก ํ์ฉํฉ๋๋ค.
`_sanitize_parameters`์ ๋ฐํ ๊ฐ์ `preprocess`, `_forward`, `postprocess`์ ์ง์ ์ ๋ฌ๋๋ 3๊ฐ์ kwargs ๋์
๋๋ฆฌ์
๋๋ค.
ํธ์ถ์๊ฐ ์ถ๊ฐ ๋งค๊ฐ๋ณ์๋ก ํธ์ถํ์ง ์์๋ค๋ฉด ์๋ฌด๊ฒ๋ ์ฑ์ฐ์ง ๋ง์ญ์์ค.
์ด๋ ๊ฒ ํ๋ฉด ํญ์ ๋ "์์ฐ์ค๋ฌ์ด" ํจ์ ์ ์์ ๊ธฐ๋ณธ ์ธ์๋ฅผ ์ ์งํ ์ ์์ต๋๋ค.
๋ถ๋ฅ ์์
์์ `top_k` ๋งค๊ฐ๋ณ์๊ฐ ๋ํ์ ์ธ ์์
๋๋ค.
```python
>>> pipe = pipeline("my-new-task")
>>> pipe("This is a test")
[{"label": "1-star", "score": 0.8}, {"label": "2-star", "score": 0.1}, {"label": "3-star", "score": 0.05}
{"label": "4-star", "score": 0.025}, {"label": "5-star", "score": 0.025}]
>>> pipe("This is a test", top_k=2)
[{"label": "1-star", "score": 0.8}, {"label": "2-star", "score": 0.1}]
```
์ด๋ฅผ ๋ฌ์ฑํ๊ธฐ ์ํด ์ฐ๋ฆฌ๋ `postprocess` ๋ฉ์๋๋ฅผ ๊ธฐ๋ณธ ๋งค๊ฐ๋ณ์์ธ `5`๋ก ์
๋ฐ์ดํธํ๊ณ `_sanitize_parameters`๋ฅผ ์์ ํ์ฌ ์ด ์ ๋งค๊ฐ๋ณ์๋ฅผ ํ์ฉํฉ๋๋ค.
```python
def postprocess(self, model_outputs, top_k=5):
best_class = model_outputs["logits"].softmax(-1)
# top_k๋ฅผ ์ฒ๋ฆฌํ๋ ๋ก์ง ์ถ๊ฐ
return best_class
def _sanitize_parameters(self, **kwargs):
preprocess_kwargs = {}
if "maybe_arg" in kwargs:
preprocess_kwargs["maybe_arg"] = kwargs["maybe_arg"]
postprocess_kwargs = {}
if "top_k" in kwargs:
postprocess_kwargs["top_k"] = kwargs["top_k"]
return preprocess_kwargs, {}, postprocess_kwargs
```
์
/์ถ๋ ฅ์ ๊ฐ๋ฅํ ํ ๊ฐ๋จํ๊ณ ์์ ํ JSON ์ง๋ ฌํ ๊ฐ๋ฅํ ํ์์ผ๋ก ์ ์งํ๋ ค๊ณ ๋
ธ๋ ฅํ์ญ์์ค.
์ด๋ ๊ฒ ํ๋ฉด ์ฌ์ฉ์๊ฐ ์๋ก์ด ์ข
๋ฅ์ ๊ฐ์ฒด๋ฅผ ์ดํดํ์ง ์๊ณ ๋ ํ์ดํ๋ผ์ธ์ ์ฝ๊ฒ ์ฌ์ฉํ ์ ์์ต๋๋ค.
๋ํ ์ฌ์ฉ ์ฉ์ด์ฑ์ ์ํด ์ฌ๋ฌ ๊ฐ์ง ์ ํ์ ์ธ์(์ค๋์ค ํ์ผ์ ํ์ผ ์ด๋ฆ, URL ๋๋ ์์ํ ๋ฐ์ดํธ์ผ ์ ์์)๋ฅผ ์ง์ํ๋ ๊ฒ์ด ๋น๊ต์ ์ผ๋ฐ์ ์
๋๋ค.
## ์ง์๋๋ ์์
๋ชฉ๋ก์ ์ถ๊ฐํ๊ธฐ [[adding-it-to-the-list-of-supported-tasks]]
`new-task`๋ฅผ ์ง์๋๋ ์์
๋ชฉ๋ก์ ๋ฑ๋กํ๋ ค๋ฉด `PIPELINE_REGISTRY`์ ์ถ๊ฐํด์ผ ํฉ๋๋ค:
```python
from transformers.pipelines import PIPELINE_REGISTRY
PIPELINE_REGISTRY.register_pipeline(
"new-task",
pipeline_class=MyPipeline,
pt_model=AutoModelForSequenceClassification,
)
```
์ํ๋ ๊ฒฝ์ฐ ๊ธฐ๋ณธ ๋ชจ๋ธ์ ์ง์ ํ ์ ์์ผ๋ฉฐ, ์ด ๊ฒฝ์ฐ ํน์ ๊ฐ์ (๋ถ๊ธฐ ์ด๋ฆ ๋๋ ์ปค๋ฐ ํด์์ผ ์ ์์, ์ฌ๊ธฐ์๋ "abcdef")๊ณผ ํ์
์ ํจ๊ป ๊ฐ์ ธ์์ผ ํฉ๋๋ค:
```python
PIPELINE_REGISTRY.register_pipeline(
"new-task",
pipeline_class=MyPipeline,
pt_model=AutoModelForSequenceClassification,
default={"pt": ("user/awesome_model", "abcdef")},
type="text", # ํ์ฌ ์ง์ ์ ํ: text, audio, image, multimodal
)
```
## Hub์ ํ์ดํ๋ผ์ธ ๊ณต์ ํ๊ธฐ [[share-your-pipeline-on-the-hub]]
Hub์ ์ฌ์ฉ์ ์ ์ ํ์ดํ๋ผ์ธ์ ๊ณต์ ํ๋ ค๋ฉด `Pipeline` ํ์ ํด๋์ค์ ์ฌ์ฉ์ ์ ์ ์ฝ๋๋ฅผ Python ํ์ผ์ ์ ์ฅํ๊ธฐ๋ง ํ๋ฉด ๋ฉ๋๋ค.
์๋ฅผ ๋ค์ด, ๋ค์๊ณผ ๊ฐ์ด ๋ฌธ์ฅ ์ ๋ถ๋ฅ๋ฅผ ์ํ ์ฌ์ฉ์ ์ ์ ํ์ดํ๋ผ์ธ์ ์ฌ์ฉํ๋ค๊ณ ๊ฐ์ ํด ๋ณด๊ฒ ์ต๋๋ค:
```py
import numpy as np
from transformers import Pipeline
def softmax(outputs):
maxes = np.max(outputs, axis=-1, keepdims=True)
shifted_exp = np.exp(outputs - maxes)
return shifted_exp / shifted_exp.sum(axis=-1, keepdims=True)
class PairClassificationPipeline(Pipeline):
def _sanitize_parameters(self, **kwargs):
preprocess_kwargs = {}
if "second_text" in kwargs:
preprocess_kwargs["second_text"] = kwargs["second_text"]
return preprocess_kwargs, {}, {}
def preprocess(self, text, second_text=None):
return self.tokenizer(text, text_pair=second_text, return_tensors=self.framework)
def _forward(self, model_inputs):
return self.model(**model_inputs)
def postprocess(self, model_outputs):
logits = model_outputs.logits[0].numpy()
probabilities = softmax(logits)
best_class = np.argmax(probabilities)
label = self.model.config.id2label[best_class]
score = probabilities[best_class].item()
logits = logits.tolist()
return {"label": label, "score": score, "logits": logits}
```
๊ตฌํ์ ํ๋ ์์ํฌ์ ๊ตฌ์ ๋ฐ์ง ์์ผ๋ฉฐ, PyTorch์ TensorFlow ๋ชจ๋ธ์ ๋ํด ์๋ํฉ๋๋ค.
์ด๋ฅผ `pair_classification.py`๋ผ๋ ํ์ผ์ ์ ์ฅํ ๊ฒฝ์ฐ, ๋ค์๊ณผ ๊ฐ์ด ๊ฐ์ ธ์ค๊ณ ๋ฑ๋กํ ์ ์์ต๋๋ค:
```py
from pair_classification import PairClassificationPipeline
from transformers.pipelines import PIPELINE_REGISTRY
from transformers import AutoModelForSequenceClassification, TFAutoModelForSequenceClassification
PIPELINE_REGISTRY.register_pipeline(
"pair-classification",
pipeline_class=PairClassificationPipeline,
pt_model=AutoModelForSequenceClassification,
tf_model=TFAutoModelForSequenceClassification,
)
```
์ด ์์
์ด ์๋ฃ๋๋ฉด ์ฌ์ ํ๋ จ๋ ๋ชจ๋ธ๊ณผ ํจ๊ป ์ฌ์ฉํ ์ ์์ต๋๋ค.
์๋ฅผ ๋ค์ด, `sgugger/finetuned-bert-mrpc`์ MRPC ๋ฐ์ดํฐ ์ธํธ์์ ๋ฏธ์ธ ์กฐ์ ๋์ด ๋ฌธ์ฅ ์์ ํจ๋ฌํ๋ ์ด์ฆ์ธ์ง ์๋์ง๋ฅผ ๋ถ๋ฅํฉ๋๋ค.
```py
from transformers import pipeline
classifier = pipeline("pair-classification", model="sgugger/finetuned-bert-mrpc")
```
๊ทธ๋ฐ ๋ค์ `push_to_hub` ๋ฉ์๋๋ฅผ ์ฌ์ฉํ์ฌ ํ๋ธ์ ๊ณต์ ํ ์ ์์ต๋๋ค:
```py
classifier.push_to_hub("test-dynamic-pipeline")
```
์ด๋ ๊ฒ ํ๋ฉด "test-dynamic-pipeline" ํด๋ ๋ด์ `PairClassificationPipeline`์ ์ ์ํ ํ์ผ์ด ๋ณต์ฌ๋๋ฉฐ, ํ์ดํ๋ผ์ธ์ ๋ชจ๋ธ๊ณผ ํ ํฌ๋์ด์ ๋ ์ ์ฅํ ํ, `{your_username}/test-dynamic-pipeline` ์ ์ฅ์์ ์๋ ๋ชจ๋ ๊ฒ์ ํธ์ํฉ๋๋ค.
์ดํ์๋ `trust_remote_code=True` ์ต์
๋ง ์ ๊ณตํ๋ฉด ๋๊ตฌ๋ ์ฌ์ฉํ ์ ์์ต๋๋ค.
```py
from transformers import pipeline
classifier = pipeline(model="{your_username}/test-dynamic-pipeline", trust_remote_code=True)
```
## ๐ค Transformers์ ํ์ดํ๋ผ์ธ ์ถ๊ฐํ๊ธฐ [[add-the-pipeline-to-transformers]]
๐ค Transformers์ ์ฌ์ฉ์ ์ ์ ํ์ดํ๋ผ์ธ์ ๊ธฐ์ฌํ๋ ค๋ฉด, `pipelines` ํ์ ๋ชจ๋์ ์ฌ์ฉ์ ์ ์ ํ์ดํ๋ผ์ธ ์ฝ๋์ ํจ๊ป ์ ๋ชจ๋์ ์ถ๊ฐํ ๋ค์, `pipelines/__init__.py`์์ ์ ์๋ ์์
๋ชฉ๋ก์ ์ถ๊ฐํด์ผ ํฉ๋๋ค.
๊ทธ๋ฐ ๋ค์ ํ
์คํธ๋ฅผ ์ถ๊ฐํด์ผ ํฉ๋๋ค.
`tests/test_pipelines_MY_PIPELINE.py`๋ผ๋ ์ ํ์ผ์ ๋ง๋ค๊ณ ๋ค๋ฅธ ํ
์คํธ์ ์์ ๋ฅผ ํจ๊ป ์์ฑํฉ๋๋ค.
`run_pipeline_test` ํจ์๋ ๋งค์ฐ ์ผ๋ฐ์ ์ด๋ฉฐ, `model_mapping` ๋ฐ `tf_model_mapping`์์ ์ ์๋ ๊ฐ๋ฅํ ๋ชจ๋ ์ํคํ
์ฒ์ ์์ ๋ฌด์์ ๋ชจ๋ธ์์ ์คํ๋ฉ๋๋ค.
์ด๋ ํฅํ ํธํ์ฑ์ ํ
์คํธํ๋ ๋ฐ ๋งค์ฐ ์ค์ํ๋ฉฐ, ๋๊ตฐ๊ฐ `XXXForQuestionAnswering`์ ์ํ ์ ๋ชจ๋ธ์ ์ถ๊ฐํ๋ฉด ํ์ดํ๋ผ์ธ ํ
์คํธ๊ฐ ํด๋น ๋ชจ๋ธ์์ ์คํ์ ์๋ํ๋ค๋ ์๋ฏธ์
๋๋ค.
๋ชจ๋ธ์ด ๋ฌด์์์ด๊ธฐ ๋๋ฌธ์ ์ค์ ๊ฐ์ ํ์ธํ๋ ๊ฒ์ ๋ถ๊ฐ๋ฅํ๋ฏ๋ก, ๋จ์ํ ํ์ดํ๋ผ์ธ ์ถ๋ ฅ `TYPE`๊ณผ ์ผ์น์ํค๊ธฐ ์ํ ๋์ฐ๋ฏธ `ANY`๊ฐ ์์ต๋๋ค.
๋ํ 2๊ฐ(์ด์์ ์ผ๋ก๋ 4๊ฐ)์ ํ
์คํธ๋ฅผ ๊ตฌํํด์ผ ํฉ๋๋ค.
- `test_small_model_pt`: ์ด ํ์ดํ๋ผ์ธ์ ๋ํ ์์ ๋ชจ๋ธ 1๊ฐ๋ฅผ ์ ์(๊ฒฐ๊ณผ๊ฐ ์๋ฏธ ์์ด๋ ์๊ด์์)ํ๊ณ ํ์ดํ๋ผ์ธ ์ถ๋ ฅ์ ํ
์คํธํฉ๋๋ค.
๊ฒฐ๊ณผ๋ `test_small_model_tf`์ ๋์ผํด์ผ ํฉ๋๋ค.
- `test_small_model_tf`: ์ด ํ์ดํ๋ผ์ธ์ ๋ํ ์์ ๋ชจ๋ธ 1๊ฐ๋ฅผ ์ ์(๊ฒฐ๊ณผ๊ฐ ์๋ฏธ ์์ด๋ ์๊ด์์)ํ๊ณ ํ์ดํ๋ผ์ธ ์ถ๋ ฅ์ ํ
์คํธํฉ๋๋ค.
๊ฒฐ๊ณผ๋ `test_small_model_pt`์ ๋์ผํด์ผ ํฉ๋๋ค.
- `test_large_model_pt`(`์ ํ์ฌํญ`): ๊ฒฐ๊ณผ๊ฐ ์๋ฏธ ์์ ๊ฒ์ผ๋ก ์์๋๋ ์ค์ ํ์ดํ๋ผ์ธ์์ ํ์ดํ๋ผ์ธ์ ํ
์คํธํฉ๋๋ค.
์ด๋ฌํ ํ
์คํธ๋ ์๋๊ฐ ๋๋ฆฌ๋ฏ๋ก ์ด๋ฅผ ํ์ํด์ผ ํฉ๋๋ค.
์ฌ๊ธฐ์์ ๋ชฉํ๋ ํ์ดํ๋ผ์ธ์ ๋ณด์ฌ์ฃผ๊ณ ํฅํ ๋ฆด๋ฆฌ์ฆ์์์ ๋ณํ๊ฐ ์๋์ง ํ์ธํ๋ ๊ฒ์
๋๋ค.
- `test_large_model_tf`(`์ ํ์ฌํญ`): ๊ฒฐ๊ณผ๊ฐ ์๋ฏธ ์์ ๊ฒ์ผ๋ก ์์๋๋ ์ค์ ํ์ดํ๋ผ์ธ์์ ํ์ดํ๋ผ์ธ์ ํ
์คํธํฉ๋๋ค.
์ด๋ฌํ ํ
์คํธ๋ ์๋๊ฐ ๋๋ฆฌ๋ฏ๋ก ์ด๋ฅผ ํ์ํด์ผ ํฉ๋๋ค.
์ฌ๊ธฐ์์ ๋ชฉํ๋ ํ์ดํ๋ผ์ธ์ ๋ณด์ฌ์ฃผ๊ณ ํฅํ ๋ฆด๋ฆฌ์ฆ์์์ ๋ณํ๊ฐ ์๋์ง ํ์ธํ๋ ๊ฒ์
๋๋ค.
| 0 |
mavonic_private_repos/transformers/docs/source | mavonic_private_repos/transformers/docs/source/ko/_toctree.yml | - sections:
- local: index
title: ๐ค Transformers
- local: quicktour
title: ๋๋ฌ๋ณด๊ธฐ
- local: installation
title: ์ค์น๋ฐฉ๋ฒ
title: ์์ํ๊ธฐ
- sections:
- local: pipeline_tutorial
title: Pipeline์ผ๋ก ์ถ๋ก ํ๊ธฐ
- local: autoclass_tutorial
title: AutoClass๋ก ์ฌ์ ํ์ต๋ ์ธ์คํด์ค ๋ก๋ํ๊ธฐ
- local: preprocessing
title: ๋ฐ์ดํฐ ์ ์ฒ๋ฆฌํ๊ธฐ
- local: training
title: ์ฌ์ ํ์ต๋ ๋ชจ๋ธ ๋ฏธ์ธ ์กฐ์ ํ๊ธฐ
- local: run_scripts
title: ์คํฌ๋ฆฝํธ๋ก ํ์ตํ๊ธฐ
- local: accelerate
title: ๐ค Accelerate๋ก ๋ถ์ฐ ํ์ต ๊ตฌ์ฑํ๊ธฐ
- local: peft
title: ๐ค PEFT๋ก ์ด๋ํฐ ๋ก๋ ๋ฐ ํ์ตํ๊ธฐ
- local: model_sharing
title: ๋ง๋ ๋ชจ๋ธ ๊ณต์ ํ๊ธฐ
- local: transformers_agents
title: ์์ด์ ํธ
- local: llm_tutorial
title: ๋๊ท๋ชจ ์ธ์ด ๋ชจ๋ธ๋ก ์์ฑํ๊ธฐ
title: ํํ ๋ฆฌ์ผ
- sections:
- isExpanded: false
sections:
- local: tasks/sequence_classification
title: ํ
์คํธ ๋ถ๋ฅ
- local: tasks/token_classification
title: ํ ํฐ ๋ถ๋ฅ
- local: tasks/question_answering
title: ์ง์ ์๋ต(Question Answering)
- local: tasks/language_modeling
title: ์ธ๊ณผ์ ์ธ์ด ๋ชจ๋ธ๋ง(Causal language modeling)
- local: tasks/masked_language_modeling
title: ๋ง์คํน๋ ์ธ์ด ๋ชจ๋ธ๋ง(Masked language modeling)
- local: tasks/translation
title: ๋ฒ์ญ
- local: tasks/summarization
title: ์์ฝ
- local: tasks/multiple_choice
title: ๊ฐ๊ด์ ๋ฌธ์ (Multiple Choice)
title: ์์ฐ์ด์ฒ๋ฆฌ
- isExpanded: false
sections:
- local: tasks/audio_classification
title: ์ค๋์ค ๋ถ๋ฅ
- local: tasks/asr
title: ์๋ ์์ฑ ์ธ์
title: ์ค๋์ค
- isExpanded: false
sections:
- local: tasks/image_classification
title: ์ด๋ฏธ์ง ๋ถ๋ฅ
- local: tasks/semantic_segmentation
title: ์๋ฏธ์ ๋ถํ (Semantic segmentation)
- local: tasks/video_classification
title: ์์ ๋ถ๋ฅ
- local: tasks/object_detection
title: ๊ฐ์ฒด ํ์ง
- local: tasks/zero_shot_object_detection
title: ์ ๋ก์ท(zero-shot) ๊ฐ์ฒด ํ์ง
- local: tasks/zero_shot_image_classification
title: ์ ๋ก์ท(zero-shot) ์ด๋ฏธ์ง ๋ถ๋ฅ
- local: tasks/monocular_depth_estimation
title: ๋จ์ผ ์์ ๊ธฐ๋ฐ ๊น์ด ์ถ์
- local: in_translation
title: (๋ฒ์ญ์ค) Image-to-Image
- local: in_translation
title: (๋ฒ์ญ์ค) Image Feature Extraction
- local: in_translation
title: (๋ฒ์ญ์ค) Mask Generation
- local: in_translation
title: (๋ฒ์ญ์ค) Knowledge Distillation for Computer Vision
title: ์ปดํจํฐ ๋น์
- isExpanded: false
sections:
- local: tasks/image_captioning
title: ์ด๋ฏธ์ง ์บก์
๋
- local: tasks/document_question_answering
title: ๋ฌธ์ ์ง์ ์๋ต(Document Question Answering)
- local: tasks/visual_question_answering
title: ์๊ฐ์ ์ง์์๋ต (Visual Question Answering)
- local: in_translation
title: (๋ฒ์ญ์ค) Text to speech
title: ๋ฉํฐ๋ชจ๋ฌ
- isExpanded: false
sections:
- local: generation_strategies
title: ํ
์คํธ ์์ฑ ์ ๋ต ์ฌ์ฉ์ ์ ์
title: ์์ฑ
- isExpanded: false
sections:
- local: in_translation
title: (๋ฒ์ญ์ค) Image tasks with IDEFICS
- local: in_translation
title: (๋ฒ์ญ์ค) LLM prompting guide
title: (๋ฒ์ญ์ค) ํ๋กฌํํ
title: ํ์คํฌ ๊ฐ์ด๋
- sections:
- local: fast_tokenizers
title: ๐ค Tokenizers ๋ผ์ด๋ธ๋ฌ๋ฆฌ์์ ํ ํฌ๋์ด์ ์ฌ์ฉํ๊ธฐ
- local: multilingual
title: ๋ค๊ตญ์ด ๋ชจ๋ธ ์ถ๋ก ํ๊ธฐ
- local: create_a_model
title: ๋ชจ๋ธ๋ณ API ์ฌ์ฉํ๊ธฐ
- local: custom_models
title: ์ฌ์ฉ์ ์ ์ ๋ชจ๋ธ ๊ณต์ ํ๊ธฐ
- local: in_translation
title: (๋ฒ์ญ์ค) Templates for chat models
- local: in_translation
title: (๋ฒ์ญ์ค) Trainer
- local: sagemaker
title: Amazon SageMaker์์ ํ์ต ์คํํ๊ธฐ
- local: serialization
title: ONNX๋ก ๋ด๋ณด๋ด๊ธฐ
- local: tflite
title: TFLite๋ก ๋ด๋ณด๋ด๊ธฐ
- local: torchscript
title: TorchScript๋ก ๋ด๋ณด๋ด๊ธฐ
- local: in_translation
title: (๋ฒ์ญ์ค) Benchmarks
- local: in_translation
title: (๋ฒ์ญ์ค) Notebooks with examples
- local: community
title: ์ปค๋ฎค๋ํฐ ๋ฆฌ์์ค
- local: custom_tools
title: ์ฌ์ฉ์ ์ ์ ๋๊ตฌ์ ํ๋กฌํํธ
- local: troubleshooting
title: ๋ฌธ์ ํด๊ฒฐ
- local: in_translation
title: (๋ฒ์ญ์ค) Contribute new quantization method
title: (๋ฒ์ญ์ค) ๊ฐ๋ฐ์ ๊ฐ์ด๋
- sections:
- local: performance
title: ์ฑ๋ฅ ๋ฐ ํ์ฅ์ฑ
- local: in_translation
title: (๋ฒ์ญ์ค) Quantization
- sections:
- local: in_translation
title: (๋ฒ์ญ์ค) Training on one GPU
- local: perf_train_gpu_many
title: ๋ค์ค GPU์์ ํ๋ จ ์งํํ๊ธฐ
- local: in_translation
title: (๋ฒ์ญ์ค) Fully Sharded Data Parallel
- local: in_translation
title: (๋ฒ์ญ์ค) DeepSpeed
- local: perf_train_cpu
title: CPU์์ ํ๋ จ
- local: perf_train_cpu_many
title: ๋ค์ค CPU์์ ํ๋ จํ๊ธฐ
- local: perf_train_tpu_tf
title: TensorFlow๋ก TPU์์ ํ๋ จํ๊ธฐ
- local: in_translation
title: (๋ฒ์ญ์ค) PyTorch training on Apple silicon
- local: perf_hardware
title: ํ๋ จ์ฉ ์ฌ์ฉ์ ๋ง์ถคํ ํ๋์จ์ด
- local: hpo_train
title: Trainer API๋ฅผ ์ฌ์ฉํ ํ์ดํผํ๋ผ๋ฏธํฐ ํ์
title: (๋ฒ์ญ์ค) ํจ์จ์ ์ธ ํ์ต ๊ธฐ์ ๋ค
- sections:
- local: perf_infer_cpu
title: CPU๋ก ์ถ๋ก ํ๊ธฐ
- local: perf_infer_gpu_one
title: ํ๋์ GPU๋ฅผ ํ์ฉํ ์ถ๋ก
title: ์ถ๋ก ์ต์ ํํ๊ธฐ
- local: big_models
title: ๋ํ ๋ชจ๋ธ์ ์ธ์คํด์คํ
- local: debugging
title: ๋๋ฒ๊น
- local: tf_xla
title: TensorFlow ๋ชจ๋ธ์ ์ํ XLA ํตํฉ
- local: in_translation
title: (๋ฒ์ญ์ค) Optimize inference using `torch.compile()`
title: (๋ฒ์ญ์ค) ์ฑ๋ฅ ๋ฐ ํ์ฅ์ฑ
- sections:
- local: contributing
title: ๐ค Transformers์ ๊ธฐ์ฌํ๋ ๋ฐฉ๋ฒ
- local: add_new_model
title: ๐ค Transformers์ ์๋ก์ด ๋ชจ๋ธ์ ์ถ๊ฐํ๋ ๋ฐฉ๋ฒ
- local: add_new_pipeline
title: ์ด๋ป๊ฒ ๐ค Transformers์ ํ์ดํ๋ผ์ธ์ ์ถ๊ฐํ๋์?
- local: testing
title: ํ
์คํธ
- local: pr_checks
title: Pull Request์ ๋ํ ๊ฒ์ฌ
title: (๋ฒ์ญ์ค) ๊ธฐ์ฌํ๊ธฐ
- sections:
- local: philosophy
title: ์ด๋
๊ณผ ๋ชฉํ
- local: in_translation
title: (๋ฒ์ญ์ค) Glossary
- local: task_summary
title: ๐ค Transformers๋ก ํ ์ ์๋ ์์
- local: tasks_explained
title: ๐ค Transformers๋ก ์์
์ ํด๊ฒฐํ๋ ๋ฐฉ๋ฒ
- local: model_summary
title: Transformer ๋ชจ๋ธ๊ตฐ
- local: tokenizer_summary
title: ํ ํฌ๋์ด์ ์์ฝ
- local: attention
title: ์ดํ
์
๋งค์ปค๋์ฆ
- local: pad_truncation
title: ํจ๋ฉ๊ณผ ์๋ผ๋ด๊ธฐ
- local: bertology
title: BERTology
- local: perplexity
title: ๊ณ ์ ๊ธธ์ด ๋ชจ๋ธ์ ํํ๋ ์ํฐ(Perplexity)
- local: pipeline_webserver
title: ์ถ๋ก ์น ์๋ฒ๋ฅผ ์ํ ํ์ดํ๋ผ์ธ
- local: model_memory_anatomy
title: ๋ชจ๋ธ ํ์ต ํด๋ถํ๊ธฐ
- local: in_translation
title: (๋ฒ์ญ์ค) Getting the most out of LLMs
title: (๋ฒ์ญ์ค) ๊ฐ๋
๊ฐ์ด๋
- sections:
- sections:
- local: in_translation
title: (๋ฒ์ญ์ค) Agents and Tools
- local: in_translation
title: (๋ฒ์ญ์ค) Auto Classes
- local: in_translation
title: (๋ฒ์ญ์ค) Backbones
- local: in_translation
title: (๋ฒ์ญ์ค) Callbacks
- local: in_translation
title: (๋ฒ์ญ์ค) Configuration
- local: in_translation
title: (๋ฒ์ญ์ค) Data Collator
- local: in_translation
title: (๋ฒ์ญ์ค) Keras callbacks
- local: in_translation
title: (๋ฒ์ญ์ค) Logging
- local: in_translation
title: (๋ฒ์ญ์ค) Models
- local: in_translation
title: (๋ฒ์ญ์ค) Text Generation
- local: in_translation
title: (๋ฒ์ญ์ค) ONNX
- local: in_translation
title: (๋ฒ์ญ์ค) Optimization
- local: in_translation
title: (๋ฒ์ญ์ค) Model outputs
- local: in_translation
title: (๋ฒ์ญ์ค) Pipelines
- local: in_translation
title: (๋ฒ์ญ์ค) Processors
- local: in_translation
title: (๋ฒ์ญ์ค) Quantization
- local: in_translation
title: (๋ฒ์ญ์ค) Tokenizer
- local: in_translation
title: (๋ฒ์ญ์ค) Trainer
- local: in_translation
title: (๋ฒ์ญ์ค) DeepSpeed
- local: in_translation
title: (๋ฒ์ญ์ค) Feature Extractor
- local: in_translation
title: (๋ฒ์ญ์ค) Image Processor
title: (๋ฒ์ญ์ค) ๋ฉ์ธ ํด๋์ค
- sections:
- isExpanded: false
sections:
- local: in_translation
title: (๋ฒ์ญ์ค) ALBERT
- local: in_translation
title: (๋ฒ์ญ์ค) BART
- local: in_translation
title: (๋ฒ์ญ์ค) BARThez
- local: in_translation
title: (๋ฒ์ญ์ค) BARTpho
- local: in_translation
title: (๋ฒ์ญ์ค) BERT
- local: in_translation
title: (๋ฒ์ญ์ค) BertGeneration
- local: in_translation
title: (๋ฒ์ญ์ค) BertJapanese
- local: in_translation
title: (๋ฒ์ญ์ค) Bertweet
- local: in_translation
title: (๋ฒ์ญ์ค) BigBird
- local: in_translation
title: (๋ฒ์ญ์ค) BigBirdPegasus
- local: in_translation
title: (๋ฒ์ญ์ค) BioGpt
- local: in_translation
title: (๋ฒ์ญ์ค) Blenderbot
- local: in_translation
title: (๋ฒ์ญ์ค) Blenderbot Small
- local: in_translation
title: (๋ฒ์ญ์ค) BLOOM
- local: in_translation
title: (๋ฒ์ญ์ค) BORT
- local: in_translation
title: (๋ฒ์ญ์ค) ByT5
- local: in_translation
title: (๋ฒ์ญ์ค) CamemBERT
- local: in_translation
title: (๋ฒ์ญ์ค) CANINE
- local: in_translation
title: (๋ฒ์ญ์ค) CodeGen
- local: in_translation
title: (๋ฒ์ญ์ค) ConvBERT
- local: in_translation
title: (๋ฒ์ญ์ค) CPM
- local: in_translation
title: (๋ฒ์ญ์ค) CPMANT
- local: in_translation
title: (๋ฒ์ญ์ค) CTRL
- local: in_translation
title: (๋ฒ์ญ์ค) DeBERTa
- local: in_translation
title: (๋ฒ์ญ์ค) DeBERTa-v2
- local: in_translation
title: (๋ฒ์ญ์ค) DialoGPT
- local: in_translation
title: (๋ฒ์ญ์ค) DistilBERT
- local: in_translation
title: (๋ฒ์ญ์ค) DPR
- local: in_translation
title: (๋ฒ์ญ์ค) ELECTRA
- local: in_translation
title: (๋ฒ์ญ์ค) Encoder Decoder Models
- local: in_translation
title: (๋ฒ์ญ์ค) ERNIE
- local: in_translation
title: (๋ฒ์ญ์ค) ErnieM
- local: in_translation
title: (๋ฒ์ญ์ค) ESM
- local: in_translation
title: (๋ฒ์ญ์ค) FLAN-T5
- local: in_translation
title: (๋ฒ์ญ์ค) FLAN-UL2
- local: in_translation
title: (๋ฒ์ญ์ค) FlauBERT
- local: in_translation
title: (๋ฒ์ญ์ค) FNet
- local: in_translation
title: (๋ฒ์ญ์ค) FSMT
- local: in_translation
title: (๋ฒ์ญ์ค) Funnel Transformer
- local: in_translation
title: (๋ฒ์ญ์ค) GPT
- local: in_translation
title: (๋ฒ์ญ์ค) GPT Neo
- local: in_translation
title: (๋ฒ์ญ์ค) GPT NeoX
- local: in_translation
title: (๋ฒ์ญ์ค) GPT NeoX Japanese
- local: in_translation
title: (๋ฒ์ญ์ค) GPT-J
- local: in_translation
title: (๋ฒ์ญ์ค) GPT2
- local: in_translation
title: (๋ฒ์ญ์ค) GPTBigCode
- local: in_translation
title: (๋ฒ์ญ์ค) GPTSAN Japanese
- local: in_translation
title: (๋ฒ์ญ์ค) GPTSw3
- local: in_translation
title: (๋ฒ์ญ์ค) HerBERT
- local: in_translation
title: (๋ฒ์ญ์ค) I-BERT
- local: in_translation
title: (๋ฒ์ญ์ค) Jukebox
- local: in_translation
title: (๋ฒ์ญ์ค) LED
- local: model_doc/llama
title: LLaMA
- local: model_doc/llama2
title: LLaMA2
- local: in_translation
title: (๋ฒ์ญ์ค) Longformer
- local: in_translation
title: (๋ฒ์ญ์ค) LongT5
- local: in_translation
title: (๋ฒ์ญ์ค) LUKE
- local: in_translation
title: (๋ฒ์ญ์ค) M2M100
- local: in_translation
title: (๋ฒ์ญ์ค) MarianMT
- local: in_translation
title: (๋ฒ์ญ์ค) MarkupLM
- local: in_translation
title: (๋ฒ์ญ์ค) MBart and MBart-50
- local: in_translation
title: (๋ฒ์ญ์ค) MEGA
- local: in_translation
title: (๋ฒ์ญ์ค) MegatronBERT
- local: in_translation
title: (๋ฒ์ญ์ค) MegatronGPT2
- local: in_translation
title: (๋ฒ์ญ์ค) mLUKE
- local: in_translation
title: (๋ฒ์ญ์ค) MobileBERT
- local: in_translation
title: (๋ฒ์ญ์ค) MPNet
- local: in_translation
title: (๋ฒ์ญ์ค) MT5
- local: in_translation
title: (๋ฒ์ญ์ค) MVP
- local: in_translation
title: (๋ฒ์ญ์ค) NEZHA
- local: in_translation
title: (๋ฒ์ญ์ค) NLLB
- local: in_translation
title: (๋ฒ์ญ์ค) NLLB-MoE
- local: in_translation
title: (๋ฒ์ญ์ค) Nystrรถmformer
- local: in_translation
title: (๋ฒ์ญ์ค) Open-Llama
- local: in_translation
title: (๋ฒ์ญ์ค) OPT
- local: in_translation
title: (๋ฒ์ญ์ค) Pegasus
- local: in_translation
title: (๋ฒ์ญ์ค) PEGASUS-X
- local: in_translation
title: (๋ฒ์ญ์ค) PhoBERT
- local: in_translation
title: (๋ฒ์ญ์ค) PLBart
- local: in_translation
title: (๋ฒ์ญ์ค) ProphetNet
- local: in_translation
title: (๋ฒ์ญ์ค) QDQBert
- local: in_translation
title: (๋ฒ์ญ์ค) RAG
- local: in_translation
title: (๋ฒ์ญ์ค) REALM
- local: in_translation
title: (๋ฒ์ญ์ค) Reformer
- local: in_translation
title: (๋ฒ์ญ์ค) RemBERT
- local: in_translation
title: (๋ฒ์ญ์ค) RetriBERT
- local: in_translation
title: (๋ฒ์ญ์ค) RoBERTa
- local: in_translation
title: (๋ฒ์ญ์ค) RoBERTa-PreLayerNorm
- local: in_translation
title: (๋ฒ์ญ์ค) RoCBert
- local: in_translation
title: (๋ฒ์ญ์ค) RoFormer
- local: in_translation
title: (๋ฒ์ญ์ค) Splinter
- local: in_translation
title: (๋ฒ์ญ์ค) SqueezeBERT
- local: in_translation
title: (๋ฒ์ญ์ค) SwitchTransformers
- local: in_translation
title: (๋ฒ์ญ์ค) T5
- local: in_translation
title: (๋ฒ์ญ์ค) T5v1.1
- local: in_translation
title: (๋ฒ์ญ์ค) TAPEX
- local: in_translation
title: (๋ฒ์ญ์ค) Transformer XL
- local: in_translation
title: (๋ฒ์ญ์ค) UL2
- local: in_translation
title: (๋ฒ์ญ์ค) X-MOD
- local: in_translation
title: (๋ฒ์ญ์ค) XGLM
- local: in_translation
title: (๋ฒ์ญ์ค) XLM
- local: in_translation
title: (๋ฒ์ญ์ค) XLM-ProphetNet
- local: in_translation
title: (๋ฒ์ญ์ค) XLM-RoBERTa
- local: in_translation
title: (๋ฒ์ญ์ค) XLM-RoBERTa-XL
- local: in_translation
title: (๋ฒ์ญ์ค) XLM-V
- local: in_translation
title: (๋ฒ์ญ์ค) XLNet
- local: in_translation
title: (๋ฒ์ญ์ค) YOSO
title: (๋ฒ์ญ์ค) ํ
์คํธ ๋ชจ๋ธ
- isExpanded: false
sections:
- local: in_translation
title: (๋ฒ์ญ์ค) BEiT
- local: in_translation
title: (๋ฒ์ญ์ค) BiT
- local: in_translation
title: (๋ฒ์ญ์ค) Conditional DETR
- local: in_translation
title: (๋ฒ์ญ์ค) ConvNeXT
- local: in_translation
title: (๋ฒ์ญ์ค) ConvNeXTV2
- local: in_translation
title: (๋ฒ์ญ์ค) CvT
- local: in_translation
title: (๋ฒ์ญ์ค) Deformable DETR
- local: in_translation
title: (๋ฒ์ญ์ค) DeiT
- local: in_translation
title: (๋ฒ์ญ์ค) DETA
- local: in_translation
title: (๋ฒ์ญ์ค) DETR
- local: in_translation
title: (๋ฒ์ญ์ค) DiNAT
- local: in_translation
title: (๋ฒ์ญ์ค) DiT
- local: in_translation
title: (๋ฒ์ญ์ค) DPT
- local: in_translation
title: (๋ฒ์ญ์ค) EfficientFormer
- local: in_translation
title: (๋ฒ์ญ์ค) EfficientNet
- local: in_translation
title: (๋ฒ์ญ์ค) FocalNet
- local: in_translation
title: (๋ฒ์ญ์ค) GLPN
- local: in_translation
title: (๋ฒ์ญ์ค) ImageGPT
- local: in_translation
title: (๋ฒ์ญ์ค) LeViT
- local: in_translation
title: (๋ฒ์ญ์ค) Mask2Former
- local: in_translation
title: (๋ฒ์ญ์ค) MaskFormer
- local: in_translation
title: (๋ฒ์ญ์ค) MobileNetV1
- local: in_translation
title: (๋ฒ์ญ์ค) MobileNetV2
- local: in_translation
title: (๋ฒ์ญ์ค) MobileViT
- local: in_translation
title: (๋ฒ์ญ์ค) NAT
- local: in_translation
title: (๋ฒ์ญ์ค) PoolFormer
- local: in_translation
title: (๋ฒ์ญ์ค) RegNet
- local: in_translation
title: (๋ฒ์ญ์ค) ResNet
- local: in_translation
title: (๋ฒ์ญ์ค) SegFormer
- local: in_translation
title: (๋ฒ์ญ์ค) Swin Transformer
- local: in_translation
title: (๋ฒ์ญ์ค) Swin Transformer V2
- local: in_translation
title: (๋ฒ์ญ์ค) Swin2SR
- local: in_translation
title: (๋ฒ์ญ์ค) Table Transformer
- local: in_translation
title: (๋ฒ์ญ์ค) TimeSformer
- local: in_translation
title: (๋ฒ์ญ์ค) UperNet
- local: in_translation
title: (๋ฒ์ญ์ค) VAN
- local: in_translation
title: (๋ฒ์ญ์ค) VideoMAE
- local: in_translation
title: (๋ฒ์ญ์ค) Vision Transformer (ViT)
- local: in_translation
title: (๋ฒ์ญ์ค) ViT Hybrid
- local: in_translation
title: (๋ฒ์ญ์ค) ViTMAE
- local: in_translation
title: (๋ฒ์ญ์ค) ViTMSN
- local: in_translation
title: (๋ฒ์ญ์ค) YOLOS
title: (๋ฒ์ญ์ค) ๋น์ ๋ชจ๋ธ
- isExpanded: false
sections:
- local: in_translation
title: (๋ฒ์ญ์ค) Audio Spectrogram Transformer
- local: in_translation
title: (๋ฒ์ญ์ค) CLAP
- local: in_translation
title: (๋ฒ์ญ์ค) Hubert
- local: in_translation
title: (๋ฒ์ญ์ค) MCTCT
- local: in_translation
title: (๋ฒ์ญ์ค) SEW
- local: in_translation
title: (๋ฒ์ญ์ค) SEW-D
- local: in_translation
title: (๋ฒ์ญ์ค) Speech2Text
- local: in_translation
title: (๋ฒ์ญ์ค) Speech2Text2
- local: in_translation
title: (๋ฒ์ญ์ค) SpeechT5
- local: in_translation
title: (๋ฒ์ญ์ค) UniSpeech
- local: in_translation
title: (๋ฒ์ญ์ค) UniSpeech-SAT
- local: in_translation
title: (๋ฒ์ญ์ค) Wav2Vec2
- local: in_translation
title: (๋ฒ์ญ์ค) Wav2Vec2-Conformer
- local: in_translation
title: (๋ฒ์ญ์ค) Wav2Vec2Phoneme
- local: in_translation
title: (๋ฒ์ญ์ค) WavLM
- local: model_doc/whisper
title: Whisper
- local: in_translation
title: (๋ฒ์ญ์ค) XLS-R
- local: in_translation
title: (๋ฒ์ญ์ค) XLSR-Wav2Vec2
title: (๋ฒ์ญ์ค) ์ค๋์ค ๋ชจ๋ธ
- isExpanded: false
sections:
- local: in_translation
title: (๋ฒ์ญ์ค) ALIGN
- local: in_translation
title: (๋ฒ์ญ์ค) AltCLIP
- local: in_translation
title: (๋ฒ์ญ์ค) BLIP
- local: in_translation
title: (๋ฒ์ญ์ค) BLIP-2
- local: in_translation
title: (๋ฒ์ญ์ค) BridgeTower
- local: in_translation
title: (๋ฒ์ญ์ค) Chinese-CLIP
- local: in_translation
title: (๋ฒ์ญ์ค) CLIP
- local: in_translation
title: (๋ฒ์ญ์ค) CLIPSeg
- local: in_translation
title: (๋ฒ์ญ์ค) Data2Vec
- local: in_translation
title: (๋ฒ์ญ์ค) DePlot
- local: in_translation
title: (๋ฒ์ญ์ค) Donut
- local: in_translation
title: (๋ฒ์ญ์ค) FLAVA
- local: in_translation
title: (๋ฒ์ญ์ค) GIT
- local: in_translation
title: (๋ฒ์ญ์ค) GroupViT
- local: in_translation
title: (๋ฒ์ญ์ค) LayoutLM
- local: in_translation
title: (๋ฒ์ญ์ค) LayoutLMV2
- local: in_translation
title: (๋ฒ์ญ์ค) LayoutLMV3
- local: in_translation
title: (๋ฒ์ญ์ค) LayoutXLM
- local: in_translation
title: (๋ฒ์ญ์ค) LiLT
- local: in_translation
title: (๋ฒ์ญ์ค) LXMERT
- local: in_translation
title: (๋ฒ์ญ์ค) MatCha
- local: in_translation
title: (๋ฒ์ญ์ค) MGP-STR
- local: in_translation
title: (๋ฒ์ญ์ค) OneFormer
- local: in_translation
title: (๋ฒ์ญ์ค) OWL-ViT
- local: in_translation
title: (๋ฒ์ญ์ค) Perceiver
- local: in_translation
title: (๋ฒ์ญ์ค) Pix2Struct
- local: in_translation
title: (๋ฒ์ญ์ค) Segment Anything
- local: in_translation
title: (๋ฒ์ญ์ค) Speech Encoder Decoder Models
- local: in_translation
title: (๋ฒ์ญ์ค) TAPAS
- local: in_translation
title: (๋ฒ์ญ์ค) TrOCR
- local: in_translation
title: (๋ฒ์ญ์ค) TVLT
- local: in_translation
title: (๋ฒ์ญ์ค) ViLT
- local: in_translation
title: (๋ฒ์ญ์ค) Vision Encoder Decoder Models
- local: in_translation
title: (๋ฒ์ญ์ค) Vision Text Dual Encoder
- local: in_translation
title: (๋ฒ์ญ์ค) VisualBERT
- local: in_translation
title: (๋ฒ์ญ์ค) X-CLIP
title: (๋ฒ์ญ์ค) ๋ฉํฐ๋ชจ๋ฌ ๋ชจ๋ธ
- isExpanded: false
sections:
- local: in_translation
title: (๋ฒ์ญ์ค) Decision Transformer
- local: in_translation
title: (๋ฒ์ญ์ค) Trajectory Transformer
title: (๋ฒ์ญ์ค) ๊ฐํํ์ต ๋ชจ๋ธ
- isExpanded: false
sections:
- local: in_translation
title: (๋ฒ์ญ์ค) Informer
- local: in_translation
title: (๋ฒ์ญ์ค) Time Series Transformer
title: (๋ฒ์ญ์ค) ์๊ณ์ด ๋ชจ๋ธ
- isExpanded: false
sections:
- local: in_translation
title: (๋ฒ์ญ์ค) Graphormer
title: (๋ฒ์ญ์ค) Graph models
title: (๋ฒ์ญ์ค) ๋ชจ๋ธ
- sections:
- local: in_translation
title: (๋ฒ์ญ์ค) Custom Layers and Utilities
- local: in_translation
title: (๋ฒ์ญ์ค) Utilities for pipelines
- local: in_translation
title: (๋ฒ์ญ์ค) Utilities for Tokenizers
- local: in_translation
title: (๋ฒ์ญ์ค) Utilities for Trainer
- local: in_translation
title: (๋ฒ์ญ์ค) Utilities for Generation
- local: in_translation
title: (๋ฒ์ญ์ค) Utilities for Image Processors
- local: in_translation
title: (๋ฒ์ญ์ค) Utilities for Audio processing
- local: in_translation
title: (๋ฒ์ญ์ค) General Utilities
- local: in_translation
title: (๋ฒ์ญ์ค) Utilities for Time Series
title: (๋ฒ์ญ์ค) Internal Helpers
title: (๋ฒ์ญ์ค) API
| 0 |
mavonic_private_repos/transformers/docs/source | mavonic_private_repos/transformers/docs/source/ko/tasks_explained.md | <!--Copyright 2023 The HuggingFace Team. All rights reserved.
Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
the License. You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
specific language governing permissions and limitations under the License.
โ ๏ธ Note that this file is in Markdown but contain specific syntax for our doc-builder (similar to MDX) that may not be
rendered properly in your Markdown viewer.
-->
# ๐ค Transformers๋ก ์์
์ ํด๊ฒฐํ๋ ๋ฐฉ๋ฒ[[how-transformers-solve-tasks]]
[๐ค Transformers๋ก ํ ์ ์๋ ์์
](task_summary)์์ ์์ฐ์ด ์ฒ๋ฆฌ(NLP), ์์ฑ ๋ฐ ์ค๋์ค, ์ปดํจํฐ ๋น์ ์์
๋ฑ์ ์ค์ํ ์์ฉ์ ๋ฐฐ์ ์ต๋๋ค. ์ด ํ์ด์ง์์๋ ๋ชจ๋ธ์ด ์ด๋ฌํ ์์
์ ์ด๋ป๊ฒ ํด๊ฒฐํ๋์ง ์์ธํ ์ดํด๋ณด๊ณ ๋ด๋ถ์์ ์ด๋ค ์ผ์ด ์ผ์ด๋๋์ง ์ค๋ช
ํฉ๋๋ค. ์ฃผ์ด์ง ์์
์ ํด๊ฒฐํ๋ ๋ง์ ๋ฐฉ๋ฒ์ด ์์ผ๋ฉฐ, ์ผ๋ถ ๋ชจ๋ธ์ ํน์ ๊ธฐ์ ์ ๊ตฌํํ๊ฑฐ๋ ์ฌ์ง์ด ์๋ก์ด ๋ฐฉ์์ผ๋ก ์์
์ ์ ๊ทผํ ์๋ ์์ง๋ง, Transformer ๋ชจ๋ธ์ ๊ฒฝ์ฐ ์ผ๋ฐ์ ์ธ ์์ด๋์ด๋ ๋์ผํฉ๋๋ค. ์ ์ฐํ ์ํคํ
์ฒ ๋๋ถ์ ๋๋ถ๋ถ์ ๋ชจ๋ธ์ ์ธ์ฝ๋, ๋์ฝ๋ ๋๋ ์ธ์ฝ๋-๋์ฝ๋ ๊ตฌ์กฐ์ ๋ณํ์
๋๋ค. Transformer ๋ชจ๋ธ๋ฟ๋ง ์๋๋ผ ์ฐ๋ฆฌ์ ๋ผ์ด๋ธ๋ฌ๋ฆฌ์๋ ์ค๋๋ ์ปดํจํฐ ๋น์ ์์
์ ์ฌ์ฉ๋๋ ๋ช ๊ฐ์ง ํฉ์ฑ๊ณฑ ์ ๊ฒฝ๋ง(CNNs)๋ ์์ต๋๋ค. ๋ํ, ์ฐ๋ฆฌ๋ ํ๋ CNN์ ์๋ ๋ฐฉ์์ ๋ํด ์ค๋ช
ํ ๊ฒ์
๋๋ค.
์์
์ด ์ด๋ป๊ฒ ํด๊ฒฐ๋๋์ง ์ค๋ช
ํ๊ธฐ ์ํด, ์ ์ฉํ ์์ธก์ ์ถ๋ ฅํ๊ณ ์ ๋ชจ๋ธ ๋ด๋ถ์์ ์ด๋ค ์ผ์ด ์ผ์ด๋๋์ง ์ดํด๋ด
๋๋ค.
- ์ค๋์ค ๋ถ๋ฅ ๋ฐ ์๋ ์์ฑ ์ธ์(ASR)์ ์ํ [Wav2Vec2](model_doc/wav2vec2)
- ์ด๋ฏธ์ง ๋ถ๋ฅ๋ฅผ ์ํ [Vision Transformer (ViT)](model_doc/vit) ๋ฐ [ConvNeXT](model_doc/convnext)
- ๊ฐ์ฒด ํ์ง๋ฅผ ์ํ [DETR](model_doc/detr)
- ์ด๋ฏธ์ง ๋ถํ ์ ์ํ [Mask2Former](model_doc/mask2former)
- ๊น์ด ์ถ์ ์ ์ํ [GLPN](model_doc/glpn)
- ์ธ์ฝ๋๋ฅผ ์ฌ์ฉํ๋ ํ
์คํธ ๋ถ๋ฅ, ํ ํฐ ๋ถ๋ฅ ๋ฐ ์ง์์๋ต๊ณผ ๊ฐ์ NLP ์์
์ ์ํ [BERT](model_doc/bert)
- ๋์ฝ๋๋ฅผ ์ฌ์ฉํ๋ ํ
์คํธ ์์ฑ๊ณผ ๊ฐ์ NLP ์์
์ ์ํ [GPT2](model_doc/gpt2)
- ์ธ์ฝ๋-๋์ฝ๋๋ฅผ ์ฌ์ฉํ๋ ์์ฝ ๋ฐ ๋ฒ์ญ๊ณผ ๊ฐ์ NLP ์์
์ ์ํ [BART](model_doc/bart)
<Tip>
๋ ๋์๊ฐ๊ธฐ ์ ์, ๊ธฐ์กด Transformer ์ํคํ
์ฒ์ ๋ํ ๊ธฐ๋ณธ์ ์ธ ์ง์์ ์์งํ๋ ๊ฒ์ด ์ข์ต๋๋ค. ์ธ์ฝ๋, ๋์ฝ๋ ๋ฐ ์ดํ
์
์ ์๋ ๋ฐฉ์์ ์๋ฉด ๋ค์ํ Transformer ๋ชจ๋ธ์ด ์ด๋ป๊ฒ ์๋ํ๋์ง ์ดํดํ๋ ๋ฐ ๋์์ด ๋ฉ๋๋ค. ์์ ๋จ๊ณ๊ฑฐ๋ ๋ณต์ต์ด ํ์ํ ๊ฒฝ์ฐ, ๋ ๋ง์ ์ ๋ณด๋ฅผ ์ํด [์ฝ์ค](https://huggingface.co/course/chapter1/4?fw=pt)๋ฅผ ํ์ธํ์ธ์!
</Tip>
## ์์ฑ ๋ฐ ์ค๋์ค[[speech-and-audio]]
[Wav2Vec2](model_doc/wav2vec2)๋ ๋ ์ด๋ธ์ด ์ง์ ๋์ง ์์ ์์ฑ ๋ฐ์ดํฐ์ ๋ํด ์ฌ์ ํ๋ จ๋ ๋ชจ๋ธ๋ก, ์ค๋์ค ๋ถ๋ฅ ๋ฐ ์๋ ์์ฑ ์ธ์์ ์ํด ๋ ์ด๋ธ์ด ์ง์ ๋ ๋ฐ์ดํฐ๋ก ๋ฏธ์ธ ์กฐ์ ํฉ๋๋ค.
<div class="flex justify-center">
<img src="https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/wav2vec2_architecture.png"/>
</div>
์ด ๋ชจ๋ธ์๋ 4๊ฐ์ง ์ฃผ์ ๊ตฌ์ฑ ์์๊ฐ ์์ต๋๋ค:
1. *ํน์ง ์ธ์ฝ๋(feature encoder)*๋ ์์ ์ค๋์ค ํํ(raw audio waveform)์ ๊ฐ์ ธ์์ ์ ๋ก ํ๊ท ๋ฐ ๋จ์ ๋ถ์ฐ์ผ๋ก ํ์คํํ๊ณ , ๊ฐ๊ฐ 20ms ๊ธธ์ด์ ํน์ง ๋ฒกํฐ์ ์ํ์ค๋ก ๋ณํํฉ๋๋ค.
2. ์ค๋์ค ํํ์ ๋ณธ์ง์ ์ผ๋ก ์ฐ์์ ์ด๊ธฐ ๋๋ฌธ์, ํ
์คํธ ์ํ์ค๋ฅผ ๋จ์ด๋ก ๋๋๋ ๊ฒ๊ณผ ๊ฐ์ด ๋ถํ ํ ์ ์์ต๋๋ค. ๊ทธ๋์ *์์ํ ๋ชจ๋(quantization module)*๋ก ์ ๋ฌ๋๋ ํน์ง ๋ฒกํฐ๋ ์ด์ฐํ ์์ฑ ๋จ์๋ฅผ ํ์ตํ๊ธฐ ์ํ ๊ฒ์
๋๋ค. ์์ฑ ๋จ์๋ *์ฝ๋๋ถ(codebook)*(์ดํ์ง์ด๋ผ๊ณ ์๊ฐํ ์ ์์ต๋๋ค)์ด๋ผ๋ ์ฝ๋๋จ์ด(codewords) ์ฝ๋ ์
์์ ์ ํ๋ฉ๋๋ค. ์ฝ๋๋ถ์์ ์ฐ์์ ์ธ ์ค๋์ค ์
๋ ฅ์ ๊ฐ์ฅ ์ ๋ํ๋ด๋ ๋ฒกํฐ ๋๋ ์์ฑ ๋จ์๊ฐ ์ ํ๋์ด ๋ชจ๋ธ์ ํต๊ณผํฉ๋๋ค.
3. ํน์ง ๋ฒกํฐ์ ์ ๋ฐ์ ๋ฌด์์๋ก ๋ง์คํฌ๊ฐ ์ ์ฉ๋๋ฉฐ, ๋ง์คํฌ๋ ํน์ง ๋ฒกํฐ๋ *์๋์ ์์น ์๋ฒ ๋ฉ*์ ์ถ๊ฐํ๋ Transformer ์ธ์ฝ๋์ธ *๋ฌธ๋งฅ ๋คํธ์ํฌ(context network)*๋ก ์ ๋ฌ๋ฉ๋๋ค.
4. ๋ฌธ๋งฅ ๋คํธ์ํฌ์ ์ฌ์ ํ๋ จ ๋ชฉํ๋ *๋์กฐ์ ์์
(contrastive task)*์
๋๋ค. ๋ชจ๋ธ์ ์๋ชป๋ ์์ธก ์ํ์ค์์ ๋ง์คํฌ๋ ์์ธก์ ์ค์ ์์ํ๋ ์์ฑ ํํ์ ์์ธกํ๋ฉฐ, ๋ชจ๋ธ์ด ๊ฐ์ฅ ์ ์ฌํ ์ปจํ
์คํธ ๋ฒกํฐ์ ์์ํ๋ ์์ฑ ๋จ์(ํ๊ฒ ๋ ์ด๋ธ)๋ฅผ ์ฐพ๋๋ก ๊ถ์ฅํฉ๋๋ค.
์ด์ wav2vec2๊ฐ ์ฌ์ ํ๋ จ๋์์ผ๋ฏ๋ก, ์ค๋์ค ๋ถ๋ฅ ๋๋ ์๋ ์์ฑ ์ธ์์ ์ํด ๋ฐ์ดํฐ์ ๋ง์ถฐ ๋ฏธ์ธ ์กฐ์ ํ ์ ์์ต๋๋ค!
### ์ค๋์ค ๋ถ๋ฅ[[audio-classification]]
์ฌ์ ํ๋ จ๋ ๋ชจ๋ธ์ ์ค๋์ค ๋ถ๋ฅ์ ์ฌ์ฉํ๋ ค๋ฉด, ๊ธฐ๋ณธ Wav2Vec2 ๋ชจ๋ธ ์๋จ์ ์ํ์ค ๋ถ๋ฅ ํค๋๋ฅผ ์ถ๊ฐํ๋ฉด ๋ฉ๋๋ค. ๋ถ๋ฅ ํค๋๋ ์ธ์ฝ๋์ ์๋ ์ํ(hidden states)๋ฅผ ๋ฐ๋ ์ ํ ๋ ์ด์ด์
๋๋ค. ์๋ ์ํ๋ ๊ฐ๊ฐ ๊ธธ์ด๊ฐ ๋ค๋ฅธ ์ค๋์ค ํ๋ ์์์ ํ์ต๋ ํน์ง์ ๋ํ๋
๋๋ค. ๊ณ ์ ๊ธธ์ด์ ๋ฒกํฐ ํ๋๋ฅผ ๋ง๋ค๊ธฐ ์ํด, ์๋ ์ํ๋ ๋จผ์ ํ๋ง๋๊ณ , ํด๋์ค ๋ ์ด๋ธ์ ๋ํ ๋ก์ง์ผ๋ก ๋ณํ๋ฉ๋๋ค. ๊ฐ์ฅ ๊ฐ๋ฅ์ฑ์ด ๋์ ํด๋์ค๋ฅผ ์ฐพ๊ธฐ ์ํด ๋ก์ง๊ณผ ํ๊ฒ ์ฌ์ด์ ๊ต์ฐจ ์ํธ๋กํผ ์์ค์ด ๊ณ์ฐ๋ฉ๋๋ค.
์ค๋์ค ๋ถ๋ฅ์ ์ง์ ๋์ ํ ์ค๋น๊ฐ ๋์
จ๋์? ์์ ํ [์ค๋์ค ๋ถ๋ฅ ๊ฐ์ด๋](tasks/audio_classification)๋ฅผ ํ์ธํ์ฌ Wav2Vec2๋ฅผ ๋ฏธ์ธ ์กฐ์ ํ๊ณ ์ถ๋ก ์ ์ฌ์ฉํ๋ ๋ฐฉ๋ฒ์ ํ์ตํ์ธ์!
### ์๋ ์์ฑ ์ธ์[[automatic-speech-recognition]]
์ฌ์ ํ๋ จ๋ ๋ชจ๋ธ์ ์๋ ์์ฑ ์ธ์์ ์ฌ์ฉํ๋ ค๋ฉด, [์ฐ๊ฒฐ์ฃผ์์ ์๊ฐ ๋ถ๋ฅ(CTC, Connectionist Temporal Classification)](glossary#connectionist-temporal-classification-ctc)๋ฅผ ์ํด ๊ธฐ๋ณธ Wav2Vec2 ๋ชจ๋ธ ์๋จ์ ์ธ์ด ๋ชจ๋ธ๋ง ํค๋๋ฅผ ์ถ๊ฐํฉ๋๋ค. ์ธ์ด ๋ชจ๋ธ๋ง ํค๋๋ ์ธ์ฝ๋์ ์๋ ์ํ๋ฅผ ๋ฐ์์ ๋ก์ง์ผ๋ก ๋ณํํฉ๋๋ค. ๊ฐ ๋ก์ง์ ํ ํฐ ํด๋์ค(ํ ํฐ ์๋ ์์
์ ์ดํ์์ ๋ํ๋ฉ๋๋ค)๋ฅผ ๋ํ๋
๋๋ค. CTC ์์ค์ ํ
์คํธ๋ก ๋์ฝ๋ฉ๋ ํ ํฐ์์ ๊ฐ์ฅ ๊ฐ๋ฅ์ฑ์ด ๋์ ํ ํฐ ์ํ์ค๋ฅผ ์ฐพ๊ธฐ ์ํด ๋ก์ง๊ณผ ํ๊ฒ ์ฌ์ด์์ ๊ณ์ฐ๋ฉ๋๋ค.
์๋ ์์ฑ ์ธ์์ ์ง์ ๋์ ํ ์ค๋น๊ฐ ๋์
จ๋์? ์์ ํ [์๋ ์์ฑ ์ธ์ ๊ฐ์ด๋](tasks/asr)๋ฅผ ํ์ธํ์ฌ Wav2Vec2๋ฅผ ๋ฏธ์ธ ์กฐ์ ํ๊ณ ์ถ๋ก ์ ์ฌ์ฉํ๋ ๋ฐฉ๋ฒ์ ํ์ตํ์ธ์!
## ์ปดํจํฐ ๋น์ [[computer-vision]]
์ปดํจํฐ ๋น์ ์์
์ ์ ๊ทผํ๋ 2๊ฐ์ง ๋ฐฉ๋ฒ์ด ์์ต๋๋ค:
1. ์ด๋ฏธ์ง๋ฅผ ํจ์น ์ํ์ค๋ก ๋ถ๋ฆฌํ๊ณ Transformer๋ก ๋ณ๋ ฌ ์ฒ๋ฆฌํฉ๋๋ค.
2. [ConvNeXT](model_doc/convnext)์ ๊ฐ์ ํ๋ CNN์ ์ฌ์ฉํฉ๋๋ค. ์ด๋ ํฉ์ฑ๊ณฑ ๋ ์ด์ด๋ฅผ ๊ธฐ๋ฐ์ผ๋ก ํ์ง๋ง ํ๋ ๋คํธ์ํฌ ์ค๊ณ๋ฅผ ์ ์ฉํฉ๋๋ค.
<Tip>
์ธ ๋ฒ์งธ ๋ฐฉ๋ฒ์ Transformer์ ํฉ์ฑ๊ณฑ(์๋ฅผ ๋ค์ด, [Convolutional Vision Transformer](model_doc/cvt) ๋๋ [LeViT](model_doc/levit))์ ๊ฒฐํฉํ๋ ๊ฒ์
๋๋ค. ์ฐ๋ฆฌ๋ ์ดํด๋ณผ ๋ ๊ฐ์ง ๋ฐฉ๋ฒ๋ง ๊ฒฐํฉํ๊ธฐ ๋๋ฌธ์ ์ฌ๊ธฐ์ ์ด ๋ฐฉ๋ฒ์ ๋ค๋ฃจ์ง ์์ต๋๋ค.
</Tip>
ViT์ ConvNeXT๋ ์ผ๋ฐ์ ์ผ๋ก ์ด๋ฏธ์ง ๋ถ๋ฅ์์ ์ฌ์ฉ๋์ง๋ง, ๋ฌผ์ฒด ๊ฐ์ง, ๋ถํ , ๊น์ด ์ถ์ ๊ณผ ๊ฐ์ ๋ค๋ฅธ ๋น์ ์์
์๋ ๊ฐ๊ฐ DETR, Mask2Former, GLPN์ด ๋ ์ ํฉํ๋ฏ๋ก ์ด๋ฌํ ๋ชจ๋ธ์ ์ดํด๋ณด๊ฒ ์ต๋๋ค.
### ์ด๋ฏธ์ง ๋ถ๋ฅ[[image-classification]]
ViT์ ConvNeXT ๋ชจ๋ ์ด๋ฏธ์ง ๋ถ๋ฅ์ ์ฌ์ฉ๋ ์ ์์ง๋ง, ViT๋ ์ดํ
์
๋ฉ์ปค๋์ฆ์, ConvNeXT๋ ํฉ์ฑ๊ณฑ์ ์ฌ์ฉํ๋ ๊ฒ์ด ์ฃผ๋ ์ฐจ์ด์
๋๋ค.
#### Transformer[[transformer]]
[ViT](model_doc/vit)์ ํฉ์ฑ๊ณฑ์ ์ ์ ์ผ๋ก ์์ Transformer ์ํคํ
์ฒ๋ก ๋์ฒดํฉ๋๋ค. ๊ธฐ์กด Transformer์ ์ต์ํ๋ค๋ฉด, ViT๋ฅผ ์ดํดํ๋ ๋ฐฉ๋ฒ์ ๋๋ถ๋ถ์ ์ด๋ฏธ ํ์
ํ๋ค๊ณ ๋ณผ ์ ์์ต๋๋ค.
<div class="flex justify-center">
<img src="https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/transformers/model_doc/vit_architecture.jpg"/>
</div>
ViT๊ฐ ๋์
ํ ์ฃผ์ ๋ณ๊ฒฝ ์ฌํญ์ ์ด๋ฏธ์ง๊ฐ Transformer๋ก ์ด๋ป๊ฒ ์ ๋ฌ๋๋์ง์ ์์ต๋๋ค:
1. ์ด๋ฏธ์ง๋ ์๋ก ์ค์ฒฉ๋์ง ์๋ ์ ์ฌ๊ฐํ ํจ์น๋ก ๋ถํ ๋๊ณ , ๊ฐ ํจ์น๋ ๋ฒกํฐ ๋๋ *ํจ์น ์๋ฒ ๋ฉ(patch embedding)*์ผ๋ก ๋ณํ๋ฉ๋๋ค. ํจ์น ์๋ฒ ๋ฉ์ ์ ์ ํ ์
๋ ฅ ์ฐจ์์ ๋ง๋๋ 2D ํฉ์ฑ๊ณฑ ๊ณ์ธต์์ ์์ฑ๋ฉ๋๋ค(๊ธฐ๋ณธ Transformer์ ๊ฒฝ์ฐ ๊ฐ ํจ์น์ ์๋ฒ ๋ฉ๋ง๋ค 768๊ฐ์ ๊ฐ์ด ํ์ํฉ๋๋ค). 224x224 ํฝ์
์ด๋ฏธ์ง๊ฐ ์๋ค๋ฉด, 16x16 ์ด๋ฏธ์ง ํจ์น 196๊ฐ๋ก ๋ถํ ํ ์ ์์ต๋๋ค. ํ
์คํธ๊ฐ ๋จ์ด๋ก ํ ํฐํ๋๋ ๊ฒ์ฒ๋ผ, ์ด๋ฏธ์ง๋ ํจ์น ์ํ์ค๋ก "ํ ํฐํ"๋ฉ๋๋ค.
2. *ํ์ต ๊ฐ๋ฅํ ์๋ฒ ๋ฉ(learnable embedding)*(ํน์ํ `[CLS]` ํ ํฐ)์ด BERT์ ๊ฐ์ด ํจ์น ์๋ฒ ๋ฉ์ ์์ ๋ถ๋ถ์ ์ถ๊ฐ๋ฉ๋๋ค. `[CLS]` ํ ํฐ์ ๋ง์ง๋ง ์๋ ์ํ๋ ๋ถ์ฐฉ๋ ๋ถ๋ฅ ํค๋์ ์
๋ ฅ์ผ๋ก ์ฌ์ฉ๋๊ณ , ๋ค๋ฅธ ์ถ๋ ฅ์ ๋ฌด์๋ฉ๋๋ค. ์ด ํ ํฐ์ ๋ชจ๋ธ์ด ์ด๋ฏธ์ง์ ํํ์ ์ธ์ฝ๋ฉํ๋ ๋ฐฉ๋ฒ์ ํ์ตํ๋ ๋ฐ ๋์์ด ๋ฉ๋๋ค.
3. ํจ์น์ ํ์ต ๊ฐ๋ฅํ ์๋ฒ ๋ฉ์ ๋ง์ง๋ง์ผ๋ก ์ถ๊ฐํ ๊ฒ์ *์์น ์๋ฒ ๋ฉ*์
๋๋ค. ์๋ํ๋ฉด ๋ชจ๋ธ์ ์ด๋ฏธ์ง ํจ์น์ ์์๋ฅผ ๋ชจ๋ฅด๊ธฐ ๋๋ฌธ์
๋๋ค. ์์น ์๋ฒ ๋ฉ๋ ํ์ต ๊ฐ๋ฅํ๋ฉฐ, ํจ์น ์๋ฒ ๋ฉ๊ณผ ๋์ผํ ํฌ๊ธฐ๋ฅผ ๊ฐ์ง๋๋ค. ์ต์ข
์ ์ผ๋ก, ๋ชจ๋ ์๋ฒ ๋ฉ์ด Transformer ์ธ์ฝ๋์ ์ ๋ฌ๋ฉ๋๋ค.
4. `[CLS]` ํ ํฐ์ ํฌํจํ ์ถ๋ ฅ์ ๋ค์ธต ํผ์
ํธ๋ก ํค๋(MLP)์ ์ ๋ฌ๋ฉ๋๋ค. ViT์ ์ฌ์ ํ๋ จ ๋ชฉํ๋ ๋จ์ํ ๋ถ๋ฅ์
๋๋ค. ๋ค๋ฅธ ๋ถ๋ฅ ํค๋์ ๊ฐ์ด, MLP ํค๋๋ ์ถ๋ ฅ์ ํด๋์ค ๋ ์ด๋ธ์ ๋ํด ๋ก์ง์ผ๋ก ๋ณํํ๊ณ ๊ต์ฐจ ์ํธ๋กํผ ์์ค์ ๊ณ์ฐํ์ฌ ๊ฐ์ฅ ๊ฐ๋ฅ์ฑ์ด ๋์ ํด๋์ค๋ฅผ ์ฐพ์ต๋๋ค.
์ด๋ฏธ์ง ๋ถ๋ฅ์ ์ง์ ๋์ ํ ์ค๋น๊ฐ ๋์
จ๋์? ์์ ํ [์ด๋ฏธ์ง ๋ถ๋ฅ ๊ฐ์ด๋](tasks/image_classification)๋ฅผ ํ์ธํ์ฌ ViT๋ฅผ ๋ฏธ์ธ ์กฐ์ ํ๊ณ ์ถ๋ก ์ ์ฌ์ฉํ๋ ๋ฐฉ๋ฒ์ ํ์ตํ์ธ์!
#### CNN[[cnn]]
<Tip>
์ด ์น์
์์๋ ํฉ์ฑ๊ณฑ์ ๋ํด ๊ฐ๋ตํ๊ฒ ์ค๋ช
ํฉ๋๋ค. ๊ทธ๋ฌ๋ ์ด๋ฏธ์ง์ ๋ชจ์๊ณผ ํฌ๊ธฐ๊ฐ ์ด๋ป๊ฒ ๋ณํํ๋์ง์ ๋ํ ์ฌ์ ์ดํด๊ฐ ์๋ค๋ฉด ๋์์ด ๋ ๊ฒ์
๋๋ค. ํฉ์ฑ๊ณฑ์ ์ต์ํ์ง ์์ ๊ฒฝ์ฐ, fastai book์ [ํฉ์ฑ๊ณฑ ์ ๊ฒฝ๋ง ์ฑํฐ](https://github.com/fastai/fastbook/blob/master/13_convolutions.ipynb)๋ฅผ ํ์ธํ์ธ์!
</Tip>
[ConvNeXT](model_doc/convnext)๋ ์ฑ๋ฅ์ ๋์ด๊ธฐ ์ํด ์๋ก์ด ํ๋ ๋คํธ์ํฌ ์ค๊ณ๋ฅผ ์ ์ฉํ CNN ๊ตฌ์กฐ์
๋๋ค. ๊ทธ๋ฌ๋ ํฉ์ฑ๊ณฑ์ ์ฌ์ ํ ๋ชจ๋ธ์ ํต์ฌ์
๋๋ค. ๋์ ์์ค์ ๊ด์ ์์ ๋ณผ ๋, [ํฉ์ฑ๊ณฑ](glossary#convolution)์ ์์ ํ๋ ฌ(*์ปค๋*)์ ์ด๋ฏธ์ง ํฝ์
์ ์์ ์๋์ฐ๋ฅผ ๊ณฑํ๋ ์ฐ์ฐ์
๋๋ค. ์ด๋ ํน์ ํ
์ค์ณ(texture)์ด๋ ์ ์ ๊ณก๋ฅ ๊ณผ ๊ฐ์ ์ผ๋ถ ํน์ง์ ๊ณ์ฐํฉ๋๋ค. ๊ทธ๋ฌ๊ณ ๋ค์ ํฝ์
์๋์ฐ๋ก ๋์ด๊ฐ๋๋ฐ, ์ฌ๊ธฐ์ ํฉ์ฑ๊ณฑ์ด ์ด๋ํ๋ ๊ฑฐ๋ฆฌ๋ฅผ *๋ณดํญ(stride)*์ด๋ผ๊ณ ํฉ๋๋ค.
<div class="flex justify-center">
<img src="https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/convolution.gif"/>
</div>
<small>ํจ๋ฉ์ด๋ ๋ณดํญ์ด ์๋ ๊ธฐ๋ณธ ํฉ์ฑ๊ณฑ, <a href="https://arxiv.org/abs/1603.07285">๋ฅ๋ฌ๋์ ์ํ ํฉ์ฑ๊ณฑ ์ฐ์ฐ ๊ฐ์ด๋</a></small>
์ด ์ถ๋ ฅ์ ๋ค๋ฅธ ํฉ์ฑ๊ณฑ ๋ ์ด์ด์ ์ ๋ฌํ ์ ์์ผ๋ฉฐ, ๊ฐ ์ฐ์์ ์ธ ๋ ์ด์ด๋ฅผ ํตํด ๋คํธ์ํฌ๋ ํซ๋๊ทธ๋ ๋ก์ผ๊ณผ ๊ฐ์ด ๋ ๋ณต์กํ๊ณ ์ถ์์ ์ธ ๊ฒ์ ํ์ตํฉ๋๋ค. ํฉ์ฑ๊ณฑ ๋ ์ด์ด ์ฌ์ด์ ํ๋ง ๋ ์ด์ด๋ฅผ ์ถ๊ฐํ์ฌ ์ฐจ์์ ์ค์ด๊ณ ํน์ง์ ์์น ๋ณํ์ ๋ํด ๋ชจ๋ธ์ ๋ ๊ฒฌ๊ณ ํ๊ฒ ๋ง๋๋ ๊ฒ์ด ์ผ๋ฐ์ ์
๋๋ค.
<div class="flex justify-center">
<img src="https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/convnext_architecture.png"/>
</div>
ConvNeXT๋ CNN์ 5๊ฐ์ง ๋ฐฉ์์ผ๋ก ํ๋ํํฉ๋๋ค:
1. ๊ฐ ๋จ๊ณ์ ๋ธ๋ก ์๋ฅผ ๋ณ๊ฒฝํ๊ณ ๋ ํฐ ๋ณดํญ๊ณผ ๊ทธ์ ๋์ํ๋ ์ปค๋ ํฌ๊ธฐ๋ก ์ด๋ฏธ์ง๋ฅผ "ํจ์นํ(patchify)"ํฉ๋๋ค. ๊ฒน์น์ง ์๋ ์ฌ๋ผ์ด๋ฉ ์๋์ฐ๋ ViT๊ฐ ์ด๋ฏธ์ง๋ฅผ ํจ์น๋ก ๋ถํ ํ๋ ๋ฐฉ๋ฒ๊ณผ ์ ์ฌํ๊ฒ ์ด ํจ์นํ ์ ๋ต์ ๋ง๋ญ๋๋ค.
2. *๋ณ๋ชฉ(bottleneck)* ๋ ์ด์ด๋ ์ฑ๋ ์๋ฅผ ์ค์๋ค๊ฐ ๋ค์ ๋ณต์ํฉ๋๋ค. ์๋ํ๋ฉด 1x1 ํฉ์ฑ๊ณฑ์ ์ํํ๋ ๊ฒ์ด ๋ ๋น ๋ฅด๊ณ , ๊น์ด๋ฅผ ๋๋ฆด ์ ์๊ธฐ ๋๋ฌธ์
๋๋ค. ์ญ ๋ณ๋ชฉ(inverted bottlenect)์ ์ฑ๋ ์๋ฅผ ํ์ฅํ๊ณ ์ถ์ํจ์ผ๋ก์จ ๊ทธ ๋ฐ๋๋ก ์ํํ๋ฏ๋ก, ๋ฉ๋ชจ๋ฆฌ ํจ์จ์ด ๋ ๋์ต๋๋ค.
3. ๋ณ๋ชฉ ๋ ์ด์ด์ ์ผ๋ฐ์ ์ธ 3x3 ํฉ์ฑ๊ณฑ ๋ ์ด์ด๋ฅผ ๊ฐ ์
๋ ฅ ์ฑ๋์ ๊ฐ๋ณ์ ์ผ๋ก ํฉ์ฑ๊ณฑ์ ์ ์ฉํ ๋ค์ ๋ง์ง๋ง์ ์๋ *๊น์ด๋ณ ํฉ์ฑ๊ณฑ(depthwise convolution)*์ผ๋ก ๋์ฒดํฉ๋๋ค. ์ด๋ ๋คํธ์ํฌ ํญ์ด ๋ํ ์ฑ๋ฅ์ด ํฅ์๋ฉ๋๋ค.
4. ViT๋ ์ดํ
์
๋ฉ์ปค๋์ฆ ๋๋ถ์ ํ ๋ฒ์ ๋ ๋ง์ ์ด๋ฏธ์ง๋ฅผ ๋ณผ ์ ์๋ ์ ์ญ ์์ ํ๋๋ฅผ ๊ฐ์ง๊ณ ์์ต๋๋ค. ConvNeXT๋ ์ปค๋ ํฌ๊ธฐ๋ฅผ 7x7๋ก ๋๋ ค ์ด ํจ๊ณผ๋ฅผ ์ฌํํ๋ ค๊ณ ์๋ํฉ๋๋ค.
5. ๋ํ ConvNeXT๋ Transformer ๋ชจ๋ธ์ ๋ชจ๋ฐฉํ๋ ๋ช ๊ฐ์ง ๋ ์ด์ด ์ค๊ณ๋ฅผ ๋ณ๊ฒฝํฉ๋๋ค. ํ์ฑํ ๋ฐ ์ ๊ทํ ๋ ์ด์ด๊ฐ ๋ ์ ๊ณ , ํ์ฑํ ํจ์๊ฐ ReLU ๋์ GELU๋ก ์ ํ๋๊ณ , BatchNorm ๋์ LayerNorm์ ์ฌ์ฉํฉ๋๋ค.
ํฉ์ฑ๊ณฑ ๋ธ๋ก์ ์ถ๋ ฅ์ ๋ถ๋ฅ ํค๋๋ก ์ ๋ฌ๋๋ฉฐ, ๋ถ๋ฅ ํค๋๋ ์ถ๋ ฅ์ ๋ก์ง์ผ๋ก ๋ณํํ๊ณ ๊ต์ฐจ ์ํธ๋กํผ ์์ค์ ๊ณ์ฐํ์ฌ ๊ฐ์ฅ ๊ฐ๋ฅ์ฑ์ด ๋์ ๋ ์ด๋ธ์ ์ฐพ์ต๋๋ค.
### ๊ฐ์ฒด ํ์ง[[object-detection]]
[DETR](model_doc/detr), *DEtection TRansformer*๋ CNN๊ณผ Transformer ์ธ์ฝ๋-๋์ฝ๋๋ฅผ ๊ฒฐํฉํ ์ข
๋จ๊ฐ(end-to-end) ๊ฐ์ฒด ํ์ง ๋ชจ๋ธ์
๋๋ค.
<div class="flex justify-center">
<img src="https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/detr_architecture.png"/>
</div>
1. ์ฌ์ ํ๋ จ๋ CNN *๋ฐฑ๋ณธ(backbone)*์ ํฝ์
๊ฐ์ผ๋ก ๋ํ๋ธ ์ด๋ฏธ์ง๋ฅผ ๊ฐ์ ธ์ ์ ํด์๋ ํน์ง ๋งต์ ๋ง๋ญ๋๋ค. ํน์ง ๋งต์ ๋ํด 1x1 ํฉ์ฑ๊ณฑ์ ์ ์ฉํ์ฌ ์ฐจ์์ ์ค์ด๊ณ , ๊ณ ์์ค ์ด๋ฏธ์ง ํํ์ ๊ฐ์ง ์๋ก์ด ํน์ง ๋งต์ ์์ฑํฉ๋๋ค. Transformer๋ ์ํ์ค ๋ชจ๋ธ์ด๊ธฐ ๋๋ฌธ์ ํน์ง ๋งต์ ์์น ์๋ฒ ๋ฉ๊ณผ ๊ฒฐํฉ๋ ํน์ง ๋ฒกํฐ์ ์ํ์ค๋ก ํํํํฉ๋๋ค.
2. ํน์ง ๋ฒกํฐ๋ ์ดํ
์
๋ ์ด์ด๋ฅผ ์ฌ์ฉํ์ฌ ์ด๋ฏธ์ง ํํ์ ํ์ตํ๋ ์ธ์ฝ๋์ ์ ๋ฌ๋ฉ๋๋ค. ๋ค์์ผ๋ก, ์ธ์ฝ๋์ ์๋ ์ํ๋ ๋์ฝ๋์์ *๊ฐ์ฒด ์ฟผ๋ฆฌ*์ ๊ฒฐํฉ๋ฉ๋๋ค. ๊ฐ์ฒด ์ฟผ๋ฆฌ๋ ์ด๋ฏธ์ง์ ๋ค๋ฅธ ์์ญ์ ์ด์ ์ ๋ง์ถ ํ์ต๋ ์๋ฒ ๋ฉ์ผ๋ก ํ์ต๋๊ณ , ๊ฐ ์ดํ
์
๋ ์ด์ด๋ฅผ ์งํํ๋ฉด์ ๊ฐฑ์ ๋ฉ๋๋ค. ๋์ฝ๋์ ์๋ ์ํ๋ ๊ฐ ๊ฐ์ฒด ์ฟผ๋ฆฌ์ ๋ํ ๋ฐ์ด๋ฉ ๋ฐ์ค ์ขํ์ ํด๋์ค ๋ ์ด๋ธ์ ์์ธกํ๋ ์๋ฐฉํฅ ๋คํธ์ํฌ์ ์ ๋ฌ๋๋ฉฐ, ๊ฐ์ฒด๊ฐ ์๋ ๊ฒฝ์ฐ `no object`๊ฐ ์ถ๋ ฅ๋ฉ๋๋ค.
DETR์ ๊ฐ ๊ฐ์ฒด ์ฟผ๋ฆฌ๋ฅผ ๋ณ๋ ฌ๋ก ๋์ฝ๋ฉํ์ฌ *N* ๊ฐ์ ์ต์ข
์์ธก์ ์ถ๋ ฅํฉ๋๋ค. ์ฌ๊ธฐ์ *N*์ ์ฟผ๋ฆฌ ์์
๋๋ค. ํ ๋ฒ์ ํ๋์ ์์๋ฅผ ์์ธกํ๋ ์ผ๋ฐ์ ์ธ ์๊ธฐํ๊ท ๋ชจ๋ธ๊ณผ ๋ฌ๋ฆฌ, ๊ฐ์ฒด ํ์ง๋ ํ ๋ฒ์ *N* ๊ฐ์ ์์ธก์ ์ํํ๋ ์งํฉ ์์ธก ์์
(`๋ฐ์ด๋ฉ ๋ฐ์ค`, `ํด๋์ค ๋ ์ด๋ธ`)์
๋๋ค.
3. DETR์ ํ๋ จ ์ค *์ด๋ถ ๋งค์นญ ์์ค(bipartite matching loss)*์ ์ฌ์ฉํ์ฌ ๊ณ ์ ๋ ์์ ์์ธก๊ณผ ๊ณ ์ ๋ ์ค์ ์ ๋ต ๋ ์ด๋ธ(ground truth labels) ์ธํธ๋ฅผ ๋น๊ตํฉ๋๋ค. *N*๊ฐ์ ๋ ์ด๋ธ ์ธํธ์ ์ค์ ์ ๋ต ๋ ์ด๋ธ๋ณด๋ค ์ ์ ๊ฒฝ์ฐ, `no object` ํด๋์ค๋ก ํจ๋ฉ๋ฉ๋๋ค. ์ด ์์ค ํจ์๋ DETR์ด ์์ธก๊ณผ ์ค์ ์ ๋ต ๋ ์ด๋ธ ๊ฐ 1:1 ๋์์ ์ฐพ๋๋ก ๊ถ์ฅํฉ๋๋ค. ๋ฐ์ด๋ฉ ๋ฐ์ค ๋๋ ํด๋์ค ๋ ์ด๋ธ ์ค ํ๋๋ผ๋ ์๋ชป๋ ๊ฒฝ์ฐ, ์์ค์ด ๋ฐ์ํฉ๋๋ค. ๋ง์ฐฌ๊ฐ์ง๋ก, ์กด์ฌํ์ง ์๋ ๊ฐ์ฒด๋ฅผ ์์ธกํ๋ ๊ฒฝ์ฐ, ํจ๋ํฐ๋ฅผ ๋ฐ์ต๋๋ค. ์ด๋ก ์ธํด DETR์ ์ด๋ฏธ์ง์์ ๋์ ์ ๋๋ ๋ฌผ์ฒด ํ๋์ ์ง์คํ๋ ๋์ , ๋ค๋ฅธ ๊ฐ์ฒด๋ฅผ ์ฐพ๋๋ก ๊ถ์ฅ๋ฉ๋๋ค.
๊ฐ์ฒด ํ์ง ํค๋๊ฐ DETR ์๋จ์ ์ถ๊ฐ๋์ด ํด๋์ค ๋ ์ด๋ธ๊ณผ ๋ฐ์ด๋ฉ ๋ฐ์ค์ ์ขํ๋ฅผ ์ฐพ์ต๋๋ค. ๊ฐ์ฒด ํ์ง ํค๋์๋ ๋ ๊ฐ์ง ๊ตฌ์ฑ ์์๊ฐ ์์ต๋๋ค: ๋์ฝ๋ ์๋ ์ํ๋ฅผ ํด๋์ค ๋ ์ด๋ธ์ ๋ก์ง์ผ๋ก ๋ณํํ๋ ์ ํ ๋ ์ด์ด ๋ฐ ๋ฐ์ด๋ฉ ๋ฐ์ค๋ฅผ ์์ธกํ๋ MLP
๊ฐ์ฒด ํ์ง์ ์ง์ ๋์ ํ ์ค๋น๊ฐ ๋์
จ๋์? ์์ ํ [๊ฐ์ฒด ํ์ง ๊ฐ์ด๋](tasks/object_detection)๋ฅผ ํ์ธํ์ฌ DETR์ ๋ฏธ์ธ ์กฐ์ ํ๊ณ ์ถ๋ก ์ ์ฌ์ฉํ๋ ๋ฐฉ๋ฒ์ ํ์ตํ์ธ์!
### ์ด๋ฏธ์ง ๋ถํ [[image-segmentation]]
[Mask2Former](model_doc/mask2former)๋ ๋ชจ๋ ์ ํ์ ์ด๋ฏธ์ง ๋ถํ ์์
์ ํด๊ฒฐํ๋ ๋ฒ์ฉ ์ํคํ
์ฒ์
๋๋ค. ์ ํต์ ์ธ ๋ถํ ๋ชจ๋ธ์ ์ผ๋ฐ์ ์ผ๋ก ์๋ฉํฑ(semantic) ๋๋ ํ๋ํฑ(panoptic) ๋ถํ ๊ณผ ๊ฐ์ ์ด๋ฏธ์ง ๋ถํ ์ ํน์ ํ์ ์์
์ ๋ง์ถฐ ์กฐ์ ๋ฉ๋๋ค. Mask2Former๋ ๋ชจ๋ ์์
์ *๋ง์คํฌ ๋ถ๋ฅ* ๋ฌธ์ ๋ก ๊ตฌ์ฑํฉ๋๋ค. ๋ง์คํฌ ๋ถ๋ฅ๋ ํฝ์
์ *N*๊ฐ ์ธ๊ทธ๋จผํธ๋ก ๊ทธ๋ฃนํํ๊ณ , ์ฃผ์ด์ง ์ด๋ฏธ์ง์ ๋ํด *N*๊ฐ์ ๋ง์คํฌ์ ๊ทธ์ ๋์ํ๋ ํด๋์ค ๋ ์ด๋ธ์ ์์ธกํฉ๋๋ค. ์ด ์น์
์์ Mask2Former์ ์๋ ๋ฐฉ๋ฒ์ ์ค๋ช
ํ ๋ค์, ๋ง์ง๋ง์ SegFormer๋ฅผ ๋ฏธ์ธ ์กฐ์ ํด๋ณผ ์ ์์ต๋๋ค.
<div class="flex justify-center">
<img src="https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/mask2former_architecture.png"/>
</div>
Mask2Former์๋ 3๊ฐ์ง ์ฃผ์ ๊ตฌ์ฑ ์์๊ฐ ์์ต๋๋ค:
1. [Swin](model_doc/swin) ๋ฐฑ๋ณธ์ด ์ด๋ฏธ์ง๋ฅผ ๋ฐ์ 3๊ฐ์ ์ฐ์๋ 3x3 ํฉ์ฑ๊ณฑ์์ ์ ํด์๋ ์ด๋ฏธ์ง ํน์ง ๋งต์ ์์ฑํฉ๋๋ค.
2. ํน์ง ๋งต์ *ํฝ์
๋์ฝ๋*์ ์ ๋ฌ๋ฉ๋๋ค. ์ด ๋์ฝ๋๋ ์ ํด์๋ ํน์ง์ ๊ณ ํด์๋ ํฝ์
์๋ฒ ๋ฉ์ผ๋ก ์ ์ง์ ์ผ๋ก ์
์ํ๋งํฉ๋๋ค. ํฝ์
๋์ฝ๋๋ ์ค์ ๋ก ์๋ณธ ์ด๋ฏธ์ง์ 1/32, 1/16, 1/8 ํด์๋์ ๋ค์ค ์ค์ผ์ผ ํน์ง(์ ํด์๋ ๋ฐ ๊ณ ํด์๋ ํน์ง ๋ชจ๋ ํฌํจ)์ ์์ฑํฉ๋๋ค.
3. ์ด๋ฌํ ์๋ก ๋ค๋ฅธ ํฌ๊ธฐ์ ํน์ง ๋งต์ ๊ณ ํด์๋ ํน์ง์์ ์์ ๊ฐ์ฒด๋ฅผ ํฌ์ฐฉํ๊ธฐ ์ํด ํ ๋ฒ์ ํ๋์ Transformer ๋์ฝ๋ ๋ ์ด์ด์ ์ฐ์์ ์ผ๋ก ๊ณต๊ธ๋ฉ๋๋ค. Mask2Former์ ํต์ฌ์ ๋์ฝ๋์ *๋ง์คํฌ ์ดํ
์
* ๋ฉ์ปค๋์ฆ์
๋๋ค. ์ ์ฒด ์ด๋ฏธ์ง๋ฅผ ์ฐธ์กฐํ ์ ์๋ ํฌ๋ก์ค ์ดํ
์
(cross-attention)๊ณผ ๋ฌ๋ฆฌ, ๋ง์คํฌ ์ดํ
์
์ ์ด๋ฏธ์ง์ ํน์ ์์ญ์๋ง ์ง์คํฉ๋๋ค. ์ด๋ ์ด๋ฏธ์ง์ ์ง์ญ์ ํน์ง๋ง์ผ๋ก ๋ชจ๋ธ์ด ์ถฉ๋ถํ ํ์ตํ ์ ์๊ธฐ ๋๋ฌธ์ ๋ ๋น ๋ฅด๊ณ ์ฑ๋ฅ์ด ์ฐ์ํฉ๋๋ค.
4. [DETR](tasks_explained#object-detection)๊ณผ ๊ฐ์ด, Mask2Former๋ ํ์ต๋ ๊ฐ์ฒด ์ฟผ๋ฆฌ๋ฅผ ์ฌ์ฉํ๊ณ ์ด๋ฅผ ํฝ์
๋์ฝ๋์์์ ์ด๋ฏธ์ง ํน์ง๊ณผ ๊ฒฐํฉํ์ฌ ์์ธก ์งํฉ(`ํด๋์ค ๋ ์ด๋ธ`, `๋ง์คํฌ ์์ธก`)์ ์์ฑํฉ๋๋ค. ๋์ฝ๋์ ์๋ ์ํ๋ ์ ํ ๋ ์ด์ด๋ก ์ ๋ฌ๋์ด ํด๋์ค ๋ ์ด๋ธ์ ๋ํ ๋ก์ง์ผ๋ก ๋ณํ๋ฉ๋๋ค. ๋ก์ง๊ณผ ํด๋์ค ๋ ์ด๋ธ ์ฌ์ด์ ๊ต์ฐจ ์ํธ๋กํผ ์์ค์ ๊ณ์ฐํ์ฌ ๊ฐ์ฅ ๊ฐ๋ฅ์ฑ์ด ๋์ ๊ฒ์ ์ฐพ์ต๋๋ค.
๋ง์คํฌ ์์ธก์ ํฝ์
์๋ฒ ๋ฉ๊ณผ ์ต์ข
๋์ฝ๋ ์๋ ์ํ๋ฅผ ๊ฒฐํฉํ์ฌ ์์ฑ๋ฉ๋๋ค. ์๊ทธ๋ชจ์ด๋ ๊ต์ฐจ ์ํธ๋กํผ ๋ฐ Dice ์์ค์ ๋ก์ง๊ณผ ์ค์ ์ ๋ต ๋ง์คํฌ(ground truth mask) ์ฌ์ด์์ ๊ณ์ฐ๋์ด ๊ฐ์ฅ ๊ฐ๋ฅ์ฑ์ด ๋์ ๋ง์คํฌ๋ฅผ ์ฐพ์ต๋๋ค.
์ด๋ฏธ์ง ๋ถํ ์ ์ง์ ๋์ ํ ์ค๋น๊ฐ ๋์
จ๋์? ์์ ํ [์ด๋ฏธ์ง ๋ถํ ๊ฐ์ด๋](tasks/semantic_segmentation)๋ฅผ ํ์ธํ์ฌ SegFormer๋ฅผ ๋ฏธ์ธ ์กฐ์ ํ๊ณ ์ถ๋ก ์ ์ฌ์ฉํ๋ ๋ฐฉ๋ฒ์ ํ์ตํ์ธ์!
### ๊น์ด ์ถ์ [[depth-estimation]]
[GLPN](model_doc/glpn), *Global-Local Path Network*๋ [SegFormer](model_doc/segformer) ์ธ์ฝ๋์ ๊ฒฝ๋ ๋์ฝ๋๋ฅผ ๊ฒฐํฉํ ๊น์ด ์ถ์ ์ ์ํ Transformer์
๋๋ค.
<div class="flex justify-center">
<img src="https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/glpn_architecture.jpg"/>
</div>
1. ViT์ ๊ฐ์ด, ์ด๋ฏธ์ง๋ ํจ์น ์ํ์ค๋ก ๋ถํ ๋์ง๋ง, ์ด๋ฏธ์ง ํจ์น๊ฐ ๋ ์๋ค๋ ์ ์ด ๋ค๋ฆ
๋๋ค. ์ด๋ ์ธ๊ทธ๋ฉํ
์ด์
์ด๋ ๊น์ด ์ถ์ ๊ณผ ๊ฐ์ ๋ฐ๋ ์์ธก ์์
์ ๋ ์ ํฉํฉ๋๋ค. ์ด๋ฏธ์ง ํจ์น๋ ํจ์น ์๋ฒ ๋ฉ์ผ๋ก ๋ณํ๋์ด(ํจ์น ์๋ฒ ๋ฉ์ด ์์ฑ๋๋ ๋ฐฉ๋ฒ์ [์ด๋ฏธ์ง ๋ถ๋ฅ](#image-classification) ์น์
์ ์ฐธ์กฐํ์ธ์), ์ธ์ฝ๋๋ก ์ ๋ฌ๋ฉ๋๋ค.
2. ์ธ์ฝ๋๋ ํจ์น ์๋ฒ ๋ฉ์ ๋ฐ์, ์ฌ๋ฌ ์ธ์ฝ๋ ๋ธ๋ก์ ์ ๋ฌํฉ๋๋ค. ๊ฐ ๋ธ๋ก์ ์ดํ
์
๋ฐ Mix-FFN ๋ ์ด์ด๋ก ๊ตฌ์ฑ๋ฉ๋๋ค. ํ์์ ๋ชฉ์ ์ ์์น ์ ๋ณด๋ฅผ ์ ๊ณตํ๋ ๊ฒ์
๋๋ค. ๊ฐ ์ธ์ฝ๋ ๋ธ๋ก์ ๋์๋ ๊ณ์ธต์ ํํ์ ์์ฑํ๊ธฐ ์ํ *ํจ์น ๋ณํฉ(patch merging)* ๋ ์ด์ด๊ฐ ์์ต๋๋ค. ๊ฐ ์ธ์ ํ ํจ์น ๊ทธ๋ฃน์ ํน์ง์ ์ฐ๊ฒฐ๋๊ณ , ์ฐ๊ฒฐ๋ ํน์ง์ ์ ํ ๋ ์ด์ด๊ฐ ์ ์ฉ๋์ด ํจ์น ์๋ฅผ 1/4์ ํด์๋๋ก ์ค์
๋๋ค. ์ด๋ ๋ค์ ์ธ์ฝ๋ ๋ธ๋ก์ ์
๋ ฅ์ด ๋๋ฉฐ, ์ด๋ฌํ ์ ์ฒด ํ๋ก์ธ์ค๋ 1/8, 1/16, 1/32 ํด์๋์ ์ด๋ฏธ์ง ํน์ง์ ๊ฐ์ง ๋๊น์ง ๋ฐ๋ณต๋ฉ๋๋ค.
3. ๊ฒฝ๋ ๋์ฝ๋๋ ์ธ์ฝ๋์์ ๋ง์ง๋ง ํน์ง ๋งต(1/32 ํฌ๊ธฐ)์ ๊ฐ์ ธ์ 1/16 ํฌ๊ธฐ๋ก ์
์ํ๋งํฉ๋๋ค. ์ฌ๊ธฐ์, ํน์ง์ *์ ํ์ ํน์ง ์ตํฉ(SFF, Selective Feature Fusion)* ๋ชจ๋๋ก ์ ๋ฌ๋ฉ๋๋ค. ์ด ๋ชจ๋์ ๊ฐ ํน์ง์ ๋ํด ์ดํ
์
๋งต์์ ๋ก์ปฌ ๋ฐ ์ ์ญ ํน์ง์ ์ ํํ๊ณ ๊ฒฐํฉํ ๋ค์, 1/8๋ก ์
์ํ๋งํฉ๋๋ค. ์ด ํ๋ก์ธ์ค๋ ๋์ฝ๋ฉ๋ ํน์ฑ์ด ์๋ณธ ์ด๋ฏธ์ง์ ๋์ผํ ํฌ๊ธฐ๊ฐ ๋ ๋๊น์ง ๋ฐ๋ณต๋ฉ๋๋ค. ์ถ๋ ฅ์ ๋ ๊ฐ์ ํฉ์ฑ๊ณฑ ๋ ์ด์ด๋ฅผ ๊ฑฐ์น ๋ค์, ์๊ทธ๋ชจ์ด๋ ํ์ฑํ๊ฐ ์ ์ฉ๋์ด ๊ฐ ํฝ์
์ ๊น์ด๋ฅผ ์์ธกํฉ๋๋ค.
## ์์ฐ์ด์ฒ๋ฆฌ[[natural-language-processing]]
Transformer๋ ์ด๊ธฐ์ ๊ธฐ๊ณ ๋ฒ์ญ์ ์ํด ์ค๊ณ๋์๊ณ , ๊ทธ ์ดํ๋ก๋ ์ฌ์ค์ ๋ชจ๋ NLP ์์
์ ํด๊ฒฐํ๊ธฐ ์ํ ๊ธฐ๋ณธ ์ํคํ
์ฒ๊ฐ ๋์์ต๋๋ค. ์ด๋ค ์์
์ Transformer์ ์ธ์ฝ๋ ๊ตฌ์กฐ์ ์ ํฉํ๋ฉฐ, ๋ค๋ฅธ ์์
์ ๋์ฝ๋์ ๋ ์ ํฉํฉ๋๋ค. ๋ ๋ค๋ฅธ ์์
์ Transformer์ ์ธ์ฝ๋-๋์ฝ๋ ๊ตฌ์กฐ๋ฅผ ๋ชจ๋ ํ์ฉํฉ๋๋ค.
### ํ
์คํธ ๋ถ๋ฅ[[text-classification]]
[BERT](model_doc/bert)๋ ์ธ์ฝ๋ ์ ์ฉ ๋ชจ๋ธ์ด๋ฉฐ, ํ
์คํธ์ ํ๋ถํ ํํ์ ํ์ตํ๊ธฐ ์ํด ์๋ฐฉํฅ์ ๋จ์ด์ ์ฃผ๋ชฉํจ์ผ๋ก์จ ์ฌ์ธต ์๋ฐฉํฅ์ฑ(deep bidirectionality)์ ํจ๊ณผ์ ์ผ๋ก ๊ตฌํํ ์ต์ด์ ๋ชจ๋ธ์
๋๋ค.
1. BERT๋ [WordPiece](tokenizer_summary#wordpiece) ํ ํฐํ๋ฅผ ์ฌ์ฉํ์ฌ ๋ฌธ์ฅ์ ํ ํฐ ์๋ฒ ๋ฉ์ ์์ฑํฉ๋๋ค. ๋จ์ผ ๋ฌธ์ฅ๊ณผ ํ ์์ ๋ฌธ์ฅ์ ๊ตฌ๋ถํ๊ธฐ ์ํด ํน์ํ `[SEP]` ํ ํฐ์ด ์ถ๊ฐ๋ฉ๋๋ค. ๋ชจ๋ ํ
์คํธ ์ํ์ค์ ์์ ๋ถ๋ถ์๋ ํน์ํ `[CLS]` ํ ํฐ์ด ์ถ๊ฐ๋ฉ๋๋ค. `[CLS]` ํ ํฐ์ด ์๋ ์ต์ข
์ถ๋ ฅ์ ๋ถ๋ฅ ์์
์ ์ํ ๋ถ๋ฅ ํค๋๋ก ์
๋ ฅ์ ์ฌ์ฉ๋ฉ๋๋ค. BERT๋ ๋ํ ํ ์์ ๋ฌธ์ฅ์์ ๊ฐ ํ ํฐ์ด ์ฒซ ๋ฒ์งธ ๋ฌธ์ฅ์ธ์ง ๋ ๋ฒ์งธ ๋ฌธ์ฅ์ ์ํ๋์ง ๋ํ๋ด๋ ์ธ๊ทธ๋จผํธ ์๋ฒ ๋ฉ(segment embedding)์ ์ถ๊ฐํฉ๋๋ค.
2. BERT๋ ๋ง์คํฌ๋ ์ธ์ด ๋ชจ๋ธ๋ง๊ณผ ๋ค์ ๋ฌธ์ฅ ์์ธก, ๋ ๊ฐ์ง ๋ชฉ์ ์ผ๋ก ์ฌ์ ํ๋ จ๋ฉ๋๋ค. ๋ง์คํฌ๋ ์ธ์ด ๋ชจ๋ธ๋ง์์๋ ์
๋ ฅ ํ ํฐ์ ์ผ๋ถ๊ฐ ๋ฌด์์๋ก ๋ง์คํน๋๊ณ , ๋ชจ๋ธ์ ์ด๋ฅผ ์์ธกํด์ผ ํฉ๋๋ค. ์ด๋ ๋ชจ๋ธ์ด ๋ชจ๋ ๋จ์ด๋ฅผ ๋ณด๊ณ ๋ค์ ๋จ์ด๋ฅผ "์์ธก"ํ ์ ์๋ ์๋ฐฉํฅ์ฑ ๋ฌธ์ ๋ฅผ ํด๊ฒฐํฉ๋๋ค. ์์ธก๋ ๋ง์คํฌ ํ ํฐ์ ์ต์ข
์๋ ์ํ๋ ์ดํ์ ๋ํ ์ํํธ๋งฅ์ค๊ฐ ์๋ ์๋ฐฉํฅ ๋คํธ์ํฌ๋ก ์ ๋ฌ๋์ด ๋ง์คํฌ๋ ๋จ์ด๋ฅผ ์์ธกํฉ๋๋ค.
๋ ๋ฒ์งธ ์ฌ์ ํ๋ จ ๋์์ ๋ค์ ๋ฌธ์ฅ ์์ธก์
๋๋ค. ๋ชจ๋ธ์ ๋ฌธ์ฅ B๊ฐ ๋ฌธ์ฅ A ๋ค์์ ์ค๋์ง ์์ธกํด์ผ ํฉ๋๋ค. ๋ฌธ์ฅ B๊ฐ ๋ค์ ๋ฌธ์ฅ์ธ ๊ฒฝ์ฐ์ ๋ฌด์์ ๋ฌธ์ฅ์ธ ๊ฒฝ์ฐ ๊ฐ๊ฐ 50%์ ํ๋ฅ ๋ก ๋ฐ์ํฉ๋๋ค. ๋ค์ ๋ฌธ์ฅ์ธ์ง ์๋์ง์ ๋ํ ์์ธก์ ๋ ๊ฐ์ ํด๋์ค(`IsNext` ๋ฐ `NotNext`)์ ๋ํ ์ํํธ๋งฅ์ค๊ฐ ์๋ ์๋ฐฉํฅ ๋คํธ์ํฌ๋ก ์ ๋ฌ๋ฉ๋๋ค.
3. ์
๋ ฅ ์๋ฒ ๋ฉ์ ์ฌ๋ฌ ์ธ์ฝ๋ ๋ ์ด์ด๋ฅผ ๊ฑฐ์ณ์ ์ต์ข
์๋ ์ํ๋ฅผ ์ถ๋ ฅํฉ๋๋ค.
์ฌ์ ํ๋ จ๋ ๋ชจ๋ธ์ ํ
์คํธ ๋ถ๋ฅ์ ์ฌ์ฉํ๋ ค๋ฉด, ๊ธฐ๋ณธ BERT ๋ชจ๋ธ ์๋จ์ ์ํ์ค ๋ถ๋ฅ ํค๋๋ฅผ ์ถ๊ฐํฉ๋๋ค. ์ํ์ค ๋ถ๋ฅ ํค๋๋ ์ต์ข
์๋ ์ํ๋ฅผ ๋ฐ๋ ์ ํ ๋ ์ด์ด์ด๋ฉฐ, ๋ก์ง์ผ๋ก ๋ณํํ๊ธฐ ์ํด ์ ํ ๋ณํ์ ์ํํฉ๋๋ค. ๊ต์ฐจ ์ํธ๋กํผ ์์ค์ ๋ก์ง๊ณผ ํ๊ฒ ๊ฐ์ ๊ณ์ฐ๋์ด ๊ฐ์ฅ ๊ฐ๋ฅ์ฑ์ด ๋์ ๋ ์ด๋ธ์ ์ฐพ์ต๋๋ค.
ํ
์คํธ ๋ถ๋ฅ์ ์ง์ ๋์ ํ ์ค๋น๊ฐ ๋์
จ๋์? ์์ ํ [ํ
์คํธ ๋ถ๋ฅ ๊ฐ์ด๋](tasks/sequence_classification)๋ฅผ ํ์ธํ์ฌ DistilBERT๋ฅผ ๋ฏธ์ธ ์กฐ์ ํ๊ณ ์ถ๋ก ์ ์ฌ์ฉํ๋ ๋ฐฉ๋ฒ์ ํ์ตํ์ธ์!
### ํ ํฐ ๋ถ๋ฅ[[token-classification]]
๊ฐ์ฒด๋ช
์ธ์(Named Entity Recognition, NER)๊ณผ ๊ฐ์ ํ ํฐ ๋ถ๋ฅ ์์
์ BERT๋ฅผ ์ฌ์ฉํ๋ ค๋ฉด, ๊ธฐ๋ณธ BERT ๋ชจ๋ธ ์๋จ์ ํ ํฐ ๋ถ๋ฅ ํค๋๋ฅผ ์ถ๊ฐํฉ๋๋ค. ํ ํฐ ๋ถ๋ฅ ํค๋๋ ์ต์ข
์๋ ์ํ๋ฅผ ๋ฐ๋ ์ ํ ๋ ์ด์ด์ด๋ฉฐ, ๋ก์ง์ผ๋ก ๋ณํํ๊ธฐ ์ํด ์ ํ ๋ณํ์ ์ํํฉ๋๋ค. ๊ต์ฐจ ์ํธ๋กํผ ์์ค์ ๋ก์ง๊ณผ ๊ฐ ํ ํฐ ๊ฐ์ ๊ณ์ฐ๋์ด ๊ฐ์ฅ ๊ฐ๋ฅ์ฑ์ด ๋์ ๋ ์ด๋ธ์ ์ฐพ์ต๋๋ค.
ํ ํฐ ๋ถ๋ฅ์ ์ง์ ๋์ ํ ์ค๋น๊ฐ ๋์
จ๋์? ์์ ํ [ํ ํฐ ๋ถ๋ฅ ๊ฐ์ด๋](tasks/token_classification)๋ฅผ ํ์ธํ์ฌ DistilBERT๋ฅผ ๋ฏธ์ธ ์กฐ์ ํ๊ณ ์ถ๋ก ์ ์ฌ์ฉํ๋ ๋ฐฉ๋ฒ์ ํ์ตํ์ธ์!
### ์ง์์๋ต[[question-answering]]
์ง์์๋ต์ BERT๋ฅผ ์ฌ์ฉํ๋ ค๋ฉด, ๊ธฐ๋ณธ BERT ๋ชจ๋ธ ์์ ์คํฌ(span) ๋ถ๋ฅ ํค๋๋ฅผ ์ถ๊ฐํฉ๋๋ค. ์ด ์ ํ ๋ ์ด์ด๋ ์ต์ข
์๋ ์ํ๋ฅผ ๋ฐ๊ณ , ๋ต๋ณ์ ๋์ํ๋ `์คํฌ`์ ์์๊ณผ ๋ ๋ก๊ทธ๋ฅผ ๊ณ์ฐํ๊ธฐ ์ํด ์ ํ ๋ณํ์ ์ํํฉ๋๋ค. ๊ต์ฐจ ์ํธ๋กํผ ์์ค์ ๋ก์ง๊ณผ ๊ฐ ๋ ์ด๋ธ ์์น ๊ฐ์ ๊ณ์ฐ๋์ด ๋ต๋ณ์ ๋์ํ๋ ๊ฐ์ฅ ๊ฐ๋ฅ์ฑ์ด ๋์ ํ
์คํธ์ ์คํฌ์ ์ฐพ์ต๋๋ค.
์ง์์๋ต์ ์ง์ ๋์ ํ ์ค๋น๊ฐ ๋์
จ๋์? ์์ ํ [์ง์์๋ต ๊ฐ์ด๋](tasks/question_answering)๋ฅผ ํ์ธํ์ฌ DistilBERT๋ฅผ ๋ฏธ์ธ ์กฐ์ ํ๊ณ ์ถ๋ก ์ ์ฌ์ฉํ๋ ๋ฐฉ๋ฒ์ ํ์ตํ์ธ์!
<Tip>
๐ก ์ฌ์ ํ๋ จ๋ BERT๋ฅผ ๋ค์ํ ์์
์ ์ฌ์ฉํ๋ ๊ฒ์ด ์ผ๋ง๋ ์ฌ์ด์ง ์ฃผ๋ชฉํ์ธ์. ์ฌ์ ํ๋ จ๋ ๋ชจ๋ธ์ ํน์ ํค๋๋ฅผ ์ถ๊ฐํ๊ธฐ๋ง ํ๋ฉด ์๋ ์ํ๋ฅผ ์ํ๋ ์ถ๋ ฅ์ผ๋ก ์กฐ์ํ ์ ์์ต๋๋ค!
</Tip>
### ํ
์คํธ ์์ฑ[[text-generation]]
[GPT-2](model_doc/gpt2)๋ ๋๋์ ํ
์คํธ์ ๋ํด ์ฌ์ ํ๋ จ๋ ๋์ฝ๋ฉ ์ ์ฉ ๋ชจ๋ธ์
๋๋ค. ํ๋กฌํํธ๋ฅผ ์ฃผ์ด์ง๋ฉด ์ค๋๋ ฅ ์๋ (ํญ์ ์ฌ์ค์ ์๋์ง๋ง!) ํ
์คํธ๋ฅผ ์์ฑํ๊ณ ๋ช
์์ ์ผ๋ก ํ๋ จ๋์ง ์์์์๋ ๋ถ๊ตฌํ๊ณ ์ง์์๋ต๊ณผ ๊ฐ์ ๋ค๋ฅธ NLP ์์
์ ์์ํ ์ ์์ต๋๋ค.
<div class="flex justify-center">
<img src="https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/gpt2_architecture.png"/>
</div>
1. GPT-2๋ ๋จ์ด๋ฅผ ํ ํฐํํ๊ณ ํ ํฐ ์๋ฒ ๋ฉ์ ์์ฑํ๊ธฐ ์ํด [๋ฐ์ดํธ ํ์ด ์ธ์ฝ๋ฉ(BPE, byte pair encoding)](tokenizer_summary#bytepair-encoding-bpe)์ ์ฌ์ฉํฉ๋๋ค. ์์น ์ธ์ฝ๋ฉ์ ์ํ์ค์์ ๊ฐ ํ ํฐ์ ์์น๋ฅผ ๋ํ๋ด๊ธฐ ์ํด ํ ํฐ ์๋ฒ ๋ฉ์ ์ถ๊ฐ๋ฉ๋๋ค. ์
๋ ฅ ์๋ฒ ๋ฉ์ ์ฌ๋ฌ ๋์ฝ๋ ๋ธ๋ก์ ๊ฑฐ์ณ ์ผ๋ถ ์ต์ข
์๋ ์ํ๋ฅผ ์ถ๋ ฅํฉ๋๋ค. ๊ฐ ๋์ฝ๋ ๋ธ๋ก ๋ด์์ GPT-2๋ *๋ง์คํฌ๋ ์
ํ ์ดํ
์
(masked self-attention)* ๋ ์ด์ด๋ฅผ ์ฌ์ฉํฉ๋๋ค. ์ด๋ GPT-2๊ฐ ์ดํ ํ ํฐ(future tokens)์ ์ฃผ์๋ฅผ ๊ธฐ์ธ์ผ ์ ์๋๋ก ํฉ๋๋ค. ์ผ์ชฝ์ ์๋ ํ ํฐ์๋ง ์ฃผ์๋ฅผ ๊ธฐ์ธ์ผ ์ ์์ต๋๋ค. ๋ง์คํฌ๋ ์
ํ ์ดํ
์
์์๋ ์ดํ
์
๋ง์คํฌ๋ฅผ ์ฌ์ฉํ์ฌ ์ดํ ํ ํฐ์ ๋ํ ์ ์(score)๋ฅผ `0`์ผ๋ก ์ค์ ํ๊ธฐ ๋๋ฌธ์ BERT์ [`mask`] ํ ํฐ๊ณผ ๋ค๋ฆ
๋๋ค.
2. ๋์ฝ๋์ ์ถ๋ ฅ์ ์ธ์ด ๋ชจ๋ธ๋ง ํค๋์ ์ ๋ฌ๋๋ฉฐ, ์ธ์ด ๋ชจ๋ธ๋ง ํค๋๋ ์๋ ์ํ๋ฅผ ๋ก์ง์ผ๋ก ์ ํ ๋ณํ์ ์ํํฉ๋๋ค. ๋ ์ด๋ธ์ ์ํ์ค์ ๋ค์ ํ ํฐ์ผ๋ก, ๋ก์ง์ ์ค๋ฅธ์ชฝ์ผ๋ก ํ๋์ฉ ์ด๋ํ์ฌ ์์ฑ๋ฉ๋๋ค. ๊ต์ฐจ ์ํธ๋กํผ ์์ค์ ์ด๋๋ ๋ก์ง๊ณผ ๋ ์ด๋ธ ๊ฐ์ ๊ณ์ฐ๋์ด ๊ฐ์ฅ ๊ฐ๋ฅ์ฑ์ด ๋์ ๋ค์ ํ ํฐ์ ์ถ๋ ฅํฉ๋๋ค.
GPT-2์ ์ฌ์ ํ๋ จ ๋ชฉ์ ์ ์ ์ ์ผ๋ก [์ธ๊ณผ์ ์ธ์ด ๋ชจ๋ธ๋ง](glossary#causal-language-modeling)์ ๊ธฐ๋ฐํ์ฌ, ์ํ์ค์์ ๋ค์ ๋จ์ด๋ฅผ ์์ธกํ๋ ๊ฒ์
๋๋ค. ์ด๋ GPT-2๊ฐ ํ
์คํธ ์์ฑ์ ๊ด๋ จ๋ ์์
์ ํนํ ์ฐ์ํ๋๋ก ํฉ๋๋ค.
ํ
์คํธ ์์ฑ์ ์ง์ ๋์ ํ ์ค๋น๊ฐ ๋์
จ๋์? ์์ ํ [์ธ๊ณผ์ ์ธ์ด ๋ชจ๋ธ๋ง ๊ฐ์ด๋](tasks/language_modeling#causal-language-modeling)๋ฅผ ํ์ธํ์ฌ DistilGPT-2๋ฅผ ๋ฏธ์ธ ์กฐ์ ํ๊ณ ์ถ๋ก ์ ์ฌ์ฉํ๋ ๋ฐฉ๋ฒ์ ํ์ตํ์ธ์!
<Tip>
ํ
์คํธ ์์ฑ์ ๋ํ ์์ธํ ๋ด์ฉ์ [ํ
์คํธ ์์ฑ ์ ๋ต](generation_strategies) ๊ฐ์ด๋๋ฅผ ํ์ธํ์ธ์!
</Tip>
### ์์ฝ[[summarization]]
[BART](model_doc/bart) ๋ฐ [T5](model_doc/t5)์ ๊ฐ์ ์ธ์ฝ๋-๋์ฝ๋ ๋ชจ๋ธ์ ์์ฝ ์์
์ ์ํ์ค-ํฌ-์ํ์ค ํจํด์ ์ํด ์ค๊ณ๋์์ต๋๋ค. ์ด ์น์
์์ BART์ ์๋ ๋ฐฉ๋ฒ์ ์ค๋ช
ํ ๋ค์, ๋ง์ง๋ง์ T5๋ฅผ ๋ฏธ์ธ ์กฐ์ ํด๋ณผ ์ ์์ต๋๋ค.
<div class="flex justify-center">
<img src="https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/bart_architecture.png"/>
</div>
1. BART์ ์ธ์ฝ๋ ์ํคํ
์ฒ๋ BERT์ ๋งค์ฐ ์ ์ฌํ๋ฉฐ ํ
์คํธ์ ํ ํฐ ๋ฐ ์์น ์๋ฒ ๋ฉ์ ๋ฐ์ต๋๋ค. BART๋ ์
๋ ฅ์ ๋ณํ์ํค๊ณ ๋์ฝ๋๋ก ์ฌ๊ตฌ์ฑํ์ฌ ์ฌ์ ํ๋ จ๋ฉ๋๋ค. ํน์ ๋ณํ ๊ธฐ๋ฒ์ด ์๋ ๋ค๋ฅธ ์ธ์ฝ๋์๋ ๋ฌ๋ฆฌ, BART๋ ๋ชจ๋ ์ ํ์ ๋ณํ์ ์ ์ฉํ ์ ์์ต๋๋ค. ๊ทธ๋ฌ๋ *text infilling* ๋ณํ ๊ธฐ๋ฒ์ด ๊ฐ์ฅ ์ ์๋ํฉ๋๋ค. Text Infiling์์๋ ์ฌ๋ฌ ํ
์คํธ ์คํฌ์ **๋จ์ผ** [`mask`] ํ ํฐ์ผ๋ก ๋์ฒดํฉ๋๋ค. ์ด๋ ๋ชจ๋ธ์ด ๋ง์คํฌ๋ ํ ํฐ์ ์์ธกํด์ผ ํ๊ณ , ๋ชจ๋ธ์ ๋๋ฝ๋ ํ ํฐ์ ์๋ฅผ ์์ธกํ๋๋ก ๊ฐ๋ฅด์น๊ธฐ ๋๋ฌธ์ ์ค์ํฉ๋๋ค. ์
๋ ฅ ์๋ฒ ๋ฉ๊ณผ ๋ง์คํฌ๋ ์คํฌ์ด ์ธ์ฝ๋๋ฅผ ๊ฑฐ์ณ ์ต์ข
์๋ ์ํ๋ฅผ ์ถ๋ ฅํ์ง๋ง, BERT์ ๋ฌ๋ฆฌ BART๋ ๋ง์ง๋ง์ ๋จ์ด๋ฅผ ์์ธกํ๋ ์๋ฐฉํฅ ๋คํธ์ํฌ๋ฅผ ์ถ๊ฐํ์ง ์์ต๋๋ค.
2. ์ธ์ฝ๋์ ์ถ๋ ฅ์ ๋์ฝ๋๋ก ์ ๋ฌ๋๋ฉฐ, ๋์ฝ๋๋ ์ธ์ฝ๋์ ์ถ๋ ฅ์์ ๋ง์คํฌ ํ ํฐ๊ณผ ๋ณํ๋์ง ์์ ํ ํฐ์ ์์ธกํด์ผ ํฉ๋๋ค. ์ด๋ ๋์ฝ๋๊ฐ ์๋ณธ ํ
์คํธ๋ฅผ ๋ณต์ํ๋ ๋ฐ ๋์์ด ๋๋ ์ถ๊ฐ์ ์ธ ๋ฌธ๋งฅ์ ์ป๋๋ก ํฉ๋๋ค. ๋์ฝ๋์ ์ถ๋ ฅ์ ์ธ์ด ๋ชจ๋ธ๋ง ํค๋์ ์ ๋ฌ๋๋ฉฐ, ์ธ์ด ๋ชจ๋ธ๋ง ํค๋๋ ์๋ ์ํ๋ฅผ ๋ก์ง์ผ๋ก ์ ํ ๋ณํ์ ์ํํฉ๋๋ค. ๊ต์ฐจ ์ํธ๋กํผ ์์ค์ ๋ก์ง๊ณผ ํ ํฐ์ด ์ค๋ฅธ์ชฝ์ผ๋ก ์ด๋๋ ๋ ์ด๋ธ ๊ฐ์ ๊ณ์ฐ๋ฉ๋๋ค.
์์ฝ์ ์ง์ ๋์ ํ ์ค๋น๊ฐ ๋์
จ๋์? ์์ ํ [์์ฝ ๊ฐ์ด๋](tasks/summarization)๋ฅผ ํ์ธํ์ฌ T5๋ฅผ ๋ฏธ์ธ ์กฐ์ ํ๊ณ ์ถ๋ก ์ ์ฌ์ฉํ๋ ๋ฐฉ๋ฒ์ ํ์ตํ์ธ์!
<Tip>
ํ
์คํธ ์์ฑ์ ๋ํ ์์ธํ ๋ด์ฉ์ [ํ
์คํธ ์์ฑ ์ ๋ต](generation_strategies) ๊ฐ์ด๋๋ฅผ ํ์ธํ์ธ์!
</Tip>
### ๋ฒ์ญ[[translation]]
๋ฒ์ญ์ ์ํ์ค-ํฌ-์ํ์ค ์์
์ ๋ ๋ค๋ฅธ ์๋ก, [BART](model_doc/bart) ๋๋ [T5](model_doc/t5)์ ๊ฐ์ ์ธ์ฝ๋-๋์ฝ๋ ๋ชจ๋ธ์ ์ฌ์ฉํ ์ ์์ต๋๋ค. ์ด ์น์
์์ BART์ ์๋ ๋ฐฉ๋ฒ์ ์ค๋ช
ํ ๋ค์, ๋ง์ง๋ง์ T5๋ฅผ ๋ฏธ์ธ ์กฐ์ ํด๋ณผ ์ ์์ต๋๋ค.
BART๋ ์์ฒ ์ธ์ด๋ฅผ ํ๊ฒ ์ธ์ด๋ก ๋์ฝ๋ฉํ ์ ์๋ ์
๋ ฅ์ ๋งคํํ๊ธฐ ์ํด ๋ฌด์์๋ก ์ด๊ธฐํ๋ ๋ณ๋์ ์ธ์ฝ๋๋ฅผ ์ถ๊ฐํ์ฌ ๋ฒ์ญ์ ์ ์ฉํฉ๋๋ค. ์ด ์๋ก์ด ์ธ์ฝ๋์ ์๋ฒ ๋ฉ์ ์๋ณธ ๋จ์ด ์๋ฒ ๋ฉ ๋์ ์ฌ์ ํ๋ จ๋ ์ธ์ฝ๋๋ก ์ ๋ฌ๋ฉ๋๋ค. ์์ฒ ์ธ์ฝ๋๋ ๋ชจ๋ธ ์ถ๋ ฅ์ ๊ต์ฐจ ์ํธ๋กํผ ์์ค๋ก๋ถํฐ ์์ฒ ์ธ์ฝ๋, ์์น ์๋ฒ ๋ฉ, ์
๋ ฅ ์๋ฒ ๋ฉ์ ๊ฐฑ์ ํ์ฌ ํ๋ จ๋ฉ๋๋ค. ์ฒซ ๋ฒ์งธ ๋จ๊ณ์์๋ ๋ชจ๋ธ ํ๋ผ๋ฏธํฐ๊ฐ ๊ณ ์ ๋๊ณ , ๋ ๋ฒ์งธ ๋จ๊ณ์์๋ ๋ชจ๋ ๋ชจ๋ธ ํ๋ผ๋ฏธํฐ๊ฐ ํจ๊ป ํ๋ จ๋ฉ๋๋ค.
BART๋ ์ดํ ๋ฒ์ญ์ ์ํด ๋ค์ํ ์ธ์ด๋ก ์ฌ์ ํ๋ จ๋ ๋ค๊ตญ์ด ๋ฒ์ ์ mBART๋ก ํ์ฅ๋์์ต๋๋ค.
๋ฒ์ญ์ ์ง์ ๋์ ํ ์ค๋น๊ฐ ๋์
จ๋์? ์์ ํ [๋ฒ์ญ ๊ฐ์ด๋](tasks/summarization)๋ฅผ ํ์ธํ์ฌ T5๋ฅผ ๋ฏธ์ธ ์กฐ์ ํ๊ณ ์ถ๋ก ์ ์ฌ์ฉํ๋ ๋ฐฉ๋ฒ์ ํ์ตํ์ธ์!
<Tip>
ํ
์คํธ ์์ฑ์ ๋ํ ์์ธํ ๋ด์ฉ์ [ํ
์คํธ ์์ฑ ์ ๋ต](generation_strategies) ๊ฐ์ด๋๋ฅผ ํ์ธํ์ธ์!
</Tip> | 0 |
mavonic_private_repos/transformers/docs/source | mavonic_private_repos/transformers/docs/source/ko/perf_infer_gpu_one.md | <!--Copyright 2022 The HuggingFace Team. All rights reserved.
Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
the License. You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
โ ๏ธ Note that this file is in Markdown but contain specific syntax for our doc-builder (similar to MDX) that may not be
rendered properly in your Markdown viewer.
-->
# ๋จ์ผ GPU์์ ํจ์จ์ ์ธ ์ถ๋ก [[efficient-inference-on-a-single-gpu]]
์ด ๊ฐ์ด๋ ์ธ์๋, [๋จ์ผ GPU์์์ ํ๋ จ ๊ฐ์ด๋](perf_train_gpu_one)์ [CPU์์์ ์ถ๋ก ๊ฐ์ด๋](perf_infer_cpu)์์๋ ๊ด๋ จ ์ ๋ณด๋ฅผ ์ฐพ์ ์ ์์ต๋๋ค.
## Better Transformer: PyTorch ๋ค์ดํฐ๋ธ Transformer ํจ์คํธํจ์ค [[better-transformer-pytorchnative-transformer-fastpath]]
PyTorch ๋ค์ดํฐ๋ธ [`nn.MultiHeadAttention`](https://pytorch.org/blog/a-better-transformer-for-fast-transformer-encoder-inference/) ์ดํ
์
ํจ์คํธํจ์ค์ธ BetterTransformer๋ [๐ค Optimum ๋ผ์ด๋ธ๋ฌ๋ฆฌ](https://huggingface.co/docs/optimum/bettertransformer/overview)์ ํตํฉ์ ํตํด Transformers์ ํจ๊ป ์ฌ์ฉํ ์ ์์ต๋๋ค.
PyTorch์ ์ดํ
์
ํจ์คํธํจ์ค๋ ์ปค๋ ํจ์ ๊ณผ [์ค์ฒฉ๋ ํ
์](https://pytorch.org/docs/stable/nested.html)์ ์ฌ์ฉ์ ํตํด ์ถ๋ก ์๋๋ฅผ ๋์ผ ์ ์์ต๋๋ค. ์์ธํ ๋ฒค์น๋งํฌ๋ [์ด ๋ธ๋ก๊ทธ ๊ธ](https://medium.com/pytorch/bettertransformer-out-of-the-box-performance-for-huggingface-transformers-3fbe27d50ab2)์์ ํ์ธํ ์ ์์ต๋๋ค.
[`optimum`](https://github.com/huggingface/optimum) ํจํค์ง๋ฅผ ์ค์นํ ํ์๋ ์ถ๋ก ์ค Better Transformer๋ฅผ ์ฌ์ฉํ ์ ์๋๋ก [`~PreTrainedModel.to_bettertransformer`]๋ฅผ ํธ์ถํ์ฌ ๊ด๋ จ ๋ด๋ถ ๋ชจ๋์ ๋์ฒดํฉ๋๋ค:
```python
model = model.to_bettertransformer()
```
[`~PreTrainedModel.reverse_bettertransformer`] ๋ฉ์๋๋ ์ ๊ทํ๋ transformers ๋ชจ๋ธ๋ง์ ์ฌ์ฉํ๊ธฐ ์ํด ๋ชจ๋ธ์ ์ ์ฅํ๊ธฐ ์ ์๋์ ๋ชจ๋ธ๋ง์ผ๋ก ๋์๊ฐ ์ ์๋๋ก ํด์ค๋๋ค:
```python
model = model.reverse_bettertransformer()
model.save_pretrained("saved_model")
```
PyTorch 2.0๋ถํฐ๋ ์ดํ
์
ํจ์คํธํจ์ค๊ฐ ์ธ์ฝ๋์ ๋์ฝ๋ ๋ชจ๋์์ ์ง์๋ฉ๋๋ค. ์ง์๋๋ ์ํคํ
์ฒ ๋ชฉ๋ก์ [์ฌ๊ธฐ](https://huggingface.co/docs/optimum/bettertransformer/overview#supported-models)์์ ํ์ธํ ์ ์์ต๋๋ค.
## FP4 ํผํฉ ์ ๋ฐ๋ ์ถ๋ก ์ ์ํ `bitsandbytes` ํตํฉ [[bitsandbytes-integration-for-fp4-mixedprecision-inference]]
`bitsandbytes`๋ฅผ ์ค์นํ๋ฉด GPU์์ ์์ฝ๊ฒ ๋ชจ๋ธ์ ์์ถํ ์ ์์ต๋๋ค. FP4 ์์ํ๋ฅผ ์ฌ์ฉํ๋ฉด ์๋์ ์ ์ฒด ์ ๋ฐ๋ ๋ฒ์ ๊ณผ ๋น๊ตํ์ฌ ๋ชจ๋ธ ํฌ๊ธฐ๋ฅผ ์ต๋ 8๋ฐฐ ์ค์ผ ์ ์์ต๋๋ค. ์๋์์ ์์ํ๋ ๋ฐฉ๋ฒ์ ํ์ธํ์ธ์.
<Tip>
์ด ๊ธฐ๋ฅ์ ๋ค์ค GPU ์ค์ ์์๋ ์ฌ์ฉํ ์ ์์ต๋๋ค.
</Tip>
### ์๊ตฌ ์ฌํญ [[requirements-for-fp4-mixedprecision-inference]]
- ์ต์ `bitsandbytes` ๋ผ์ด๋ธ๋ฌ๋ฆฌ
`pip install bitsandbytes>=0.39.0`
- ์ต์ `accelerate`๋ฅผ ์์ค์์ ์ค์น
`pip install git+https://github.com/huggingface/accelerate.git`
- ์ต์ `transformers`๋ฅผ ์์ค์์ ์ค์น
`pip install git+https://github.com/huggingface/transformers.git`
### FP4 ๋ชจ๋ธ ์คํ - ๋จ์ผ GPU ์ค์ - ๋น ๋ฅธ ์์ [[running-fp4-models-single-gpu-setup-quickstart]]
๋ค์ ์ฝ๋๋ฅผ ์คํํ์ฌ ๋จ์ผ GPU์์ ๋น ๋ฅด๊ฒ FP4 ๋ชจ๋ธ์ ์คํํ ์ ์์ต๋๋ค.
```py
from transformers import AutoModelForCausalLM
model_name = "bigscience/bloom-2b5"
model_4bit = AutoModelForCausalLM.from_pretrained(model_name, device_map="auto", load_in_4bit=True)
```
`device_map`์ ์ ํ ์ฌํญ์
๋๋ค. ๊ทธ๋ฌ๋ `device_map = 'auto'`๋ก ์ค์ ํ๋ ๊ฒ์ด ์ฌ์ฉ ๊ฐ๋ฅํ ๋ฆฌ์์ค๋ฅผ ํจ์จ์ ์ผ๋ก ๋์คํจ์นํ๊ธฐ ๋๋ฌธ์ ์ถ๋ก ์ ์์ด ๊ถ์ฅ๋ฉ๋๋ค.
### FP4 ๋ชจ๋ธ ์คํ - ๋ค์ค GPU ์ค์ [[running-fp4-models-multi-gpu-setup]]
๋ค์ค GPU์์ ํผํฉ 4๋นํธ ๋ชจ๋ธ์ ๊ฐ์ ธ์ค๋ ๋ฐฉ๋ฒ์ ๋จ์ผ GPU ์ค์ ๊ณผ ๋์ผํฉ๋๋ค(๋์ผํ ๋ช
๋ น์ด ์ฌ์ฉ):
```py
model_name = "bigscience/bloom-2b5"
model_4bit = AutoModelForCausalLM.from_pretrained(model_name, device_map="auto", load_in_4bit=True)
```
ํ์ง๋ง `accelerate`๋ฅผ ์ฌ์ฉํ์ฌ ๊ฐ GPU์ ํ ๋นํ GPU RAM์ ์ ์ดํ ์ ์์ต๋๋ค. ๋ค์๊ณผ ๊ฐ์ด `max_memory` ์ธ์๋ฅผ ์ฌ์ฉํ์ธ์:
```py
max_memory_mapping = {0: "600MB", 1: "1GB"}
model_name = "bigscience/bloom-3b"
model_4bit = AutoModelForCausalLM.from_pretrained(
model_name, device_map="auto", load_in_4bit=True, max_memory=max_memory_mapping
)
```
์ด ์์์๋ ์ฒซ ๋ฒ์งธ GPU๊ฐ 600MB์ ๋ฉ๋ชจ๋ฆฌ๋ฅผ ์ฌ์ฉํ๊ณ ๋ ๋ฒ์งธ GPU๊ฐ 1GB๋ฅผ ์ฌ์ฉํฉ๋๋ค.
### ๊ณ ๊ธ ์ฌ์ฉ๋ฒ [[advanced-usage]]
์ด ๋ฐฉ๋ฒ์ ๋ ๊ณ ๊ธ ์ฌ์ฉ๋ฒ์ ๋ํด์๋ [์์ํ](main_classes/quantization) ๋ฌธ์ ํ์ด์ง๋ฅผ ์ฐธ์กฐํ์ธ์.
## Int8 ํผํฉ ์ ๋ฐ๋ ํ๋ ฌ ๋ถํด๋ฅผ ์ํ `bitsandbytes` ํตํฉ [[bitsandbytes-integration-for-int8-mixedprecision-matrix-decomposition]]
<Tip>
์ด ๊ธฐ๋ฅ์ ๋ค์ค GPU ์ค์ ์์๋ ์ฌ์ฉํ ์ ์์ต๋๋ค.
</Tip>
[`LLM.int8() : 8-bit Matrix Multiplication for Transformers at Scale`](https://arxiv.org/abs/2208.07339) ๋
ผ๋ฌธ์์ ์ฐ๋ฆฌ๋ ๋ช ์ค์ ์ฝ๋๋ก Hub์ ๋ชจ๋ ๋ชจ๋ธ์ ๋ํ Hugging Face ํตํฉ์ ์ง์ํฉ๋๋ค.
์ด ๋ฐฉ๋ฒ์ `float16` ๋ฐ `bfloat16` ๊ฐ์ค์น์ ๋ํด `nn.Linear` ํฌ๊ธฐ๋ฅผ 2๋ฐฐ๋ก ์ค์ด๊ณ , `float32` ๊ฐ์ค์น์ ๋ํด 4๋ฐฐ๋ก ์ค์
๋๋ค. ์ด๋ ์ ๋ฐ ์ ๋ฐ๋์์ ์ด์์น๋ฅผ ์ฒ๋ฆฌํจ์ผ๋ก์จ ํ์ง์ ๊ฑฐ์ ์ํฅ์ ๋ฏธ์น์ง ์์ต๋๋ค.
Int8 ํผํฉ ์ ๋ฐ๋ ํ๋ ฌ ๋ถํด๋ ํ๋ ฌ ๊ณฑ์
์ ๋ ๊ฐ์ ์คํธ๋ฆผ์ผ๋ก ๋ถ๋ฆฌํฉ๋๋ค: (1) fp16๋ก ๊ณฑํด์ง๋ ์ฒด๊ณ์ ์ธ ํน์ด๊ฐ ์ด์์น ์คํธ๋ฆผ ํ๋ ฌ(0.01%) ๋ฐ (2) int8 ํ๋ ฌ ๊ณฑ์
์ ์ผ๋ฐ์ ์ธ ์คํธ๋ฆผ(99.9%). ์ด ๋ฐฉ๋ฒ์ ์ฌ์ฉํ๋ฉด ๋งค์ฐ ํฐ ๋ชจ๋ธ์ ๋ํด ์์ธก ์ ํ ์์ด int8 ์ถ๋ก ์ด ๊ฐ๋ฅํฉ๋๋ค.
์ด ๋ฐฉ๋ฒ์ ๋ํ ์์ธํ ๋ด์ฉ์ [๋
ผ๋ฌธ](https://arxiv.org/abs/2208.07339)์ด๋ [ํตํฉ์ ๊ดํ ๋ธ๋ก๊ทธ ๊ธ](https://huggingface.co/blog/hf-bitsandbytes-integration)์์ ํ์ธํ ์ ์์ต๋๋ค.
์ปค๋์ GPU ์ ์ฉ์ผ๋ก ์ปดํ์ผ๋์ด ์๊ธฐ ๋๋ฌธ์ ํผํฉ 8๋นํธ ๋ชจ๋ธ์ ์คํํ๋ ค๋ฉด GPU๊ฐ ํ์ํฉ๋๋ค. ์ด ๊ธฐ๋ฅ์ ์ฌ์ฉํ๊ธฐ ์ ์ ๋ชจ๋ธ์ 1/4(๋๋ ๋ชจ๋ธ ๊ฐ์ค์น๊ฐ ์ ๋ฐ ์ ๋ฐ๋์ธ ๊ฒฝ์ฐ ์ ๋ฐ)์ ์ ์ฅํ ์ถฉ๋ถํ GPU ๋ฉ๋ชจ๋ฆฌ๊ฐ ์๋์ง ํ์ธํ์ธ์.
์ด ๋ชจ๋์ ์ฌ์ฉํ๋ ๋ฐ ๋์์ด ๋๋ ๋ช ๊ฐ์ง ์ฐธ๊ณ ์ฌํญ์ด ์๋์ ๋์ ์์ต๋๋ค. ๋๋ [Google colab](#colab-demos)์์ ๋ฐ๋ชจ๋ฅผ ๋ฐ๋ผํ ์๋ ์์ต๋๋ค.
### ์๊ตฌ ์ฌํญ [[requirements-for-int8-mixedprecision-matrix-decomposition]]
- `bitsandbytes<0.37.0`์ ์ฌ์ฉํ๋ ๊ฒฝ์ฐ, 8๋นํธ ํ
์ ์ฝ์ด(Turing, Ampere ๋๋ ์ดํ ์ํคํ
์ฒ - ์: T4, RTX20s RTX30s, A40-A100)๋ฅผ ์ง์ํ๋ NVIDIA GPU์์ ์คํํ๋์ง ํ์ธํ์ธ์. `bitsandbytes>=0.37.0`์ ์ฌ์ฉํ๋ ๊ฒฝ์ฐ, ๋ชจ๋ GPU๊ฐ ์ง์๋ฉ๋๋ค.
- ์ฌ๋ฐ๋ฅธ ๋ฒ์ ์ `bitsandbytes`๋ฅผ ๋ค์ ๋ช
๋ น์ผ๋ก ์ค์นํ์ธ์:
`pip install bitsandbytes>=0.31.5`
- `accelerate`๋ฅผ ์ค์นํ์ธ์
`pip install accelerate>=0.12.0`
### ํผํฉ Int8 ๋ชจ๋ธ ์คํ - ๋จ์ผ GPU ์ค์ [[running-mixedint8-models-single-gpu-setup]]
ํ์ํ ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ฅผ ์ค์นํ ํ ํผํฉ 8๋นํธ ๋ชจ๋ธ์ ๊ฐ์ ธ์ค๋ ๋ฐฉ๋ฒ์ ๋ค์๊ณผ ๊ฐ์ต๋๋ค:
```py
from transformers import AutoModelForCausalLM
model_name = "bigscience/bloom-2b5"
model_8bit = AutoModelForCausalLM.from_pretrained(model_name, device_map="auto", load_in_8bit=True)
```
ํ
์คํธ ์์ฑ์ ๊ฒฝ์ฐ:
* `pipeline()` ํจ์ ๋์ ๋ชจ๋ธ์ `generate()` ๋ฉ์๋๋ฅผ ์ฌ์ฉํ๋ ๊ฒ์ ๊ถ์ฅํฉ๋๋ค. `pipeline()` ํจ์๋ก๋ ์ถ๋ก ์ด ๊ฐ๋ฅํ์ง๋ง, ํผํฉ 8๋นํธ ๋ชจ๋ธ์ ์ต์ ํ๋์ง ์์๊ธฐ ๋๋ฌธ์ `generate()` ๋ฉ์๋๋ฅผ ์ฌ์ฉํ๋ ๊ฒ๋ณด๋ค ๋๋ฆด ์ ์์ต๋๋ค. ๋ํ, nucleus ์ํ๋ง๊ณผ ๊ฐ์ ์ผ๋ถ ์ํ๋ง ์ ๋ต์ ํผํฉ 8๋นํธ ๋ชจ๋ธ์ ๋ํด `pipeline()` ํจ์์์ ์ง์๋์ง ์์ต๋๋ค.
* ์
๋ ฅ์ ๋ชจ๋ธ๊ณผ ๋์ผํ GPU์ ๋ฐฐ์นํ๋ ๊ฒ์ด ์ข์ต๋๋ค.
๋ค์์ ๊ฐ๋จํ ์์
๋๋ค:
```py
from transformers import AutoModelForCausalLM, AutoTokenizer
model_name = "bigscience/bloom-2b5"
tokenizer = AutoTokenizer.from_pretrained(model_name)
model_8bit = AutoModelForCausalLM.from_pretrained(model_name, device_map="auto", load_in_8bit=True)
prompt = "Hello, my llama is cute"
inputs = tokenizer(prompt, return_tensors="pt").to("cuda")
generated_ids = model.generate(**inputs)
outputs = tokenizer.batch_decode(generated_ids, skip_special_tokens=True)
```
### ํผํฉ Int8 ๋ชจ๋ธ ์คํ - ๋ค์ค GPU ์ค์ [[running-mixedint8-models-multi-gpu-setup]]
๋ค์ค GPU์์ ํผํฉ 8๋นํธ ๋ชจ๋ธ์ ๋ก๋ํ๋ ๋ฐฉ๋ฒ์ ๋จ์ผ GPU ์ค์ ๊ณผ ๋์ผํฉ๋๋ค(๋์ผํ ๋ช
๋ น์ด ์ฌ์ฉ):
```py
model_name = "bigscience/bloom-2b5"
model_8bit = AutoModelForCausalLM.from_pretrained(model_name, device_map="auto", load_in_8bit=True)
```
ํ์ง๋ง `accelerate`๋ฅผ ์ฌ์ฉํ์ฌ ๊ฐ GPU์ ํ ๋นํ GPU RAM์ ์ ์ดํ ์ ์์ต๋๋ค. ๋ค์๊ณผ ๊ฐ์ด `max_memory` ์ธ์๋ฅผ ์ฌ์ฉํ์ธ์:
```py
max_memory_mapping = {0: "1GB", 1: "2GB"}
model_name = "bigscience/bloom-3b"
model_8bit = AutoModelForCausalLM.from_pretrained(
model_name, device_map="auto", load_in_8bit=True, max_memory=max_memory_mapping
)
```
์ด ์์์์๋ ์ฒซ ๋ฒ์งธ GPU๊ฐ 1GB์ ๋ฉ๋ชจ๋ฆฌ๋ฅผ ์ฌ์ฉํ๊ณ ๋ ๋ฒ์งธ GPU๊ฐ 2GB๋ฅผ ์ฌ์ฉํฉ๋๋ค.
### Colab ๋ฐ๋ชจ [[colab-demos]]
์ด ๋ฐฉ๋ฒ์ ์ฌ์ฉํ๋ฉด ์ด์ ์ Google Colab์์ ์ถ๋ก ํ ์ ์์๋ ๋ชจ๋ธ์ ๋ํด ์ถ๋ก ํ ์ ์์ต๋๋ค.
Google Colab์์ 8๋นํธ ์์ํ๋ฅผ ์ฌ์ฉํ์ฌ T5-11b(42GB in fp32)๋ฅผ ์คํํ๋ ๋ฐ๋ชจ๋ฅผ ํ์ธํ์ธ์:
[](https://colab.research.google.com/drive/1YORPWx4okIHXnjW7MSAidXN29mPVNT7F?usp=sharing)
๋๋ BLOOM-3B์ ๋ํ ๋ฐ๋ชจ๋ฅผ ํ์ธํ์ธ์:
[](https://colab.research.google.com/drive/1qOjXfQIAULfKvZqwCen8-MoWKGdSatZ4?usp=sharing) | 0 |
mavonic_private_repos/transformers/docs/source | mavonic_private_repos/transformers/docs/source/ko/debugging.md | <!--Copyright 2021 The HuggingFace Team. All rights reserved.
Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
the License. You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
specific language governing permissions and limitations under the License.
โ ๏ธ Note that this file is in Markdown but contain specific syntax for our doc-builder (similar to MDX) that may not be
rendered properly in your Markdown viewer.
-->
# ๋๋ฒ๊น
[[debugging]]
## Multi-GPU ๋คํธ์ํฌ ๋ฌธ์ ๋๋ฒ๊ทธ [[multigpu-network-issues-debug]]
`DistributedDataParallel` ๋ฐ ๋ค์ค GPU๋ฅผ ์ฌ์ฉํ์ฌ ํ๋ จํ๊ฑฐ๋ ์ถ๋ก ํ ๋, ํ๋ก์ธ์ค ๋ฐ/๋๋ ๋
ธ๋ ๊ฐ์ ์ํธ ํต์ ๋ฌธ์ ๊ฐ ๋ฐ์ํ๋ ๊ฒฝ์ฐ, ๋ค์ ์คํฌ๋ฆฝํธ๋ฅผ ์ฌ์ฉํ์ฌ ๋คํธ์ํฌ ๋ฌธ์ ๋ฅผ ์ง๋จํ ์ ์์ต๋๋ค.
```bash
wget https://raw.githubusercontent.com/huggingface/transformers/main/scripts/distributed/torch-distributed-gpu-test.py
```
์๋ฅผ ๋ค์ด, 2๊ฐ์ GPU๊ฐ ์ํธ ์์ฉํ๋ ๋ฐฉ์์ ํ
์คํธํ๋ ค๋ฉด ๋ค์์ ์คํํ์ธ์:
```bash
python -m torch.distributed.run --nproc_per_node 2 --nnodes 1 torch-distributed-gpu-test.py
```
๋ ํ๋ก์ธ์ค๊ฐ ์๋ก ํต์ ํ๊ณ GPU ๋ฉ๋ชจ๋ฆฌ๋ฅผ ํ ๋นํ๋ ๊ฒฝ์ฐ, ๊ฐ๊ฐ "OK" ์ํ๋ฅผ ์ถ๋ ฅํฉ๋๋ค.
๋ ๋ง์ GPU ๋๋ ๋
ธ๋์ ๊ฒฝ์ฐ ์คํฌ๋ฆฝํธ์ ์ธ์๋ฅผ ์กฐ์ ํ๋ฉด ๋ฉ๋๋ค.
์ง๋จ ์คํฌ๋ฆฝํธ ๋ด์์ ๋ ๋ง์ ์ธ๋ถ ์ ๋ณด์ SLURM ํ๊ฒฝ์์ ์คํํ๋ ๋ฐฉ๋ฒ์ ๋ํ ๋ ์ํผ๋ฅผ ์ฐพ์ ์ ์์ต๋๋ค.
์ถ๊ฐ์ ์ธ ๋๋ฒ๊ทธ ์์ค์ ๋ค์๊ณผ ๊ฐ์ด `NCCL_DEBUG=INFO` ํ๊ฒฝ ๋ณ์๋ฅผ ์ถ๊ฐํ๋ ๊ฒ์
๋๋ค:
```bash
NCCL_DEBUG=INFO python -m torch.distributed.run --nproc_per_node 2 --nnodes 1 torch-distributed-gpu-test.py
```
์ด๋ ๊ฒ ํ๋ฉด NCCL ๊ด๋ จ ๋๋ฒ๊ทธ ์ ๋ณด๊ฐ ๋ง์ด ์ถ๋ ฅ๋๋ฉฐ, ๋ฌธ์ ๊ฐ ๋ณด๊ณ ๋ ๊ฒฝ์ฐ์๋ ์ธํฐ๋ท์์ ๊ฒ์ํ ์ ์์ต๋๋ค. ๋๋ ์ถ๋ ฅ์ ํด์ํ๋ ๋ฐฉ๋ฒ์ ์ ๋ชจ๋ฅด๋ ๊ฒฝ์ฐ ๋ก๊ทธ ํ์ผ์ ์ด์์ ๊ณต์ ํ ์ ์์ต๋๋ค.
## ์ธ๋ํ๋ก ๋ฐ ์ค๋ฒํ๋ก ๊ฐ์ง [[underflow-and-overflow-detection]]
<Tip>
์ด ๊ธฐ๋ฅ์ ํ์ฌ PyTorch์์๋ง ์ฌ์ฉํ ์ ์์ต๋๋ค.
</Tip>
<Tip>
๋ค์ค GPU ํ๋ จ์ ์ํด์๋ DDP (`torch.distributed.launch`)๊ฐ ํ์ํฉ๋๋ค.
</Tip>
<Tip>
์ด ๊ธฐ๋ฅ์ `nn.Module`์ ๊ธฐ๋ฐ์ผ๋ก ํ๋ ๋ชจ๋ธ๊ณผ ํจ๊ป ์ฌ์ฉํ ์ ์์ต๋๋ค.
</Tip>
`loss=NaN`์ด ๋ํ๋๊ฑฐ๋ ๋ชจ๋ธ์ด `inf` ๋๋ `nan`์ผ๋ก ์ธํด ๋ค๋ฅธ ์ด์ํ ๋์์ ํ๋ ๊ฒฝ์ฐ, ์ธ๋ํ๋ก ๋๋ ์ค๋ฒํ๋ก์ ์ฒซ ๋ฒ์งธ ๋ฐ์ ์์น์ ๊ทธ ์์ธ์ ํ์
ํด์ผ ํฉ๋๋ค. ๋คํํ๋ ์ด๋ฅผ ์๋์ผ๋ก ๊ฐ์งํ๋ ํน์ ๋ชจ๋์ ํ์ฑํํ์ฌ ์ฝ๊ฒ ์์๋ผ ์ ์์ต๋๋ค.
[`Trainer`]๋ฅผ ์ฌ์ฉํ๋ ๊ฒฝ์ฐ, ๋ค์์ ๊ธฐ์กด์ ๋ช
๋ น์ค ์ธ์์ ์ถ๊ฐํ๋ฉด ๋ฉ๋๋ค.
```bash
--debug underflow_overflow
```
๋๋ [`TrainingArguments`] ๊ฐ์ฒด๋ฅผ ์์ฑํ ๋ `debug="underflow_overflow"`๋ฅผ ์ ๋ฌํฉ๋๋ค.
์์ฒด ํ๋ จ ๋ฃจํ๋ ๋ค๋ฅธ Trainer๋ฅผ ์ฌ์ฉํ๋ ๊ฒฝ์ฐ, ๋ค์๊ณผ ๊ฐ์ด ์ํํ ์ ์์ต๋๋ค.
```python
from transformers.debug_utils import DebugUnderflowOverflow
debug_overflow = DebugUnderflowOverflow(model)
```
[`~debug_utils.DebugUnderflowOverflow`]๋ ๋ชจ๋ธ์ ํํฌ๋ฅผ ์ฝ์
ํ์ฌ ๊ฐ forward ํธ์ถ ์งํ์ ์
๋ ฅ ๋ฐ ์ถ๋ ฅ ๋ณ์ ๋ฐ ํด๋น ๋ชจ๋์ ๊ฐ์ค์น๋ฅผ ํ
์คํธํฉ๋๋ค. ํ์ฑํ๋ ๊ฐ์ค์น์ ์ต์ํ ํ๋์ ์์์์ `inf` ๋๋ `nan`์ด ๊ฐ์ง๋๋ฉด ํ๋ก๊ทธ๋จ์ด ์ด์คํธ๋๊ณ ๋ค์๊ณผ ๊ฐ์ ๋ณด๊ณ ์๊ฐ ์ถ๋ ฅ๋ฉ๋๋ค. (์ด ์์ ๋ fp16 ํผํฉ ์ ๋ฐ๋์์ `google/mt5-small`์์ ์บก์ฒ๋ ๊ฒ์
๋๋ค):
```
Detected inf/nan during batch_number=0
Last 21 forward frames:
abs min abs max metadata
encoder.block.1.layer.1.DenseReluDense.dropout Dropout
0.00e+00 2.57e+02 input[0]
0.00e+00 2.85e+02 output
[...]
encoder.block.2.layer.0 T5LayerSelfAttention
6.78e-04 3.15e+03 input[0]
2.65e-04 3.42e+03 output[0]
None output[1]
2.25e-01 1.00e+04 output[2]
encoder.block.2.layer.1.layer_norm T5LayerNorm
8.69e-02 4.18e-01 weight
2.65e-04 3.42e+03 input[0]
1.79e-06 4.65e+00 output
encoder.block.2.layer.1.DenseReluDense.wi_0 Linear
2.17e-07 4.50e+00 weight
1.79e-06 4.65e+00 input[0]
2.68e-06 3.70e+01 output
encoder.block.2.layer.1.DenseReluDense.wi_1 Linear
8.08e-07 2.66e+01 weight
1.79e-06 4.65e+00 input[0]
1.27e-04 2.37e+02 output
encoder.block.2.layer.1.DenseReluDense.dropout Dropout
0.00e+00 8.76e+03 input[0]
0.00e+00 9.74e+03 output
encoder.block.2.layer.1.DenseReluDense.wo Linear
1.01e-06 6.44e+00 weight
0.00e+00 9.74e+03 input[0]
3.18e-04 6.27e+04 output
encoder.block.2.layer.1.DenseReluDense T5DenseGatedGeluDense
1.79e-06 4.65e+00 input[0]
3.18e-04 6.27e+04 output
encoder.block.2.layer.1.dropout Dropout
3.18e-04 6.27e+04 input[0]
0.00e+00 inf output
```
์์ ์ถ๋ ฅ์ ๊ฐ๋ต์ฑ์ ์ํด ์ค๊ฐ ๋ถ๋ถ์ด ์๋ ค ์์ต๋๋ค.
๋ ๋ฒ์งธ ์ด์ ์ ๋์ ์ผ๋ก ๊ฐ์ฅ ํฐ ์์์ ๊ฐ์ด๋ฉฐ, ๋ฐ๋ผ์ ๋ง์ง๋ง ๋ช ๊ฐ์ ํ๋ ์์ ์์ธํ ์ดํด๋ณด๋ฉด ์
๋ ฅ๊ณผ ์ถ๋ ฅ์ด `1e4` ๋ฒ์์ ์์์ ์ ์ ์์ต๋๋ค. ๋ฐ๋ผ์ ์ด ํ๋ จ์ `fp16` ํผํฉ ์ ๋ฐ๋๋ก ์ํ๋ ๋ ๊ฐ์ฅ ๋ง์ง๋ง ๋จ๊ณ์์ ์ค๋ฒํ๋ก์ฐ๊ฐ ๋ฐ์ํ์ต๋๋ค (`fp16`์์ `inf` ์ด์ ์ ๊ฐ์ฅ ํฐ ์ซ์๋ `64e3`์
๋๋ค). `fp16` ์๋์์ ์ค๋ฒํ๋ก์ฐ๋ฅผ ํผํ๊ธฐ ์ํด์๋ ํ์ฑํ๋ `1e4`๋ณด๋ค ํจ์ฌ ์์์ผ ํฉ๋๋ค. ์๋ํ๋ฉด `1e4 * 1e4 = 1e8`์ด๊ธฐ ๋๋ฌธ์ ํฐ ํ์ฑํ์์ ํ๋ ฌ ๊ณฑ์ ์์น์ ์ธ ์ค๋ฒํ๋ก์ฐ ์กฐ๊ฑด์ผ๋ก ์ด์ด์ง ๊ฒ์
๋๋ค.
์ถ์ ์ ๋งจ ์ฒ์์์ ์ด๋ ๋ฐฐ์น ๋ฒํธ์์ ๋ฌธ์ ๊ฐ ๋ฐ์ํ๋์ง ์ ์ ์์ต๋๋ค (์ฌ๊ธฐ์ `Detected inf/nan during batch_number=0`์ ๋ฌธ์ ๊ฐ ์ฒซ ๋ฒ์งธ ๋ฐฐ์น์์ ๋ฐ์ํ์์ ์๋ฏธํฉ๋๋ค).
๊ฐ ๋ณด๊ณ ๋ ํ๋ ์์ ํด๋น ํ๋ ์์ด ๋ณด๊ณ ํ๋ ํด๋น ๋ชจ๋์ ๋ํ ์์ ํ ํญ๋ชฉ์ ์ ์ธํ๋ฉฐ, ์ด ํ๋ ์๋ง ์ดํด๋ณด๋ฉด ๋ค์๊ณผ ๊ฐ์ต๋๋ค.
```
encoder.block.2.layer.1.layer_norm T5LayerNorm
8.69e-02 4.18e-01 weight
2.65e-04 3.42e+03 input[0]
1.79e-06 4.65e+00 output
```
์ฌ๊ธฐ์ `encoder.block.2.layer.1.layer_norm`์ ์ธ์ฝ๋์ ๋ ๋ฒ์งธ ๋ธ๋ก์ ์ฒซ ๋ฒ์งธ ๋ ์ด์ด์ ๋ํ ๋ ์ด์ด ์ ๊ทํ๋ฅผ ์๋ฏธํ๋ฉฐ, `forward`์ ํน์ ํธ์ถ์ `T5LayerNorm`์
๋๋ค.
์ด ๋ณด๊ณ ์์ ๋ง์ง๋ง ๋ช ๊ฐ ํ๋ ์์ ์ดํด๋ณด๊ฒ ์ต๋๋ค:
```
Detected inf/nan during batch_number=0
Last 21 forward frames:
abs min abs max metadata
[...]
encoder.block.2.layer.1.DenseReluDense.wi_0 Linear
2.17e-07 4.50e+00 weight
1.79e-06 4.65e+00 input[0]
2.68e-06 3.70e+01 output
encoder.block.2.layer.1.DenseReluDense.wi_1 Linear
8.08e-07 2.66e+01 weight
1.79e-06 4.65e+00 input[0]
1.27e-04 2.37e+02 output
encoder.block.2.layer.1.DenseReluDense.wo Linear
1.01e-06 6.44e+00 weight
0.00e+00 9.74e+03 input[0]
3.18e-04 6.27e+04 output
encoder.block.2.layer.1.DenseReluDense T5DenseGatedGeluDense
1.79e-06 4.65e+00 input[0]
3.18e-04 6.27e+04 output
encoder.block.2.layer.1.dropout Dropout
3.18e-04 6.27e+04 input[0]
0.00e+00 inf output
```
๋ง์ง๋ง ํ๋ ์์ `Dropout.forward` ํจ์์ ๋ํ ๋ณด๊ณ ์
๋๋ค. ์ฒซ ๋ฒ์งธ ํญ๋ชฉ์ ์ ์ผํ ์
๋ ฅ์ ๋ํ๋ด๊ณ ๋ ๋ฒ์งธ ํญ๋ชฉ์ ์ ์ผํ ์ถ๋ ฅ์ ๋ํ๋
๋๋ค. ์ด ํจ์๊ฐ `DenseReluDense` ํด๋์ค ๋ด๋ถ์ `dropout` ์์ฑ์์ ํธ์ถ๋ ๊ฒ์ ๋ณผ ์ ์์ต๋๋ค. ์ด๋ ์ฒซ ๋ฒ์งธ ๋ ์ด์ด์ ๋ ๋ฒ์งธ ๋ธ๋ก์์ ์ฒซ ๋ฒ์งธ ๋ฐฐ์น ์ค์ ๋ฐ์ํ๋ค๋ ๊ฒ์ ์ ์ ์์ต๋๋ค. ๋ง์ง๋ง์ผ๋ก, ์ ๋์ ์ผ๋ก ๊ฐ์ฅ ํฐ ์
๋ ฅ ์์๋ `6.27e+04`์ด๊ณ ์ถ๋ ฅ๋ ๋ง์ฐฌ๊ฐ์ง๋ก `inf`์
๋๋ค.
์ฌ๊ธฐ์์๋ `T5DenseGatedGeluDense.forward`๊ฐ ์ถ๋ ฅ ํ์ฑํ๋ฅผ ์์ฑํ๋๋ฐ, ์ ๋์ ์ผ๋ก ๊ฐ์ฅ ํฐ ๊ฐ์ด ์ฝ 62.7K์ธ ๊ฒ์ ๋ณผ ์ ์์ต๋๋ค. ์ด ๊ฐ์ fp16์ ์ต๋ ์ ํ์ธ 64K์ ๋งค์ฐ ๊ทผ์ ํฉ๋๋ค. ๋ค์ ํ๋ ์์์๋ ์ผ๋ถ ์์๋ฅผ 0์ผ๋ก ๋ง๋ ํ ๊ฐ์ค์น๋ฅผ ์ฌ์ ๊ทํํ๋ `Dropout`์ด ์์ต๋๋ค. ์ด๋ก ์ธํด ์ ๋ ์ต๋๊ฐ์ด 64K๋ฅผ ์ด๊ณผํ๊ณ ์ค๋ฒํ๋ก์ฐ(`inf`)๊ฐ ๋ฐ์ํฉ๋๋ค.
๋ณด์๋ค์ํผ, fp16 ์ซ์์ ๊ฒฝ์ฐ ์ซ์๊ฐ ๋งค์ฐ ์ปค์ง ๋ ์ด์ ํ๋ ์์ ์ดํด๋ณด์์ผ ํฉ๋๋ค.
๋ณด๊ณ ์๋ฅผ `models/t5/modeling_t5.py`์ ์ฝ๋์ ์ผ์น์์ผ ๋ณด๊ฒ ์ต๋๋ค.
```python
class T5DenseGatedGeluDense(nn.Module):
def __init__(self, config):
super().__init__()
self.wi_0 = nn.Linear(config.d_model, config.d_ff, bias=False)
self.wi_1 = nn.Linear(config.d_model, config.d_ff, bias=False)
self.wo = nn.Linear(config.d_ff, config.d_model, bias=False)
self.dropout = nn.Dropout(config.dropout_rate)
self.gelu_act = ACT2FN["gelu_new"]
def forward(self, hidden_states):
hidden_gelu = self.gelu_act(self.wi_0(hidden_states))
hidden_linear = self.wi_1(hidden_states)
hidden_states = hidden_gelu * hidden_linear
hidden_states = self.dropout(hidden_states)
hidden_states = self.wo(hidden_states)
return hidden_states
```
์ด์ `dropout` ํธ์ถ๊ณผ ์ด์ ์ ๋ชจ๋ ํธ์ถ์ ์ฝ๊ฒ ํ์ธํ ์ ์์ต๋๋ค.
๊ฐ์ง๋ `forward` ํํฌ์์ ๋ฐ์ํ๋ฏ๋ก, ์ด๋ฌํ ๋ณด๊ณ ์๋ ๊ฐ `forward`๊ฐ ๋ฐํ๋ ์งํ์ ์ฆ์ ์ถ๋ ฅ๋ฉ๋๋ค.
์ ์ฒด ๋ณด๊ณ ์๋ก ๋์๊ฐ์ ๋ฌธ์ ์ ๋ํ ์กฐ์น ๋ฐ ์์ ์ ํ๋ ค๋ฉด, ์ซ์๊ฐ ์ฆ๊ฐํ๊ธฐ ์์ํ ๋ช ๊ฐ์ ํ๋ ์ ์๋ก ์ด๋ํด์ ์ฌ๊ธฐ์ `fp32` ๋ชจ๋๋ก ์ ํํด์ผ ํฉ๋๋ค. ์ด๋ ๊ฒ ํด์ผ ์ซ์๊ฐ ๊ณฑํด์ง๊ฑฐ๋ ํฉ์ณ์ง ๋ ์ค๋ฒํ๋ก์ฐ๋์ง ์์ ๊ฐ๋ฅ์ฑ์ด ๋์ต๋๋ค. ๋ฌผ๋ก ๋ค๋ฅธ ํด๊ฒฐ์ฑ
๋ ์์ ์ ์์ต๋๋ค. ์๋ฅผ ๋ค์ด, `amp`๊ฐ ํ์ฑํ๋ ๊ฒฝ์ฐ ์ผ์์ ์ผ๋ก ๋๊ณ ์๋์ `forward`๋ฅผ ๋์ฐ๋ฏธ ๋ํผ๋ก ์ด๋ํ ํ ๋ค์๊ณผ ๊ฐ์ด ํ ์ ์์ต๋๋ค:
```python
def _forward(self, hidden_states):
hidden_gelu = self.gelu_act(self.wi_0(hidden_states))
hidden_linear = self.wi_1(hidden_states)
hidden_states = hidden_gelu * hidden_linear
hidden_states = self.dropout(hidden_states)
hidden_states = self.wo(hidden_states)
return hidden_states
import torch
def forward(self, hidden_states):
if torch.is_autocast_enabled():
with torch.cuda.amp.autocast(enabled=False):
return self._forward(hidden_states)
else:
return self._forward(hidden_states)
```
์๋ ๊ฐ์ง๊ธฐ๋ ์ ์ฒด ํ๋ ์์ ์
๋ ฅ๊ณผ ์ถ๋ ฅ์ ๋ํด์๋ง ๋ณด๊ณ ํ๋ฏ๋ก, ์ด๋๋ฅผ ์ดํด๋ด์ผ ํ๋์ง ์๋ฉด ํน์ `forward` ํจ์์ ์ค๊ฐ ๋จ๊ณ๋ ๋ถ์ํ ์ ์์ต๋๋ค. ์ด ๊ฒฝ์ฐ์๋ `detect_overflow` ๋์ฐ๋ฏธ ํจ์๋ฅผ ์ฌ์ฉํ์ฌ ์ํ๋ ์์น์ ๊ฐ์ง๊ธฐ๋ฅผ ์ฝ์
ํ ์ ์์ต๋๋ค. ์๋ฅผ ๋ค์ด:
```python
from debug_utils import detect_overflow
class T5LayerFF(nn.Module):
[...]
def forward(self, hidden_states):
forwarded_states = self.layer_norm(hidden_states)
detect_overflow(forwarded_states, "after layer_norm")
forwarded_states = self.DenseReluDense(forwarded_states)
detect_overflow(forwarded_states, "after DenseReluDense")
return hidden_states + self.dropout(forwarded_states)
```
์ฌ๊ธฐ์๋ ์ด๋ฅผ ์ถ๊ฐํ์ฌ 2๊ฐ์ ๊ฒ์ ์ถ์ ํ๊ณ ์ด์ `forwarded_states`์ `inf` ๋๋ `nan`์ด ์ค๊ฐ์ ๊ฐ์ง๋์๋์ง๋ฅผ ์ถ์ ํฉ๋๋ค.
์ค์ ๋ก ์์ ์์ ์์ ๊ฐ ํธ์ถ์ด `nn.Module`์ด๊ธฐ ๋๋ฌธ์ ํ์ง๊ธฐ๊ฐ ์ด๋ฏธ ์ด๋ฅผ ๋ณด๊ณ ํฉ๋๋ค. ๋ก์ปฌ์์ ์ง์ ๊ณ์ฐํ๋ ๊ฒฝ์ฐ ์ด๋ ๊ฒ ์ํํ๋ค๊ณ ๊ฐ์ ํด ๋ด
์๋ค.
๋ํ, ์์ฒด ์ฝ๋์์ ๋๋ฒ๊ฑฐ๋ฅผ ์ธ์คํด์คํํ๋ ๊ฒฝ์ฐ ๊ธฐ๋ณธ๊ฐ์์ ์ถ๋ ฅ๋๋ ํ๋ ์ ์๋ฅผ ์กฐ์ ํ ์ ์์ต๋๋ค. ์๋ฅผ ๋ค์ด:
```python
from transformers.debug_utils import DebugUnderflowOverflow
debug_overflow = DebugUnderflowOverflow(model, max_frames_to_save=100)
```
### ํน์ ๋ฐฐ์น์ ์ ๋๊ฐ ์ต์ ๋ฐ ์ต๋ ๊ฐ ์ถ์ [[specific-batch-absolute-min-and-max-value-tracing]]
๋์ผํ ๋๋ฒ๊น
ํด๋์ค๋ ์ธ๋ํ๋ก์ฐ/์ค๋ฒํ๋ก์ฐ ๊ฐ์ง ๊ธฐ๋ฅ์ด ๊บผ์ง ์ํ์์ ๋ฐฐ์น๋ณ ์ถ์ ์๋ ์ฌ์ฉํ ์ ์์ต๋๋ค.
์๋ฅผ ๋ค์ด, ํน์ ๋ฐฐ์น์ ๊ฐ `forward` ํธ์ถ์ ๋ชจ๋ ๊ตฌ์ฑ ์ฑ๋ถ์ ๋ํ ์ ๋ ์ต์๊ฐ๊ณผ ์ต๋๊ฐ์ ํ์ธํ๊ณ , ์ด๋ฅผ ๋ฐฐ์น 1๊ณผ 3์ ๋ํด์๋ง ์ํํ๋ ค๋ฉด ๋ค์๊ณผ ๊ฐ์ด ์ด ํด๋์ค๋ฅผ ์ธ์คํด์คํํฉ๋๋ค:
```python
debug_overflow = DebugUnderflowOverflow(model, trace_batch_nums=[1, 3])
```
๊ทธ๋ฌ๋ฉด ์ด์ ๋ฐฐ์น 1๊ณผ 3 ์ ์ฒด๊ฐ ์ธ๋ํ๋ก์ฐ/์ค๋ฒํ๋ก์ฐ ๊ฐ์ง๊ธฐ์ ๋์ผํ ํ์์ผ๋ก ์ถ์ ๋ฉ๋๋ค.
๋ฐฐ์น๋ 0๋ถํฐ ์์ํฉ๋๋ค.
์ด๋ ํ๋ก๊ทธ๋จ์ด ํน์ ๋ฐฐ์น ๋ฒํธ ์ดํ์ ์ค์๋ํ๊ธฐ ์์ํ๋ ๊ฒ์ ์๊ณ ์๋ ๊ฒฝ์ฐ์ ์ ์ฉํฉ๋๋ค. ๊ทธ๋ ๊ธฐ ๋๋ฌธ์ ํด๋น ์์ญ์ผ๋ก ๋ฐ๋ก ์ด๋ํ ์ ์์ต๋๋ค. ์ด๋ฐ ๊ตฌ์ฑ์ ๋ํ ์ํ ์ถ์๋ ์ถ๋ ฅ์ ๋ค์๊ณผ ๊ฐ์ต๋๋ค.
```
*** Starting batch number=1 ***
abs min abs max metadata
shared Embedding
1.01e-06 7.92e+02 weight
0.00e+00 2.47e+04 input[0]
5.36e-05 7.92e+02 output
[...]
decoder.dropout Dropout
1.60e-07 2.27e+01 input[0]
0.00e+00 2.52e+01 output
decoder T5Stack
not a tensor output
lm_head Linear
1.01e-06 7.92e+02 weight
0.00e+00 1.11e+00 input[0]
6.06e-02 8.39e+01 output
T5ForConditionalGeneration
not a tensor output
*** Starting batch number=3 ***
abs min abs max metadata
shared Embedding
1.01e-06 7.92e+02 weight
0.00e+00 2.78e+04 input[0]
5.36e-05 7.92e+02 output
[...]
```
์ฌ๊ธฐ์์๋ ๋ชจ๋ธ์ forward ํธ์ถ ์์ ๋์ผํ ์์ ํ๋ ์์ด ๋คํ๋๋ฏ๋ก ๋ง์ ์์ ํ๋ ์์ด ์์ฑ๋ฉ๋๋ค. ๋ฐ๋ผ์ ์ํ๋ ๊ฒ์ผ ์๋ ์๊ณ ์๋ ์๋ ์์ต๋๋ค. ๊ทธ๋ฌ๋ ๋๋ก๋ ์ผ๋ฐ ๋๋ฒ๊ฑฐ๋ณด๋ค ๋๋ฒ๊น
๋ชฉ์ ์ผ๋ก ๋ ์ฝ๊ฒ ์ฌ์ฉํ ์ ์์ต๋๋ค. ์๋ฅผ ๋ค์ด, ๋ฌธ์ ๊ฐ ๋ฐฐ์น ๋ฒํธ 150์์ ์์ํ๋ ๊ฒฝ์ฐ 149์ 150์ ์ถ์ ์ ๋คํํ๊ณ ์ซ์๊ฐ ์ด๋์๋ถํฐ ๋ค๋ฅด๊ฒ ๋์๋์ง ๋น๊ตํ ์ ์์ต๋๋ค.
๋ํ, ํ๋ จ์ ์ค์งํ ๋ฐฐ์น ๋ฒํธ๋ฅผ ์ง์ ํ ์๋ ์์ต๋๋ค. ๋ค์๊ณผ ๊ฐ์ด ์ง์ ํ ์ ์์ต๋๋ค.
```python
debug_overflow = DebugUnderflowOverflow(model, trace_batch_nums=[1, 3], abort_after_batch_num=3)
```
| 0 |
mavonic_private_repos/transformers/docs/source | mavonic_private_repos/transformers/docs/source/ko/index.md | <!--Copyright 2020 The HuggingFace Team. All rights reserved.
Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
the License. You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
specific language governing permissions and limitations under the License.
โ ๏ธ Note that this file is in Markdown but contain specific syntax for our doc-builder (similar to MDX) that may not be
rendered properly in your Markdown viewer.
-->
# ๐ค Transformers
[PyTorch](https://pytorch.org/), [TensorFlow](https://www.tensorflow.org/), [JAX](https://jax.readthedocs.io/en/latest/)๋ฅผ ์ํ ์ต์ฒจ๋จ ๋จธ์ ๋ฌ๋
๐ค Transformers๋ ์ฌ์ ํ์ต๋ ์ต์ฒจ๋จ ๋ชจ๋ธ๋ค์ ์ฝ๊ฒ ๋ค์ด๋ก๋ํ๊ณ ํ๋ จ์ํฌ ์ ์๋ API์ ๋๊ตฌ๋ฅผ ์ ๊ณตํฉ๋๋ค. ์ฌ์ ํ์ต๋ ๋ชจ๋ธ์ ์ฐ๋ฉด ์ปดํจํ
๋น์ฉ๊ณผ ํ์ ๋ฐฐ์ถ๋์ด ์ค๊ณ , ๋ชจ๋ธ์ ์ฒ์๋ถํฐ ํ๋ จ์ํค๋ ๋ฐ ํ์ํ ์๊ฐ๊ณผ ๋ฆฌ์์ค๋ฅผ ์ ์ฝํ ์ ์์ต๋๋ค. ์ ํฌ ๋ชจ๋ธ๋ค์ ๋ค์ํ ๋ถ์ผ์ ํ์คํฌ๋ฅผ ์ง์ํฉ๋๋ค.
๐ **์์ฐ์ด ์ฒ๋ฆฌ**: ํ
์คํธ ๋ถ๋ฅ, ๊ฐ์ฒด๋ช
์ธ์, ์ง์์๋ต, ์ธ์ด ๋ชจ๋ธ๋ง, ์์ฝ, ๋ฒ์ญ, ๊ฐ๊ด์ ์ง์์๋ต, ํ
์คํธ ์์ฑ<br>
๐ผ๏ธ **์ปดํจํฐ ๋น์ **: ์ด๋ฏธ์ง ๋ถ๋ฅ, ๊ฐ์ฒด ํ์ง, ๊ฐ์ฒด ๋ถํ <br>
๐ฃ๏ธ **์ค๋์ค**: ์๋์์ฑ์ธ์, ์ค๋์ค ๋ถ๋ฅ<br>
๐ **๋ฉํฐ๋ชจ๋ฌ**: ํ ์ง์์๋ต, ๊ดํ ๋ฌธ์ ์ธ์ (OCR), ์ค์บํ ๋ฌธ์์์ ์ ๋ณด ์ถ์ถ, ๋น๋์ค ๋ถ๋ฅ, ์๊ฐ ์ง์์๋ต
๐ค Transformers๋ PyTorch, TensorFlow์ JAX ๊ฐ์ ์ํธ์ด์ฉ์ฑ์ ์ง์ํฉ๋๋ค. ์ ์ฐํ๊ฒ ๋ชจ๋ธ์ ๊ฐ ๋จ๊ณ๋ง๋ค ๋ค๋ฅธ ํ๋ ์์ํฌ๋ฅผ ์ฌ์ฉํ ์๋ ์์ต๋๋ค. ์๋ฅผ ๋ค์ด ์ฝ๋ 3์ค๋ง ์จ์ ๋ชจ๋ธ์ ํ๋ จ์ํจ ๋ค์, ๋ค๋ฅธ ํ๋ ์์ํฌ ์์์ ์ถ๋ก ํ ์ ์์ต๋๋ค. ๋ชจ๋ธ์ ์ด์ ํ๊ฒฝ์ ๋ฐฐํฌํ๊ธฐ ์ํด ONNX๋ TorchScript ํ์์ผ๋ก ๋ด๋ณด๋ผ ์๋ ์์ต๋๋ค.
์ปค๋ฎค๋ํฐ์ ์ฐธ์ฌํ์๋ ค๋ฉด [Hub](https://huggingface.co/models), [ํฌ๋ผ](https://discuss.huggingface.co/), [๋์ค์ฝ๋](https://discord.com/invite/JfAtkvEtRb)๋ฅผ ๋ฐฉ๋ฌธํด์ฃผ์ธ์!
## Hugging Face ํ๊ณผ ์ง์ ๋ํํ๊ณ ์ถ์ผ์ ๊ฐ์?[[hugging-face-team]]
<a target="_blank" href="https://huggingface.co/support">
<img alt="HuggingFace Expert Acceleration Program" src="https://cdn-media.huggingface.co/marketing/transformers/new-support-improved.png" style="width: 100%; max-width: 600px; border: 1px solid #eee; border-radius: 4px; box-shadow: 0 1px 2px 0 rgba(0, 0, 0, 0.05);">
</a>
## ์ฝํ
์ธ [[contents]]
์ ํฌ ๊ธฐ์ ๋ฌธ์๋ ํฌ๊ฒ 5๊ฐ ์น์
์ผ๋ก ๋๋ ์ ์์ต๋๋ค:
- **์์ํ๊ธฐ**์์ ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ฅผ ๊ฐ๋จํ ํ์ด๋ณด๊ณ , ๋ณธ๊ฒฉ์ ์ผ๋ก ๋ฐ์ด๋ค ์ ์๊ฒ ์ค์น ๋ฐฉ๋ฒ์ ์๋ดํฉ๋๋ค.
- **ํํ ๋ฆฌ์ผ**์์ ๋ผ์ด๋ธ๋ฌ๋ฆฌ์ ์ต์ํด์ง ์ ์๋๋ก ์์ธํ๊ณ ๋ ์ฝ๊ฒ ๊ธฐ๋ณธ์ ์ธ ๋ถ๋ถ์ ์๋ดํฉ๋๋ค.
- **How-to ๊ฐ์ด๋**์์ ์ธ์ด ๋ชจ๋ธ๋ง์ ์ํด ์ฌ์ ํ์ต๋ ๋ชจ๋ธ์ ํ์ธ ํ๋ํ๋ ๋ฐฉ๋ฒ์ด๋, ์ง์ ๋ชจ๋ธ์ ์์ฑํ๊ณ ๊ณต์ ํ๋ ๋ฐฉ๋ฒ๊ณผ ๊ฐ์ด ํน์ ๋ชฉํ๋ฅผ ๋ฌ์ฑํ๋ ๋ฐฉ๋ฒ์ ์๋ดํฉ๋๋ค.
- **๊ฐ๋
๊ฐ์ด๋**์์ ๐ค Transformers์ ์ค๊ณ ์ฒ ํ๊ณผ ํจ๊ป ๋ชจ๋ธ์ด๋ ํ์คํฌ ๋ค์ ์จ๊ฒจ์ง ๊ฐ๋
๋ค๊ณผ ์์ด๋์ด๋ฅผ ํ๊ตฌํ๊ณ ์ค๋ช
์ ๋ง๋ถ์
๋๋ค.
- **API**์์ ๋ชจ๋ ํด๋์ค์ ํจ์๋ฅผ ์ค๋ช
ํฉ๋๋ค.
- **๋ฉ์ธ ํด๋์ค**์์ configuration, model, tokenizer, pipeline๊ณผ ๊ฐ์ด ์ ์ผ ์ค์ํ ํด๋์ค๋ค์ ์์ธํ ์ค๋ช
ํฉ๋๋ค.
- **๋ชจ๋ธ**์์ ๋ผ์ด๋ธ๋ฌ๋ฆฌ ์ ๊ตฌํ๋ ๊ฐ ๋ชจ๋ธ๊ณผ ์ฐ๊ด๋ ํด๋์ค์ ํจ์๋ฅผ ์์ธํ ์ค๋ช
ํฉ๋๋ค.
- **๋ด๋ถ ์ ํธ๋ฆฌํฐ**์์ ๋ด๋ถ์ ์ผ๋ก ์ฌ์ฉ๋๋ ์ ํธ๋ฆฌํฐ ํด๋์ค์ ํจ์๋ฅผ ์์ธํ ์ค๋ช
ํฉ๋๋ค.
### ์ง์ ๋ชจ๋ธ[[supported-models]]
<!--This list is updated automatically from the README with _make fix-copies_. Do not update manually! -->
1. **[ALBERT](model_doc/albert)** (from Google Research and the Toyota Technological Institute at Chicago) released with the paper [ALBERT: A Lite BERT for Self-supervised Learning of Language Representations](https://arxiv.org/abs/1909.11942), by Zhenzhong Lan, Mingda Chen, Sebastian Goodman, Kevin Gimpel, Piyush Sharma, Radu Soricut.
1. **[BART](model_doc/bart)** (from Facebook) released with the paper [BART: Denoising Sequence-to-Sequence Pre-training for Natural Language Generation, Translation, and Comprehension](https://arxiv.org/abs/1910.13461) by Mike Lewis, Yinhan Liu, Naman Goyal, Marjan Ghazvininejad, Abdelrahman Mohamed, Omer Levy, Ves Stoyanov and Luke Zettlemoyer.
1. **[BARThez](model_doc/barthez)** (from รcole polytechnique) released with the paper [BARThez: a Skilled Pretrained French Sequence-to-Sequence Model](https://arxiv.org/abs/2010.12321) by Moussa Kamal Eddine, Antoine J.-P. Tixier, Michalis Vazirgiannis.
1. **[BARTpho](model_doc/bartpho)** (from VinAI Research) released with the paper [BARTpho: Pre-trained Sequence-to-Sequence Models for Vietnamese](https://arxiv.org/abs/2109.09701) by Nguyen Luong Tran, Duong Minh Le and Dat Quoc Nguyen.
1. **[BEiT](model_doc/beit)** (from Microsoft) released with the paper [BEiT: BERT Pre-Training of Image Transformers](https://arxiv.org/abs/2106.08254) by Hangbo Bao, Li Dong, Furu Wei.
1. **[BERT](model_doc/bert)** (from Google) released with the paper [BERT: Pre-training of Deep Bidirectional Transformers for Language Understanding](https://arxiv.org/abs/1810.04805) by Jacob Devlin, Ming-Wei Chang, Kenton Lee and Kristina Toutanova.
1. **[BERT For Sequence Generation](model_doc/bert-generation)** (from Google) released with the paper [Leveraging Pre-trained Checkpoints for Sequence Generation Tasks](https://arxiv.org/abs/1907.12461) by Sascha Rothe, Shashi Narayan, Aliaksei Severyn.
1. **[BERTweet](model_doc/bertweet)** (from VinAI Research) released with the paper [BERTweet: A pre-trained language model for English Tweets](https://aclanthology.org/2020.emnlp-demos.2/) by Dat Quoc Nguyen, Thanh Vu and Anh Tuan Nguyen.
1. **[BigBird-Pegasus](model_doc/bigbird_pegasus)** (from Google Research) released with the paper [Big Bird: Transformers for Longer Sequences](https://arxiv.org/abs/2007.14062) by Manzil Zaheer, Guru Guruganesh, Avinava Dubey, Joshua Ainslie, Chris Alberti, Santiago Ontanon, Philip Pham, Anirudh Ravula, Qifan Wang, Li Yang, Amr Ahmed.
1. **[BigBird-RoBERTa](model_doc/big_bird)** (from Google Research) released with the paper [Big Bird: Transformers for Longer Sequences](https://arxiv.org/abs/2007.14062) by Manzil Zaheer, Guru Guruganesh, Avinava Dubey, Joshua Ainslie, Chris Alberti, Santiago Ontanon, Philip Pham, Anirudh Ravula, Qifan Wang, Li Yang, Amr Ahmed.
1. **[Blenderbot](model_doc/blenderbot)** (from Facebook) released with the paper [Recipes for building an open-domain chatbot](https://arxiv.org/abs/2004.13637) by Stephen Roller, Emily Dinan, Naman Goyal, Da Ju, Mary Williamson, Yinhan Liu, Jing Xu, Myle Ott, Kurt Shuster, Eric M. Smith, Y-Lan Boureau, Jason Weston.
1. **[BlenderbotSmall](model_doc/blenderbot-small)** (from Facebook) released with the paper [Recipes for building an open-domain chatbot](https://arxiv.org/abs/2004.13637) by Stephen Roller, Emily Dinan, Naman Goyal, Da Ju, Mary Williamson, Yinhan Liu, Jing Xu, Myle Ott, Kurt Shuster, Eric M. Smith, Y-Lan Boureau, Jason Weston.
1. **[BLOOM](model_doc/bloom)** (from BigScience workshop) released by the [BigScience Workshop](https://bigscience.huggingface.co/).
1. **[BORT](model_doc/bort)** (from Alexa) released with the paper [Optimal Subarchitecture Extraction For BERT](https://arxiv.org/abs/2010.10499) by Adrian de Wynter and Daniel J. Perry.
1. **[ByT5](model_doc/byt5)** (from Google Research) released with the paper [ByT5: Towards a token-free future with pre-trained byte-to-byte models](https://arxiv.org/abs/2105.13626) by Linting Xue, Aditya Barua, Noah Constant, Rami Al-Rfou, Sharan Narang, Mihir Kale, Adam Roberts, Colin Raffel.
1. **[CamemBERT](model_doc/camembert)** (from Inria/Facebook/Sorbonne) released with the paper [CamemBERT: a Tasty French Language Model](https://arxiv.org/abs/1911.03894) by Louis Martin*, Benjamin Muller*, Pedro Javier Ortiz Suรกrez*, Yoann Dupont, Laurent Romary, รric Villemonte de la Clergerie, Djamรฉ Seddah and Benoรฎt Sagot.
1. **[CANINE](model_doc/canine)** (from Google Research) released with the paper [CANINE: Pre-training an Efficient Tokenization-Free Encoder for Language Representation](https://arxiv.org/abs/2103.06874) by Jonathan H. Clark, Dan Garrette, Iulia Turc, John Wieting.
1. **[CLIP](model_doc/clip)** (from OpenAI) released with the paper [Learning Transferable Visual Models From Natural Language Supervision](https://arxiv.org/abs/2103.00020) by Alec Radford, Jong Wook Kim, Chris Hallacy, Aditya Ramesh, Gabriel Goh, Sandhini Agarwal, Girish Sastry, Amanda Askell, Pamela Mishkin, Jack Clark, Gretchen Krueger, Ilya Sutskever.
1. **[CLIPSeg](model_doc/clipseg)** (from University of Gรถttingen) released with the paper [Image Segmentation Using Text and Image Prompts](https://arxiv.org/abs/2112.10003) by Timo Lรผddecke and Alexander Ecker.
1. **[CodeGen](model_doc/codegen)** (from Salesforce) released with the paper [A Conversational Paradigm for Program Synthesis](https://arxiv.org/abs/2203.13474) by Erik Nijkamp, Bo Pang, Hiroaki Hayashi, Lifu Tu, Huan Wang, Yingbo Zhou, Silvio Savarese, Caiming Xiong.
1. **[Conditional DETR](model_doc/conditional_detr)** (from Microsoft Research Asia) released with the paper [Conditional DETR for Fast Training Convergence](https://arxiv.org/abs/2108.06152) by Depu Meng, Xiaokang Chen, Zejia Fan, Gang Zeng, Houqiang Li, Yuhui Yuan, Lei Sun, Jingdong Wang.
1. **[ConvBERT](model_doc/convbert)** (from YituTech) released with the paper [ConvBERT: Improving BERT with Span-based Dynamic Convolution](https://arxiv.org/abs/2008.02496) by Zihang Jiang, Weihao Yu, Daquan Zhou, Yunpeng Chen, Jiashi Feng, Shuicheng Yan.
1. **[ConvNeXT](model_doc/convnext)** (from Facebook AI) released with the paper [A ConvNet for the 2020s](https://arxiv.org/abs/2201.03545) by Zhuang Liu, Hanzi Mao, Chao-Yuan Wu, Christoph Feichtenhofer, Trevor Darrell, Saining Xie.
1. **[ConvNeXTV2](model_doc/convnextv2)** (from Facebook AI) released with the paper [ConvNeXt V2: Co-designing and Scaling ConvNets with Masked Autoencoders](https://arxiv.org/abs/2301.00808) by Sanghyun Woo, Shoubhik Debnath, Ronghang Hu, Xinlei Chen, Zhuang Liu, In So Kweon, Saining Xie.
1. **[CPM](model_doc/cpm)** (from Tsinghua University) released with the paper [CPM: A Large-scale Generative Chinese Pre-trained Language Model](https://arxiv.org/abs/2012.00413) by Zhengyan Zhang, Xu Han, Hao Zhou, Pei Ke, Yuxian Gu, Deming Ye, Yujia Qin, Yusheng Su, Haozhe Ji, Jian Guan, Fanchao Qi, Xiaozhi Wang, Yanan Zheng, Guoyang Zeng, Huanqi Cao, Shengqi Chen, Daixuan Li, Zhenbo Sun, Zhiyuan Liu, Minlie Huang, Wentao Han, Jie Tang, Juanzi Li, Xiaoyan Zhu, Maosong Sun.
1. **[CTRL](model_doc/ctrl)** (from Salesforce) released with the paper [CTRL: A Conditional Transformer Language Model for Controllable Generation](https://arxiv.org/abs/1909.05858) by Nitish Shirish Keskar*, Bryan McCann*, Lav R. Varshney, Caiming Xiong and Richard Socher.
1. **[CvT](model_doc/cvt)** (from Microsoft) released with the paper [CvT: Introducing Convolutions to Vision Transformers](https://arxiv.org/abs/2103.15808) by Haiping Wu, Bin Xiao, Noel Codella, Mengchen Liu, Xiyang Dai, Lu Yuan, Lei Zhang.
1. **[Data2Vec](model_doc/data2vec)** (from Facebook) released with the paper [Data2Vec: A General Framework for Self-supervised Learning in Speech, Vision and Language](https://arxiv.org/abs/2202.03555) by Alexei Baevski, Wei-Ning Hsu, Qiantong Xu, Arun Babu, Jiatao Gu, Michael Auli.
1. **[DeBERTa](model_doc/deberta)** (from Microsoft) released with the paper [DeBERTa: Decoding-enhanced BERT with Disentangled Attention](https://arxiv.org/abs/2006.03654) by Pengcheng He, Xiaodong Liu, Jianfeng Gao, Weizhu Chen.
1. **[DeBERTa-v2](model_doc/deberta-v2)** (from Microsoft) released with the paper [DeBERTa: Decoding-enhanced BERT with Disentangled Attention](https://arxiv.org/abs/2006.03654) by Pengcheng He, Xiaodong Liu, Jianfeng Gao, Weizhu Chen.
1. **[Decision Transformer](model_doc/decision_transformer)** (from Berkeley/Facebook/Google) released with the paper [Decision Transformer: Reinforcement Learning via Sequence Modeling](https://arxiv.org/abs/2106.01345) by Lili Chen, Kevin Lu, Aravind Rajeswaran, Kimin Lee, Aditya Grover, Michael Laskin, Pieter Abbeel, Aravind Srinivas, Igor Mordatch.
1. **[Deformable DETR](model_doc/deformable_detr)** (from SenseTime Research) released with the paper [Deformable DETR: Deformable Transformers for End-to-End Object Detection](https://arxiv.org/abs/2010.04159) by Xizhou Zhu, Weijie Su, Lewei Lu, Bin Li, Xiaogang Wang, Jifeng Dai.
1. **[DeiT](model_doc/deit)** (from Facebook) released with the paper [Training data-efficient image transformers & distillation through attention](https://arxiv.org/abs/2012.12877) by Hugo Touvron, Matthieu Cord, Matthijs Douze, Francisco Massa, Alexandre Sablayrolles, Hervรฉ Jรฉgou.
1. **[DETR](model_doc/detr)** (from Facebook) released with the paper [End-to-End Object Detection with Transformers](https://arxiv.org/abs/2005.12872) by Nicolas Carion, Francisco Massa, Gabriel Synnaeve, Nicolas Usunier, Alexander Kirillov, Sergey Zagoruyko.
1. **[DialoGPT](model_doc/dialogpt)** (from Microsoft Research) released with the paper [DialoGPT: Large-Scale Generative Pre-training for Conversational Response Generation](https://arxiv.org/abs/1911.00536) by Yizhe Zhang, Siqi Sun, Michel Galley, Yen-Chun Chen, Chris Brockett, Xiang Gao, Jianfeng Gao, Jingjing Liu, Bill Dolan.
1. **[DistilBERT](model_doc/distilbert)** (from HuggingFace), released together with the paper [DistilBERT, a distilled version of BERT: smaller, faster, cheaper and lighter](https://arxiv.org/abs/1910.01108) by Victor Sanh, Lysandre Debut and Thomas Wolf. The same method has been applied to compress GPT2 into [DistilGPT2](https://github.com/huggingface/transformers/tree/main/examples/research_projects/distillation), RoBERTa into [DistilRoBERTa](https://github.com/huggingface/transformers/tree/main/examples/research_projects/distillation), Multilingual BERT into [DistilmBERT](https://github.com/huggingface/transformers/tree/main/examples/research_projects/distillation) and a German version of DistilBERT.
1. **[DiT](model_doc/dit)** (from Microsoft Research) released with the paper [DiT: Self-supervised Pre-training for Document Image Transformer](https://arxiv.org/abs/2203.02378) by Junlong Li, Yiheng Xu, Tengchao Lv, Lei Cui, Cha Zhang, Furu Wei.
1. **[Donut](model_doc/donut)** (from NAVER), released together with the paper [OCR-free Document Understanding Transformer](https://arxiv.org/abs/2111.15664) by Geewook Kim, Teakgyu Hong, Moonbin Yim, Jeongyeon Nam, Jinyoung Park, Jinyeong Yim, Wonseok Hwang, Sangdoo Yun, Dongyoon Han, Seunghyun Park.
1. **[DPR](model_doc/dpr)** (from Facebook) released with the paper [Dense Passage Retrieval for Open-Domain Question Answering](https://arxiv.org/abs/2004.04906) by Vladimir Karpukhin, Barlas Oฤuz, Sewon Min, Patrick Lewis, Ledell Wu, Sergey Edunov, Danqi Chen, and Wen-tau Yih.
1. **[DPT](master/model_doc/dpt)** (from Intel Labs) released with the paper [Vision Transformers for Dense Prediction](https://arxiv.org/abs/2103.13413) by Renรฉ Ranftl, Alexey Bochkovskiy, Vladlen Koltun.
1. **[EfficientNet](model_doc/efficientnet)** (from Google Research) released with the paper [EfficientNet: Rethinking Model Scaling for Convolutional Neural Networks](https://arxiv.org/abs/1905.11946) by Mingxing Tan and Quoc V. Le.
1. **[ELECTRA](model_doc/electra)** (from Google Research/Stanford University) released with the paper [ELECTRA: Pre-training text encoders as discriminators rather than generators](https://arxiv.org/abs/2003.10555) by Kevin Clark, Minh-Thang Luong, Quoc V. Le, Christopher D. Manning.
1. **[EncoderDecoder](model_doc/encoder-decoder)** (from Google Research) released with the paper [Leveraging Pre-trained Checkpoints for Sequence Generation Tasks](https://arxiv.org/abs/1907.12461) by Sascha Rothe, Shashi Narayan, Aliaksei Severyn.
1. **[ERNIE](model_doc/ernie)** (from Baidu) released with the paper [ERNIE: Enhanced Representation through Knowledge Integration](https://arxiv.org/abs/1904.09223) by Yu Sun, Shuohuan Wang, Yukun Li, Shikun Feng, Xuyi Chen, Han Zhang, Xin Tian, Danxiang Zhu, Hao Tian, Hua Wu.
1. **[ESM](model_doc/esm)** (from Meta AI) are transformer protein language models. **ESM-1b** was released with the paper [Biological structure and function emerge from scaling unsupervised learning to 250 million protein sequences](https://www.pnas.org/content/118/15/e2016239118) by Alexander Rives, Joshua Meier, Tom Sercu, Siddharth Goyal, Zeming Lin, Jason Liu, Demi Guo, Myle Ott, C. Lawrence Zitnick, Jerry Ma, and Rob Fergus. **ESM-1v** was released with the paper [Language models enable zero-shot prediction of the effects of mutations on protein function](https://doi.org/10.1101/2021.07.09.450648) by Joshua Meier, Roshan Rao, Robert Verkuil, Jason Liu, Tom Sercu and Alexander Rives. **ESM-2 and ESMFold** were released with the paper [Language models of protein sequences at the scale of evolution enable accurate structure prediction](https://doi.org/10.1101/2022.07.20.500902) by Zeming Lin, Halil Akin, Roshan Rao, Brian Hie, Zhongkai Zhu, Wenting Lu, Allan dos Santos Costa, Maryam Fazel-Zarandi, Tom Sercu, Sal Candido, Alexander Rives.
1. **[FLAN-T5](model_doc/flan-t5)** (from Google AI) released in the repository [google-research/t5x](https://github.com/google-research/t5x/blob/main/docs/models.md#flan-t5-checkpoints) by Hyung Won Chung, Le Hou, Shayne Longpre, Barret Zoph, Yi Tay, William Fedus, Eric Li, Xuezhi Wang, Mostafa Dehghani, Siddhartha Brahma, Albert Webson, Shixiang Shane Gu, Zhuyun Dai, Mirac Suzgun, Xinyun Chen, Aakanksha Chowdhery, Sharan Narang, Gaurav Mishra, Adams Yu, Vincent Zhao, Yanping Huang, Andrew Dai, Hongkun Yu, Slav Petrov, Ed H. Chi, Jeff Dean, Jacob Devlin, Adam Roberts, Denny Zhou, Quoc V. Le, and Jason Wei
1. **[FlauBERT](model_doc/flaubert)** (from CNRS) released with the paper [FlauBERT: Unsupervised Language Model Pre-training for French](https://arxiv.org/abs/1912.05372) by Hang Le, Loรฏc Vial, Jibril Frej, Vincent Segonne, Maximin Coavoux, Benjamin Lecouteux, Alexandre Allauzen, Benoรฎt Crabbรฉ, Laurent Besacier, Didier Schwab.
1. **[FLAVA](model_doc/flava)** (from Facebook AI) released with the paper [FLAVA: A Foundational Language And Vision Alignment Model](https://arxiv.org/abs/2112.04482) by Amanpreet Singh, Ronghang Hu, Vedanuj Goswami, Guillaume Couairon, Wojciech Galuba, Marcus Rohrbach, and Douwe Kiela.
1. **[FNet](model_doc/fnet)** (from Google Research) released with the paper [FNet: Mixing Tokens with Fourier Transforms](https://arxiv.org/abs/2105.03824) by James Lee-Thorp, Joshua Ainslie, Ilya Eckstein, Santiago Ontanon.
1. **[Funnel Transformer](model_doc/funnel)** (from CMU/Google Brain) released with the paper [Funnel-Transformer: Filtering out Sequential Redundancy for Efficient Language Processing](https://arxiv.org/abs/2006.03236) by Zihang Dai, Guokun Lai, Yiming Yang, Quoc V. Le.
1. **[GLPN](model_doc/glpn)** (from KAIST) released with the paper [Global-Local Path Networks for Monocular Depth Estimation with Vertical CutDepth](https://arxiv.org/abs/2201.07436) by Doyeon Kim, Woonghyun Ga, Pyungwhan Ahn, Donggyu Joo, Sehwan Chun, Junmo Kim.
1. **[GPT](model_doc/openai-gpt)** (from OpenAI) released with the paper [Improving Language Understanding by Generative Pre-Training](https://openai.com/research/language-unsupervised/) by Alec Radford, Karthik Narasimhan, Tim Salimans and Ilya Sutskever.
1. **[GPT Neo](model_doc/gpt_neo)** (from EleutherAI) released in the repository [EleutherAI/gpt-neo](https://github.com/EleutherAI/gpt-neo) by Sid Black, Stella Biderman, Leo Gao, Phil Wang and Connor Leahy.
1. **[GPT NeoX](model_doc/gpt_neox)** (from EleutherAI) released with the paper [GPT-NeoX-20B: An Open-Source Autoregressive Language Model](https://arxiv.org/abs/2204.06745) by Sid Black, Stella Biderman, Eric Hallahan, Quentin Anthony, Leo Gao, Laurence Golding, Horace He, Connor Leahy, Kyle McDonell, Jason Phang, Michael Pieler, USVSN Sai Prashanth, Shivanshu Purohit, Laria Reynolds, Jonathan Tow, Ben Wang, Samuel Weinbach
1. **[GPT NeoX Japanese](model_doc/gpt_neox_japanese)** (from ABEJA) released by Shinya Otani, Takayoshi Makabe, Anuj Arora, and Kyo Hattori.
1. **[GPT-2](model_doc/gpt2)** (from OpenAI) released with the paper [Language Models are Unsupervised Multitask Learners](https://openai.com/research/better-language-models/) by Alec Radford, Jeffrey Wu, Rewon Child, David Luan, Dario Amodei and Ilya Sutskever.
1. **[GPT-J](model_doc/gptj)** (from EleutherAI) released in the repository [kingoflolz/mesh-transformer-jax](https://github.com/kingoflolz/mesh-transformer-jax/) by Ben Wang and Aran Komatsuzaki.
1. **[GPTSAN-japanese](model_doc/gptsan-japanese)** released in the repository [tanreinama/GPTSAN](https://github.com/tanreinama/GPTSAN/blob/main/report/model.md) by Toshiyuki Sakamoto(tanreinama).
1. **[GroupViT](model_doc/groupvit)** (from UCSD, NVIDIA) released with the paper [GroupViT: Semantic Segmentation Emerges from Text Supervision](https://arxiv.org/abs/2202.11094) by Jiarui Xu, Shalini De Mello, Sifei Liu, Wonmin Byeon, Thomas Breuel, Jan Kautz, Xiaolong Wang.
1. **[Hubert](model_doc/hubert)** (from Facebook) released with the paper [HuBERT: Self-Supervised Speech Representation Learning by Masked Prediction of Hidden Units](https://arxiv.org/abs/2106.07447) by Wei-Ning Hsu, Benjamin Bolte, Yao-Hung Hubert Tsai, Kushal Lakhotia, Ruslan Salakhutdinov, Abdelrahman Mohamed.
1. **[I-BERT](model_doc/ibert)** (from Berkeley) released with the paper [I-BERT: Integer-only BERT Quantization](https://arxiv.org/abs/2101.01321) by Sehoon Kim, Amir Gholami, Zhewei Yao, Michael W. Mahoney, Kurt Keutzer.
1. **[ImageGPT](model_doc/imagegpt)** (from OpenAI) released with the paper [Generative Pretraining from Pixels](https://openai.com/blog/image-gpt/) by Mark Chen, Alec Radford, Rewon Child, Jeffrey Wu, Heewoo Jun, David Luan, Ilya Sutskever.
1. **[Jukebox](model_doc/jukebox)** (from OpenAI) released with the paper [Jukebox: A Generative Model for Music](https://arxiv.org/pdf/2005.00341.pdf) by Prafulla Dhariwal, Heewoo Jun, Christine Payne, Jong Wook Kim, Alec Radford, Ilya Sutskever.
1. **[LayoutLM](model_doc/layoutlm)** (from Microsoft Research Asia) released with the paper [LayoutLM: Pre-training of Text and Layout for Document Image Understanding](https://arxiv.org/abs/1912.13318) by Yiheng Xu, Minghao Li, Lei Cui, Shaohan Huang, Furu Wei, Ming Zhou.
1. **[LayoutLMv2](model_doc/layoutlmv2)** (from Microsoft Research Asia) released with the paper [LayoutLMv2: Multi-modal Pre-training for Visually-Rich Document Understanding](https://arxiv.org/abs/2012.14740) by Yang Xu, Yiheng Xu, Tengchao Lv, Lei Cui, Furu Wei, Guoxin Wang, Yijuan Lu, Dinei Florencio, Cha Zhang, Wanxiang Che, Min Zhang, Lidong Zhou.
1. **[LayoutLMv3](model_doc/layoutlmv3)** (from Microsoft Research Asia) released with the paper [LayoutLMv3: Pre-training for Document AI with Unified Text and Image Masking](https://arxiv.org/abs/2204.08387) by Yupan Huang, Tengchao Lv, Lei Cui, Yutong Lu, Furu Wei.
1. **[LayoutXLM](model_doc/layoutxlm)** (from Microsoft Research Asia) released with the paper [LayoutXLM: Multimodal Pre-training for Multilingual Visually-rich Document Understanding](https://arxiv.org/abs/2104.08836) by Yiheng Xu, Tengchao Lv, Lei Cui, Guoxin Wang, Yijuan Lu, Dinei Florencio, Cha Zhang, Furu Wei.
1. **[LED](model_doc/led)** (from AllenAI) released with the paper [Longformer: The Long-Document Transformer](https://arxiv.org/abs/2004.05150) by Iz Beltagy, Matthew E. Peters, Arman Cohan.
1. **[LeViT](model_doc/levit)** (from Meta AI) released with the paper [LeViT: A Vision Transformer in ConvNet's Clothing for Faster Inference](https://arxiv.org/abs/2104.01136) by Ben Graham, Alaaeldin El-Nouby, Hugo Touvron, Pierre Stock, Armand Joulin, Hervรฉ Jรฉgou, Matthijs Douze.
1. **[LiLT](model_doc/lilt)** (from South China University of Technology) released with the paper [LiLT: A Simple yet Effective Language-Independent Layout Transformer for Structured Document Understanding](https://arxiv.org/abs/2202.13669) by Jiapeng Wang, Lianwen Jin, Kai Ding.
1. **[Longformer](model_doc/longformer)** (from AllenAI) released with the paper [Longformer: The Long-Document Transformer](https://arxiv.org/abs/2004.05150) by Iz Beltagy, Matthew E. Peters, Arman Cohan.
1. **[LongT5](model_doc/longt5)** (from Google AI) released with the paper [LongT5: Efficient Text-To-Text Transformer for Long Sequences](https://arxiv.org/abs/2112.07916) by Mandy Guo, Joshua Ainslie, David Uthus, Santiago Ontanon, Jianmo Ni, Yun-Hsuan Sung, Yinfei Yang.
1. **[LUKE](model_doc/luke)** (from Studio Ousia) released with the paper [LUKE: Deep Contextualized Entity Representations with Entity-aware Self-attention](https://arxiv.org/abs/2010.01057) by Ikuya Yamada, Akari Asai, Hiroyuki Shindo, Hideaki Takeda, Yuji Matsumoto.
1. **[LXMERT](model_doc/lxmert)** (from UNC Chapel Hill) released with the paper [LXMERT: Learning Cross-Modality Encoder Representations from Transformers for Open-Domain Question Answering](https://arxiv.org/abs/1908.07490) by Hao Tan and Mohit Bansal.
1. **[M-CTC-T](model_doc/mctct)** (from Facebook) released with the paper [Pseudo-Labeling For Massively Multilingual Speech Recognition](https://arxiv.org/abs/2111.00161) by Loren Lugosch, Tatiana Likhomanenko, Gabriel Synnaeve, and Ronan Collobert.
1. **[M2M100](model_doc/m2m_100)** (from Facebook) released with the paper [Beyond English-Centric Multilingual Machine Translation](https://arxiv.org/abs/2010.11125) by Angela Fan, Shruti Bhosale, Holger Schwenk, Zhiyi Ma, Ahmed El-Kishky, Siddharth Goyal, Mandeep Baines, Onur Celebi, Guillaume Wenzek, Vishrav Chaudhary, Naman Goyal, Tom Birch, Vitaliy Liptchinsky, Sergey Edunov, Edouard Grave, Michael Auli, Armand Joulin.
1. **[MarianMT](model_doc/marian)** Machine translation models trained using [OPUS](http://opus.nlpl.eu/) data by Jรถrg Tiedemann. The [Marian Framework](https://marian-nmt.github.io/) is being developed by the Microsoft Translator Team.
1. **[MarkupLM](model_doc/markuplm)** (from Microsoft Research Asia) released with the paper [MarkupLM: Pre-training of Text and Markup Language for Visually-rich Document Understanding](https://arxiv.org/abs/2110.08518) by Junlong Li, Yiheng Xu, Lei Cui, Furu Wei.
1. **[Mask2Former](model_doc/mask2former)** (from FAIR and UIUC) released with the paper [Masked-attention Mask Transformer for Universal Image Segmentation](https://arxiv.org/abs/2112.01527) by Bowen Cheng, Ishan Misra, Alexander G. Schwing, Alexander Kirillov, Rohit Girdhar.
1. **[MaskFormer](model_doc/maskformer)** (from Meta and UIUC) released with the paper [Per-Pixel Classification is Not All You Need for Semantic Segmentation](https://arxiv.org/abs/2107.06278) by Bowen Cheng, Alexander G. Schwing, Alexander Kirillov.
1. **[mBART](model_doc/mbart)** (from Facebook) released with the paper [Multilingual Denoising Pre-training for Neural Machine Translation](https://arxiv.org/abs/2001.08210) by Yinhan Liu, Jiatao Gu, Naman Goyal, Xian Li, Sergey Edunov, Marjan Ghazvininejad, Mike Lewis, Luke Zettlemoyer.
1. **[mBART-50](model_doc/mbart)** (from Facebook) released with the paper [Multilingual Translation with Extensible Multilingual Pretraining and Finetuning](https://arxiv.org/abs/2008.00401) by Yuqing Tang, Chau Tran, Xian Li, Peng-Jen Chen, Naman Goyal, Vishrav Chaudhary, Jiatao Gu, Angela Fan.
1. **[Megatron-BERT](model_doc/megatron-bert)** (from NVIDIA) released with the paper [Megatron-LM: Training Multi-Billion Parameter Language Models Using Model Parallelism](https://arxiv.org/abs/1909.08053) by Mohammad Shoeybi, Mostofa Patwary, Raul Puri, Patrick LeGresley, Jared Casper and Bryan Catanzaro.
1. **[Megatron-GPT2](model_doc/megatron_gpt2)** (from NVIDIA) released with the paper [Megatron-LM: Training Multi-Billion Parameter Language Models Using Model Parallelism](https://arxiv.org/abs/1909.08053) by Mohammad Shoeybi, Mostofa Patwary, Raul Puri, Patrick LeGresley, Jared Casper and Bryan Catanzaro.
1. **[mLUKE](model_doc/mluke)** (from Studio Ousia) released with the paper [mLUKE: The Power of Entity Representations in Multilingual Pretrained Language Models](https://arxiv.org/abs/2110.08151) by Ryokan Ri, Ikuya Yamada, and Yoshimasa Tsuruoka.
1. **[MobileBERT](model_doc/mobilebert)** (from CMU/Google Brain) released with the paper [MobileBERT: a Compact Task-Agnostic BERT for Resource-Limited Devices](https://arxiv.org/abs/2004.02984) by Zhiqing Sun, Hongkun Yu, Xiaodan Song, Renjie Liu, Yiming Yang, and Denny Zhou.
1. **[MobileViT](model_doc/mobilevit)** (from Apple) released with the paper [MobileViT: Light-weight, General-purpose, and Mobile-friendly Vision Transformer](https://arxiv.org/abs/2110.02178) by Sachin Mehta and Mohammad Rastegari.
1. **[MPNet](model_doc/mpnet)** (from Microsoft Research) released with the paper [MPNet: Masked and Permuted Pre-training for Language Understanding](https://arxiv.org/abs/2004.09297) by Kaitao Song, Xu Tan, Tao Qin, Jianfeng Lu, Tie-Yan Liu.
1. **[MT5](model_doc/mt5)** (from Google AI) released with the paper [mT5: A massively multilingual pre-trained text-to-text transformer](https://arxiv.org/abs/2010.11934) by Linting Xue, Noah Constant, Adam Roberts, Mihir Kale, Rami Al-Rfou, Aditya Siddhant, Aditya Barua, Colin Raffel.
1. **[MVP](model_doc/mvp)** (from RUC AI Box) released with the paper [MVP: Multi-task Supervised Pre-training for Natural Language Generation](https://arxiv.org/abs/2206.12131) by Tianyi Tang, Junyi Li, Wayne Xin Zhao and Ji-Rong Wen.
1. **[Nezha](model_doc/nezha)** (from Huawei Noahโs Ark Lab) released with the paper [NEZHA: Neural Contextualized Representation for Chinese Language Understanding](https://arxiv.org/abs/1909.00204) by Junqiu Wei, Xiaozhe Ren, Xiaoguang Li, Wenyong Huang, Yi Liao, Yasheng Wang, Jiashu Lin, Xin Jiang, Xiao Chen and Qun Liu.
1. **[NLLB](model_doc/nllb)** (from Meta) released with the paper [No Language Left Behind: Scaling Human-Centered Machine Translation](https://arxiv.org/abs/2207.04672) by the NLLB team.
1. **[Nystrรถmformer](model_doc/nystromformer)** (from the University of Wisconsin - Madison) released with the paper [Nystrรถmformer: A Nystrรถm-Based Algorithm for Approximating Self-Attention](https://arxiv.org/abs/2102.03902) by Yunyang Xiong, Zhanpeng Zeng, Rudrasis Chakraborty, Mingxing Tan, Glenn Fung, Yin Li, Vikas Singh.
1. **[OneFormer](model_doc/oneformer)** (from SHI Labs) released with the paper [OneFormer: One Transformer to Rule Universal Image Segmentation](https://arxiv.org/abs/2211.06220) by Jitesh Jain, Jiachen Li, MangTik Chiu, Ali Hassani, Nikita Orlov, Humphrey Shi.
1. **[OPT](master/model_doc/opt)** (from Meta AI) released with the paper [OPT: Open Pre-trained Transformer Language Models](https://arxiv.org/abs/2205.01068) by Susan Zhang, Stephen Roller, Naman Goyal, Mikel Artetxe, Moya Chen, Shuohui Chen et al.
1. **[OWL-ViT](model_doc/owlvit)** (from Google AI) released with the paper [Simple Open-Vocabulary Object Detection with Vision Transformers](https://arxiv.org/abs/2205.06230) by Matthias Minderer, Alexey Gritsenko, Austin Stone, Maxim Neumann, Dirk Weissenborn, Alexey Dosovitskiy, Aravindh Mahendran, Anurag Arnab, Mostafa Dehghani, Zhuoran Shen, Xiao Wang, Xiaohua Zhai, Thomas Kipf, and Neil Houlsby.
1. **[Pegasus](model_doc/pegasus)** (from Google) released with the paper [PEGASUS: Pre-training with Extracted Gap-sentences for Abstractive Summarization](https://arxiv.org/abs/1912.08777) by Jingqing Zhang, Yao Zhao, Mohammad Saleh and Peter J. Liu.
1. **[PEGASUS-X](model_doc/pegasus_x)** (from Google) released with the paper [Investigating Efficiently Extending Transformers for Long Input Summarization](https://arxiv.org/abs/2208.04347) by Jason Phang, Yao Zhao, and Peter J. Liu.
1. **[Perceiver IO](model_doc/perceiver)** (from Deepmind) released with the paper [Perceiver IO: A General Architecture for Structured Inputs & Outputs](https://arxiv.org/abs/2107.14795) by Andrew Jaegle, Sebastian Borgeaud, Jean-Baptiste Alayrac, Carl Doersch, Catalin Ionescu, David Ding, Skanda Koppula, Daniel Zoran, Andrew Brock, Evan Shelhamer, Olivier Hรฉnaff, Matthew M. Botvinick, Andrew Zisserman, Oriol Vinyals, Joรฃo Carreira.
1. **[PhoBERT](model_doc/phobert)** (from VinAI Research) released with the paper [PhoBERT: Pre-trained language models for Vietnamese](https://www.aclweb.org/anthology/2020.findings-emnlp.92/) by Dat Quoc Nguyen and Anh Tuan Nguyen.
1. **[PLBart](model_doc/plbart)** (from UCLA NLP) released with the paper [Unified Pre-training for Program Understanding and Generation](https://arxiv.org/abs/2103.06333) by Wasi Uddin Ahmad, Saikat Chakraborty, Baishakhi Ray, Kai-Wei Chang.
1. **[PoolFormer](model_doc/poolformer)** (from Sea AI Labs) released with the paper [MetaFormer is Actually What You Need for Vision](https://arxiv.org/abs/2111.11418) by Yu, Weihao and Luo, Mi and Zhou, Pan and Si, Chenyang and Zhou, Yichen and Wang, Xinchao and Feng, Jiashi and Yan, Shuicheng.
1. **[ProphetNet](model_doc/prophetnet)** (from Microsoft Research) released with the paper [ProphetNet: Predicting Future N-gram for Sequence-to-Sequence Pre-training](https://arxiv.org/abs/2001.04063) by Yu Yan, Weizhen Qi, Yeyun Gong, Dayiheng Liu, Nan Duan, Jiusheng Chen, Ruofei Zhang and Ming Zhou.
1. **[QDQBert](model_doc/qdqbert)** (from NVIDIA) released with the paper [Integer Quantization for Deep Learning Inference: Principles and Empirical Evaluation](https://arxiv.org/abs/2004.09602) by Hao Wu, Patrick Judd, Xiaojie Zhang, Mikhail Isaev and Paulius Micikevicius.
1. **[RAG](model_doc/rag)** (from Facebook) released with the paper [Retrieval-Augmented Generation for Knowledge-Intensive NLP Tasks](https://arxiv.org/abs/2005.11401) by Patrick Lewis, Ethan Perez, Aleksandara Piktus, Fabio Petroni, Vladimir Karpukhin, Naman Goyal, Heinrich Kรผttler, Mike Lewis, Wen-tau Yih, Tim Rocktรคschel, Sebastian Riedel, Douwe Kiela.
1. **[REALM](model_doc/realm.html)** (from Google Research) released with the paper [REALM: Retrieval-Augmented Language Model Pre-Training](https://arxiv.org/abs/2002.08909) by Kelvin Guu, Kenton Lee, Zora Tung, Panupong Pasupat and Ming-Wei Chang.
1. **[Reformer](model_doc/reformer)** (from Google Research) released with the paper [Reformer: The Efficient Transformer](https://arxiv.org/abs/2001.04451) by Nikita Kitaev, ลukasz Kaiser, Anselm Levskaya.
1. **[RegNet](model_doc/regnet)** (from META Platforms) released with the paper [Designing Network Design Space](https://arxiv.org/abs/2003.13678) by Ilija Radosavovic, Raj Prateek Kosaraju, Ross Girshick, Kaiming He, Piotr Dollรกr.
1. **[RemBERT](model_doc/rembert)** (from Google Research) released with the paper [Rethinking embedding coupling in pre-trained language models](https://arxiv.org/abs/2010.12821) by Hyung Won Chung, Thibault Fรฉvry, Henry Tsai, M. Johnson, Sebastian Ruder.
1. **[ResNet](model_doc/resnet)** (from Microsoft Research) released with the paper [Deep Residual Learning for Image Recognition](https://arxiv.org/abs/1512.03385) by Kaiming He, Xiangyu Zhang, Shaoqing Ren, Jian Sun.
1. **[RoBERTa](model_doc/roberta)** (from Facebook), released together with the paper [RoBERTa: A Robustly Optimized BERT Pretraining Approach](https://arxiv.org/abs/1907.11692) by Yinhan Liu, Myle Ott, Naman Goyal, Jingfei Du, Mandar Joshi, Danqi Chen, Omer Levy, Mike Lewis, Luke Zettlemoyer, Veselin Stoyanov.
1. **[RoCBert](model_doc/roc_bert)** (from WeChatAI) released with the paper [RoCBert: Robust Chinese Bert with Multimodal Contrastive Pretraining](https://aclanthology.org/2022.acl-long.65.pdf) by HuiSu, WeiweiShi, XiaoyuShen, XiaoZhou, TuoJi, JiaruiFang, JieZhou.
1. **[RoFormer](model_doc/roformer)** (from ZhuiyiTechnology), released together with the paper [RoFormer: Enhanced Transformer with Rotary Position Embedding](https://arxiv.org/abs/2104.09864) by Jianlin Su and Yu Lu and Shengfeng Pan and Bo Wen and Yunfeng Liu.
1. **[SegFormer](model_doc/segformer)** (from NVIDIA) released with the paper [SegFormer: Simple and Efficient Design for Semantic Segmentation with Transformers](https://arxiv.org/abs/2105.15203) by Enze Xie, Wenhai Wang, Zhiding Yu, Anima Anandkumar, Jose M. Alvarez, Ping Luo.
1. **[SEW](model_doc/sew)** (from ASAPP) released with the paper [Performance-Efficiency Trade-offs in Unsupervised Pre-training for Speech Recognition](https://arxiv.org/abs/2109.06870) by Felix Wu, Kwangyoun Kim, Jing Pan, Kyu Han, Kilian Q. Weinberger, Yoav Artzi.
1. **[SEW-D](model_doc/sew_d)** (from ASAPP) released with the paper [Performance-Efficiency Trade-offs in Unsupervised Pre-training for Speech Recognition](https://arxiv.org/abs/2109.06870) by Felix Wu, Kwangyoun Kim, Jing Pan, Kyu Han, Kilian Q. Weinberger, Yoav Artzi.
1. **[SpeechToTextTransformer](model_doc/speech_to_text)** (from Facebook), released together with the paper [fairseq S2T: Fast Speech-to-Text Modeling with fairseq](https://arxiv.org/abs/2010.05171) by Changhan Wang, Yun Tang, Xutai Ma, Anne Wu, Dmytro Okhonko, Juan Pino.
1. **[SpeechToTextTransformer2](model_doc/speech_to_text_2)** (from Facebook), released together with the paper [Large-Scale Self- and Semi-Supervised Learning for Speech Translation](https://arxiv.org/abs/2104.06678) by Changhan Wang, Anne Wu, Juan Pino, Alexei Baevski, Michael Auli, Alexis Conneau.
1. **[Splinter](model_doc/splinter)** (from Tel Aviv University), released together with the paper [Few-Shot Question Answering by Pretraining Span Selection](https://arxiv.org/abs/2101.00438) by Ori Ram, Yuval Kirstain, Jonathan Berant, Amir Globerson, Omer Levy.
1. **[SqueezeBERT](model_doc/squeezebert)** (from Berkeley) released with the paper [SqueezeBERT: What can computer vision teach NLP about efficient neural networks?](https://arxiv.org/abs/2006.11316) by Forrest N. Iandola, Albert E. Shaw, Ravi Krishna, and Kurt W. Keutzer.
1. **[Swin Transformer](model_doc/swin)** (from Microsoft) released with the paper [Swin Transformer: Hierarchical Vision Transformer using Shifted Windows](https://arxiv.org/abs/2103.14030) by Ze Liu, Yutong Lin, Yue Cao, Han Hu, Yixuan Wei, Zheng Zhang, Stephen Lin, Baining Guo.
1. **[Swin Transformer V2](model_doc/swinv2)** (from Microsoft) released with the paper [Swin Transformer V2: Scaling Up Capacity and Resolution](https://arxiv.org/abs/2111.09883) by Ze Liu, Han Hu, Yutong Lin, Zhuliang Yao, Zhenda Xie, Yixuan Wei, Jia Ning, Yue Cao, Zheng Zhang, Li Dong, Furu Wei, Baining Guo.
1. **[T5](model_doc/t5)** (from Google AI) released with the paper [Exploring the Limits of Transfer Learning with a Unified Text-to-Text Transformer](https://arxiv.org/abs/1910.10683) by Colin Raffel and Noam Shazeer and Adam Roberts and Katherine Lee and Sharan Narang and Michael Matena and Yanqi Zhou and Wei Li and Peter J. Liu.
1. **[T5v1.1](model_doc/t5v1.1)** (from Google AI) released in the repository [google-research/text-to-text-transfer-transformer](https://github.com/google-research/text-to-text-transfer-transformer/blob/main/released_checkpoints.md#t511) by Colin Raffel and Noam Shazeer and Adam Roberts and Katherine Lee and Sharan Narang and Michael Matena and Yanqi Zhou and Wei Li and Peter J. Liu.
1. **[Table Transformer](model_doc/table-transformer)** (from Microsoft Research) released with the paper [PubTables-1M: Towards Comprehensive Table Extraction From Unstructured Documents](https://arxiv.org/abs/2110.00061) by Brandon Smock, Rohith Pesala, Robin Abraham.
1. **[TAPAS](model_doc/tapas)** (from Google AI) released with the paper [TAPAS: Weakly Supervised Table Parsing via Pre-training](https://arxiv.org/abs/2004.02349) by Jonathan Herzig, Paweล Krzysztof Nowak, Thomas Mรผller, Francesco Piccinno and Julian Martin Eisenschlos.
1. **[TAPEX](model_doc/tapex)** (from Microsoft Research) released with the paper [TAPEX: Table Pre-training via Learning a Neural SQL Executor](https://arxiv.org/abs/2107.07653) by Qian Liu, Bei Chen, Jiaqi Guo, Morteza Ziyadi, Zeqi Lin, Weizhu Chen, Jian-Guang Lou.
1. **[Time Series Transformer](model_doc/time_series_transformer)** (from HuggingFace).
1. **[Trajectory Transformer](model_doc/trajectory_transformers)** (from the University of California at Berkeley) released with the paper [Offline Reinforcement Learning as One Big Sequence Modeling Problem](https://arxiv.org/abs/2106.02039) by Michael Janner, Qiyang Li, Sergey Levine
1. **[Transformer-XL](model_doc/transfo-xl)** (from Google/CMU) released with the paper [Transformer-XL: Attentive Language Models Beyond a Fixed-Length Context](https://arxiv.org/abs/1901.02860) by Zihang Dai*, Zhilin Yang*, Yiming Yang, Jaime Carbonell, Quoc V. Le, Ruslan Salakhutdinov.
1. **[TrOCR](model_doc/trocr)** (from Microsoft), released together with the paper [TrOCR: Transformer-based Optical Character Recognition with Pre-trained Models](https://arxiv.org/abs/2109.10282) by Minghao Li, Tengchao Lv, Lei Cui, Yijuan Lu, Dinei Florencio, Cha Zhang, Zhoujun Li, Furu Wei.
1. **[UL2](model_doc/ul2)** (from Google Research) released with the paper [Unifying Language Learning Paradigms](https://arxiv.org/abs/2205.05131v1) by Yi Tay, Mostafa Dehghani, Vinh Q. Tran, Xavier Garcia, Dara Bahri, Tal Schuster, Huaixiu Steven Zheng, Neil Houlsby, Donald Metzler
1. **[UniSpeech](model_doc/unispeech)** (from Microsoft Research) released with the paper [UniSpeech: Unified Speech Representation Learning with Labeled and Unlabeled Data](https://arxiv.org/abs/2101.07597) by Chengyi Wang, Yu Wu, Yao Qian, Kenichi Kumatani, Shujie Liu, Furu Wei, Michael Zeng, Xuedong Huang.
1. **[UniSpeechSat](model_doc/unispeech-sat)** (from Microsoft Research) released with the paper [UNISPEECH-SAT: UNIVERSAL SPEECH REPRESENTATION LEARNING WITH SPEAKER AWARE PRE-TRAINING](https://arxiv.org/abs/2110.05752) by Sanyuan Chen, Yu Wu, Chengyi Wang, Zhengyang Chen, Zhuo Chen, Shujie Liu, Jian Wu, Yao Qian, Furu Wei, Jinyu Li, Xiangzhan Yu.
1. **[VAN](model_doc/van)** (from Tsinghua University and Nankai University) released with the paper [Visual Attention Network](https://arxiv.org/abs/2202.09741) by Meng-Hao Guo, Cheng-Ze Lu, Zheng-Ning Liu, Ming-Ming Cheng, Shi-Min Hu.
1. **[VideoMAE](model_doc/videomae)** (from Multimedia Computing Group, Nanjing University) released with the paper [VideoMAE: Masked Autoencoders are Data-Efficient Learners for Self-Supervised Video Pre-Training](https://arxiv.org/abs/2203.12602) by Zhan Tong, Yibing Song, Jue Wang, Limin Wang.
1. **[ViLT](model_doc/vilt)** (from NAVER AI Lab/Kakao Enterprise/Kakao Brain) released with the paper [ViLT: Vision-and-Language Transformer Without Convolution or Region Supervision](https://arxiv.org/abs/2102.03334) by Wonjae Kim, Bokyung Son, Ildoo Kim.
1. **[Vision Transformer (ViT)](model_doc/vit)** (from Google AI) released with the paper [An Image is Worth 16x16 Words: Transformers for Image Recognition at Scale](https://arxiv.org/abs/2010.11929) by Alexey Dosovitskiy, Lucas Beyer, Alexander Kolesnikov, Dirk Weissenborn, Xiaohua Zhai, Thomas Unterthiner, Mostafa Dehghani, Matthias Minderer, Georg Heigold, Sylvain Gelly, Jakob Uszkoreit, Neil Houlsby.
1. **[VisualBERT](model_doc/visual_bert)** (from UCLA NLP) released with the paper [VisualBERT: A Simple and Performant Baseline for Vision and Language](https://arxiv.org/pdf/1908.03557) by Liunian Harold Li, Mark Yatskar, Da Yin, Cho-Jui Hsieh, Kai-Wei Chang.
1. **[ViTMAE](model_doc/vit_mae)** (from Meta AI) released with the paper [Masked Autoencoders Are Scalable Vision Learners](https://arxiv.org/abs/2111.06377) by Kaiming He, Xinlei Chen, Saining Xie, Yanghao Li, Piotr Dollรกr, Ross Girshick.
1. **[ViTMSN](model_doc/vit_msn)** (from Meta AI) released with the paper [Masked Siamese Networks for Label-Efficient Learning](https://arxiv.org/abs/2204.07141) by Mahmoud Assran, Mathilde Caron, Ishan Misra, Piotr Bojanowski, Florian Bordes, Pascal Vincent, Armand Joulin, Michael Rabbat, Nicolas Ballas.
1. **[Wav2Vec2](model_doc/wav2vec2)** (from Facebook AI) released with the paper [wav2vec 2.0: A Framework for Self-Supervised Learning of Speech Representations](https://arxiv.org/abs/2006.11477) by Alexei Baevski, Henry Zhou, Abdelrahman Mohamed, Michael Auli.
1. **[Wav2Vec2-Conformer](model_doc/wav2vec2-conformer)** (from Facebook AI) released with the paper [FAIRSEQ S2T: Fast Speech-to-Text Modeling with FAIRSEQ](https://arxiv.org/abs/2010.05171) by Changhan Wang, Yun Tang, Xutai Ma, Anne Wu, Sravya Popuri, Dmytro Okhonko, Juan Pino.
1. **[Wav2Vec2Phoneme](model_doc/wav2vec2_phoneme)** (from Facebook AI) released with the paper [Simple and Effective Zero-shot Cross-lingual Phoneme Recognition](https://arxiv.org/abs/2109.11680) by Qiantong Xu, Alexei Baevski, Michael Auli.
1. **[WavLM](model_doc/wavlm)** (from Microsoft Research) released with the paper [WavLM: Large-Scale Self-Supervised Pre-Training for Full Stack Speech Processing](https://arxiv.org/abs/2110.13900) by Sanyuan Chen, Chengyi Wang, Zhengyang Chen, Yu Wu, Shujie Liu, Zhuo Chen, Jinyu Li, Naoyuki Kanda, Takuya Yoshioka, Xiong Xiao, Jian Wu, Long Zhou, Shuo Ren, Yanmin Qian, Yao Qian, Jian Wu, Michael Zeng, Furu Wei.
1. **[Whisper](model_doc/whisper)** (from OpenAI) released with the paper [Robust Speech Recognition via Large-Scale Weak Supervision](https://cdn.openai.com/papers/whisper.pdf) by Alec Radford, Jong Wook Kim, Tao Xu, Greg Brockman, Christine McLeavey, Ilya Sutskever.
1. **[X-CLIP](model_doc/xclip)** (from Microsoft Research) released with the paper [Expanding Language-Image Pretrained Models for General Video Recognition](https://arxiv.org/abs/2208.02816) by Bolin Ni, Houwen Peng, Minghao Chen, Songyang Zhang, Gaofeng Meng, Jianlong Fu, Shiming Xiang, Haibin Ling.
1. **[XGLM](model_doc/xglm)** (From Facebook AI) released with the paper [Few-shot Learning with Multilingual Language Models](https://arxiv.org/abs/2112.10668) by Xi Victoria Lin, Todor Mihaylov, Mikel Artetxe, Tianlu Wang, Shuohui Chen, Daniel Simig, Myle Ott, Naman Goyal, Shruti Bhosale, Jingfei Du, Ramakanth Pasunuru, Sam Shleifer, Punit Singh Koura, Vishrav Chaudhary, Brian O'Horo, Jeff Wang, Luke Zettlemoyer, Zornitsa Kozareva, Mona Diab, Veselin Stoyanov, Xian Li.
1. **[XLM](model_doc/xlm)** (from Facebook) released together with the paper [Cross-lingual Language Model Pretraining](https://arxiv.org/abs/1901.07291) by Guillaume Lample and Alexis Conneau.
1. **[XLM-ProphetNet](model_doc/xlm-prophetnet)** (from Microsoft Research) released with the paper [ProphetNet: Predicting Future N-gram for Sequence-to-Sequence Pre-training](https://arxiv.org/abs/2001.04063) by Yu Yan, Weizhen Qi, Yeyun Gong, Dayiheng Liu, Nan Duan, Jiusheng Chen, Ruofei Zhang and Ming Zhou.
1. **[XLM-RoBERTa](model_doc/xlm-roberta)** (from Facebook AI), released together with the paper [Unsupervised Cross-lingual Representation Learning at Scale](https://arxiv.org/abs/1911.02116) by Alexis Conneau*, Kartikay Khandelwal*, Naman Goyal, Vishrav Chaudhary, Guillaume Wenzek, Francisco Guzmรกn, Edouard Grave, Myle Ott, Luke Zettlemoyer and Veselin Stoyanov.
1. **[XLM-RoBERTa-XL](model_doc/xlm-roberta-xl)** (from Facebook AI), released together with the paper [Larger-Scale Transformers for Multilingual Masked Language Modeling](https://arxiv.org/abs/2105.00572) by Naman Goyal, Jingfei Du, Myle Ott, Giri Anantharaman, Alexis Conneau.
1. **[XLNet](model_doc/xlnet)** (from Google/CMU) released with the paper [โXLNet: Generalized Autoregressive Pretraining for Language Understanding](https://arxiv.org/abs/1906.08237) by Zhilin Yang*, Zihang Dai*, Yiming Yang, Jaime Carbonell, Ruslan Salakhutdinov, Quoc V. Le.
1. **[XLS-R](model_doc/xls_r)** (from Facebook AI) released with the paper [XLS-R: Self-supervised Cross-lingual Speech Representation Learning at Scale](https://arxiv.org/abs/2111.09296) by Arun Babu, Changhan Wang, Andros Tjandra, Kushal Lakhotia, Qiantong Xu, Naman Goyal, Kritika Singh, Patrick von Platen, Yatharth Saraf, Juan Pino, Alexei Baevski, Alexis Conneau, Michael Auli.
1. **[XLSR-Wav2Vec2](model_doc/xlsr_wav2vec2)** (from Facebook AI) released with the paper [Unsupervised Cross-Lingual Representation Learning For Speech Recognition](https://arxiv.org/abs/2006.13979) by Alexis Conneau, Alexei Baevski, Ronan Collobert, Abdelrahman Mohamed, Michael Auli.
1. **[YOLOS](model_doc/yolos)** (from Huazhong University of Science & Technology) released with the paper [You Only Look at One Sequence: Rethinking Transformer in Vision through Object Detection](https://arxiv.org/abs/2106.00666) by Yuxin Fang, Bencheng Liao, Xinggang Wang, Jiemin Fang, Jiyang Qi, Rui Wu, Jianwei Niu, Wenyu Liu.
1. **[YOSO](model_doc/yoso)** (from the University of Wisconsin - Madison) released with the paper [You Only Sample (Almost) Once: Linear Cost Self-Attention Via Bernoulli Sampling](https://arxiv.org/abs/2111.09714) by Zhanpeng Zeng, Yunyang Xiong, Sathya N. Ravi, Shailesh Acharya, Glenn Fung, Vikas Singh.
### ์ง์ ํ๋ ์์ํฌ[[supported-framework]]
์๋ ํ๋ ๋ผ์ด๋ธ๋ฌ๋ฆฌ ์ ๊ฐ ๋ชจ๋ธ์ ์ง์ ํํฉ์ ๋ํ๋
๋๋ค. ํ ํฐํ๋ฅผ ํ์ด์ฌ (๋ณ์นญ "slow") ๋๋ ๐ค Tokenizers (๋ณ์นญ "fast") ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ก ํ๋์ง; (Flax๋ฅผ ํตํ) Jax, PyTorch, TensorFlow ์ค ์ด๋ค ํ๋ ์์ํฌ๋ฅผ ์ง์ํ๋์ง ํ์๋์ด ์์ต๋๋ค.
<!--This table is updated automatically from the auto modules with _make fix-copies_. Do not update manually!-->
| Model | Tokenizer slow | Tokenizer fast | PyTorch support | TensorFlow support | Flax Support |
|:---------------------------:|:--------------:|:--------------:|:---------------:|:------------------:|:------------:|
| ALBERT | โ
| โ
| โ
| โ
| โ
|
| BART | โ
| โ
| โ
| โ
| โ
|
| BEiT | โ | โ | โ
| โ | โ
|
| BERT | โ
| โ
| โ
| โ
| โ
|
| Bert Generation | โ
| โ | โ
| โ | โ |
| BigBird | โ
| โ
| โ
| โ | โ
|
| BigBird-Pegasus | โ | โ | โ
| โ | โ |
| Blenderbot | โ
| โ
| โ
| โ
| โ
|
| BlenderbotSmall | โ
| โ
| โ
| โ
| โ
|
| BLOOM | โ | โ
| โ
| โ | โ |
| CamemBERT | โ
| โ
| โ
| โ
| โ |
| CANINE | โ
| โ | โ
| โ | โ |
| CLIP | โ
| โ
| โ
| โ
| โ
|
| CLIPSeg | โ | โ | โ
| โ | โ |
| CodeGen | โ
| โ
| โ
| โ | โ |
| Conditional DETR | โ | โ | โ
| โ | โ |
| ConvBERT | โ
| โ
| โ
| โ
| โ |
| ConvNeXT | โ | โ | โ
| โ
| โ |
| CTRL | โ
| โ | โ
| โ
| โ |
| CvT | โ | โ | โ
| โ
| โ |
| Data2VecAudio | โ | โ | โ
| โ | โ |
| Data2VecText | โ | โ | โ
| โ | โ |
| Data2VecVision | โ | โ | โ
| โ
| โ |
| DeBERTa | โ
| โ
| โ
| โ
| โ |
| DeBERTa-v2 | โ
| โ
| โ
| โ
| โ |
| Decision Transformer | โ | โ | โ
| โ | โ |
| Deformable DETR | โ | โ | โ
| โ | โ |
| DeiT | โ | โ | โ
| โ
| โ |
| DETR | โ | โ | โ
| โ | โ |
| DistilBERT | โ
| โ
| โ
| โ
| โ
|
| DonutSwin | โ | โ | โ
| โ | โ |
| DPR | โ
| โ
| โ
| โ
| โ |
| DPT | โ | โ | โ
| โ | โ |
| ELECTRA | โ
| โ
| โ
| โ
| โ
|
| Encoder decoder | โ | โ | โ
| โ
| โ
|
| ERNIE | โ | โ | โ
| โ | โ |
| ESM | โ
| โ | โ
| โ
| โ |
| FairSeq Machine-Translation | โ
| โ | โ
| โ | โ |
| FlauBERT | โ
| โ | โ
| โ
| โ |
| FLAVA | โ | โ | โ
| โ | โ |
| FNet | โ
| โ
| โ
| โ | โ |
| Funnel Transformer | โ
| โ
| โ
| โ
| โ |
| GLPN | โ | โ | โ
| โ | โ |
| GPT Neo | โ | โ | โ
| โ | โ
|
| GPT NeoX | โ | โ
| โ
| โ | โ |
| GPT NeoX Japanese | โ
| โ | โ
| โ | โ |
| GPT-J | โ | โ | โ
| โ
| โ
|
| GroupViT | โ | โ | โ
| โ
| โ |
| Hubert | โ | โ | โ
| โ
| โ |
| I-BERT | โ | โ | โ
| โ | โ |
| ImageGPT | โ | โ | โ
| โ | โ |
| Jukebox | โ
| โ | โ
| โ | โ |
| LayoutLM | โ
| โ
| โ
| โ
| โ |
| LayoutLMv2 | โ
| โ
| โ
| โ | โ |
| LayoutLMv3 | โ
| โ
| โ
| โ
| โ |
| LED | โ
| โ
| โ
| โ
| โ |
| LeViT | โ | โ | โ
| โ | โ |
| LiLT | โ | โ | โ
| โ | โ |
| Longformer | โ
| โ
| โ
| โ
| โ |
| LongT5 | โ | โ | โ
| โ | โ
|
| LUKE | โ
| โ | โ
| โ | โ |
| LXMERT | โ
| โ
| โ
| โ
| โ |
| M-CTC-T | โ | โ | โ
| โ | โ |
| M2M100 | โ
| โ | โ
| โ | โ |
| Marian | โ
| โ | โ
| โ
| โ
|
| MarkupLM | โ
| โ
| โ
| โ | โ |
| MaskFormer | โ | โ | โ
| โ | โ |
| mBART | โ
| โ
| โ
| โ
| โ
|
| Megatron-BERT | โ | โ | โ
| โ | โ |
| MobileBERT | โ
| โ
| โ
| โ
| โ |
| MobileViT | โ | โ | โ
| โ
| โ |
| MPNet | โ
| โ
| โ
| โ
| โ |
| MT5 | โ
| โ
| โ
| โ
| โ
|
| MVP | โ
| โ
| โ
| โ | โ |
| Nezha | โ | โ | โ
| โ | โ |
| Nystrรถmformer | โ | โ | โ
| โ | โ |
| OpenAI GPT | โ
| โ
| โ
| โ
| โ |
| OpenAI GPT-2 | โ
| โ
| โ
| โ
| โ
|
| OPT | โ | โ | โ
| โ
| โ
|
| OWL-ViT | โ | โ | โ
| โ | โ |
| Pegasus | โ
| โ
| โ
| โ
| โ
|
| PEGASUS-X | โ | โ | โ
| โ | โ |
| Perceiver | โ
| โ | โ
| โ | โ |
| PLBart | โ
| โ | โ
| โ | โ |
| PoolFormer | โ | โ | โ
| โ | โ |
| ProphetNet | โ
| โ | โ
| โ | โ |
| QDQBert | โ | โ | โ
| โ | โ |
| RAG | โ
| โ | โ
| โ
| โ |
| REALM | โ
| โ
| โ
| โ | โ |
| Reformer | โ
| โ
| โ
| โ | โ |
| RegNet | โ | โ | โ
| โ
| โ
|
| RemBERT | โ
| โ
| โ
| โ
| โ |
| ResNet | โ | โ | โ
| โ
| โ
|
| RetriBERT | โ
| โ
| โ
| โ | โ |
| RoBERTa | โ
| โ
| โ
| โ
| โ
|
| RoCBert | โ
| โ | โ
| โ | โ |
| RoFormer | โ
| โ
| โ
| โ
| โ
|
| SegFormer | โ | โ | โ
| โ
| โ |
| SEW | โ | โ | โ
| โ | โ |
| SEW-D | โ | โ | โ
| โ | โ |
| Speech Encoder decoder | โ | โ | โ
| โ | โ
|
| Speech2Text | โ
| โ | โ
| โ
| โ |
| Speech2Text2 | โ
| โ | โ | โ | โ |
| Splinter | โ
| โ
| โ
| โ | โ |
| SqueezeBERT | โ
| โ
| โ
| โ | โ |
| Swin Transformer | โ | โ | โ
| โ
| โ |
| Swin Transformer V2 | โ | โ | โ
| โ | โ |
| T5 | โ
| โ
| โ
| โ
| โ
|
| Table Transformer | โ | โ | โ
| โ | โ |
| TAPAS | โ
| โ | โ
| โ
| โ |
| Time Series Transformer | โ | โ | โ
| โ | โ |
| Trajectory Transformer | โ | โ | โ
| โ | โ |
| Transformer-XL | โ
| โ | โ
| โ
| โ |
| TrOCR | โ | โ | โ
| โ | โ |
| UniSpeech | โ | โ | โ
| โ | โ |
| UniSpeechSat | โ | โ | โ
| โ | โ |
| VAN | โ | โ | โ
| โ | โ |
| VideoMAE | โ | โ | โ
| โ | โ |
| ViLT | โ | โ | โ
| โ | โ |
| Vision Encoder decoder | โ | โ | โ
| โ
| โ
|
| VisionTextDualEncoder | โ | โ | โ
| โ | โ
|
| VisualBERT | โ | โ | โ
| โ | โ |
| ViT | โ | โ | โ
| โ
| โ
|
| ViTMAE | โ | โ | โ
| โ
| โ |
| ViTMSN | โ | โ | โ
| โ | โ |
| Wav2Vec2 | โ
| โ | โ
| โ
| โ
|
| Wav2Vec2-Conformer | โ | โ | โ
| โ | โ |
| WavLM | โ | โ | โ
| โ | โ |
| Whisper | โ
| โ | โ
| โ
| โ |
| X-CLIP | โ | โ | โ
| โ | โ |
| XGLM | โ
| โ
| โ
| โ
| โ
|
| XLM | โ
| โ | โ
| โ
| โ |
| XLM-ProphetNet | โ
| โ | โ
| โ | โ |
| XLM-RoBERTa | โ
| โ
| โ
| โ
| โ
|
| XLM-RoBERTa-XL | โ | โ | โ
| โ | โ |
| XLNet | โ
| โ
| โ
| โ
| โ |
| YOLOS | โ | โ | โ
| โ | โ |
| YOSO | โ | โ | โ
| โ | โ |
<!-- End table-->
| 0 |
mavonic_private_repos/transformers/docs/source | mavonic_private_repos/transformers/docs/source/ko/big_models.md | <!--Copyright 2022 The HuggingFace Team. All rights reserved.
Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
the License. You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
specific language governing permissions and limitations under the License.
โ ๏ธ Note that this file is in Markdown but contain specific syntax for our doc-builder (similar to MDX) that may not be
rendered properly in your Markdown viewer.
-->
# ํฐ ๋ชจ๋ธ ์ธ์คํด์คํ [[instantiating-a-big-model]]
๋งค์ฐ ํฐ ์ฌ์ ํ๋ จ๋ ๋ชจ๋ธ์ ์ฌ์ฉํ๋ ค๋ฉด, RAM ์ฌ์ฉ์ ์ต์ํํด์ผ ํ๋ ๊ณผ์ ๊ฐ ์์ต๋๋ค. ์ผ๋ฐ์ ์ธ PyTorch ์ํฌํ๋ก์ฐ๋ ๋ค์๊ณผ ๊ฐ์ต๋๋ค:
1. ๋ฌด์์ ๊ฐ์ค์น๋ก ๋ชจ๋ธ์ ์์ฑํฉ๋๋ค.
2. ์ฌ์ ํ๋ จ๋ ๊ฐ์ค์น๋ฅผ ๋ถ๋ฌ์ต๋๋ค.
3. ์ฌ์ ํ๋ จ๋ ๊ฐ์ค์น๋ฅผ ๋ฌด์์ ๋ชจ๋ธ์ ์ ์ฉํฉ๋๋ค.
1๋จ๊ณ์ 2๋จ๊ณ ๋ชจ๋ ๋ชจ๋ธ์ ์ ์ฒด ๋ฒ์ ์ ๋ฉ๋ชจ๋ฆฌ์ ์ ์ฌํด์ผ ํ๋ฉฐ, ๋๋ถ๋ถ ๋ฌธ์ ๊ฐ ์์ง๋ง ๋ชจ๋ธ์ด ๊ธฐ๊ฐ๋ฐ์ดํธ๊ธ์ ์ฉ๋์ ์ฐจ์งํ๊ธฐ ์์ํ๋ฉด ๋ณต์ฌ๋ณธ 2๊ฐ๊ฐ RAM์ ์ด๊ณผํ์ฌ ๋ฉ๋ชจ๋ฆฌ ๋ถ์กฑ ์ด์๋ฅผ ์ผ๊ธฐํ ์ ์์ต๋๋ค. ๋ ์ฌ๊ฐํ ๋ฌธ์ ๋ ๋ถ์ฐ ํ์ต์ ์ํด `torch.distributed`๋ฅผ ์ฌ์ฉํ๋ ๊ฒฝ์ฐ, ํ๋ก์ธ์ค๋ง๋ค ์ฌ์ ํ๋ จ๋ ๋ชจ๋ธ์ ๋ก๋ํ๊ณ ๋ณต์ฌ๋ณธ์ 2๊ฐ์ฉ RAM์ ์ ์ฅํ๋ค๋ ๊ฒ์
๋๋ค.
<Tip>
๋ฌด์์๋ก ์์ฑ๋ ๋ชจ๋ธ์ "๋น์ด ์๋" (์ฆ ๊ทธ๋ ๋ฉ๋ชจ๋ฆฌ์ ์๋ ๊ฒ์ผ๋ก ์ด๋ค์ง) ํ
์๋ก ์ด๊ธฐํ๋๋ฉฐ ๋ฉ๋ชจ๋ฆฌ ๊ณต๊ฐ์ ์ฐจ์งํฉ๋๋ค. ์ด๊ธฐํ๋ ๋ชจ๋ธ/ํ๋ผ๋ฏธํฐ์ ์ข
๋ฅ์ ์ ํฉํ ๋ถํฌ(์: ์ ๊ท ๋ถํฌ)์ ๋ฐ๋ฅธ ๋ฌด์์ ์ด๊ธฐํ๋ ๊ฐ๋ฅํ ํ ๋น ๋ฅด๊ฒ ํ๊ธฐ ์ํด ์ด๊ธฐํ๋์ง ์์ ๊ฐ์ค์น์ ๋ํด 3๋จ๊ณ ์ดํ์๋ง ์ํ๋ฉ๋๋ค!
</Tip>
์ด ์๋ด์์์๋ Transformers๊ฐ ์ด ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ๊ธฐ ์ํด ์ ๊ณตํ๋ ์๋ฃจ์
์ ์ดํด๋ด
๋๋ค. ์ฃผ์ํ ์ ์ ์์ง ํ๋ฐํ ๊ฐ๋ฐ ์ค์ธ ๋ถ์ผ์ด๋ฏ๋ก ์ฌ๊ธฐ์ ์ค๋ช
ํ๋ API๊ฐ ์์ผ๋ก ์ฝ๊ฐ ๋ณ๊ฒฝ๋ ์ ์๋ค๋ ๊ฒ์
๋๋ค.
## ์ค๋ฉ๋ ์ฒดํฌํฌ์ธํธ [[sharded-checkpoints]]
4.18.0 ๋ฒ์ ์ดํ, 10GB ์ด์์ ๊ณต๊ฐ์ ์ฐจ์งํ๋ ๋ชจ๋ธ ์ฒดํฌํฌ์ธํธ๋ ์๋์ผ๋ก ์์ ์กฐ๊ฐ๋ค๋ก ์ค๋ฉ๋ฉ๋๋ค. `model.save_pretrained(save_dir)`๋ฅผ ์คํํ ๋ ํ๋์ ๋จ์ผ ์ฒดํฌํฌ์ธํธ๋ฅผ ๊ฐ์ง๊ฒ ๋ ๋์ , ์ฌ๋ฌ ๋ถ๋ถ ์ฒดํฌํฌ์ธํธ(๊ฐ๊ฐ์ ํฌ๊ธฐ๋ 10GB ๋ฏธ๋ง)์ ๋งค๊ฐ๋ณ์ ์ด๋ฆ์ ํด๋น ํ์ผ์ ๋งคํํ๋ ์ธ๋ฑ์ค๊ฐ ์์ฑ๋ฉ๋๋ค.
`max_shard_size` ๋งค๊ฐ๋ณ์๋ก ์ค๋ฉ ์ ์ต๋ ํฌ๊ธฐ๋ฅผ ์ ์ดํ ์ ์์ผ๋ฏ๋ก, ์ด ์์ ๋ฅผ ์ํด ์ค๋ ํฌ๊ธฐ๊ฐ ์์ ์ผ๋ฐ ํฌ๊ธฐ์ ๋ชจ๋ธ์ ์ฌ์ฉํ๊ฒ ์ต๋๋ค: ์ ํต์ ์ธ BERT ๋ชจ๋ธ์ ์ฌ์ฉํด ๋ด
์๋ค.
```py
from transformers import AutoModel
model = AutoModel.from_pretrained("google-bert/bert-base-cased")
```
[`~PreTrainedModel.save_pretrained`]์ ์ฌ์ฉํ์ฌ ๋ชจ๋ธ์ ์ ์ฅํ๋ฉด, ๋ชจ๋ธ์ ๊ตฌ์ฑ๊ณผ ๊ฐ์ค์น๊ฐ ๋ค์ด์๋ ๋ ๊ฐ์ ํ์ผ์ด ์๋ ์ ํด๋๊ฐ ์์ฑ๋ฉ๋๋ค:
```py
>>> import os
>>> import tempfile
>>> with tempfile.TemporaryDirectory() as tmp_dir:
... model.save_pretrained(tmp_dir)
... print(sorted(os.listdir(tmp_dir)))
['config.json', 'pytorch_model.bin']
```
์ด์ ์ต๋ ์ค๋ ํฌ๊ธฐ๋ฅผ 200MB๋ก ์ฌ์ฉํด ๋ด
์๋ค:
```py
>>> with tempfile.TemporaryDirectory() as tmp_dir:
... model.save_pretrained(tmp_dir, max_shard_size="200MB")
... print(sorted(os.listdir(tmp_dir)))
['config.json', 'pytorch_model-00001-of-00003.bin', 'pytorch_model-00002-of-00003.bin', 'pytorch_model-00003-of-00003.bin', 'pytorch_model.bin.index.json']
```
๋ชจ๋ธ์ ๊ตฌ์ฑ์ ๋ํด, ์ธ ๊ฐ์ ๋ค๋ฅธ ๊ฐ์ค์น ํ์ผ๊ณผ ํ๋ผ๋ฏธํฐ ์ด๋ฆ๊ณผ ํด๋น ํ์ผ์ ๋งคํ์ด ํฌํจ๋ `index.json` ํ์ผ์ ๋ณผ ์ ์์ต๋๋ค. ์ด๋ฌํ ์ฒดํฌํฌ์ธํธ๋ [`~PreTrainedModel.from_pretrained`] ๋ฉ์๋๋ฅผ ์ฌ์ฉํ์ฌ ์์ ํ ๋ค์ ๋ก๋ํ ์ ์์ต๋๋ค:
```py
>>> with tempfile.TemporaryDirectory() as tmp_dir:
... model.save_pretrained(tmp_dir, max_shard_size="200MB")
... new_model = AutoModel.from_pretrained(tmp_dir)
```
ํฐ ๋ชจ๋ธ์ ๊ฒฝ์ฐ ์ด๋ฌํ ๋ฐฉ์์ผ๋ก ์ฒ๋ฆฌํ๋ ์ฃผ๋ ์ฅ์ ์ ์์์ ๋ณด์ฌ์ค ํ๋ฆ์ 2๋จ๊ณ์์, ๊ฐ ์ค๋๊ฐ ์ด์ ์ค๋ ๋ค์์ ๋ก๋๋๋ฏ๋ก ๋ฉ๋ชจ๋ฆฌ ์ฌ์ฉ๋์ด ๋ชจ๋ธ ํฌ๊ธฐ์ ๊ฐ์ฅ ํฐ ์ค๋์ ํฌ๊ธฐ๋ฅผ ์ด๊ณผํ์ง ์๋๋ค๋ ์ ์
๋๋ค.
์ด ์ธ๋ฑ์ค ํ์ผ์ ํค๊ฐ ์ฒดํฌํฌ์ธํธ์ ์๋์ง, ๊ทธ๋ฆฌ๊ณ ํด๋น ๊ฐ์ค์น๊ฐ ์ด๋์ ์ ์ฅ๋์ด ์๋์ง๋ฅผ ๊ฒฐ์ ํ๋ ๋ฐ ์ฌ์ฉ๋ฉ๋๋ค. ์ด ์ธ๋ฑ์ค๋ฅผ json๊ณผ ๊ฐ์ด ๋ก๋ํ๊ณ ๋์
๋๋ฆฌ๋ฅผ ์ป์ ์ ์์ต๋๋ค:
```py
>>> import json
>>> with tempfile.TemporaryDirectory() as tmp_dir:
... model.save_pretrained(tmp_dir, max_shard_size="200MB")
... with open(os.path.join(tmp_dir, "pytorch_model.bin.index.json"), "r") as f:
... index = json.load(f)
>>> print(index.keys())
dict_keys(['metadata', 'weight_map'])
```
๋ฉํ๋ฐ์ดํฐ๋ ํ์ฌ ๋ชจ๋ธ์ ์ด ํฌ๊ธฐ๋ง ํฌํจ๋ฉ๋๋ค. ์์ผ๋ก ๋ค๋ฅธ ์ ๋ณด๋ฅผ ์ถ๊ฐํ ๊ณํ์
๋๋ค:
```py
>>> index["metadata"]
{'total_size': 433245184}
```
๊ฐ์ค์น ๋งต์ ์ด ์ธ๋ฑ์ค์ ์ฃผ์ ๋ถ๋ถ์ผ๋ก, ๊ฐ ๋งค๊ฐ๋ณ์ ์ด๋ฆ(PyTorch ๋ชจ๋ธ `state_dict`์์ ๋ณดํต ์ฐพ์ ์ ์๋)์ ํด๋น ํ์ผ์ ๋งคํํฉ๋๋ค:
```py
>>> index["weight_map"]
{'embeddings.LayerNorm.bias': 'pytorch_model-00001-of-00003.bin',
'embeddings.LayerNorm.weight': 'pytorch_model-00001-of-00003.bin',
...
```
๋ง์ฝ [`~PreTrainedModel.from_pretrained`]๋ฅผ ์ฌ์ฉํ์ง ์๊ณ ๋ชจ๋ธ ๋ด์์ ์ด๋ฌํ ์ค๋ฉ๋ ์ฒดํฌํฌ์ธํธ๋ฅผ ์ง์ ๊ฐ์ ธ์ค๋ ค๋ฉด (์ ์ฒด ์ฒดํฌํฌ์ธํธ๋ฅผ ์ํด `model.load_state_dict()`๋ฅผ ์ํํ๋ ๊ฒ์ฒ๋ผ), [`~modeling_utils.load_sharded_checkpoint`]๋ฅผ ์ฌ์ฉํด์ผ ํฉ๋๋ค.
```py
>>> from transformers.modeling_utils import load_sharded_checkpoint
>>> with tempfile.TemporaryDirectory() as tmp_dir:
... model.save_pretrained(tmp_dir, max_shard_size="200MB")
... load_sharded_checkpoint(model, tmp_dir)
```
## ์ (ไฝ)๋ฉ๋ชจ๋ฆฌ ๋ก๋ฉ [[low-memory-loading]]
์ค๋ฉ๋ ์ฒดํฌํฌ์ธํธ๋ ์์์ ์ธ๊ธํ ์์
ํ๋ฆ์ 2๋จ๊ณ์์ ๋ฉ๋ชจ๋ฆฌ ์ฌ์ฉ๋์ ์ค์ด์ง๋ง, ์ (ไฝ)๋ฉ๋ชจ๋ฆฌ ์ค์ ์์ ๋ชจ๋ธ์ ์ฌ์ฉํ๊ธฐ ์ํด ์ฐ๋ฆฌ์ Accelerate ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ฅผ ๊ธฐ๋ฐ์ผ๋ก ํ ๋๊ตฌ๋ฅผ ํ์ฉํ๋ ๊ฒ์ด ์ข์ต๋๋ค.
์์ธํ ์ฌํญ์ ๋ค์ ๊ฐ์ด๋๋ฅผ ์ฐธ์กฐํด์ฃผ์ธ์: [Accelerate๋ก ๋๊ท๋ชจ ๋ชจ๋ธ ๊ฐ์ ธ์ค๊ธฐ (์๋ฌธ)](../en/main_classes/model#large-model-loading) | 0 |
mavonic_private_repos/transformers/docs/source | mavonic_private_repos/transformers/docs/source/ko/in_translation.md | <!--โ ๏ธ Note that this file is in Markdown but contain specific syntax for our doc-builder (similar to MDX) that may not be
rendered properly in your Markdown viewer.
-->
# ์ด์ฌํ ๋ฒ์ญ ์ค์
๋๋ค. ์กฐ๊ธ ์ด๋ฐ ๋ง๋์! | 0 |
mavonic_private_repos/transformers/docs/source | mavonic_private_repos/transformers/docs/source/ko/training.md | <!--Copyright 2022 The HuggingFace Team. All rights reserved.
Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
the License. You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
specific language governing permissions and limitations under the License.
โ ๏ธ Note that this file is in Markdown but contain specific syntax for our doc-builder (similar to MDX) that may not be
rendered properly in your Markdown viewer.
-->
# ์ฌ์ ํ์ต๋ ๋ชจ๋ธ ๋ฏธ์ธ ํ๋ํ๊ธฐ[[finetune-a-pretrained-model]]
[[open-in-colab]]
์ฌ์ ํ์ต๋ ๋ชจ๋ธ์ ์ฌ์ฉํ๋ฉด ์๋นํ ์ด์ ์ด ์์ต๋๋ค. ๊ณ์ฐ ๋น์ฉ๊ณผ ํ์๋ฐ์๊ตญ์ ์ค์ด๊ณ , ์ฒ์๋ถํฐ ๋ชจ๋ธ์ ํ์ต์ํฌ ํ์ ์์ด ์ต์ ๋ชจ๋ธ์ ์ฌ์ฉํ ์ ์์ต๋๋ค. ๐ค Transformers๋ ๋ค์ํ ์์
์ ์ํด ์ฌ์ ํ์ต๋ ์์ฒ ๊ฐ์ ๋ชจ๋ธ์ ์ก์ธ์คํ ์ ์์ต๋๋ค. ์ฌ์ ํ์ต๋ ๋ชจ๋ธ์ ์ฌ์ฉํ๋ ๊ฒฝ์ฐ, ์์ ์ ์์
๊ณผ ๊ด๋ จ๋ ๋ฐ์ดํฐ์
์ ์ฌ์ฉํด ํ์ตํฉ๋๋ค. ์ด๊ฒ์ ๋ฏธ์ธ ํ๋์ด๋ผ๊ณ ํ๋ ๋งค์ฐ ๊ฐ๋ ฅํ ํ๋ จ ๊ธฐ๋ฒ์
๋๋ค. ์ด ํํ ๋ฆฌ์ผ์์๋ ๋น์ ์ด ์ ํํ ๋ฅ๋ฌ๋ ํ๋ ์์ํฌ๋ก ์ฌ์ ํ์ต๋ ๋ชจ๋ธ์ ๋ฏธ์ธ ํ๋ํฉ๋๋ค:
* ๐ค Transformers๋ก ์ฌ์ ํ์ต๋ ๋ชจ๋ธ ๋ฏธ์ธ ํ๋ํ๊ธฐ [`Trainer`].
* Keras๋ฅผ ์ฌ์ฉํ์ฌ TensorFlow์์ ์ฌ์ ํ์ต๋ ๋ชจ๋ธ์ ๋ฏธ์ธ ํ๋ํ๊ธฐ.
* ๊ธฐ๋ณธ PyTorch์์ ์ฌ์ ํ์ต๋ ๋ชจ๋ธ์ ๋ฏธ์ธ ํ๋ํ๊ธฐ.
<a id='data-processing'></a>
## ๋ฐ์ดํฐ์
์ค๋น[[prepare-a-dataset]]
<Youtube id="_BZearw7f0w"/>
์ฌ์ ํ์ต๋ ๋ชจ๋ธ์ ๋ฏธ์ธ ํ๋ํ๊ธฐ ์ํด์ ๋ฐ์ดํฐ์
์ ๋ค์ด๋ก๋ํ๊ณ ํ๋ จํ ์ ์๋๋ก ์ค๋นํ์ธ์. ์ด์ ํํ ๋ฆฌ์ผ์์ ํ๋ จ์ ์ํด ๋ฐ์ดํฐ๋ฅผ ์ฒ๋ฆฌํ๋ ๋ฐฉ๋ฒ์ ๋ณด์ฌ๋๋ ธ๋๋ฐ, ์ง๊ธ์ด ๋ฐฐ์ธ ๊ฑธ ๋์ง์ ๊ธฐํ์
๋๋ค!
๋จผ์ [Yelp ๋ฆฌ๋ทฐ](https://huggingface.co/datasets/yelp_review_full) ๋ฐ์ดํฐ ์ธํธ๋ฅผ ๋ก๋ํฉ๋๋ค:
```py
>>> from datasets import load_dataset
>>> dataset = load_dataset("yelp_review_full")
>>> dataset["train"][100]
{'label': 0,
'text': 'My expectations for McDonalds are t rarely high. But for one to still fail so spectacularly...that takes something special!\\nThe cashier took my friends\'s order, then promptly ignored me. I had to force myself in front of a cashier who opened his register to wait on the person BEHIND me. I waited over five minutes for a gigantic order that included precisely one kid\'s meal. After watching two people who ordered after me be handed their food, I asked where mine was. The manager started yelling at the cashiers for \\"serving off their orders\\" when they didn\'t have their food. But neither cashier was anywhere near those controls, and the manager was the one serving food to customers and clearing the boards.\\nThe manager was rude when giving me my order. She didn\'t make sure that I had everything ON MY RECEIPT, and never even had the decency to apologize that I felt I was getting poor service.\\nI\'ve eaten at various McDonalds restaurants for over 30 years. I\'ve worked at more than one location. I expect bad days, bad moods, and the occasional mistake. But I have yet to have a decent experience at this store. It will remain a place I avoid unless someone in my party needs to avoid illness from low blood sugar. Perhaps I should go back to the racially biased service of Steak n Shake instead!'}
```
ํ
์คํธ๋ฅผ ์ฒ๋ฆฌํ๊ณ ์๋ก ๋ค๋ฅธ ๊ธธ์ด์ ์ํ์ค ํจ๋ฉ ๋ฐ ์๋ผ๋ด๊ธฐ ์ ๋ต์ ํฌํจํ๋ ค๋ฉด ํ ํฌ๋์ด์ ๊ฐ ํ์ํฉ๋๋ค. ๋ฐ์ดํฐ์
์ ํ ๋ฒ์ ์ฒ๋ฆฌํ๋ ค๋ฉด ๐ค Dataset [`map`](https://huggingface.co/docs/datasets/process#map) ๋ฉ์๋๋ฅผ ์ฌ์ฉํ์ฌ ์ ์ฒด ๋ฐ์ดํฐ์
์ ์ ์ฒ๋ฆฌ ํจ์๋ฅผ ์ ์ฉํ์ธ์:
```py
>>> from transformers import AutoTokenizer
>>> tokenizer = AutoTokenizer.from_pretrained("google-bert/bert-base-cased")
>>> def tokenize_function(examples):
... return tokenizer(examples["text"], padding="max_length", truncation=True)
>>> tokenized_datasets = dataset.map(tokenize_function, batched=True)
```
ํ์ํ ๊ฒฝ์ฐ ๋ฏธ์ธ ํ๋์ ์ํด ๋ฐ์ดํฐ์
์ ์์ ๋ถ๋ถ ์งํฉ์ ๋ง๋ค์ด ๋ฏธ์ธ ํ๋ ์์
์๊ฐ์ ์ค์ผ ์ ์์ต๋๋ค:
```py
>>> small_train_dataset = tokenized_datasets["train"].shuffle(seed=42).select(range(1000))
>>> small_eval_dataset = tokenized_datasets["test"].shuffle(seed=42).select(range(1000))
```
<a id='trainer'></a>
## Train
์ฌ๊ธฐ์๋ถํฐ๋ ์ฌ์ฉํ๋ ค๋ ํ๋ ์์ํฌ์ ํด๋นํ๋ ์น์
์ ๋ฐ๋ผ์ผ ํฉ๋๋ค. ์ค๋ฅธ์ชฝ ์ฌ์ด๋๋ฐ์ ๋งํฌ๋ฅผ ์ฌ์ฉํ์ฌ ์ํ๋ ํ๋ ์์ํฌ๋ก ์ด๋ํ ์ ์์ผ๋ฉฐ, ํน์ ํ๋ ์์ํฌ์ ๋ชจ๋ ์ฝํ
์ธ ๋ฅผ ์จ๊ธฐ๋ ค๋ฉด ํด๋น ํ๋ ์์ํฌ ๋ธ๋ก์ ์ค๋ฅธ์ชฝ ์๋จ์ ์๋ ๋ฒํผ์ ์ฌ์ฉํ๋ฉด ๋ฉ๋๋ค!
<frameworkcontent>
<pt>
<Youtube id="nvBXf7s7vTI"/>
## ํ์ดํ ์น Trainer๋ก ํ๋ จํ๊ธฐ[[train-with-pytorch-trainer]]
๐ค Transformers๋ ๐ค Transformers ๋ชจ๋ธ ํ๋ จ์ ์ต์ ํ๋ [`Trainer`] ํด๋์ค๋ฅผ ์ ๊ณตํ์ฌ ํ๋ จ ๋ฃจํ๋ฅผ ์ง์ ์์ฑํ์ง ์๊ณ ๋ ์ฝ๊ฒ ํ๋ จ์ ์์ํ ์ ์์ต๋๋ค. [`Trainer`] API๋ ๋ก๊น
(logging), ๊ฒฝ์ฌ ๋์ (gradient accumulation), ํผํฉ ์ ๋ฐ๋(mixed precision) ๋ฑ ๋ค์ํ ํ๋ จ ์ต์
๊ณผ ๊ธฐ๋ฅ์ ์ง์ํฉ๋๋ค.
๋จผ์ ๋ชจ๋ธ์ ๊ฐ์ ธ์ค๊ณ ์์๋๋ ๋ ์ด๋ธ ์๋ฅผ ์ง์ ํฉ๋๋ค. Yelp ๋ฆฌ๋ทฐ [๋ฐ์ดํฐ์
์นด๋](https://huggingface.co/datasets/yelp_review_full#data-fields)์์ 5๊ฐ์ ๋ ์ด๋ธ์ด ์์์ ์ ์ ์์ต๋๋ค:
```py
>>> from transformers import AutoModelForSequenceClassification
>>> model = AutoModelForSequenceClassification.from_pretrained("google-bert/bert-base-cased", num_labels=5)
```
<Tip>
์ฌ์ ํ๋ จ๋ ๊ฐ์ค์น ์ค ์ผ๋ถ๊ฐ ์ฌ์ฉ๋์ง ์๊ณ ์ผ๋ถ ๊ฐ์ค์น๊ฐ ๋ฌด์์๋ก ํ์๋๋ค๋ ๊ฒฝ๊ณ ๊ฐ ํ์๋ฉ๋๋ค.
๊ฑฑ์ ๋ง์ธ์. ์ด๊ฒ์ ์ฌ๋ฐ๋ฅธ ๋์์
๋๋ค! ์ฌ์ ํ์ต๋ BERT ๋ชจ๋ธ์ ํค๋๋ ํ๊ธฐ๋๊ณ ๋ฌด์์๋ก ์ด๊ธฐํ๋ ๋ถ๋ฅ ํค๋๋ก ๋์ฒด๋ฉ๋๋ค. ์ด์ ์ฌ์ ํ์ต๋ ๋ชจ๋ธ์ ์ง์์ผ๋ก ์ํ์ค ๋ถ๋ฅ ์์
์ ์ํ ์๋ก์ด ๋ชจ๋ธ ํค๋๋ฅผ ๋ฏธ์ธ ํ๋ ํฉ๋๋ค.
</Tip>
### ํ์ดํผํ๋ผ๋ฏธํฐ ํ๋ จ[[training-hyperparameters]]
๋ค์์ผ๋ก ์ ํ ์ ์๋ ๋ชจ๋ ํ์ดํผํ๋ผ๋ฏธํฐ์ ๋ค์ํ ํ๋ จ ์ต์
์ ํ์ฑํํ๊ธฐ ์ํ ํ๋๊ทธ๋ฅผ ํฌํจํ๋ [`TrainingArguments`] ํด๋์ค๋ฅผ ์์ฑํฉ๋๋ค.
์ด ํํ ๋ฆฌ์ผ์์๋ ๊ธฐ๋ณธ ํ๋ จ [ํ์ดํผํ๋ผ๋ฏธํฐ](https://huggingface.co/docs/transformers/main_classes/trainer#transformers.TrainingArguments)๋ก ์์ํ์ง๋ง, ์์ ๋กญ๊ฒ ์คํํ์ฌ ์ฌ๋ฌ๋ถ๋ค์๊ฒ ๋ง๋ ์ต์ ์ ์ค์ ์ ์ฐพ์ ์ ์์ต๋๋ค.
ํ๋ จ์์ ์ฒดํฌํฌ์ธํธ(checkpoints)๋ฅผ ์ ์ฅํ ์์น๋ฅผ ์ง์ ํฉ๋๋ค:
```py
>>> from transformers import TrainingArguments
>>> training_args = TrainingArguments(output_dir="test_trainer")
```
### ํ๊ฐ ํ๊ธฐ[[evaluate]]
[`Trainer`]๋ ํ๋ จ ์ค์ ๋ชจ๋ธ ์ฑ๋ฅ์ ์๋์ผ๋ก ํ๊ฐํ์ง ์์ต๋๋ค. ํ๊ฐ ์งํ๋ฅผ ๊ณ์ฐํ๊ณ ๋ณด๊ณ ํ ํจ์๋ฅผ [`Trainer`]์ ์ ๋ฌํด์ผ ํฉ๋๋ค.
[๐ค Evaluate](https://huggingface.co/docs/evaluate/index) ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ [`evaluate.load`](https://huggingface.co/spaces/evaluate-metric/accuracy) ํจ์๋ก ๋ก๋ํ ์ ์๋ ๊ฐ๋จํ [`accuracy`]ํจ์๋ฅผ ์ ๊ณตํฉ๋๋ค (์์ธํ ๋ด์ฉ์ [๋๋ฌ๋ณด๊ธฐ](https://huggingface.co/docs/evaluate/a_quick_tour)๋ฅผ ์ฐธ์กฐํ์ธ์):
```py
>>> import numpy as np
>>> import evaluate
>>> metric = evaluate.load("accuracy")
```
`metric`์์ [`~evaluate.compute`]๋ฅผ ํธ์ถํ์ฌ ์์ธก์ ์ ํ๋๋ฅผ ๊ณ์ฐํฉ๋๋ค. ์์ธก์ `compute`์ ์ ๋ฌํ๊ธฐ ์ ์ ์์ธก์ ๋ก์ง์ผ๋ก ๋ณํํด์ผ ํฉ๋๋ค(๋ชจ๋ ๐ค Transformers ๋ชจ๋ธ์ ๋ก์ง์ผ๋ก ๋ฐํํ๋ค๋ ์ ์ ๊ธฐ์ตํ์ธ์):
```py
>>> def compute_metrics(eval_pred):
... logits, labels = eval_pred
... predictions = np.argmax(logits, axis=-1)
... return metric.compute(predictions=predictions, references=labels)
```
๋ฏธ์ธ ํ๋ ์ค์ ํ๊ฐ ์งํ๋ฅผ ๋ชจ๋ํฐ๋งํ๋ ค๋ฉด ํ๋ จ ์ธ์์ `eval_strategy` ํ๋ผ๋ฏธํฐ๋ฅผ ์ง์ ํ์ฌ ๊ฐ ์ํญ์ด ๋๋ ๋ ํ๊ฐ ์งํ๋ฅผ ํ์ธํ ์ ์์ต๋๋ค:
```py
>>> from transformers import TrainingArguments, Trainer
>>> training_args = TrainingArguments(output_dir="test_trainer", eval_strategy="epoch")
```
### ํ๋ จ ํ๊ธฐ[[trainer]]
๋ชจ๋ธ, ํ๋ จ ์ธ์, ํ๋ จ ๋ฐ ํ
์คํธ ๋ฐ์ดํฐ์
, ํ๊ฐ ํจ์๊ฐ ํฌํจ๋ [`Trainer`] ๊ฐ์ฒด๋ฅผ ๋ง๋ญ๋๋ค:
```py
>>> trainer = Trainer(
... model=model,
... args=training_args,
... train_dataset=small_train_dataset,
... eval_dataset=small_eval_dataset,
... compute_metrics=compute_metrics,
... )
```
๊ทธ๋ฆฌ๊ณ [`~transformers.Trainer.train`]์ ํธ์ถํ์ฌ ๋ชจ๋ธ์ ๋ฏธ์ธ ํ๋ํฉ๋๋ค:
```py
>>> trainer.train()
```
</pt>
<tf>
<a id='keras'></a>
<Youtube id="rnTGBy2ax1c"/>
## Keras๋ก ํ
์ํ๋ก์ฐ ๋ชจ๋ธ ํ๋ จํ๊ธฐ[[train-a-tensorflow-model-with-keras]]
Keras API๋ฅผ ์ฌ์ฉํ์ฌ ํ
์ํ๋ก์ฐ์์ ๐ค Transformers ๋ชจ๋ธ์ ํ๋ จํ ์๋ ์์ต๋๋ค!
### Keras์ฉ ๋ฐ์ดํฐ ๋ก๋[[loading-data-for-keras]]
Keras API๋ก ๐ค Transformers ๋ชจ๋ธ์ ํ์ต์ํค๋ ค๋ฉด ๋ฐ์ดํฐ์
์ Keras๊ฐ ์ดํดํ ์ ์๋ ํ์์ผ๋ก ๋ณํํด์ผ ํฉ๋๋ค.
๋ฐ์ดํฐ ์ธํธ๊ฐ ์์ ๊ฒฝ์ฐ, ์ ์ฒด๋ฅผ NumPy ๋ฐฐ์ด๋ก ๋ณํํ์ฌ Keras๋ก ์ ๋ฌํ๋ฉด ๋ฉ๋๋ค.
๋ ๋ณต์กํ ์์
์ ์ํํ๊ธฐ ์ ์ ๋จผ์ ์ด ์์
์ ์๋ํด ๋ณด๊ฒ ์ต๋๋ค.
๋จผ์ ๋ฐ์ดํฐ ์ธํธ๋ฅผ ๋ก๋ํฉ๋๋ค. [GLUE ๋ฒค์น๋งํฌ](https://huggingface.co/datasets/glue)์ CoLA ๋ฐ์ดํฐ ์ธํธ๋ฅผ ์ฌ์ฉํ๊ฒ ์ต๋๋ค.
๊ฐ๋จํ ๋ฐ์ด๋๋ฆฌ ํ
์คํธ ๋ถ๋ฅ ์์
์ด๋ฏ๋ก ์ง๊ธ์ ํ๋ จ ๋ฐ์ดํฐ ๋ถํ ๋ง ์ฌ์ฉํฉ๋๋ค.
```py
from datasets import load_dataset
dataset = load_dataset("glue", "cola")
dataset = dataset["train"] # Just take the training split for now
```
๋ค์์ผ๋ก ํ ํฌ๋์ด์ ๋ฅผ ๋ก๋ํ๊ณ ๋ฐ์ดํฐ๋ฅผ NumPy ๋ฐฐ์ด๋ก ํ ํฐํํฉ๋๋ค. ๋ ์ด๋ธ์ ์ด๋ฏธ 0๊ณผ 1๋ก ๋ ๋ฆฌ์คํธ์ด๊ธฐ ๋๋ฌธ์ ํ ํฐํํ์ง ์๊ณ ๋ฐ๋ก NumPy ๋ฐฐ์ด๋ก ๋ณํํ ์ ์์ต๋๋ค!
```py
from transformers import AutoTokenizer
tokenizer = AutoTokenizer.from_pretrained("google-bert/bert-base-cased")
tokenized_data = tokenizer(dataset["sentence"], return_tensors="np", padding=True)
# Tokenizer returns a BatchEncoding, but we convert that to a dict for Keras
tokenized_data = dict(tokenized_data)
labels = np.array(dataset["label"]) # Label is already an array of 0 and 1
```
๋ง์ง๋ง์ผ๋ก ๋ชจ๋ธ์ ๋ก๋, [`compile`](https://keras.io/api/models/model_training_apis/#compile-method), [`fit`](https://keras.io/api/models/model_training_apis/#fit-method)ํฉ๋๋ค:
```py
from transformers import TFAutoModelForSequenceClassification
from tensorflow.keras.optimizers import Adam
# Load and compile our model
model = TFAutoModelForSequenceClassification.from_pretrained("google-bert/bert-base-cased")
# Lower learning rates are often better for fine-tuning transformers
model.compile(optimizer=Adam(3e-5))
model.fit(tokenized_data, labels)
```
<Tip>
๋ชจ๋ธ์ `compile()`ํ ๋ ์์ค ์ธ์๋ฅผ ๋ชจ๋ธ์ ์ ๋ฌํ ํ์๊ฐ ์์ต๋๋ค!
์ด ์ธ์๋ฅผ ๋น์๋๋ฉด ํ๊น
ํ์ด์ค ๋ชจ๋ธ์ ์์
๊ณผ ๋ชจ๋ธ ์ํคํ
์ฒ์ ์ ํฉํ ์์ค์ ์๋์ผ๋ก ์ ํํฉ๋๋ค.
์ํ๋ค๋ฉด ์ธ์ ๋ ์ง ์ง์ ์์ค์ ์ง์ ํ์ฌ ์ด๋ฅผ ์ฌ์ ์ํ ์ ์์ต๋๋ค!
</Tip>
์ด ์ ๊ทผ ๋ฐฉ์์ ์๊ท๋ชจ ๋ฐ์ดํฐ ์งํฉ์์๋ ์ ์๋ํ์ง๋ง, ๋๊ท๋ชจ ๋ฐ์ดํฐ ์งํฉ์์๋ ๋ฌธ์ ๊ฐ ๋ ์ ์์ต๋๋ค. ์ ๊ทธ๋ด๊น์?
ํ ํฐํ๋ ๋ฐฐ์ด๊ณผ ๋ ์ด๋ธ์ ๋ฉ๋ชจ๋ฆฌ์ ์์ ํ ๋ก๋ํ๊ณ NumPy๋ "๋ค์ญ๋ ์ญํ" ๋ฐฐ์ด์ ์ฒ๋ฆฌํ์ง ์๊ธฐ ๋๋ฌธ์,
๋ชจ๋ ํ ํฐํ๋ ์ํ์ ์ ์ฒด ๋ฐ์ดํฐ์
์์ ๊ฐ์ฅ ๊ธด ์ํ์ ๊ธธ์ด๋งํผ ํจ๋ฉํด์ผ ํฉ๋๋ค. ์ด๋ ๊ฒ ํ๋ฉด ๋ฐฐ์ด์ด ํจ์ฌ ๋ ์ปค์ง๊ณ ์ด ํจ๋ฉ ํ ํฐ์ผ๋ก ์ธํด ํ์ต ์๋๋ ๋๋ ค์ง๋๋ค!
### ๋ฐ์ดํฐ๋ฅผ tf.data.Dataset์ผ๋ก ๋ก๋ํ๊ธฐ[[loading-data-as-a-tfdatadataset]]
ํ์ต ์๋๊ฐ ๋๋ ค์ง๋ ๊ฒ์ ํผํ๋ ค๋ฉด ๋ฐ์ดํฐ๋ฅผ `tf.data.Dataset`์ผ๋ก ๋ก๋ํ ์ ์์ต๋๋ค. ์ํ๋ค๋ฉด ์ง์
`tf.data` ํ์ดํ๋ผ์ธ์ ์ง์ ์์ฑํ ์๋ ์์ง๋ง, ์ด ์์
์ ๊ฐํธํ๊ฒ ์ํํ๋ ์ ์๋ ๋ ๊ฐ์ง ๋ฐฉ๋ฒ์ด ์์ต๋๋ค:
- [`~TFPreTrainedModel.prepare_tf_dataset`]: ๋๋ถ๋ถ์ ๊ฒฝ์ฐ ์ด ๋ฐฉ๋ฒ์ ๊ถ์ฅํฉ๋๋ค. ๋ชจ๋ธ์ ๋ฉ์๋์ด๊ธฐ ๋๋ฌธ์ ๋ชจ๋ธ์ ๊ฒ์ฌํ์ฌ ๋ชจ๋ธ ์
๋ ฅ์ผ๋ก ์ฌ์ฉํ ์ ์๋ ์ด์ ์๋์ผ๋ก ํ์
ํ๊ณ
๋๋จธ์ง๋ ๋ฒ๋ ค์ ๋ ๋จ์ํ๊ณ ์ฑ๋ฅ์ด ์ข์ ๋ฐ์ดํฐ ์งํฉ์ ๋ง๋ค ์ ์์ต๋๋ค.
- [`~datasets.Dataset.to_tf_dataset`]: ์ด ๋ฐฉ๋ฒ์ ์ข ๋ ๋ฎ์ ์์ค์ด๋ฉฐ, ํฌํจํ '์ด'๊ณผ '๋ ์ด๋ธ'์ ์ ํํ ์ง์ ํ์ฌ
๋ฐ์ดํฐ์
์ ์์ฑํ๋ ๋ฐฉ๋ฒ์ ์ ํํ ์ ์ดํ๊ณ ์ถ์ ๋ ์ ์ฉํ๋ฉฐ, ํฌํจํ 'columns'๊ณผ 'label_cols'์ ์ ํํ ์ง์ ํ ์ ์์ต๋๋ค.
[`~TFPreTrainedModel.prepare_tf_dataset`]์ ์ฌ์ฉํ๋ ค๋ฉด ๋จผ์ ๋ค์ ์ฝ๋ ์ํ๊ณผ ๊ฐ์ด ํ ํฌ๋์ด์ ์ถ๋ ฅ์ ๋ฐ์ดํฐ ์ธํธ์ ์ด๋ก ์ถ๊ฐํด์ผ ํฉ๋๋ค:
```py
def tokenize_dataset(data):
# Keys of the returned dictionary will be added to the dataset as columns
return tokenizer(data["text"])
dataset = dataset.map(tokenize_dataset)
```
ํ๊น
ํ์ด์ค ๋ฐ์ดํฐ์
์ ๊ธฐ๋ณธ์ ์ผ๋ก ๋์คํฌ์ ์ ์ฅ๋๋ฏ๋ก ๋ฉ๋ชจ๋ฆฌ ์ฌ์ฉ๋์ ๋๋ฆฌ์ง ์๋๋ค๋ ์ ์ ๊ธฐ์ตํ์ธ์!
์ด์ด ์ถ๊ฐ๋๋ฉด ๋ฐ์ดํฐ์
์์ ๋ฐฐ์น๋ฅผ ์คํธ๋ฆฌ๋ฐํ๊ณ ๊ฐ ๋ฐฐ์น์ ํจ๋ฉ์ ์ถ๊ฐํ ์ ์์ผ๋ฏ๋ก ์ ์ฒด ๋ฐ์ดํฐ์
์ ํจ๋ฉ์ ์ถ๊ฐํ๋ ๊ฒ๋ณด๋ค ํจ๋ฉ ํ ํฐ์ ์๋ฅผ ํฌ๊ฒ ์ค์ผ ์ ์์ต๋๋ค.
```py
>>> tf_dataset = model.prepare_tf_dataset(dataset, batch_size=16, shuffle=True, tokenizer=tokenizer)
```
์์ ์ฝ๋ ์ํ์์๋ ๋ฐฐ์น๊ฐ ๋ก๋๋ ๋ ์ฌ๋ฐ๋ฅด๊ฒ ํจ๋ฉํ ์ ์๋๋ก `prepare_tf_dataset`์ ํ ํฌ๋์ด์ ๋ฅผ ์ ๋ฌํด์ผ ํฉ๋๋ค.
๋ฐ์ดํฐ์
์ ๋ชจ๋ ์ํ ๊ธธ์ด๊ฐ ๊ฐ๊ณ ํจ๋ฉ์ด ํ์ํ์ง ์์ ๊ฒฝ์ฐ ์ด ์ธ์๋ฅผ ๊ฑด๋๋ธ ์ ์์ต๋๋ค.
์ํ์ ์ฑ์ฐ๋ ๊ฒ๋ณด๋ค ๋ ๋ณต์กํ ์์
(์: ๋ง์คํน๋ ์ธ์ด์ ํ ํฐ ์์ ๋ชจ๋ธ๋ง)์ ์ํํ๊ธฐ ์ํด ํ ํฐ์ ์์์์ผ์ผ ํ๋ ๊ฒฝ์ฐ,
`collate_fn` ์ธ์๋ฅผ ์ฌ์ฉํ์ฌ ์ํ ๋ชฉ๋ก์ ๋ฐฐ์น๋ก ๋ณํํ๊ณ ์ํ๋ ์ ์ฒ๋ฆฌ๋ฅผ ์ ์ฉํ ํจ์๋ฅผ ์ ๋ฌํ ์ ์์ต๋๋ค.
[์์](https://github.com/huggingface/transformers/tree/main/examples) ๋๋
[๋
ธํธ๋ถ](https://huggingface.co/docs/transformers/notebooks)์ ์ฐธ์กฐํ์ฌ ์ด ์ ๊ทผ ๋ฐฉ์์ด ์ค์ ๋ก ์๋ํ๋ ๋ชจ์ต์ ํ์ธํ์ธ์.
`tf.data.Dataset`์ ์์ฑํ ํ์๋ ์ด์ ๊ณผ ๋ง์ฐฌ๊ฐ์ง๋ก ๋ชจ๋ธ์ ์ปดํ์ผํ๊ณ ํ๋ จ(fit)ํ ์ ์์ต๋๋ค:
```py
model.compile(optimizer=Adam(3e-5))
model.fit(tf_dataset)
```
</tf>
</frameworkcontent>
<a id='pytorch_native'></a>
## ๊ธฐ๋ณธ ํ์ดํ ์น๋ก ํ๋ จํ๊ธฐ[[train-in-native-pytorch]]
<frameworkcontent>
<pt>
<Youtube id="Dh9CL8fyG80"/>
[`Trainer`]๋ ํ๋ จ ๋ฃจํ๋ฅผ ์ฒ๋ฆฌํ๋ฉฐ ํ ์ค์ ์ฝ๋๋ก ๋ชจ๋ธ์ ๋ฏธ์ธ ์กฐ์ ํ ์ ์์ต๋๋ค. ์ง์ ํ๋ จ ๋ฃจํ๋ฅผ ์์ฑํ๋ ๊ฒ์ ์ ํธํ๋ ์ฌ์ฉ์์ ๊ฒฝ์ฐ, ๊ธฐ๋ณธ PyTorch์์ ๐ค Transformers ๋ชจ๋ธ์ ๋ฏธ์ธ ์กฐ์ ํ ์๋ ์์ต๋๋ค.
์ด ์์ ์์ ๋
ธํธ๋ถ์ ๋ค์ ์์ํ๊ฑฐ๋ ๋ค์ ์ฝ๋๋ฅผ ์คํํด ๋ฉ๋ชจ๋ฆฌ๋ฅผ ํ๋ณดํด์ผ ํ ์ ์์ต๋๋ค:
```py
del model
del trainer
torch.cuda.empty_cache()
```
๋ค์์ผ๋ก, 'ํ ํฐํ๋ ๋ฐ์ดํฐ์
'์ ์๋์ผ๋ก ํ์ฒ๋ฆฌํ์ฌ ํ๋ จ๋ จ์ ์ฌ์ฉํ ์ ์๋๋ก ์ค๋นํฉ๋๋ค.
1. ๋ชจ๋ธ์ด ์์ ํ
์คํธ๋ฅผ ์
๋ ฅ์ผ๋ก ํ์ฉํ์ง ์์ผ๋ฏ๋ก `text` ์ด์ ์ ๊ฑฐํฉ๋๋ค:
```py
>>> tokenized_datasets = tokenized_datasets.remove_columns(["text"])
```
2. ๋ชจ๋ธ์์ ์ธ์์ ์ด๋ฆ์ด `labels`๋ก ์ง์ ๋ ๊ฒ์ผ๋ก ์์ํ๋ฏ๋ก `label` ์ด์ ์ด๋ฆ์ `labels`๋ก ๋ณ๊ฒฝํฉ๋๋ค:
```py
>>> tokenized_datasets = tokenized_datasets.rename_column("label", "labels")
```
3. ๋ฐ์ดํฐ์
์ ํ์์ List ๋์ PyTorch ํ
์๋ฅผ ๋ฐํํ๋๋ก ์ค์ ํฉ๋๋ค:
```py
>>> tokenized_datasets.set_format("torch")
```
๊ทธ๋ฆฌ๊ณ ์์ ํ์๋ ๋๋ก ๋ฐ์ดํฐ์
์ ๋ ์์ ํ์ ์งํฉ์ ์์ฑํ์ฌ ๋ฏธ์ธ ์กฐ์ ์๋๋ฅผ ๋์
๋๋ค:
```py
>>> small_train_dataset = tokenized_datasets["train"].shuffle(seed=42).select(range(1000))
>>> small_eval_dataset = tokenized_datasets["test"].shuffle(seed=42).select(range(1000))
```
### DataLoader[[dataloader]]
ํ๋ จ ๋ฐ ํ
์คํธ ๋ฐ์ดํฐ์
์ ๋ํ 'DataLoader'๋ฅผ ์์ฑํ์ฌ ๋ฐ์ดํฐ ๋ฐฐ์น๋ฅผ ๋ฐ๋ณตํ ์ ์์ต๋๋ค:
```py
>>> from torch.utils.data import DataLoader
>>> train_dataloader = DataLoader(small_train_dataset, shuffle=True, batch_size=8)
>>> eval_dataloader = DataLoader(small_eval_dataset, batch_size=8)
```
์์ธก์ ์ํ ๋ ์ด๋ธ ๊ฐ์๋ฅผ ์ฌ์ฉํ์ฌ ๋ชจ๋ธ์ ๋ก๋ํฉ๋๋ค:
```py
>>> from transformers import AutoModelForSequenceClassification
>>> model = AutoModelForSequenceClassification.from_pretrained("google-bert/bert-base-cased", num_labels=5)
```
### ์ตํฐ๋ง์ด์ ๋ฐ ํ์ต ์๋ ์ค์ผ์ค๋ฌ[[optimizer-and-learning-rate-scheduler]]
์ตํฐ๋ง์ด์ ์ ํ์ต ์๋ ์ค์ผ์ค๋ฌ๋ฅผ ์์ฑํ์ฌ ๋ชจ๋ธ์ ๋ฏธ์ธ ์กฐ์ ํฉ๋๋ค. ํ์ดํ ์น์์ ์ ๊ณตํ๋ [`AdamW`](https://pytorch.org/docs/stable/generated/torch.optim.AdamW.html) ์ตํฐ๋ง์ด์ ๋ฅผ ์ฌ์ฉํด ๋ณด๊ฒ ์ต๋๋ค:
```py
>>> from torch.optim import AdamW
>>> optimizer = AdamW(model.parameters(), lr=5e-5)
```
[`Trainer`]์์ ๊ธฐ๋ณธ ํ์ต ์๋ ์ค์ผ์ค๋ฌ๋ฅผ ์์ฑํฉ๋๋ค:
```py
>>> from transformers import get_scheduler
>>> num_epochs = 3
>>> num_training_steps = num_epochs * len(train_dataloader)
>>> lr_scheduler = get_scheduler(
... name="linear", optimizer=optimizer, num_warmup_steps=0, num_training_steps=num_training_steps
... )
```
๋ง์ง๋ง์ผ๋ก, GPU์ ์ก์ธ์คํ ์ ์๋ ๊ฒฝ์ฐ 'device'๋ฅผ ์ง์ ํ์ฌ GPU๋ฅผ ์ฌ์ฉํ๋๋ก ํฉ๋๋ค. ๊ทธ๋ ์ง ์์ผ๋ฉด CPU์์ ํ๋ จํ๋ฉฐ ๋ช ๋ถ์ด ์๋ ๋ช ์๊ฐ์ด ๊ฑธ๋ฆด ์ ์์ต๋๋ค.
```py
>>> import torch
>>> device = torch.device("cuda") if torch.cuda.is_available() else torch.device("cpu")
>>> model.to(device)
```
<Tip>
[Colaboratory](https://colab.research.google.com/) ๋๋ [SageMaker StudioLab](https://studiolab.sagemaker.aws/)๊ณผ ๊ฐ์ ํธ์คํ
๋
ธํธ๋ถ์ด ์๋ ๊ฒฝ์ฐ ํด๋ผ์ฐ๋ GPU์ ๋ฌด๋ฃ๋ก ์ก์ธ์คํ ์ ์์ต๋๋ค.
</Tip>
์ด์ ํ๋ จํ ์ค๋น๊ฐ ๋์์ต๋๋ค! ๐ฅณ
### ํ๋ จ ๋ฃจํ[[training-loop]]
ํ๋ จ ์งํ ์ํฉ์ ์ถ์ ํ๋ ค๋ฉด [tqdm](https://tqdm.github.io/) ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ฅผ ์ฌ์ฉํ์ฌ ํธ๋ ์ด๋ ๋จ๊ณ ์์ ์งํ๋ฅ ํ์์ค์ ์ถ๊ฐํ์ธ์:
```py
>>> from tqdm.auto import tqdm
>>> progress_bar = tqdm(range(num_training_steps))
>>> model.train()
>>> for epoch in range(num_epochs):
... for batch in train_dataloader:
... batch = {k: v.to(device) for k, v in batch.items()}
... outputs = model(**batch)
... loss = outputs.loss
... loss.backward()
... optimizer.step()
... lr_scheduler.step()
... optimizer.zero_grad()
... progress_bar.update(1)
```
### ํ๊ฐ ํ๊ธฐ[[evaluate]]
[`Trainer`]์ ํ๊ฐ ํจ์๋ฅผ ์ถ๊ฐํ ๋ฐฉ๋ฒ๊ณผ ๋ง์ฐฌ๊ฐ์ง๋ก, ํ๋ จ ๋ฃจํ๋ฅผ ์ง์ ์์ฑํ ๋๋ ๋์ผํ ์์
์ ์ํํด์ผ ํฉ๋๋ค. ํ์ง๋ง ์ด๋ฒ์๋ ๊ฐ ์ํฌํฌ๊ฐ ๋๋ ๋๋ง๋ค ํ๊ฐ์งํ๋ฅผ ๊ณ์ฐํ์ฌ ๋ณด๊ณ ํ๋ ๋์ , [`~evaluate.add_batch`]๋ฅผ ์ฌ์ฉํ์ฌ ๋ชจ๋ ๋ฐฐ์น๋ฅผ ๋์ ํ๊ณ ๋งจ ๋ง์ง๋ง์ ํ๊ฐ์งํ๋ฅผ ๊ณ์ฐํฉ๋๋ค.
```py
>>> import evaluate
>>> metric = evaluate.load("accuracy")
>>> model.eval()
>>> for batch in eval_dataloader:
... batch = {k: v.to(device) for k, v in batch.items()}
... with torch.no_grad():
... outputs = model(**batch)
... logits = outputs.logits
... predictions = torch.argmax(logits, dim=-1)
... metric.add_batch(predictions=predictions, references=batch["labels"])
>>> metric.compute()
```
</pt>
</frameworkcontent>
<a id='additional-resources'></a>
## ์ถ๊ฐ ์๋ฃ[[additional-resources]]
๋ ๋ง์ ๋ฏธ์ธ ํ๋ ์์ ๋ ๋ค์์ ์ฐธ์กฐํ์ธ์:
- [๐ค Trnasformers ์์ ](https://github.com/huggingface/transformers/tree/main/examples)์๋ PyTorch ๋ฐ ํ
์ํ๋ก์ฐ์์ ์ผ๋ฐ์ ์ธ NLP ์์
์ ํ๋ จํ ์ ์๋ ์คํฌ๋ฆฝํธ๊ฐ ํฌํจ๋์ด ์์ต๋๋ค.
- [๐ค Transformers ๋
ธํธ๋ถ](notebooks)์๋ PyTorch ๋ฐ ํ
์ํ๋ก์ฐ์์ ํน์ ์์
์ ์ํด ๋ชจ๋ธ์ ๋ฏธ์ธ ํ๋ํ๋ ๋ฐฉ๋ฒ์ ๋ํ ๋ค์ํ ๋
ธํธ๋ถ์ด ํฌํจ๋์ด ์์ต๋๋ค.
| 0 |
mavonic_private_repos/transformers/docs/source | mavonic_private_repos/transformers/docs/source/ko/serialization.md | <!--Copyright 2020 The HuggingFace Team. All rights reserved.
Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
the License. You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
specific language governing permissions and limitations under the License.
โ ๏ธ Note that this file is in Markdown but contain specific syntax for our doc-builder (similar to MDX) that may not be
rendered properly in your Markdown viewer.
-->
# ONNX๋ก ๋ด๋ณด๋ด๊ธฐ [[export-to-onnx]]
๐ค Transformers ๋ชจ๋ธ์ ์ ํ ํ๊ฒฝ์์ ๋ฐฐํฌํ๊ธฐ ์ํด์๋ ๋ชจ๋ธ์ ์ง๋ ฌํ๋ ํ์์ผ๋ก ๋ด๋ณด๋ด๊ณ ํน์ ๋ฐํ์๊ณผ ํ๋์จ์ด์์ ๋ก๋ํ๊ณ ์คํํ ์ ์์ผ๋ฉด ์ ์ฉํฉ๋๋ค.
๐ค Optimum์ Transformers์ ํ์ฅ์ผ๋ก, PyTorch ๋๋ TensorFlow์์ ๋ชจ๋ธ์ ONNX์ TFLite์ ๊ฐ์ ์ง๋ ฌํ๋ ํ์์ผ๋ก ๋ด๋ณด๋ผ ์ ์๋๋ก ํ๋ `exporters` ๋ชจ๋์ ํตํด ์ ๊ณต๋ฉ๋๋ค. ๐ค Optimum์ ๋ํ ์ฑ๋ฅ ์ต์ ํ ๋๊ตฌ ์ธํธ๋ฅผ ์ ๊ณตํ์ฌ ํน์ ํ๋์จ์ด์์ ๋ชจ๋ธ์ ํ๋ จํ๊ณ ์คํํ ๋ ์ต๋ ํจ์จ์ฑ์ ๋ฌ์ฑํ ์ ์์ต๋๋ค.
์ด ์๋ด์๋ ๐ค Optimum์ ์ฌ์ฉํ์ฌ ๐ค Transformers ๋ชจ๋ธ์ ONNX๋ก ๋ด๋ณด๋ด๋ ๋ฐฉ๋ฒ์ ๋ณด์ฌ์ค๋๋ค. TFLite๋ก ๋ชจ๋ธ์ ๋ด๋ณด๋ด๋ ์๋ด์๋ [TFLite๋ก ๋ด๋ณด๋ด๊ธฐ ํ์ด์ง](tflite)๋ฅผ ์ฐธ์กฐํ์ธ์.
## ONNX๋ก ๋ด๋ณด๋ด๊ธฐ [[export-to-onnx]]
[ONNX (Open Neural Network eXchange)](http://onnx.ai)๋ PyTorch์ TensorFlow๋ฅผ ํฌํจํ ๋ค์ํ ํ๋ ์์ํฌ์์ ์ฌ์ธต ํ์ต ๋ชจ๋ธ์ ๋ํ๋ด๋ ๋ฐ ์ฌ์ฉ๋๋ ๊ณตํต ์ฐ์ฐ์ ์ธํธ์ ๊ณตํต ํ์ผ ํ์์ ์ ์ํ๋ ์คํ ํ์ค์
๋๋ค. ๋ชจ๋ธ์ด ONNX ํ์์ผ๋ก ๋ด๋ณด๋ด์ง๋ฉด ์ด๋ฌํ ์ฐ์ฐ์๋ฅผ ์ฌ์ฉํ์ฌ ์ ๊ฒฝ๋ง์ ํตํด ๋ฐ์ดํฐ๊ฐ ํ๋ฅด๋ ํ๋ฆ์ ๋ํ๋ด๋ ๊ณ์ฐ ๊ทธ๋ํ(์ผ๋ฐ์ ์ผ๋ก _์ค๊ฐ ํํ_์ด๋ผ๊ณ ํจ)๊ฐ ๊ตฌ์ฑ๋ฉ๋๋ค.
ํ์คํ๋ ์ฐ์ฐ์์ ๋ฐ์ดํฐ ์ ํ์ ๊ฐ์ง ๊ทธ๋ํ๋ฅผ ๋
ธ์ถํจ์ผ๋ก์จ, ONNX๋ ํ๋ ์์ํฌ ๊ฐ์ ์ฝ๊ฒ ์ ํํ ์ ์์ต๋๋ค. ์๋ฅผ ๋ค์ด, PyTorch์์ ํ๋ จ๋ ๋ชจ๋ธ์ ONNX ํ์์ผ๋ก ๋ด๋ณด๋ด๊ณ TensorFlow์์ ๊ฐ์ ธ์ฌ ์ ์์ต๋๋ค(๊ทธ ๋ฐ๋๋ ๊ฐ๋ฅํฉ๋๋ค).
ONNX ํ์์ผ๋ก ๋ด๋ณด๋ธ ๋ชจ๋ธ์ ๋ค์๊ณผ ๊ฐ์ด ์ฌ์ฉํ ์ ์์ต๋๋ค:
- [๊ทธ๋ํ ์ต์ ํ](https://huggingface.co/docs/optimum/onnxruntime/usage_guides/optimization) ๋ฐ [์์ํ](https://huggingface.co/docs/optimum/onnxruntime/usage_guides/quantization)์ ๊ฐ์ ๊ธฐ๋ฒ์ ์ฌ์ฉํ์ฌ ์ถ๋ก ์ ์ํด ์ต์ ํ๋ฉ๋๋ค.
- ONNX Runtime์ ํตํด ์คํํ ์ ์์ต๋๋ค. [`ORTModelForXXX` ํด๋์ค๋ค](https://huggingface.co/docs/optimum/onnxruntime/package_reference/modeling_ort)์ ํตํด ๋์ผํ `AutoModel` API๋ฅผ ๋ฐ๋ฆ
๋๋ค. ์ด API๋ ๐ค Transformers์์ ์ฌ์ฉํ๋ ๊ฒ๊ณผ ๋์ผํฉ๋๋ค.
- [์ต์ ํ๋ ์ถ๋ก ํ์ดํ๋ผ์ธ](https://huggingface.co/docs/optimum/main/en/onnxruntime/usage_guides/pipelines)์ ์ฌ์ฉํ ์ ์์ต๋๋ค. ์ด๋ ๐ค Transformers์ [`pipeline`] ํจ์์ ๋์ผํ API๋ฅผ ๊ฐ์ง๊ณ ์์ต๋๋ค.
๐ค Optimum์ ๊ตฌ์ฑ ๊ฐ์ฒด๋ฅผ ํ์ฉํ์ฌ ONNX ๋ด๋ณด๋ด๊ธฐ๋ฅผ ์ง์ํฉ๋๋ค. ์ด๋ฌํ ๊ตฌ์ฑ ๊ฐ์ฒด๋ ์ฌ๋ฌ ๋ชจ๋ธ ์ํคํ
์ฒ์ ๋ํด ๋ฏธ๋ฆฌ ์ค๋น๋์ด ์์ผ๋ฉฐ ๋ค๋ฅธ ์ํคํ
์ฒ์ ์ฝ๊ฒ ํ์ฅํ ์ ์๋๋ก ์ค๊ณ๋์์ต๋๋ค.
๋ฏธ๋ฆฌ ์ค๋น๋ ๊ตฌ์ฑ ๋ชฉ๋ก์ [๐ค Optimum ๋ฌธ์](https://huggingface.co/docs/optimum/exporters/onnx/overview)๋ฅผ ์ฐธ์กฐํ์ธ์.
๐ค Transformers ๋ชจ๋ธ์ ONNX๋ก ๋ด๋ณด๋ด๋ ๋ ๊ฐ์ง ๋ฐฉ๋ฒ์ด ์์ต๋๋ค. ์ฌ๊ธฐ์์ ๋ ๊ฐ์ง ๋ฐฉ๋ฒ์ ๋ชจ๋ ๋ณด์ฌ์ค๋๋ค:
- ๐ค Optimum์ ์ฌ์ฉํ์ฌ CLI๋ก ๋ด๋ณด๋ด๊ธฐ
- `optimum.onnxruntime`์ ์ฌ์ฉํ์ฌ ๐ค Optimum์ผ๋ก ONNX๋ก ๋ด๋ณด๋ด๊ธฐ
### CLI๋ฅผ ์ฌ์ฉํ์ฌ ๐ค Transformers ๋ชจ๋ธ์ ONNX๋ก ๋ด๋ณด๋ด๊ธฐ [[exporting-a-transformers-model-to-onnx-with-cli]]
๐ค Transformers ๋ชจ๋ธ์ ONNX๋ก ๋ด๋ณด๋ด๋ ค๋ฉด ๋จผ์ ์ถ๊ฐ ์ข
์์ฑ์ ์ค์นํ์ธ์:
```bash
pip install optimum[exporters]
```
์ฌ์ฉ ๊ฐ๋ฅํ ๋ชจ๋ ์ธ์๋ฅผ ํ์ธํ๋ ค๋ฉด [๐ค Optimum ๋ฌธ์](https://huggingface.co/docs/optimum/exporters/onnx/usage_guides/export_a_model#exporting-a-model-to-onnx-using-the-cli)๋ฅผ ์ฐธ์กฐํ๊ฑฐ๋ ๋ช
๋ น์ค์์ ๋์๋ง์ ๋ณด์ธ์.
```bash
optimum-cli export onnx --help
```
์๋ฅผ ๋ค์ด, ๐ค Hub์์ `distilbert/distilbert-base-uncased-distilled-squad`์ ๊ฐ์ ๋ชจ๋ธ์ ์ฒดํฌํฌ์ธํธ๋ฅผ ๋ด๋ณด๋ด๋ ค๋ฉด ๋ค์ ๋ช
๋ น์ ์คํํ์ธ์:
```bash
optimum-cli export onnx --model distilbert/distilbert-base-uncased-distilled-squad distilbert_base_uncased_squad_onnx/
```
์์ ๊ฐ์ด ์งํ ์ํฉ์ ๋ํ๋ด๋ ๋ก๊ทธ๊ฐ ํ์๋๊ณ ๊ฒฐ๊ณผ์ธ `model.onnx`๊ฐ ์ ์ฅ๋ ์์น๊ฐ ํ์๋ฉ๋๋ค.
```bash
Validating ONNX model distilbert_base_uncased_squad_onnx/model.onnx...
-[โ] ONNX model output names match reference model (start_logits, end_logits)
- Validating ONNX Model output "start_logits":
-[โ] (2, 16) matches (2, 16)
-[โ] all values close (atol: 0.0001)
- Validating ONNX Model output "end_logits":
-[โ] (2, 16) matches (2, 16)
-[โ] all values close (atol: 0.0001)
The ONNX export succeeded and the exported model was saved at: distilbert_base_uncased_squad_onnx
```
์์ ์์ ๋ ๐ค Hub์์ ์ฒดํฌํฌ์ธํธ๋ฅผ ๋ด๋ณด๋ด๋ ๊ฒ์ ์ค๋ช
ํฉ๋๋ค. ๋ก์ปฌ ๋ชจ๋ธ์ ๋ด๋ณด๋ผ ๋์๋ ๋ชจ๋ธ์ ๊ฐ์ค์น์ ํ ํฌ๋์ด์ ํ์ผ์ ๋์ผํ ๋๋ ํ ๋ฆฌ(`local_path`)์ ์ ์ฅํ๋์ง ํ์ธํ์ธ์. CLI๋ฅผ ์ฌ์ฉํ ๋์๋ ๐ค Hub์ ์ฒดํฌํฌ์ธํธ ์ด๋ฆ ๋์ `model` ์ธ์์ `local_path`๋ฅผ ์ ๋ฌํ๊ณ `--task` ์ธ์๋ฅผ ์ ๊ณตํ์ธ์. ์ง์๋๋ ์์
์ ๋ชฉ๋ก์ [๐ค Optimum ๋ฌธ์](https://huggingface.co/docs/optimum/exporters/task_manager)๋ฅผ ์ฐธ์กฐํ์ธ์. `task` ์ธ์๊ฐ ์ ๊ณต๋์ง ์์ผ๋ฉด ์์
์ ํนํ๋ ํค๋ ์์ด ๋ชจ๋ธ ์ํคํ
์ฒ๋ก ๊ธฐ๋ณธ ์ค์ ๋ฉ๋๋ค.
```bash
optimum-cli export onnx --model local_path --task question-answering distilbert_base_uncased_squad_onnx/
```
๊ทธ ๊ฒฐ๊ณผ๋ก ์์ฑ๋ `model.onnx` ํ์ผ์ ONNX ํ์ค์ ์ง์ํ๋ ๋ง์ [๊ฐ์๊ธฐ](https://onnx.ai/supported-tools.html#deployModel) ์ค ํ๋์์ ์คํํ ์ ์์ต๋๋ค. ์๋ฅผ ๋ค์ด, [ONNX Runtime](https://onnxruntime.ai/)์ ์ฌ์ฉํ์ฌ ๋ชจ๋ธ์ ๋ก๋ํ๊ณ ์คํํ ์ ์์ต๋๋ค:
```python
>>> from transformers import AutoTokenizer
>>> from optimum.onnxruntime import ORTModelForQuestionAnswering
>>> tokenizer = AutoTokenizer.from_pretrained("distilbert_base_uncased_squad_onnx")
>>> model = ORTModelForQuestionAnswering.from_pretrained("distilbert_base_uncased_squad_onnx")
>>> inputs = tokenizer("What am I using?", "Using DistilBERT with ONNX Runtime!", return_tensors="pt")
>>> outputs = model(**inputs)
```
Hub์ TensorFlow ์ฒดํฌํฌ์ธํธ์ ๋ํด์๋ ๋์ผํ ํ๋ก์ธ์ค๊ฐ ์ ์ฉ๋ฉ๋๋ค. ์๋ฅผ ๋ค์ด, [Keras organization](https://huggingface.co/keras-io)์์ ์์ํ TensorFlow ์ฒดํฌํฌ์ธํธ๋ฅผ ๋ด๋ณด๋ด๋ ๋ฐฉ๋ฒ์ ๋ค์๊ณผ ๊ฐ์ต๋๋ค:
```bash
optimum-cli export onnx --model keras-io/transformers-qa distilbert_base_cased_squad_onnx/
```
### `optimum.onnxruntime`์ ์ฌ์ฉํ์ฌ ๐ค Transformers ๋ชจ๋ธ์ ONNX๋ก ๋ด๋ณด๋ด๊ธฐ [[exporting-a-transformers-model-to-onnx-with-optimumonnxruntime]]
CLI ๋์ ์ `optimum.onnxruntime`์ ์ฌ์ฉํ์ฌ ํ๋ก๊ทธ๋๋ฐ ๋ฐฉ์์ผ๋ก ๐ค Transformers ๋ชจ๋ธ์ ONNX๋ก ๋ด๋ณด๋ผ ์๋ ์์ต๋๋ค. ๋ค์๊ณผ ๊ฐ์ด ์งํํ์ธ์:
```python
>>> from optimum.onnxruntime import ORTModelForSequenceClassification
>>> from transformers import AutoTokenizer
>>> model_checkpoint = "distilbert_base_uncased_squad"
>>> save_directory = "onnx/"
>>> # Load a model from transformers and export it to ONNX
>>> ort_model = ORTModelForSequenceClassification.from_pretrained(model_checkpoint, export=True)
>>> tokenizer = AutoTokenizer.from_pretrained(model_checkpoint)
>>> # Save the onnx model and tokenizer
>>> ort_model.save_pretrained(save_directory)
>>> tokenizer.save_pretrained(save_directory)
```
### ์ง์๋์ง ์๋ ์ํคํ
์ฒ์ ๋ชจ๋ธ ๋ด๋ณด๋ด๊ธฐ [[exporting-a-model-for-an-unsupported-architecture]]
ํ์ฌ ๋ด๋ณด๋ผ ์ ์๋ ๋ชจ๋ธ์ ์ง์ํ๊ธฐ ์ํด ๊ธฐ์ฌํ๋ ค๋ฉด, ๋จผ์ [`optimum.exporters.onnx`](https://huggingface.co/docs/optimum/exporters/onnx/overview)์์ ์ง์๋๋์ง ํ์ธํ ํ ์ง์๋์ง ์๋ ๊ฒฝ์ฐ์๋ [๐ค Optimum์ ๊ธฐ์ฌ](https://huggingface.co/docs/optimum/exporters/onnx/usage_guides/contribute)ํ์ธ์.
### `transformers.onnx`๋ฅผ ์ฌ์ฉํ์ฌ ๋ชจ๋ธ ๋ด๋ณด๋ด๊ธฐ [[exporting-a-model-with-transformersonnx]]
<Tip warning={true}>
`tranformers.onnx`๋ ๋ ์ด์ ์ ์ง๋์ง ์์ต๋๋ค. ์์์ ์ค๋ช
ํ ๋๋ก ๐ค Optimum์ ์ฌ์ฉํ์ฌ ๋ชจ๋ธ์ ๋ด๋ณด๋ด์ธ์. ์ด ์น์
์ ํฅํ ๋ฒ์ ์์ ์ ๊ฑฐ๋ ์์ ์
๋๋ค.
</Tip>
๐ค Transformers ๋ชจ๋ธ์ ONNX๋ก ๋ด๋ณด๋ด๋ ค๋ฉด ์ถ๊ฐ ์ข
์์ฑ์ ์ค์นํ์ธ์:
```bash
pip install transformers[onnx]
```
`transformers.onnx` ํจํค์ง๋ฅผ Python ๋ชจ๋๋ก ์ฌ์ฉํ์ฌ ์ค๋น๋ ๊ตฌ์ฑ์ ์ฌ์ฉํ์ฌ ์ฒดํฌํฌ์ธํธ๋ฅผ ๋ด๋ณด๋
๋๋ค:
```bash
python -m transformers.onnx --model=distilbert/distilbert-base-uncased onnx/
```
์ด๋ ๊ฒ ํ๋ฉด `--model` ์ธ์์ ์ ์๋ ์ฒดํฌํฌ์ธํธ์ ONNX ๊ทธ๋ํ๊ฐ ๋ด๋ณด๋ด์ง๋๋ค. ๐ค Hub์์ ์ ๊ณตํ๋ ์ฒดํฌํฌ์ธํธ๋ ๋ก์ปฌ์ ์ ์ฅ๋ ์ฒดํฌํฌ์ธํธ๋ฅผ ์ ๋ฌํ ์ ์์ต๋๋ค. ๊ฒฐ๊ณผ๋ก ์์ฑ๋ `model.onnx` ํ์ผ์ ONNX ํ์ค์ ์ง์ํ๋ ๋ง์ ๊ฐ์๊ธฐ ์ค ํ๋์์ ์คํํ ์ ์์ต๋๋ค. ์๋ฅผ ๋ค์ด, ๋ค์๊ณผ ๊ฐ์ด ONNX Runtime์ ์ฌ์ฉํ์ฌ ๋ชจ๋ธ์ ๋ก๋ํ๊ณ ์คํํ ์ ์์ต๋๋ค:
```python
>>> from transformers import AutoTokenizer
>>> from onnxruntime import InferenceSession
>>> tokenizer = AutoTokenizer.from_pretrained("distilbert/distilbert-base-uncased")
>>> session = InferenceSession("onnx/model.onnx")
>>> # ONNX Runtime expects NumPy arrays as input
>>> inputs = tokenizer("Using DistilBERT with ONNX Runtime!", return_tensors="np")
>>> outputs = session.run(output_names=["last_hidden_state"], input_feed=dict(inputs))
```
ํ์ํ ์ถ๋ ฅ ์ด๋ฆ(์: `["last_hidden_state"]`)์ ๊ฐ ๋ชจ๋ธ์ ONNX ๊ตฌ์ฑ์ ํ์ธํ์ฌ ์ป์ ์ ์์ต๋๋ค. ์๋ฅผ ๋ค์ด, DistilBERT์ ๊ฒฝ์ฐ ๋ค์๊ณผ ๊ฐ์ต๋๋ค:
```python
>>> from transformers.models.distilbert import DistilBertConfig, DistilBertOnnxConfig
>>> config = DistilBertConfig()
>>> onnx_config = DistilBertOnnxConfig(config)
>>> print(list(onnx_config.outputs.keys()))
["last_hidden_state"]
```
Hub์ TensorFlow ์ฒดํฌํฌ์ธํธ์ ๋ํด์๋ ๋์ผํ ํ๋ก์ธ์ค๊ฐ ์ ์ฉ๋ฉ๋๋ค. ์๋ฅผ ๋ค์ด, ๋ค์๊ณผ ๊ฐ์ด ์์ํ TensorFlow ์ฒดํฌํฌ์ธํธ๋ฅผ ๋ด๋ณด๋
๋๋ค:
```bash
python -m transformers.onnx --model=keras-io/transformers-qa onnx/
```
๋ก์ปฌ์ ์ ์ฅ๋ ๋ชจ๋ธ์ ๋ด๋ณด๋ด๋ ค๋ฉด ๋ชจ๋ธ์ ๊ฐ์ค์น ํ์ผ๊ณผ ํ ํฌ๋์ด์ ํ์ผ์ ๋์ผํ ๋๋ ํ ๋ฆฌ์ ์ ์ฅํ ๋ค์, transformers.onnx ํจํค์ง์ --model ์ธ์๋ฅผ ์ํ๋ ๋๋ ํ ๋ฆฌ๋ก ์ง์ ํ์ฌ ONNX๋ก ๋ด๋ณด๋
๋๋ค:
```bash
python -m transformers.onnx --model=local-pt-checkpoint onnx/
``` | 0 |
mavonic_private_repos/transformers/docs/source | mavonic_private_repos/transformers/docs/source/ko/accelerate.md | <!--Copyright 2022 The HuggingFace Team. All rights reserved.
Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
the License. You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
specific language governing permissions and limitations under the License.
โ ๏ธ Note that this file is in Markdown but contain specific syntax for our doc-builder (similar to MDX) that may not be
rendered properly in your Markdown viewer.
-->
# ๐ค Accelerate๋ฅผ ํ์ฉํ ๋ถ์ฐ ํ์ต[[distributed-training-with-accelerate]]
๋ชจ๋ธ์ด ์ปค์ง๋ฉด์ ๋ณ๋ ฌ ์ฒ๋ฆฌ๋ ์ ํ๋ ํ๋์จ์ด์์ ๋ ํฐ ๋ชจ๋ธ์ ํ๋ จํ๊ณ ํ๋ จ ์๋๋ฅผ ๋ช ๋ฐฐ๋ก ๊ฐ์ํํ๊ธฐ ์ํ ์ ๋ต์ผ๋ก ๋ฑ์ฅํ์ต๋๋ค. Hugging Face์์๋ ์ฌ์ฉ์๊ฐ ํ๋์ ๋จธ์ ์ ์ฌ๋ฌ ๊ฐ์ GPU๋ฅผ ์ฌ์ฉํ๋ ์ฌ๋ฌ ๋จธ์ ์ ์ฌ๋ฌ ๊ฐ์ GPU๋ฅผ ์ฌ์ฉํ๋ ๋ชจ๋ ์ ํ์ ๋ถ์ฐ ์ค์ ์์ ๐ค Transformers ๋ชจ๋ธ์ ์ฝ๊ฒ ํ๋ จํ ์ ์๋๋ก ๋๊ธฐ ์ํด [๐ค Accelerate](https://huggingface.co/docs/accelerate) ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ฅผ ๋ง๋ค์์ต๋๋ค. ์ด ํํ ๋ฆฌ์ผ์์๋ ๋ถ์ฐ ํ๊ฒฝ์์ ํ๋ จํ ์ ์๋๋ก ๊ธฐ๋ณธ PyTorch ํ๋ จ ๋ฃจํ๋ฅผ ์ปค์คํฐ๋ง์ด์ฆํ๋ ๋ฐฉ๋ฒ์ ์์๋ด
์๋ค.
## ์ค์ [[setup]]
๐ค Accelerate ์ค์น ์์ํ๊ธฐ:
```bash
pip install accelerate
```
๊ทธ ๋ค์, [`~accelerate.Accelerator`] ๊ฐ์ฒด๋ฅผ ๋ถ๋ฌ์ค๊ณ ์์ฑํฉ๋๋ค. [`~accelerate.Accelerator`]๋ ์๋์ผ๋ก ๋ถ์ฐ ์ค์ ์ ํ์ ๊ฐ์งํ๊ณ ํ๋ จ์ ํ์ํ ๋ชจ๋ ๊ตฌ์ฑ ์์๋ฅผ ์ด๊ธฐํํฉ๋๋ค. ์ฅ์น์ ๋ชจ๋ธ์ ๋ช
์์ ์ผ๋ก ๋ฐฐ์นํ ํ์๋ ์์ต๋๋ค.
```py
>>> from accelerate import Accelerator
>>> accelerator = Accelerator()
```
## ๊ฐ์ํ๋ฅผ ์ํ ์ค๋น[[prepare-to-accelerate]]
๋ค์ ๋จ๊ณ๋ ๊ด๋ จ๋ ๋ชจ๋ ํ๋ จ ๊ฐ์ฒด๋ฅผ [`~accelerate.Accelerator.prepare`] ๋ฉ์๋์ ์ ๋ฌํ๋ ๊ฒ์
๋๋ค. ์ฌ๊ธฐ์๋ ํ๋ จ ๋ฐ ํ๊ฐ ๋ฐ์ดํฐ๋ก๋, ๋ชจ๋ธ ๋ฐ ์ตํฐ๋ง์ด์ ๊ฐ ํฌํจ๋ฉ๋๋ค:
```py
>>> train_dataloader, eval_dataloader, model, optimizer = accelerator.prepare(
... train_dataloader, eval_dataloader, model, optimizer
... )
```
## ๋ฐฑ์๋(Backward)[[backward]]
๋ง์ง๋ง์ผ๋ก ํ๋ จ ๋ฃจํ์ ์ผ๋ฐ์ ์ธ `loss.backward()`๋ฅผ ๐ค Accelerate์ [`~accelerate.Accelerator.backward`] ๋ฉ์๋๋ก ๋์ฒดํ๊ธฐ๋ง ํ๋ฉด ๋ฉ๋๋ค:
```py
>>> for epoch in range(num_epochs):
... for batch in train_dataloader:
... outputs = model(**batch)
... loss = outputs.loss
... accelerator.backward(loss)
... optimizer.step()
... lr_scheduler.step()
... optimizer.zero_grad()
... progress_bar.update(1)
```
๋ค์ ์ฝ๋์์ ๋ณผ ์ ์๋ฏ์ด, ํ๋ จ ๋ฃจํ์ ์ฝ๋ ๋ค ์ค๋ง ์ถ๊ฐํ๋ฉด ๋ถ์ฐ ํ์ต์ ํ์ฑํํ ์ ์์ต๋๋ค!
```diff
+ from accelerate import Accelerator
from transformers import AdamW, AutoModelForSequenceClassification, get_scheduler
+ accelerator = Accelerator()
model = AutoModelForSequenceClassification.from_pretrained(checkpoint, num_labels=2)
optimizer = AdamW(model.parameters(), lr=3e-5)
- device = torch.device("cuda") if torch.cuda.is_available() else torch.device("cpu")
- model.to(device)
+ train_dataloader, eval_dataloader, model, optimizer = accelerator.prepare(
+ train_dataloader, eval_dataloader, model, optimizer
+ )
num_epochs = 3
num_training_steps = num_epochs * len(train_dataloader)
lr_scheduler = get_scheduler(
"linear",
optimizer=optimizer,
num_warmup_steps=0,
num_training_steps=num_training_steps
)
progress_bar = tqdm(range(num_training_steps))
model.train()
for epoch in range(num_epochs):
for batch in train_dataloader:
- batch = {k: v.to(device) for k, v in batch.items()}
outputs = model(**batch)
loss = outputs.loss
- loss.backward()
+ accelerator.backward(loss)
optimizer.step()
lr_scheduler.step()
optimizer.zero_grad()
progress_bar.update(1)
```
## ํ์ต[[train]]
๊ด๋ จ ์ฝ๋๋ฅผ ์ถ๊ฐํ ํ์๋ ์คํฌ๋ฆฝํธ๋ Colaboratory์ ๊ฐ์ ๋
ธํธ๋ถ์์ ํ๋ จ์ ์์ํ์ธ์.
### ์คํฌ๋ฆฝํธ๋ก ํ์ตํ๊ธฐ[[train-with-a-script]]
์คํฌ๋ฆฝํธ์์ ํ๋ จ์ ์คํํ๋ ๊ฒฝ์ฐ, ๋ค์ ๋ช
๋ น์ ์คํํ์ฌ ๊ตฌ์ฑ ํ์ผ์ ์์ฑํ๊ณ ์ ์ฅํฉ๋๋ค:
```bash
accelerate config
```
Then launch your training with:
```bash
accelerate launch train.py
```
### ๋
ธํธ๋ถ์ผ๋ก ํ์ตํ๊ธฐ[[train-with-a-notebook]]
Collaboratory์ TPU๋ฅผ ์ฌ์ฉํ๋ ค๋ ๊ฒฝ์ฐ, ๋
ธํธ๋ถ์์๋ ๐ค Accelerate๋ฅผ ์คํํ ์ ์์ต๋๋ค. ํ๋ จ์ ๋ด๋นํ๋ ๋ชจ๋ ์ฝ๋๋ฅผ ํจ์๋ก ๊ฐ์ธ์ [`~accelerate.notebook_launcher`]์ ์ ๋ฌํ์ธ์:
```py
>>> from accelerate import notebook_launcher
>>> notebook_launcher(training_function)
```
๐ค Accelerate ๋ฐ ๋ค์ํ ๊ธฐ๋ฅ์ ๋ํ ์์ธํ ๋ด์ฉ์ [documentation](https://huggingface.co/docs/accelerate)๋ฅผ ์ฐธ์กฐํ์ธ์. | 0 |
mavonic_private_repos/transformers/docs/source | mavonic_private_repos/transformers/docs/source/ko/llm_tutorial.md | <!--Copyright 2023 The HuggingFace Team. All rights reserved.
Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
the License. You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
specific language governing permissions and limitations under the License.
โ ๏ธ Note that this file is in Markdown but contain specific syntax for our doc-builder (similar to MDX) that may not be
rendered properly in your Markdown viewer.
-->
# ๋๊ท๋ชจ ์ธ์ด ๋ชจ๋ธ๋ก ์์ฑํ๊ธฐ [[generation-with-llms]]
[[open-in-colab]]
LLM ๋๋ ๋๊ท๋ชจ ์ธ์ด ๋ชจ๋ธ์ ํ
์คํธ ์์ฑ์ ํต์ฌ ๊ตฌ์ฑ ์์์
๋๋ค. ๊ฐ๋จํ ๋งํ๋ฉด, ์ฃผ์ด์ง ์
๋ ฅ ํ
์คํธ์ ๋ํ ๋ค์ ๋จ์ด(์ ํํ๊ฒ๋ ํ ํฐ)๋ฅผ ์์ธกํ๊ธฐ ์ํด ํ๋ จ๋ ๋๊ท๋ชจ ์ฌ์ ํ๋ จ ๋ณํ๊ธฐ ๋ชจ๋ธ๋ก ๊ตฌ์ฑ๋ฉ๋๋ค. ํ ํฐ์ ํ ๋ฒ์ ํ๋์ฉ ์์ธกํ๊ธฐ ๋๋ฌธ์ ์๋ก์ด ๋ฌธ์ฅ์ ์์ฑํ๋ ค๋ฉด ๋ชจ๋ธ์ ํธ์ถํ๋ ๊ฒ ์ธ์ ๋ ๋ณต์กํ ์์
์ ์ํํด์ผ ํฉ๋๋ค. ์ฆ, ์๊ธฐํ๊ท ์์ฑ์ ์ํํด์ผ ํฉ๋๋ค.
์๊ธฐํ๊ท ์์ฑ์ ๋ช ๊ฐ์ ์ด๊ธฐ ์
๋ ฅ๊ฐ์ ์ ๊ณตํ ํ, ๊ทธ ์ถ๋ ฅ์ ๋ค์ ๋ชจ๋ธ์ ์
๋ ฅ์ผ๋ก ์ฌ์ฉํ์ฌ ๋ฐ๋ณต์ ์ผ๋ก ํธ์ถํ๋ ์ถ๋ก ๊ณผ์ ์
๋๋ค. ๐ค Transformers์์๋ [`~generation.GenerationMixin.generate`] ๋ฉ์๋๊ฐ ์ด ์ญํ ์ ํ๋ฉฐ, ์ด๋ ์์ฑ ๊ธฐ๋ฅ์ ๊ฐ์ง ๋ชจ๋ ๋ชจ๋ธ์์ ์ฌ์ฉ ๊ฐ๋ฅํฉ๋๋ค.
์ด ํํ ๋ฆฌ์ผ์์๋ ๋ค์ ๋ด์ฉ์ ๋ค๋ฃจ๊ฒ ๋ฉ๋๋ค:
* LLM์ผ๋ก ํ
์คํธ ์์ฑ
* ์ผ๋ฐ์ ์ผ๋ก ๋ฐ์ํ๋ ๋ฌธ์ ํด๊ฒฐ
* LLM์ ์ต๋ํ ํ์ฉํ๊ธฐ ์ํ ๋ค์ ๋จ๊ณ
์์ํ๊ธฐ ์ ์ ํ์ํ ๋ชจ๋ ๋ผ์ด๋ธ๋ฌ๋ฆฌ๊ฐ ์ค์น๋์ด ์๋์ง ํ์ธํ์ธ์:
```bash
pip install transformers bitsandbytes>=0.39.0 -q
```
## ํ
์คํธ ์์ฑ [[generate-text]]
[์ธ๊ณผ์ ์ธ์ด ๋ชจ๋ธ๋ง(causal language modeling)](tasks/language_modeling)์ ๋ชฉ์ ์ผ๋ก ํ์ต๋ ์ธ์ด ๋ชจ๋ธ์ ์ผ๋ จ์ ํ
์คํธ ํ ํฐ์ ์
๋ ฅ์ผ๋ก ์ฌ์ฉํ๊ณ , ๊ทธ ๊ฒฐ๊ณผ๋ก ๋ค์ ํ ํฐ์ด ๋์ฌ ํ๋ฅ ๋ถํฌ๋ฅผ ์ ๊ณตํฉ๋๋ค.
<!-- [GIF 1 -- FWD PASS] -->
<figure class="image table text-center m-0 w-full">
<video
style="max-width: 90%; margin: auto;"
autoplay loop muted playsinline
src="https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/blog/assisted-generation/gif_1_1080p.mov"
></video>
<figcaption>"LLM์ ์ ๋ฐฉ ํจ์ค"</figcaption>
</figure>
LLM๊ณผ ์๊ธฐํ๊ท ์์ฑ์ ํจ๊ป ์ฌ์ฉํ ๋ ํต์ฌ์ ์ธ ๋ถ๋ถ์ ์ด ํ๋ฅ ๋ถํฌ๋ก๋ถํฐ ๋ค์ ํ ํฐ์ ์ด๋ป๊ฒ ๊ณ ๋ฅผ ๊ฒ์ธ์ง์
๋๋ค. ๋ค์ ๋ฐ๋ณต ๊ณผ์ ์ ์ฌ์ฉ๋ ํ ํฐ์ ๊ฒฐ์ ํ๋ ํ, ์ด๋ ํ ๋ฐฉ๋ฒ๋ ๊ฐ๋ฅํฉ๋๋ค. ํ๋ฅ ๋ถํฌ์์ ๊ฐ์ฅ ๊ฐ๋ฅ์ฑ์ด ๋์ ํ ํฐ์ ์ ํํ๋ ๊ฒ์ฒ๋ผ ๊ฐ๋จํ ์๋ ์๊ณ , ๊ฒฐ๊ณผ ๋ถํฌ์์ ์ํ๋งํ๊ธฐ ์ ์ ์์ญ ๊ฐ์ง ๋ณํ์ ์ ์ฉํ๋ ๊ฒ์ฒ๋ผ ๋ณต์กํ ์๋ ์์ต๋๋ค.
<!-- [GIF 2 -- TEXT GENERATION] -->
<figure class="image table text-center m-0 w-full">
<video
style="max-width: 90%; margin: auto;"
autoplay loop muted playsinline
src="https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/blog/assisted-generation/gif_2_1080p.mov"
></video>
<figcaption>"์๊ธฐํ๊ท ์์ฑ์ ํ๋ฅ ๋ถํฌ์์ ๋ค์ ํ ํฐ์ ๋ฐ๋ณต์ ์ผ๋ก ์ ํํ์ฌ ํ
์คํธ๋ฅผ ์์ฑํฉ๋๋ค."</figcaption>
</figure>
์์์ ์ค๋ช
ํ ๊ณผ์ ์ ์ด๋ค ์ข
๋ฃ ์กฐ๊ฑด์ด ์ถฉ์กฑ๋ ๋๊น์ง ๋ฐ๋ณต์ ์ผ๋ก ์ํ๋ฉ๋๋ค. ๋ชจ๋ธ์ด ์ํ์ค์ ๋(EOS ํ ํฐ)์ ์ถ๋ ฅํ ๋๊น์ง๋ฅผ ์ข
๋ฃ ์กฐ๊ฑด์ผ๋ก ํ๋ ๊ฒ์ด ์ด์์ ์
๋๋ค. ๊ทธ๋ ์ง ์์ ๊ฒฝ์ฐ์๋ ๋ฏธ๋ฆฌ ์ ์๋ ์ต๋ ๊ธธ์ด์ ๋๋ฌํ์ ๋ ์์ฑ์ด ์ค๋จ๋ฉ๋๋ค.
๋ชจ๋ธ์ด ์์๋๋ก ๋์ํ๊ธฐ ์ํด์ ํ ํฐ ์ ํ ๋จ๊ณ์ ์ ์ง ์กฐ๊ฑด์ ์ฌ๋ฐ๋ฅด๊ฒ ์ค์ ํ๋ ๊ฒ์ด ์ค์ํฉ๋๋ค. ์ด๋ฌํ ์ด์ ๋ก, ๊ฐ ๋ชจ๋ธ์๋ ๊ธฐ๋ณธ ์์ฑ ์ค์ ์ด ์ ์ ์๋ [`~generation.GenerationConfig`] ํ์ผ์ด ํจ๊ป ์ ๊ณต๋ฉ๋๋ค.
์ฝ๋๋ฅผ ํ์ธํด๋ด
์๋ค!
<Tip>
๊ธฐ๋ณธ LLM ์ฌ์ฉ์ ๊ด์ฌ์ด ์๋ค๋ฉด, ์ฐ๋ฆฌ์ [`Pipeline`](pipeline_tutorial) ์ธํฐํ์ด์ค๋ก ์์ํ๋ ๊ฒ์ ์ถ์ฒํฉ๋๋ค. ๊ทธ๋ฌ๋ LLM์ ์์ํ๋ ํ ํฐ ์ ํ ๋จ๊ณ์์์ ๋ฏธ์ธํ ์ ์ด์ ๊ฐ์ ๊ณ ๊ธ ๊ธฐ๋ฅ๋ค์ ์ข
์ข
ํ์๋ก ํฉ๋๋ค. ์ด๋ฌํ ์์
์ [`~generation.GenerationMixin.generate`]๋ฅผ ํตํด ๊ฐ์ฅ ์ ์ํ๋ ์ ์์ต๋๋ค. LLM์ ์ด์ฉํ ์๊ธฐํ๊ท ์์ฑ์ ์์์ ๋ง์ด ์๋ชจํ๋ฏ๋ก, ์ ์ ํ ์ฒ๋ฆฌ๋์ ์ํด GPU์์ ์คํ๋์ด์ผ ํฉ๋๋ค.
</Tip>
๋จผ์ , ๋ชจ๋ธ์ ๋ถ๋ฌ์ค์ธ์.
```python
>>> from transformers import AutoModelForCausalLM
>>> model = AutoModelForCausalLM.from_pretrained(
... "mistralai/Mistral-7B-v0.1", device_map="auto", load_in_4bit=True
... )
```
`from_pretrained` ํจ์๋ฅผ ํธ์ถํ ๋ 2๊ฐ์ ํ๋๊ทธ๋ฅผ ์ฃผ๋ชฉํ์ธ์:
- `device_map`์ ๋ชจ๋ธ์ด GPU๋ก ์ด๋๋๋๋ก ํฉ๋๋ค.
- `load_in_4bit`๋ ๋ฆฌ์์ค ์๊ตฌ ์ฌํญ์ ํฌ๊ฒ ์ค์ด๊ธฐ ์ํด [4๋นํธ ๋์ ์์ํ](main_classes/quantization)๋ฅผ ์ ์ฉํฉ๋๋ค.
์ด ์ธ์๋ ๋ชจ๋ธ์ ์ด๊ธฐํํ๋ ๋ค์ํ ๋ฐฉ๋ฒ์ด ์์ง๋ง, LLM์ ์ฒ์ ์์ํ ๋ ์ด ์ค์ ์ ์ถ์ฒํฉ๋๋ค.
์ด์ด์ ํ
์คํธ ์
๋ ฅ์ [ํ ํฌ๋์ด์ ](tokenizer_summary)์ผ๋ก ์ ์ฒ๋ฆฌํ์ธ์.
```python
>>> from transformers import AutoTokenizer
>>> import torch
>>> tokenizer = AutoTokenizer.from_pretrained("mistralai/Mistral-7B-v0.1")
>>> device = "cuda" if torch.cuda.is_available() else "cpu"
>>> model_inputs = tokenizer(["A list of colors: red, blue"], return_tensors="pt").to(device)
```
`model_inputs` ๋ณ์์๋ ํ ํฐํ๋ ํ
์คํธ ์
๋ ฅ๊ณผ ํจ๊ป ์ดํ
์
๋ง์คํฌ๊ฐ ๋ค์ด ์์ต๋๋ค. [`~generation.GenerationMixin.generate`]๋ ์ดํ
์
๋ง์คํฌ๊ฐ ์ ๊ณต๋์ง ์์์ ๊ฒฝ์ฐ์๋ ์ด๋ฅผ ์ถ๋ก ํ๋ ค๊ณ ๋
ธ๋ ฅํ์ง๋ง, ์ต์์ ์ฑ๋ฅ์ ์ํด์๋ ๊ฐ๋ฅํ๋ฉด ์ดํ
์
๋ง์คํฌ๋ฅผ ์ ๋ฌํ๋ ๊ฒ์ ๊ถ์ฅํฉ๋๋ค.
๋ง์ง๋ง์ผ๋ก [`~generation.GenerationMixin.generate`] ๋ฉ์๋๋ฅผ ํธ์ถํด ์์ฑ๋ ํ ํฐ์ ์ป์ ํ, ์ด๋ฅผ ์ถ๋ ฅํ๊ธฐ ์ ์ ํ
์คํธ ํํ๋ก ๋ณํํ์ธ์.
```python
>>> generated_ids = model.generate(**model_inputs)
>>> tokenizer.batch_decode(generated_ids, skip_special_tokens=True)[0]
'A list of colors: red, blue, green, yellow, black, white, and brown'
```
์ด๊ฒ ์ ๋ถ์
๋๋ค! ๋ช ์ค์ ์ฝ๋๋ง์ผ๋ก LLM์ ๋ฅ๋ ฅ์ ํ์ฉํ ์ ์๊ฒ ๋์์ต๋๋ค.
## ์ผ๋ฐ์ ์ผ๋ก ๋ฐ์ํ๋ ๋ฌธ์ [[common-pitfalls]]
[์์ฑ ์ ๋ต](generation_strategies)์ด ๋ง๊ณ , ๊ธฐ๋ณธ๊ฐ์ด ํญ์ ์ฌ์ฉ ์ฌ๋ก์ ์ ํฉํ์ง ์์ ์ ์์ต๋๋ค. ์ถ๋ ฅ์ด ์์๊ณผ ๋ค๋ฅผ ๋ ํํ ๋ฐ์ํ๋ ๋ฌธ์ ์ ์ด๋ฅผ ํด๊ฒฐํ๋ ๋ฐฉ๋ฒ์ ๋ํ ๋ชฉ๋ก์ ๋ง๋ค์์ต๋๋ค.
```py
>>> from transformers import AutoModelForCausalLM, AutoTokenizer
>>> tokenizer = AutoTokenizer.from_pretrained("mistralai/Mistral-7B-v0.1")
>>> tokenizer.pad_token = tokenizer.eos_token # Mistral has no pad token by default
>>> model = AutoModelForCausalLM.from_pretrained(
... "mistralai/Mistral-7B-v0.1", device_map="auto", load_in_4bit=True
... )
```
### ์์ฑ๋ ์ถ๋ ฅ์ด ๋๋ฌด ์งง๊ฑฐ๋ ๊ธธ๋ค [[generated-output-is-too-shortlong]]
[`~generation.GenerationConfig`] ํ์ผ์์ ๋ณ๋๋ก ์ง์ ํ์ง ์์ผ๋ฉด, `generate`๋ ๊ธฐ๋ณธ์ ์ผ๋ก ์ต๋ 20๊ฐ์ ํ ํฐ์ ๋ฐํํฉ๋๋ค. `generate` ํธ์ถ์์ `max_new_tokens`์ ์๋์ผ๋ก ์ค์ ํ์ฌ ๋ฐํํ ์ ์๋ ์ ํ ํฐ์ ์ต๋ ์๋ฅผ ์ค์ ํ๋ ๊ฒ์ด ์ข์ต๋๋ค. LLM(์ ํํ๊ฒ๋ [๋์ฝ๋ ์ ์ฉ ๋ชจ๋ธ](https://huggingface.co/learn/nlp-course/chapter1/6?fw=pt))์ ์
๋ ฅ ํ๋กฌํํธ๋ ์ถ๋ ฅ์ ์ผ๋ถ๋ก ๋ฐํํฉ๋๋ค.
```py
>>> model_inputs = tokenizer(["A sequence of numbers: 1, 2"], return_tensors="pt").to("cuda")
>>> # By default, the output will contain up to 20 tokens
>>> generated_ids = model.generate(**model_inputs, pad_token_id=tokenizer.eos_token_id)
>>> tokenizer.batch_decode(generated_ids, skip_special_tokens=True)[0]
'A sequence of numbers: 1, 2, 3, 4, 5'
>>> # Setting `max_new_tokens` allows you to control the maximum length
>>> generated_ids = model.generate(**model_inputs, pad_token_id=tokenizer.eos_token_id, max_new_tokens=50)
>>> tokenizer.batch_decode(generated_ids, skip_special_tokens=True)[0]
'A sequence of numbers: 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,'
```
### ์๋ชป๋ ์์ฑ ๋ชจ๋ [[incorrect-generation-mode]]
๊ธฐ๋ณธ์ ์ผ๋ก [`~generation.GenerationConfig`] ํ์ผ์์ ๋ณ๋๋ก ์ง์ ํ์ง ์์ผ๋ฉด, `generate`๋ ๊ฐ ๋ฐ๋ณต์์ ๊ฐ์ฅ ํ๋ฅ ์ด ๋์ ํ ํฐ์ ์ ํํฉ๋๋ค(๊ทธ๋ฆฌ๋ ๋์ฝ๋ฉ). ํ๋ ค๋ ์์
์ ๋ฐ๋ผ ์ด ๋ฐฉ๋ฒ์ ๋ฐ๋์งํ์ง ์์ ์ ์์ต๋๋ค. ์๋ฅผ ๋ค์ด, ์ฑ๋ด์ด๋ ์์ธ์ด ์์ฑ๊ณผ ๊ฐ์ ์ฐฝ์์ ์ธ ์์
์ ์ํ๋ง์ด ์ ํฉํ ์ ์์ต๋๋ค. ๋ฐ๋ฉด, ์ค๋์ค๋ฅผ ํ
์คํธ๋ก ๋ณํํ๊ฑฐ๋ ๋ฒ์ญ๊ณผ ๊ฐ์ ์
๋ ฅ ๊ธฐ๋ฐ ์์
์ ๊ทธ๋ฆฌ๋ ๋์ฝ๋ฉ์ด ๋ ์ ํฉํ ์ ์์ต๋๋ค. `do_sample=True`๋ก ์ํ๋ง์ ํ์ฑํํ ์ ์์ผ๋ฉฐ, ์ด ์ฃผ์ ์ ๋ํ ์์ธํ ๋ด์ฉ์ ์ด [๋ธ๋ก๊ทธ ํฌ์คํธ](https://huggingface.co/blog/how-to-generate)์์ ๋ณผ ์ ์์ต๋๋ค.
```python
>>> # Set seed or reproducibility -- you don't need this unless you want full reproducibility
>>> from transformers import set_seed
>>> set_seed(0)
>>> model_inputs = tokenizer(["I am a cat."], return_tensors="pt").to("cuda")
>>> # LLM + greedy decoding = repetitive, boring output
>>> generated_ids = model.generate(**model_inputs)
>>> tokenizer.batch_decode(generated_ids, skip_special_tokens=True)[0]
'I am a cat. I am a cat. I am a cat. I am a cat'
>>> # With sampling, the output becomes more creative!
>>> generated_ids = model.generate(**model_inputs, do_sample=True)
>>> tokenizer.batch_decode(generated_ids, skip_special_tokens=True)[0]
'I am a cat.\nI just need to be. I am always.\nEvery time'
```
### ์๋ชป๋ ํจ๋ฉ [[wrong-padding-side]]
LLM์ [๋์ฝ๋ ์ ์ฉ](https://huggingface.co/learn/nlp-course/chapter1/6?fw=pt) ๊ตฌ์กฐ๋ฅผ ๊ฐ์ง๊ณ ์์ด, ์
๋ ฅ ํ๋กฌํํธ์ ๋ํด ์ง์์ ์ผ๋ก ๋ฐ๋ณต ์ฒ๋ฆฌ๋ฅผ ํฉ๋๋ค. ์
๋ ฅ ๋ฐ์ดํฐ์ ๊ธธ์ด๊ฐ ๋ค๋ฅด๋ฉด ํจ๋ฉ ์์
์ด ํ์ํฉ๋๋ค. LLM์ ํจ๋ฉ ํ ํฐ์์ ์๋์ ์ด์ด๊ฐ๋๋ก ์ค๊ณ๋์ง ์์๊ธฐ ๋๋ฌธ์, ์
๋ ฅ ์ผ์ชฝ์ ํจ๋ฉ์ด ์ถ๊ฐ ๋์ด์ผ ํฉ๋๋ค. ๊ทธ๋ฆฌ๊ณ ์ดํ
์
๋ง์คํฌ๋ ๊ผญ `generate` ํจ์์ ์ ๋ฌ๋์ด์ผ ํฉ๋๋ค!
```python
>>> # The tokenizer initialized above has right-padding active by default: the 1st sequence,
>>> # which is shorter, has padding on the right side. Generation fails.
>>> model_inputs = tokenizer(
... ["1, 2, 3", "A, B, C, D, E"], padding=True, return_tensors="pt"
... ).to("cuda")
>>> generated_ids = model.generate(**model_inputs)
>>> tokenizer.batch_decode(generated_ids[0], skip_special_tokens=True)[0]
''
>>> # With left-padding, it works as expected!
>>> tokenizer = AutoTokenizer.from_pretrained("openlm-research/open_llama_7b", padding_side="left")
>>> tokenizer.pad_token = tokenizer.eos_token # Llama has no pad token by default
>>> model_inputs = tokenizer(
... ["1, 2, 3", "A, B, C, D, E"], padding=True, return_tensors="pt"
... ).to("cuda")
>>> generated_ids = model.generate(**model_inputs)
>>> tokenizer.batch_decode(generated_ids, skip_special_tokens=True)[0]
'1, 2, 3, 4, 5, 6,'
```
<!-- TODO: when the prompting guide is ready, mention the importance of setting the right prompt in this section -->
## ์ถ๊ฐ ์๋ฃ [[further-resources]]
์๊ธฐํ๊ท ์์ฑ ํ๋ก์ธ์ค๋ ์๋์ ์ผ๋ก ๋จ์ํ ํธ์ด์ง๋ง, LLM์ ์ต๋ํ ํ์ฉํ๋ ค๋ฉด ์ฌ๋ฌ ๊ฐ์ง ์์๋ฅผ ๊ณ ๋ คํด์ผ ํ๋ฏ๋ก ์ฝ์ง ์์ ์ ์์ต๋๋ค. LLM์ ๋ํ ๋ ๊น์ ์ดํด์ ํ์ฉ์ ์ํ ๋ค์ ๋จ๊ณ๋ ์๋์ ๊ฐ์ต๋๋ค:
<!-- TODO: complete with new guides -->
### ๊ณ ๊ธ ์์ฑ ์ฌ์ฉ [[advanced-generate-usage]]
1. [๊ฐ์ด๋](generation_strategies)๋ ๋ค์ํ ์์ฑ ๋ฐฉ๋ฒ์ ์ ์ดํ๋ ๋ฐฉ๋ฒ, ์์ฑ ์ค์ ํ์ผ์ ์ค์ ํ๋ ๋ฐฉ๋ฒ, ์ถ๋ ฅ์ ์คํธ๋ฆฌ๋ฐํ๋ ๋ฐฉ๋ฒ์ ๋ํด ์ค๋ช
ํฉ๋๋ค.
2. [`~generation.GenerationConfig`]์ [`~generation.GenerationMixin.generate`], [generate-related classes](internal/generation_utils)๋ฅผ ์ฐธ์กฐํด๋ณด์ธ์.
### LLM ๋ฆฌ๋๋ณด๋ [[llm-leaderboards]]
1. [Open LLM Leaderboard](https://huggingface.co/spaces/HuggingFaceH4/open_llm_leaderboard)๋ ์คํ ์์ค ๋ชจ๋ธ์ ํ์ง์ ์ค์ ์ ๋ก๋๋ค.
2. [Open LLM-Perf Leaderboard](https://huggingface.co/spaces/optimum/llm-perf-leaderboard)๋ LLM ์ฒ๋ฆฌ๋์ ์ค์ ์ ๋ก๋๋ค.
### ์ง์ฐ ์๊ฐ ๋ฐ ์ฒ๋ฆฌ๋ [[latency-and-throughput]]
1. ๋ฉ๋ชจ๋ฆฌ ์๊ตฌ ์ฌํญ์ ์ค์ด๋ ค๋ฉด, ๋์ ์์ํ์ ๋ํ [๊ฐ์ด๋](main_classes/quantization)๋ฅผ ์ฐธ์กฐํ์ธ์.
### ๊ด๋ จ ๋ผ์ด๋ธ๋ฌ๋ฆฌ [[related-libraries]]
1. [`text-generation-inference`](https://github.com/huggingface/text-generation-inference)๋ LLM์ ์ํ ์ค์ ์ด์ ํ๊ฒฝ์ ์ ํฉํ ์๋ฒ์
๋๋ค.
2. [`optimum`](https://github.com/huggingface/optimum)์ ํน์ ํ๋์จ์ด ์ฅ์น์์ LLM์ ์ต์ ํํ๊ธฐ ์ํด ๐ค Transformers๋ฅผ ํ์ฅํ ๊ฒ์
๋๋ค.
| 0 |
mavonic_private_repos/transformers/docs/source | mavonic_private_repos/transformers/docs/source/ko/perf_train_tpu_tf.md | <!--Copyright 2023 The HuggingFace Team. All rights reserved.
Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
the License. You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
โ ๏ธ Note that this file is in Markdown but contain specific syntax for our doc-builder (similar to MDX) that may not be
rendered properly in your Markdown viewer.
-->
# TensorFlow๋ก TPU์์ ํ๋ จํ๊ธฐ[[training-on-tpu-with-tensorflow]]
<Tip>
์์ธํ ์ค๋ช
์ด ํ์ํ์ง ์๊ณ ๋ฐ๋ก TPU ์ํ ์ฝ๋๋ฅผ ์์ํ๊ณ ์ถ๋ค๋ฉด [์ฐ๋ฆฌ์ TPU ์์ ๋
ธํธ๋ถ!](https://colab.research.google.com/github/huggingface/notebooks/blob/main/examples/tpu_training-tf.ipynb)์ ํ์ธํ์ธ์.
</Tip>
### TPU๊ฐ ๋ฌด์์ธ๊ฐ์?[[what-is-a-tpu]]
TPU๋ **ํ
์ ์ฒ๋ฆฌ ์ฅ์น**์
๋๋ค. Google์์ ์ค๊ณํ ํ๋์จ์ด๋ก, GPU์ฒ๋ผ ์ ๊ฒฝ๋ง ๋ด์์ ํ
์ ์ฐ์ฐ์ ๋์ฑ ๋น ๋ฅด๊ฒ ์ฒ๋ฆฌํ๊ธฐ ์ํด ์ฌ์ฉ๋ฉ๋๋ค. ๋คํธ์ํฌ ํ๋ จ๊ณผ ์ถ๋ก ๋ชจ๋์ ์ฌ์ฉํ ์ ์์ต๋๋ค. ์ผ๋ฐ์ ์ผ๋ก Google์ ํด๋ผ์ฐ๋ ์๋น์ค๋ฅผ ํตํด ์ด์ฉํ ์ ์์ง๋ง, Google Colab๊ณผ Kaggle Kernel์ ํตํด ์๊ท๋ชจ TPU๋ฅผ ๋ฌด๋ฃ๋ก ์ง์ ์ด์ฉํ ์๋ ์์ต๋๋ค.
[๐ค Transformers์ ๋ชจ๋ Tensorflow ๋ชจ๋ธ์ Keras ๋ชจ๋ธ](https://huggingface.co/blog/tensorflow-philosophy)์ด๊ธฐ ๋๋ฌธ์, ์ด ๋ฌธ์์์ ๋ค๋ฃจ๋ ๋๋ถ๋ถ์ ๋ฉ์๋๋ ๋์ฒด๋ก ๋ชจ๋ Keras ๋ชจ๋ธ์ ์ํ TPU ํ๋ จ์ ์ ์ฉํ ์ ์์ต๋๋ค! ํ์ง๋ง Transformer์ ๋ฐ์ดํฐ ์ธํธ์ HuggingFace ์ํ๊ณ(hug-o-system?)์ ํนํ๋ ๋ช ๊ฐ์ง ์ฌํญ์ด ์์ผ๋ฉฐ, ํด๋น ์ฌํญ์ ๋ํด ์ค๋ช
ํ ๋ ๋ฐ๋์ ์ธ๊ธํ๋๋ก ํ๊ฒ ์ต๋๋ค.
### ์ด๋ค ์ข
๋ฅ์ TPU๊ฐ ์๋์?[[what-kinds-of-tpu-are-available]]
์ ๊ท ์ฌ์ฉ์๋ TPU์ ๋ฒ์์ ๋ค์ํ ์ด์ฉ ๋ฐฉ๋ฒ์ ๋ํด ๋งค์ฐ ํผ๋์ค๋ฌ์ํ๋ ๊ฒฝ์ฐ๊ฐ ๋ง์ต๋๋ค. **TPU ๋
ธ๋**์ **TPU VM**์ ์ฐจ์ด์ ์ ๊ฐ์ฅ ๋จผ์ ์ดํดํด์ผ ํ ํต์ฌ์ ์ธ ๊ตฌ๋ถ ์ฌํญ์
๋๋ค.
**TPU ๋
ธ๋**๋ฅผ ์ฌ์ฉํ๋ค๋ฉด, ์ค์ ๋ก๋ ์๊ฒฉ TPU๋ฅผ ๊ฐ์ ์ ์ผ๋ก ์ด์ฉํ๋ ๊ฒ์
๋๋ค. ๋คํธ์ํฌ์ ๋ฐ์ดํฐ ํ์ดํ๋ผ์ธ์ ์ด๊ธฐํํ ๋ค์, ์ด๋ฅผ ์๊ฒฉ ๋
ธ๋๋ก ์ ๋ฌํ ๋ณ๋์ VM์ด ํ์ํฉ๋๋ค. Google Colab์์ TPU๋ฅผ ์ฌ์ฉํ๋ ๊ฒฝ์ฐ, **TPU ๋
ธ๋** ๋ฐฉ์์ผ๋ก ์ด์ฉํ๊ฒ ๋ฉ๋๋ค.
TPU ๋
ธ๋๋ฅผ ์ฌ์ฉํ๋ ๊ฒ์ ์ด๋ฅผ ์ฌ์ฉํ์ง ์๋ ์ฌ์ฉ์์๊ฒ ์๊ธฐ์น ์์ ํ์์ด ๋ฐ์ํ๊ธฐ๋ ํฉ๋๋ค! ํนํ, TPU๋ ํ์ด์ฌ ์ฝ๋๋ฅผ ์คํํ๋ ๊ธฐ๊ธฐ(machine)์ ๋ฌผ๋ฆฌ์ ์ผ๋ก ๋ค๋ฅธ ์์คํ
์ ์๊ธฐ ๋๋ฌธ์ ๋ก์ปฌ ๊ธฐ๊ธฐ์ ๋ฐ์ดํฐ๋ฅผ ์ ์ฅํ ์ ์์ต๋๋ค. ์ฆ, ์ปดํจํฐ์ ๋ด๋ถ ์ ์ฅ์์์ ๊ฐ์ ธ์ค๋ ๋ฐ์ดํฐ ํ์ดํ๋ผ์ธ์ ์ ๋ ์๋ํ์ง ์์ต๋๋ค! ๋ก์ปฌ ๊ธฐ๊ธฐ์ ๋ฐ์ดํฐ๋ฅผ ์ ์ฅํ๋ ๋์ ์, ๋ฐ์ดํฐ ํ์ดํ๋ผ์ธ์ด ์๊ฒฉ TPU ๋
ธ๋์์ ์คํ ์ค์ผ ๋์๋ ๋ฐ์ดํฐ ํ์ดํ๋ผ์ธ์ด ๊ณ์ ์ด์ฉํ ์ ์๋ Google Cloud Storage์ ๋ฐ์ดํฐ๋ฅผ ์ ์ฅํด์ผ ํฉ๋๋ค.
<Tip>
๋ฉ๋ชจ๋ฆฌ์ ์๋ ๋ชจ๋ ๋ฐ์ดํฐ๋ฅผ `np.ndarray` ๋๋ `tf.Tensor`๋ก ๋ง์ถ ์ ์๋ค๋ฉด, Google Cloud Storage์ ์
๋ก๋ํ ํ์ ์์ด, Colab ๋๋ TPU ๋
ธ๋๋ฅผ ์ฌ์ฉํด์ ํด๋น ๋ฐ์ดํฐ์ `fit()` ํ ์ ์์ต๋๋ค.
</Tip>
<Tip>
**๐คํน์ํ Hugging Face ํ๐ค:** TF ์ฝ๋ ์์ ์์ ๋ณผ ์ ์๋ `Dataset.to_tf_dataset()` ๋ฉ์๋์ ๊ทธ ์์ ๋ํผ(wrapper)์ธ `model.prepare_tf_dataset()`๋ ๋ชจ๋ TPU ๋
ธ๋์์ ์๋ํ์ง ์์ต๋๋ค. ๊ทธ ์ด์ ๋ `tf.data.Dataset`์ ์์ฑํ๋๋ผ๋ โ์์ํโ `tf.data` ํ์ดํ๋ผ์ธ์ด ์๋๋ฉฐ `tf.numpy_function` ๋๋ `Dataset.from_generator()`๋ฅผ ์ฌ์ฉํ์ฌ ๊ธฐ๋ณธ HuggingFace `Dataset`์์ ๋ฐ์ดํฐ๋ฅผ ์ ์กํ๊ธฐ ๋๋ฌธ์
๋๋ค. ์ด HuggingFace `Dataset`๋ ๋ก์ปฌ ๋์คํฌ์ ์๋ ๋ฐ์ดํฐ๋ก ์ง์๋๋ฉฐ ์๊ฒฉ TPU ๋
ธ๋๊ฐ ์ฝ์ ์ ์์ต๋๋ค.
</Tip>
TPU๋ฅผ ์ด์ฉํ๋ ๋ ๋ฒ์งธ ๋ฐฉ๋ฒ์ **TPU VM**์ ์ฌ์ฉํ๋ ๊ฒ์
๋๋ค. TPU VM์ ์ฌ์ฉํ ๋, GPU VM์์ ํ๋ จํ๋ ๊ฒ๊ณผ ๊ฐ์ด TPU๊ฐ ์ฅ์ฐฉ๋ ๊ธฐ๊ธฐ์ ์ง์ ์ฐ๊ฒฐํฉ๋๋ค. ํนํ ๋ฐ์ดํฐ ํ์ดํ๋ผ์ธ๊ณผ ๊ด๋ จํ์ฌ, TPU VM์ ๋์ฒด๋ก ์์
ํ๊ธฐ ๋ ์ฝ์ต๋๋ค. ์์ ๋ชจ๋ ๊ฒฝ๊ณ ๋ TPU VM์๋ ํด๋น๋์ง ์์ต๋๋ค!
์ด ๋ฌธ์๋ ์๊ฒฌ์ด ํฌํจ๋ ๋ฌธ์์ด๋ฉฐ, ์ ํฌ์ ์๊ฒฌ์ด ์ฌ๊ธฐ์ ์์ต๋๋ค: **๊ฐ๋ฅํ๋ฉด TPU ๋
ธ๋๋ฅผ ์ฌ์ฉํ์ง ๋ง์ธ์.** TPU ๋
ธ๋๋ TPU VM๋ณด๋ค ๋ ๋ณต์กํ๊ณ ๋๋ฒ๊น
ํ๊ธฐ๊ฐ ๋ ์ด๋ ต์ต๋๋ค. ๋ํ ํฅํ์๋ ์ง์๋์ง ์์ ๊ฐ๋ฅ์ฑ์ด ๋์ต๋๋ค. Google์ ์ต์ TPU์ธ TPUv4๋ TPU VM์ผ๋ก๋ง ์ด์ฉํ ์ ์์ผ๋ฏ๋ก, TPU ๋
ธ๋๋ ์ ์ ๋ "๊ตฌ์" ์ด์ฉ ๋ฐฉ๋ฒ์ด ๋ ๊ฒ์ผ๋ก ์ ๋ง๋ฉ๋๋ค. ๊ทธ๋ฌ๋ TPU ๋
ธ๋๋ฅผ ์ฌ์ฉํ๋ Colab๊ณผ Kaggle Kernel์์๋ง ๋ฌด๋ฃ TPU ์ด์ฉ์ด ๊ฐ๋ฅํ ๊ฒ์ผ๋ก ํ์ธ๋์ด, ํ์ํ ๊ฒฝ์ฐ ์ด๋ฅผ ๋ค๋ฃจ๋ ๋ฐฉ๋ฒ์ ์ค๋ช
ํด ๋๋ฆฌ๊ฒ ์ต๋๋ค! ์ด์ ๋ํ ์์ธํ ์ค๋ช
์ด ๋ด๊ธด ์ฝ๋ ์ํ์ [TPU ์์ ๋
ธํธ๋ถ](https://colab.research.google.com/github/huggingface/notebooks/blob/main/examples/tpu_training-tf.ipynb)์์ ํ์ธํ์๊ธฐ ๋ฐ๋๋๋ค.
### ์ด๋ค ํฌ๊ธฐ์ TPU๋ฅผ ์ฌ์ฉํ ์ ์๋์?[[what-sizes-of-tpu-are-available]]
๋จ์ผ TPU(v2-8/v3-8/v4-8)๋ 8๊ฐ์ ๋ณต์ ๋ณธ(replicas)์ ์คํํฉ๋๋ค. TPU๋ ์๋ฐฑ ๋๋ ์์ฒ ๊ฐ์ ๋ณต์ ๋ณธ์ ๋์์ ์คํํ ์ ์๋ **pod**๋ก ์กด์ฌํฉ๋๋ค. ๋จ์ผ TPU๋ฅผ ํ๋ ์ด์ ์ฌ์ฉํ์ง๋ง ์ ์ฒด Pod๋ณด๋ค ์ ๊ฒ ์ฌ์ฉํ๋ ๊ฒฝ์ฐ(์๋ฅผ ๋ค๋ฉด, v3-32), TPU ๊ตฌ์ฑ์ **pod ์ฌ๋ผ์ด์ค**๋ผ๊ณ ํฉ๋๋ค.
Colab์ ํตํด ๋ฌด๋ฃ TPU์ ์ด์ฉํ๋ ๊ฒฝ์ฐ, ๊ธฐ๋ณธ์ ์ผ๋ก ๋จ์ผ v2-8 TPU๋ฅผ ์ ๊ณต๋ฐ์ต๋๋ค.
### XLA์ ๋ํด ๋ค์ด๋ณธ ์ ์ด ์์ต๋๋ค. XLA๋ ๋ฌด์์ด๊ณ TPU์ ์ด๋ค ๊ด๋ จ์ด ์๋์?[[i-keep-hearing-about-this-xla-thing-whats-xla-and-how-does-it-relate-to-tpus]]
XLA๋ ์ต์ ํ ์ปดํ์ผ๋ฌ๋ก, TensorFlow์ JAX์์ ๋ชจ๋ ์ฌ์ฉ๋ฉ๋๋ค. JAX์์๋ ์ ์ผํ ์ปดํ์ผ๋ฌ์ด์ง๋ง, TensorFlow์์๋ ์ ํ ์ฌํญ์
๋๋ค(ํ์ง๋ง TPU์์๋ ํ์์
๋๋ค!). Keras ๋ชจ๋ธ์ ํ๋ จํ ๋ ์ด๋ฅผ ํ์ฑํํ๋ ๊ฐ์ฅ ์ฌ์ด ๋ฐฉ๋ฒ์ `jit_compile=True` ์ธ์๋ฅผ `model.compile()`์ ์ ๋ฌํ๋ ๊ฒ์
๋๋ค. ์ค๋ฅ๊ฐ ์๊ณ ์ฑ๋ฅ์ด ์ํธํ๋ค๋ฉด, TPU๋ก ์ ํํ ์ค๋น๊ฐ ๋์๋ค๋ ์ข์ ์ ํธ์
๋๋ค!
TPU์์ ๋๋ฒ๊น
ํ๋ ๊ฒ์ ๋๊ฐ CPU/GPU๋ณด๋ค ์กฐ๊ธ ๋ ์ด๋ ต๊ธฐ ๋๋ฌธ์, TPU์์ ์๋ํ๊ธฐ ์ ์ ๋จผ์ XLA๋ก CPU/GPU์์ ์ฝ๋๋ฅผ ์คํํ๋ ๊ฒ์ ๊ถ์ฅํฉ๋๋ค. ๋ฌผ๋ก ์ค๋ ํ์ตํ ํ์๋ ์์ต๋๋ค. ์ฆ, ๋ชจ๋ธ๊ณผ ๋ฐ์ดํฐ ํ์ดํ๋ผ์ธ์ด ์์๋๋ก ์๋ํ๋์ง ํ์ธํ๊ธฐ ์ํด ๋ช ๋จ๊ณ๋ง ๊ฑฐ์น๋ฉด ๋ฉ๋๋ค.
<Tip>
XLA๋ก ์ปดํ์ผ๋ ์ฝ๋๋ ๋์ฒด๋ก ๋ ๋น ๋ฆ
๋๋ค. ๋ฐ๋ผ์ TPU์์ ์คํํ ๊ณํ์ด ์๋๋ผ๋, `jit_compile=True`๋ฅผ ์ถ๊ฐํ๋ฉด ์ฑ๋ฅ์ด ํฅ์๋ ์ ์์ต๋๋ค. ํ์ง๋ง XLA ํธํ์ฑ์ ๋ํ ์๋ ์ฃผ์ ์ฌํญ์ ๋ฐ๋์ ํ์ธํ์ธ์!
</Tip>
<Tip warning={true}>
**๋ผ์ํ ๊ฒฝํ์์ ์ป์ ํ:** `jit_compile=True`๋ฅผ ์ฌ์ฉํ๋ฉด ์๋๋ฅผ ๋์ด๊ณ CPU/GPU ์ฝ๋๊ฐ XLA์ ํธํ๋๋์ง ๊ฒ์ฆํ ์ ์๋ ์ข์ ๋ฐฉ๋ฒ์ด์ง๋ง, ์ค์ TPU์์ ํ๋ จํ ๋ ๊ทธ๋๋ก ๋จ๊ฒจ๋๋ฉด ๋ง์ ๋ฌธ์ ๋ฅผ ์ด๋ํ ์ ์์ต๋๋ค. XLA ์ปดํ์ผ์ TPU์์ ์์์ ์ผ๋ก ์ด๋ค์ง๋ฏ๋ก, ์ค์ TPU์์ ์ฝ๋๋ฅผ ์คํํ๊ธฐ ์ ์ ํด๋น ์ค์ ์ ๊ฑฐํ๋ ๊ฒ์ ์์ง ๋ง์ธ์!
</Tip>
### ์ XLA ๋ชจ๋ธ๊ณผ ํธํํ๋ ค๋ฉด ์ด๋ป๊ฒ ํด์ผ ํ๋์?[[how-do-i-make-my-model-xla-compatible]]
๋๋ถ๋ถ์ ๊ฒฝ์ฐ, ์ฌ๋ฌ๋ถ์ ์ฝ๋๋ ์ด๋ฏธ XLA์ ํธํ๋ ๊ฒ์
๋๋ค! ๊ทธ๋ฌ๋ ํ์ค TensorFlow์์ ์๋ํ์ง๋ง, XLA์์๋ ์๋ํ์ง ์๋ ๋ช ๊ฐ์ง ์ฌํญ์ด ์์ต๋๋ค. ์ด๋ฅผ ์๋ ์ธ ๊ฐ์ง ํต์ฌ ๊ท์น์ผ๋ก ๊ฐ์ถ๋ ธ์ต๋๋ค:
<Tip>
**ํน์ํ HuggingFace ํ๐ค:** ์ ํฌ๋ TensorFlow ๋ชจ๋ธ๊ณผ ์์ค ํจ์๋ฅผ XLA์ ํธํ๋๋๋ก ์ฌ์์ฑํ๋ ๋ฐ ๋ง์ ๋
ธ๋ ฅ์ ๊ธฐ์ธ์์ต๋๋ค. ์ ํฌ์ ๋ชจ๋ธ๊ณผ ์์ค ํจ์๋ ๋๊ฐ ๊ธฐ๋ณธ์ ์ผ๋ก ๊ท์น #1๊ณผ #2๋ฅผ ๋ฐ๋ฅด๋ฏ๋ก `transformers` ๋ชจ๋ธ์ ์ฌ์ฉํ๋ ๊ฒฝ์ฐ, ์ด๋ฅผ ๊ฑด๋๋ธ ์ ์์ต๋๋ค. ํ์ง๋ง ์์ฒด ๋ชจ๋ธ๊ณผ ์์ค ํจ์๋ฅผ ์์ฑํ ๋๋ ์ด๋ฌํ ๊ท์น์ ์์ง ๋ง์ธ์!
</Tip>
#### XLA ๊ท์น #1: ์ฝ๋์์ โ๋ฐ์ดํฐ ์ข
์ ์กฐ๊ฑด๋ฌธโ์ ์ฌ์ฉํ ์ ์์ต๋๋ค[[xla-rule-1-your-code-cannot-have-datadependent-conditionals]]
์ด๋ค `if`๋ฌธ๋ `tf.Tensor` ๋ด๋ถ์ ๊ฐ์ ์ข
์๋ ์ ์๋ค๋ ๊ฒ์ ์๋ฏธํฉ๋๋ค. ์๋ฅผ ๋ค์ด, ์ด ์ฝ๋ ๋ธ๋ก์ XLA๋ก ์ปดํ์ผํ ์ ์์ต๋๋ค!
```python
if tf.reduce_sum(tensor) > 10:
tensor = tensor / 2.0
```
์ฒ์์๋ ๋งค์ฐ ์ ํ์ ์ผ๋ก ๋ณด์ผ ์ ์์ง๋ง, ๋๋ถ๋ถ์ ์ ๊ฒฝ๋ง ์ฝ๋์์๋ ์ด๋ฅผ ์ํํ ํ์๊ฐ ์์ต๋๋ค. `tf.cond`๋ฅผ ์ฌ์ฉํ๊ฑฐ๋([์ฌ๊ธฐ](https://www.tensorflow.org/api_docs/python/tf/cond) ๋ฌธ์๋ฅผ ์ฐธ์กฐ), ๋ค์๊ณผ ๊ฐ์ด ์กฐ๊ฑด๋ฌธ์ ์ ๊ฑฐํ๊ณ ๋์ ์งํ ๋ณ์๋ฅผ ์ฌ์ฉํ๋ ์๋ฆฌํ ์ํ ํธ๋ฆญ์ ์ฐพ์๋ด์ด ์ด ์ ํ์ ์ฐํํ ์ ์์ต๋๋ค:
```python
sum_over_10 = tf.cast(tf.reduce_sum(tensor) > 10, tf.float32)
tensor = tensor / (1.0 + sum_over_10)
```
์ด ์ฝ๋๋ ์์ ์ฝ๋์ ์ ํํ ๋์ผํ ํจ๊ณผ๋ฅผ ๊ตฌํํ์ง๋ง, ์กฐ๊ฑด๋ฌธ์ ์ ๊ฑฐํ์ฌ ๋ฌธ์ ์์ด XLA๋ก ์ปดํ์ผ๋๋๋ก ํฉ๋๋ค!
#### XLA ๊ท์น #2: ์ฝ๋์์ "๋ฐ์ดํฐ ์ข
์ ํฌ๊ธฐ"๋ฅผ ๊ฐ์ง ์ ์์ต๋๋ค[[xla-rule-2-your-code-cannot-have-datadependent-shapes]]
์ฝ๋์์ ๋ชจ๋ `tf.Tensor` ๊ฐ์ฒด์ ํฌ๊ธฐ๊ฐ ํด๋น ๊ฐ์ ์ข
์๋ ์ ์๋ค๋ ๊ฒ์ ์๋ฏธํฉ๋๋ค. ์๋ฅผ ๋ค์ด, `tf.unique` ํจ์๋ ์
๋ ฅ์์ ๊ฐ ๊ณ ์ ๊ฐ์ ์ธ์คํด์ค ํ๋๋ฅผ ํฌํจํ๋ `tensor`๋ฅผ ๋ฐํํ๊ธฐ ๋๋ฌธ์ XLA๋ก ์ปดํ์ผํ ์ ์์ต๋๋ค. ์ด ์ถ๋ ฅ์ ํฌ๊ธฐ๋ ์
๋ ฅ `Tensor`๊ฐ ์ผ๋ง๋ ๋ฐ๋ณต์ ์ธ์ง์ ๋ฐ๋ผ ๋ถ๋ช
ํ ๋ฌ๋ผ์ง ๊ฒ์ด๋ฏ๋ก, XLA๋ ์ด๋ฅผ ์ฒ๋ฆฌํ์ง ๋ชปํฉ๋๋ค!
์ผ๋ฐ์ ์ผ๋ก, ๋๋ถ๋ถ์ ์ ๊ฒฝ๋ง ์ฝ๋๋ ๊ธฐ๋ณธ๊ฐ์ผ๋ก ๊ท์น 2๋ฅผ ๋ฐ๋ฆ
๋๋ค. ๊ทธ๋ฌ๋ ๋ฌธ์ ๊ฐ ๋๋ ๋ช ๊ฐ์ง ๋ํ์ ์ธ ์ฌ๋ก๊ฐ ์์ต๋๋ค. ๊ฐ์ฅ ํํ ์ฌ๋ก ์ค ํ๋๋ **๋ ์ด๋ธ ๋ง์คํน**์ ์ฌ์ฉํ์ฌ ์์ค(loss)์ ๊ณ์ฐํ ๋, ํด๋น ์์น๋ฅผ ๋ฌด์ํ๋๋ก ๋ํ๋ด๊ธฐ ์ํด ๋ ์ด๋ธ์ ์์ ๊ฐ์ผ๋ก ์ค์ ํ๋ ๊ฒฝ์ฐ์
๋๋ค. ๋ ์ด๋ธ ๋ง์คํน์ ์ง์ํ๋ NumPy๋ PyTorch ์์ค ํจ์๋ฅผ ๋ณด๋ฉด [๋ถ ์ธ๋ฑ์ฑ](https://numpy.org/doc/stable/user/basics.indexing.html#boolean-array-indexing)์ ์ฌ์ฉํ๋ ๋ค์๊ณผ ๊ฐ์ ์ฝ๋๋ฅผ ์์ฃผ ์ ํ ์ ์์ต๋๋ค:
```python
label_mask = labels >= 0
masked_outputs = outputs[label_mask]
masked_labels = labels[label_mask]
loss = compute_loss(masked_outputs, masked_labels)
mean_loss = torch.mean(loss)
```
์ด ์ฝ๋๋ NumPy๋ PyTorch์์๋ ๋ฌธ์ ์์ด ์๋ํ์ง๋ง, XLA์์๋ ์์๋ฉ๋๋ค! ์ ๊ทธ๋ด๊น์? ์ผ๋ง๋ ๋ง์ ์์น๊ฐ ๋ง์คํน๋๋์ง์ ๋ฐ๋ผ `masked_outputs`์ `masked_labels`์ ํฌ๊ธฐ๊ฐ ๋ฌ๋ผ์ ธ์, **๋ฐ์ดํฐ ์ข
์ ํฌ๊ธฐ**๊ฐ ๋๊ธฐ ๋๋ฌธ์
๋๋ค. ๊ทธ๋ฌ๋ ๊ท์น #1๊ณผ ๋ง์ฐฌ๊ฐ์ง๋ก, ์ด ์ฝ๋๋ฅผ ๋ค์ ์์ฑํ๋ฉด ๋ฐ์ดํฐ ์ข
์์ ๋ชจ์ ํฌ๊ธฐ๊ฐ ์ ํํ ๋์ผํ ์ถ๋ ฅ์ ์ฐ์ถํ ์ ์์ต๋๋ค.
```python
label_mask = tf.cast(labels >= 0, tf.float32)
loss = compute_loss(outputs, labels)
loss = loss * label_mask # Set negative label positions to 0
mean_loss = tf.reduce_sum(loss) / tf.reduce_sum(label_mask)
```
์ฌ๊ธฐ์, ๋ชจ๋ ์์น์ ๋ํ ์์ค์ ๊ณ์ฐํ์ง๋ง, ํ๊ท ์ ๊ณ์ฐํ ๋ ๋ถ์์ ๋ถ๋ชจ ๋ชจ๋์์ ๋ง์คํฌ๋ ์์น๋ฅผ 0์ผ๋ก ์ฒ๋ฆฌํฉ๋๋ค. ์ด๋ ๋ฐ์ดํฐ ์ข
์ ํฌ๊ธฐ๋ฅผ ๋ฐฉ์งํ๊ณ XLA ํธํ์ฑ์ ์ ์งํ๋ฉด์ ์ฒซ ๋ฒ์งธ ๋ธ๋ก๊ณผ ์ ํํ ๋์ผํ ๊ฒฐ๊ณผ๋ฅผ ์ฐ์ถํฉ๋๋ค. ๊ท์น #1์์์ ๋์ผํ ํธ๋ฆญ์ ์ฌ์ฉํ์ฌ `tf.bool`์ `tf.float32`๋ก ๋ณํํ๊ณ ์ด๋ฅผ ์งํ ๋ณ์๋ก ์ฌ์ฉํฉ๋๋ค. ํด๋น ํธ๋ฆญ์ ๋งค์ฐ ์ ์ฉํ๋ฉฐ, ์์ฒด ์ฝ๋๋ฅผ XLA๋ก ๋ณํํด์ผ ํ ๊ฒฝ์ฐ ๊ธฐ์ตํด ๋์ธ์!
#### XLA ๊ท์น #3: XLA๋ ๊ฐ๊ธฐ ๋ค๋ฅธ ์
๋ ฅ ํฌ๊ธฐ๊ฐ ๋ํ๋ ๋๋ง๋ค ๋ชจ๋ธ์ ๋ค์ ์ปดํ์ผํด์ผ ํฉ๋๋ค[[xla-rule-3-xla-will-need-to-recompile-your-model-for-every-different-input-shape-it-sees]]
์ด๊ฒ์ ๊ฐ์ฅ ํฐ ๋ฌธ์ ์
๋๋ค. ์
๋ ฅ ํฌ๊ธฐ๊ฐ ๋งค์ฐ ๊ฐ๋ณ์ ์ธ ๊ฒฝ์ฐ, XLA๋ ๋ชจ๋ธ์ ๋ฐ๋ณตํด์ ๋ค์ ์ปดํ์ผํด์ผ ํ๋ฏ๋ก ์ฑ๋ฅ์ ํฐ ๋ฌธ์ ๊ฐ ๋ฐ์ํ ์ ์์ต๋๋ค. ์ด ๋ฌธ์ ๋ ํ ํฐํ ํ ์
๋ ฅ ํ
์คํธ์ ๊ธธ์ด๊ฐ ๊ฐ๋ณ์ ์ธ NLP ๋ชจ๋ธ์์ ์ฃผ๋ก ๋ฐ์ํฉ๋๋ค. ๋ค๋ฅธ ๋ชจ๋ฌ๋ฆฌํฐ์์๋ ์ ์ ํฌ๊ธฐ๊ฐ ๋ ํํ๋ฉฐ, ํด๋น ๊ท์น์ด ํจ์ฌ ๋ ๋ฌธ์ ์ ๋ฉ๋๋ค.
๊ท์น #3์ ์ด๋ป๊ฒ ์ฐํํ ์ ์์๊น์? ํต์ฌ์ **ํจ๋ฉ**์
๋๋ค. ๋ชจ๋ ์
๋ ฅ์ ๋์ผํ ๊ธธ์ด๋ก ํจ๋ฉํ ๋ค์, `attention_mask`๋ฅผ ์ฌ์ฉํ๋ฉด ์ด๋ค XLA ๋ฌธ์ ๋ ์์ด ๊ฐ๋ณ ํฌ๊ธฐ์์ ๊ฐ์ ธ์จ ๊ฒ๊ณผ ๋์ผํ ๊ฒฐ๊ณผ๋ฅผ ๊ฐ์ ธ์ฌ ์ ์์ต๋๋ค. ๊ทธ๋ฌ๋ ๊ณผ๋ํ ํจ๋ฉ์ ์ฌ๊ฐํ ์๋ ์ ํ๋ฅผ ์ผ๊ธฐํ ์๋ ์์ต๋๋ค. ๋ชจ๋ ์ํ์ ์ ์ฒด ๋ฐ์ดํฐ ์ธํธ์ ์ต๋ ๊ธธ์ด๋ก ํจ๋ฉํ๋ฉด, ๋ฌดํํ ํจ๋ฉ ํ ํฐ์ผ๋ก ๊ตฌ์ฑ๋ ๋ฐฐ์น๊ฐ ์์ฑ๋์ด ๋ง์ ์ฐ์ฐ๊ณผ ๋ฉ๋ชจ๋ฆฌ๊ฐ ๋ญ๋น๋ ์ ์์ต๋๋ค!
์ด ๋ฌธ์ ์ ๋ํ ์๋ฒฝํ ํด๊ฒฐ์ฑ
์ ์์ต๋๋ค. ํ์ง๋ง, ๋ช ๊ฐ์ง ํธ๋ฆญ์ ์๋ํด๋ณผ ์ ์์ต๋๋ค. ํ ๊ฐ์ง ์ ์ฉํ ํธ๋ฆญ์ **์ํ ๋ฐฐ์น๋ฅผ 32 ๋๋ 64 ํ ํฐ๊ณผ ๊ฐ์ ์ซ์์ ๋ฐฐ์๊น์ง ํจ๋ฉํ๋ ๊ฒ์
๋๋ค.** ์ด๋ ํ ํฐ ์๊ฐ ์ํญ ์ฆ๊ฐํ์ง๋ง, ๋ชจ๋ ์
๋ ฅ ํฌ๊ธฐ๊ฐ 32 ๋๋ 64์ ๋ฐฐ์์ฌ์ผ ํ๊ธฐ ๋๋ฌธ์ ๊ณ ์ ํ ์
๋ ฅ ํฌ๊ธฐ์ ์๊ฐ ๋ํญ ์ค์ด๋ญ๋๋ค. ๊ณ ์ ํ ์
๋ ฅ ํฌ๊ธฐ๊ฐ ์ ๋ค๋ ๊ฒ์ XLA ์ปดํ์ผ ํ์๊ฐ ์ ์ด์ง๋ค๋ ๊ฒ์ ์๋ฏธํฉ๋๋ค!
<Tip>
**๐คํน์ํ HuggingFace ํ๐ค:** ํ ํฌ๋์ด์ ์ ๋ฐ์ดํฐ ์ฝ๋ ์ดํฐ์ ๋์์ด ๋ ์ ์๋ ๋ฉ์๋๊ฐ ์์ต๋๋ค. ํ ํฌ๋์ด์ ๋ฅผ ๋ถ๋ฌ์ฌ ๋ `padding="max_length"` ๋๋ `padding="longest"`๋ฅผ ์ฌ์ฉํ์ฌ ํจ๋ฉ๋ ๋ฐ์ดํฐ๋ฅผ ์ถ๋ ฅํ๋๋ก ํ ์ ์์ต๋๋ค. ํ ํฌ๋์ด์ ์ ๋ฐ์ดํฐ ์ฝ๋ ์ดํฐ๋ ๋ํ๋๋ ๊ณ ์ ํ ์
๋ ฅ ํฌ๊ธฐ์ ์๋ฅผ ์ค์ด๊ธฐ ์ํด ์ฌ์ฉํ ์ ์๋ `pad_to_multiple_of` ์ธ์๋ ์์ต๋๋ค!
</Tip>
### ์ค์ TPU๋ก ๋ชจ๋ธ์ ํ๋ จํ๋ ค๋ฉด ์ด๋ป๊ฒ ํด์ผ ํ๋์?[[how-do-i-actually-train-my-model-on-tpu]]
ํ๋ จ์ด XLA์ ํธํ๋๊ณ (TPU ๋
ธ๋/Colab์ ์ฌ์ฉํ๋ ๊ฒฝ์ฐ) ๋ฐ์ดํฐ ์ธํธ๊ฐ ์ ์ ํ๊ฒ ์ค๋น๋์๋ค๋ฉด, TPU์์ ์คํํ๋ ๊ฒ์ ๋๋๋๋ก ์ฝ์ต๋๋ค! ์ฝ๋์์ ๋ช ์ค๋ง ์ถ๊ฐํ์ฌ, TPU๋ฅผ ์ด๊ธฐํํ๊ณ ๋ชจ๋ธ๊ณผ ๋ฐ์ดํฐ ์ธํธ๊ฐ `TPUStrategy` ๋ฒ์ ๋ด์ ์์ฑ๋๋๋ก ๋ณ๊ฒฝํ๋ฉด ๋ฉ๋๋ค. [์ฐ๋ฆฌ์ TPU ์์ ๋
ธํธ๋ถ](https://colab.research.google.com/github/huggingface/notebooks/blob/main/examples/tpu_training-tf.ipynb)์ ์ฐธ์กฐํ์ฌ ์ค์ ๋ก ์๋ํ๋ ๋ชจ์ต์ ํ์ธํด ๋ณด์ธ์!
### ์์ฝ[[summary]]
์ฌ๊ธฐ์ ๋ง์ ๋ด์ฉ์ด ํฌํจ๋์ด ์์ผ๋ฏ๋ก, TPU ํ๋ จ์ ์ํ ๋ชจ๋ธ์ ์ค๋นํ ๋ ๋ฐ๋ฅผ ์ ์๋ ๊ฐ๋ตํ ์ฒดํฌ๋ฆฌ์คํธ๋ก ์์ฝํด ๋ณด๊ฒ ์ต๋๋ค:
- ์ฝ๋๊ฐ XLA์ ์ธ ๊ฐ์ง ๊ท์น์ ๋ฐ๋ฅด๋์ง ํ์ธํฉ๋๋ค.
- CPU/GPU์์ `jit_compile=True`๋ก ๋ชจ๋ธ์ ์ปดํ์ผํ๊ณ XLA๋ก ํ๋ จํ ์ ์๋์ง ํ์ธํฉ๋๋ค.
- ๋ฐ์ดํฐ ์ธํธ๋ฅผ ๋ฉ๋ชจ๋ฆฌ์ ๊ฐ์ ธ์ค๊ฑฐ๋ TPU ํธํ ๋ฐ์ดํฐ ์ธํธ๋ฅผ ๊ฐ์ ธ์ค๋ ๋ฐฉ์์ ์ฌ์ฉํฉ๋๋ค([๋
ธํธ๋ถ](https://colab.research.google.com/github/huggingface/notebooks/blob/main/examples/tpu_training-tf.ipynb) ์ฐธ์กฐ)
- ์ฝ๋๋ฅผ Colab(accelerator๊ฐ โTPUโ๋ก ์ค์ ๋จ) ๋๋ Google Cloud์ TPU VM์ผ๋ก ๋ง์ด๊ทธ๋ ์ด์
ํฉ๋๋ค.
- TPU ์ด๊ธฐํ ์ฝ๋๋ฅผ ์ถ๊ฐํฉ๋๋ค([๋
ธํธ๋ถ](https://colab.research.google.com/github/huggingface/notebooks/blob/main/examples/tpu_training-tf.ipynb) ์ฐธ์กฐ)
- `TPUStrategy`๋ฅผ ์์ฑํ๊ณ ๋ฐ์ดํฐ ์ธํธ๋ฅผ ๊ฐ์ ธ์ค๋ ๊ฒ๊ณผ ๋ชจ๋ธ ์์ฑ์ด `strategy.scope()` ๋ด์ ์๋์ง ํ์ธํฉ๋๋ค([๋
ธํธ๋ถ](https://colab.research.google.com/github/huggingface/notebooks/blob/main/examples/tpu_training-tf.ipynb) ์ฐธ์กฐ)
- TPU๋ก ์ด๋ํ ๋ `jit_compile=True`๋ฅผ ๋ค์ ์ค์ ํ๋ ๊ฒ์ ์์ง ๋ง์ธ์!
- ๐๐๐๐ฅบ๐ฅบ๐ฅบ
- model.fit()์ ๋ถ๋ฌ์ต๋๋ค.
- ์ฌ๋ฌ๋ถ์ด ํด๋์ต๋๋ค! | 0 |
mavonic_private_repos/transformers/docs/source | mavonic_private_repos/transformers/docs/source/ko/perf_hardware.md | <!---
Copyright 2022 The HuggingFace Team. All rights reserved.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
โ ๏ธ Note that this file is in Markdown but contain specific syntax for our doc-builder (similar to MDX) that may not be
rendered properly in your Markdown viewer.
-->
# ํ๋ จ์ฉ ์ฌ์ฉ์ ๋ง์ถคํ ํ๋์จ์ด [[custom-hardware-for-training]]
๋ชจ๋ธ ํ๋ จ๊ณผ ์ถ๋ก ์ ์ฌ์ฉํ๋ ํ๋์จ์ด๋ ์ฑ๋ฅ์ ํฐ ์ํฅ์ ๋ฏธ์น ์ ์์ต๋๋ค. GPU์ ๋ํด ์์ธํ ์์๋ณด๋ ค๋ฉด, Tim Dettmer์ ํ๋ฅญํ ๋ธ๋ก๊ทธ ํฌ์คํธ๋ฅผ ํ์ธํด๋ณด์ธ์. [๋ธ๋ก๊ทธ ํฌ์คํธ ๋งํฌ](https://timdettmers.com/2020/09/07/which-gpu-for-deep-learning/) (์์ด๋ก ์์ฑ๋จ).
GPU ์ค์ ์ ๋ํ ์ค์ฉ์ ์ธ ์กฐ์ธ์ ์ดํด๋ณด๊ฒ ์ต๋๋ค.
## GPU [[gpu]]
๋ ํฐ ๋ชจ๋ธ์ ํ๋ จ์ํฌ ๋๋ ๊ธฐ๋ณธ์ ์ผ๋ก ์ธ ๊ฐ์ง ์ต์
์ด ์์ต๋๋ค:
- ๋ ํฐ GPU
- ๋ ๋ง์ GPU
- ๋ ๋ง์ CPU ๋ฐ NVMe ([DeepSpeed-Infinity](../en/main_classes/deepspeed#nvme-support)๋ฅผ ํตํ ์คํ๋ก๋(offload))
์ฐ์ , ํ๋์ GPU๋ง ์ฌ์ฉํ๋ ๊ฒฝ์ฐ๋ถํฐ ์์ํด๋ด
์๋ค.
### ์ ์ ๊ณต๊ธ๊ณผ ๋๊ฐ [[power-and-cooling]]
๋น์ผ ๊ณ ์ฑ๋ฅ GPU๋ฅผ ๊ตฌ๋งคํ ๊ฒฝ์ฐ, ์ฌ๋ฐ๋ฅธ ์ ์ ๊ณต๊ธ๊ณผ ์ถฉ๋ถํ ๋๊ฐ์ ์ ๊ณตํด์ผ ํฉ๋๋ค.
**์ ์ ๊ณต๊ธ**:
์ผ๋ถ ๊ณ ์ฑ๋ฅ ์๋น์์ฉ GPU๋ 2๊ฐ ํน์ ๊ฐ๋๊ฐ๋ค 3๊ฐ์ PCI-E 8ํ ์ ์ ์์ผ์ด ์์ต๋๋ค. ์นด๋์ ์๋ ์์ผ ์๋งํผ ๋
๋ฆฝ์ ์ธ 12V PCI-E 8ํ ์ผ์ด๋ธ์ด ์ฐ๊ฒฐ๋์ด ์๋์ง ํ์ธํ์ธ์. ๊ฐ์ ์ผ์ด๋ธ์ ํ์ชฝ ๋์ ์๋ 2๊ฐ์ ์คํ๋ฆฟ(๋๋ ํผ๊ทธํ
์ผ(pigtail) ์ผ์ด๋ธ)์ ์ฌ์ฉํ์ง ๋ง์ธ์. ์ฆ, GPU์ 2๊ฐ์ ์์ผ์ด ์๋ค๋ฉด, PSU(์ ์ ๊ณต๊ธ ์ฅ์น)์์ ์นด๋๋ก ์ฐ๊ฒฐ๋๋ 2๊ฐ์ PCI-E 8ํ ์ผ์ด๋ธ์ด ํ์ํ๋ฉฐ, ๋์ 2๊ฐ์ PCI-E 8ํ ์ปค๋ฅํฐ๊ฐ ์๋ ์ผ์ด๋ธ์ด ํ์ํ์ง ์์ต๋๋ค! ๊ทธ๋ ์ง ์์ผ๋ฉด ์นด๋์ ์ ์ฒด ์ฑ๋ฅ์ ์ ๋๋ก ๋ฐํํ์ง ๋ชปํ ์ ์์ต๋๋ค.
๊ฐ๊ฐ์ PCI-E 8ํ ์ ์ ์ผ์ด๋ธ์ PSU ์ชฝ์ 12V ๋ ์ผ์ ์ฐ๊ฒฐ๋์ด์ผ ํ๋ฉฐ ์ต๋ 150W์ ์ ๋ ฅ์ ๊ณต๊ธํ ์ ์์ต๋๋ค.
์ผ๋ถ ๋ค๋ฅธ GPU๋ PCI-E 12ํ ์ปค๋ฅํฐ๋ฅผ ์ฌ์ฉํ๋ฉฐ, ์ด๋ฌํ ์ปค๋ฅํฐ๋ ์ต๋ 500W-600W์ ์ ๋ ฅ์ ๊ณต๊ธํ ์ ์์ต๋๋ค.
์ ๊ฐํ GPU๋ 6ํ ์ปค๋ฅํฐ๋ฅผ ์ฌ์ฉํ๋ฉฐ, ์ต๋ 75W์ ์ ๋ ฅ์ ๊ณต๊ธํฉ๋๋ค.
๋ํ GPU๊ฐ ์์ ์ ์ธ ์ ์์ ๋ฐ์ ์ ์๋๋ก ๊ณ ๊ธ PSU๋ฅผ ์ ํํด์ผ ํฉ๋๋ค. ์ผ๋ถ ์ ํ์ง์ PSU๋ GPU๊ฐ ์ต๊ณ ์ฑ๋ฅ์ผ๋ก ๋์ํ๊ธฐ ์ํด ํ์ํ ์ ์์ ์์ ์ ์ผ๋ก ๊ณต๊ธํ์ง ๋ชปํ ์ ์์ต๋๋ค.
๋ฌผ๋ก , PSU๋ GPU์ ์ ์์ ๊ณต๊ธํ๊ธฐ์ ์ถฉ๋ถํ ์ฌ๋ถ์ ์ ๋ ฅ ์ฉ๋์ ๊ฐ์ ธ์ผ ํฉ๋๋ค.
**๋๊ฐ**:
GPU๊ฐ ๊ณผ์ด๋๋ฉด ์ฑ๋ฅ์ด ์ ํ๋๊ณ ์ต๋ ์ฑ๋ฅ์ ๋ฐํํ์ง ๋ชปํ ์ ์์ผ๋ฉฐ, ๋๋ฌด ๋จ๊ฑฐ์์ง๋ฉด ์ค์ง๋ ์ ์์ต๋๋ค.
GPU๊ฐ ๊ณผ์ด๋ ๋ ์ ํํ ์ ์ ์จ๋๋ฅผ ์๊ธฐ ์ด๋ ค์ฐ๋, ์๋ง๋ +80โ ๋ฏธ๋ง์ด๋ฉด ์ข์ง๋ง ๋ ๋ฎ์์๋ก ์ข์ต๋๋ค. 70โ-75โ ์ ๋๊ฐ ํ๋ฅญํ ์จ๋ ๋ฒ์์
๋๋ค. ์ฑ๋ฅ ์ ํ๊ฐ ๋ฐ์ํ๊ธฐ ์์ํ๋ ์จ๋๋ ๋๋ต 84โ-90โ ์ ๋์ผ ๊ฒ์
๋๋ค. ํ์ง๋ง ์ฑ๋ฅ ์ ํ ์ด์ธ์๋ ์ง์์ ์ผ๋ก ๋งค์ฐ ๋์ ์จ๋๋ GPU ์๋ช
์ ๋จ์ถ์ํฌ ์ ์์ต๋๋ค.
์ด์ด์, ์ฌ๋ฌ ๊ฐ์ GPU๋ฅผ ์ฌ์ฉํ ๋ ๊ฐ์ฅ ์ค์ํ ์ธก๋ฉด ์ค ํ๋์ธ GPU ๊ฐ ์ฐ๊ฒฐ ๋ฐฉ์์ ์ดํด๋ณด๊ฒ ์ต๋๋ค.
### ๋ค์ค GPU ์ฐ๊ฒฐ ๋ฐฉ์ [[multigpu-connectivity]]
๋ค์ค GPU๋ฅผ ์ฌ์ฉํ๋ ๊ฒฝ์ฐ GPU ๊ฐ์ ์ฐ๊ฒฐ ๋ฐฉ์์ ์ ์ฒด ํ๋ จ ์๊ฐ์ ํฐ ์ํฅ์ ๋ฏธ์น ์ ์์ต๋๋ค. ๋ง์ฝ GPU๊ฐ ๋์ผํ ๋ฌผ๋ฆฌ์ ๋
ธ๋์ ์์ ๊ฒฝ์ฐ, ๋ค์๊ณผ ๊ฐ์ด ํ์ธํ ์ ์์ต๋๋ค:
```bash
nvidia-smi topo -m
```
๋ง์ฝ NVLink๋ก ์ฐ๊ฒฐ๋ ๋์ผ GPU ํ๊ฒฝ์ด๋ผ๋ฉด, ๋ค์๊ณผ ๊ฐ์ ๊ฒฐ๊ณผ๋ฅผ ํ์ธํ ์ ์์ต๋๋ค:
```
GPU0 GPU1 CPU Affinity NUMA Affinity
GPU0 X NV2 0-23 N/A
GPU1 NV2 X 0-23 N/A
```
NVLink๋ฅผ ์ง์ํ์ง ์๋ ๋ค๋ฅธ ํ๊ฒฝ์ ๊ฒฝ์ฐ์๋ ๋ค์๊ณผ ๊ฐ์ ๊ฒฐ๊ณผ๋ฅผ ํ์ธํ ์ ์์ต๋๋ค:
```
GPU0 GPU1 CPU Affinity NUMA Affinity
GPU0 X PHB 0-11 N/A
GPU1 PHB X 0-11 N/A
```
์ด ๊ฒฐ๊ณผ์๋ ๋ค์๊ณผ ๊ฐ์ ๋ฒ๋ก๊ฐ ํฌํจ๋์ด ์์ต๋๋ค:
```
X = Self
SYS = Connection traversing PCIe as well as the SMP interconnect between NUMA nodes (e.g., QPI/UPI)
NODE = Connection traversing PCIe as well as the interconnect between PCIe Host Bridges within a NUMA node
PHB = Connection traversing PCIe as well as a PCIe Host Bridge (typically the CPU)
PXB = Connection traversing multiple PCIe bridges (without traversing the PCIe Host Bridge)
PIX = Connection traversing at most a single PCIe bridge
NV# = Connection traversing a bonded set of # NVLinks
```
๋ฐ๋ผ์ ์ฒซ ๋ฒ์งธ ๊ฒฐ๊ณผ์ `NV2`๋ GPU๊ฐ 2๊ฐ์ NVLink๋ก ์ฐ๊ฒฐ๋์ด ์๋ค๋ ๊ฒ์ ๋ํ๋ด๊ณ , ๋ ๋ฒ์งธ ๊ฒฐ๊ณผ์ `PHB`๋ ์ผ๋ฐ์ ์ธ ์๋น์์ฉ PCIe+๋ธ๋ฆฟ์ง ์ค์ ์ ๊ฐ์ง๊ณ ์๋ค๋ ๊ฒ์ ๋ํ๋
๋๋ค.
์ค์ ์์ ์ด๋ค ์ ํ์ ์ฐ๊ฒฐ ๋ฐฉ์์ ๊ฐ์ง๊ณ ์๋์ง ํ์ธํ์ธ์. ์ผ๋ถ ์ฐ๊ฒฐ ๋ฐฉ์์ GPU ๊ฐ ํต์ ์ ๋ ๋น ๋ฅด๊ฒ ๋ง๋ค ์ ์์ผ๋ฉฐ(NVLink์ ๊ฐ์ด), ์ด๋ค ์ฐ๊ฒฐ ๋ฐฉ์์ ๋ ๋๋ฆฌ๊ฒ ๋ง๋ค ์ ์์ต๋๋ค(PHB์ ๊ฐ์ด).
์ฌ์ฉํ๋ ํ์ฅ์ฑ ์๋ฃจ์
์ ์ข
๋ฅ์ ๋ฐ๋ผ ์ฐ๊ฒฐ ์๋๊ฐ ์ฃผ์ํ ์ํฅ์ ๋ฏธ์น ์๋ ์๊ณ ๋ฏธ๋ฏธํ ์ํฅ์ ๋ฏธ์น ์๋ ์์ต๋๋ค. DDP์ ๊ฐ์ด GPU๊ฐ ๊ฑฐ์ ๋๊ธฐํํ์ง ์์๋ ๋๋ ๊ฒฝ์ฐ, ์ฐ๊ฒฐ ์๋๊ฐ ๋๋ ค๋ ํฐ ์ํฅ์ ๋ฐ์ง ์์ต๋๋ค. ๋ฐ๋ฉด ZeRO-DP์ ๊ฐ์ด GPU๊ฐ ํต์ ์ด ๋ง์ด ํ์ํ ๊ฒฝ์ฐ, ๋ ๋น ๋ฅธ ํ๋ จ์ ์ํด์๋ ๋ ๋น ๋ฅธ ์ฐ๊ฒฐ ์๋๊ฐ ์ค์ํฉ๋๋ค.
#### NVLink [[nvlink]]
[NVLink](https://en.wikipedia.org/wiki/NVLink)๋ Nvidia์์ ๊ฐ๋ฐํ ์ ์ ๊ธฐ๋ฐ์ ์ง๋ ฌ ๋ค์ค ๋ ์ธ ๊ทผ๊ฑฐ๋ฆฌ ํต์ ๋งํฌ์
๋๋ค.
์๋ก์ด ์ธ๋์ NVLink๋ ๋ ๋น ๋ฅธ ๋์ญํญ์ ์ ๊ณตํฉ๋๋ค. [Nvidia Ampere GA102 GPU Architecture](https://www.nvidia.com/content/dam/en-zz/Solutions/geforce/ampere/pdf/NVIDIA-ampere-GA102-GPU-Architecture-Whitepaper-V1.pdf)์์ ์๋์ ๊ฐ์ ์ ๋ณด๋ฅผ ํ์ธํ์ค ์ ์์ต๋๋ค:
> 3์ธ๋ NVLinkยฎ
> GA102 GPU๋ 4๊ฐ์ x4 ๋งํฌ๋ฅผ ํฌํจํ๋ NVIDIA์ 3์ธ๋ NVLink ์ธํฐํ์ด์ค๋ฅผ ํ์ฉํ๋ฉฐ,
> ๊ฐ ๋งํฌ๋ ๋ ๊ฐ์ GPU ๊ฐ์ ๊ฐ ๋ฐฉํฅ์ผ๋ก ์ด๋น 14.0625GB์ ๋์ญํญ์ ์ ๊ณตํฉ๋๋ค.
> 4๊ฐ์ ๋งํฌ๋ ๊ฐ ๋ฐฉํฅ์ ์ด๋น 56.25GB์ ๋์ญํญ์ ์ ๊ณตํ๋ฉฐ, ๋ ๊ฐ์ GPU ๊ฐ์๋ ์ด๋น 112.5GB์ ์ด ๋์ญํญ์ ์ ๊ณตํฉ๋๋ค.
> ๋ ๊ฐ์ RTX 3090 GPU๋ฅผ NVLink๋ฅผ ์ฌ์ฉํด SLI๋ก ์ฐ๊ฒฐํ ์ ์์ต๋๋ค.
> (3-Way ๋ฐ 4-Way SLI ๊ตฌ์ฑ์ ์ง์๋์ง ์์์ ์ ์ํ์ธ์.)
๋ฐ๋ผ์ `nvidia-smi topo -m`์ ๊ฒฐ๊ณผ์์ `NVX`์ ๊ฐ์ด ๋์์๋ก ๋ ์ข์ต๋๋ค. ์ธ๋๋ GPU ์ํคํ
์ฒ์ ๋ฐ๋ผ ๋ค๋ฅผ ์ ์์ต๋๋ค.
๊ทธ๋ ๋ค๋ฉด, openai-community/gpt2๋ฅผ ์์ wikitext ์ํ๋ก ํ์ต์ํค๋ ์์ ๋ฅผ ํตํด, NVLink๊ฐ ํ๋ จ์ ์ด๋ค ์ํฅ์ ๋ฏธ์น๋์ง ์ดํด๋ณด๊ฒ ์ต๋๋ค.
๊ฒฐ๊ณผ๋ ๋ค์๊ณผ ๊ฐ์ต๋๋ค:
| NVlink | Time |
| ----- | ---: |
| Y | 101s |
| N | 131s |
NVLink ์ฌ์ฉ ์ ํ๋ จ์ด ์ฝ 23% ๋ ๋น ๋ฅด๊ฒ ์๋ฃ๋จ์ ํ์ธํ ์ ์์ต๋๋ค. ๋ ๋ฒ์งธ ๋ฒค์น๋งํฌ์์๋ `NCCL_P2P_DISABLE=1`์ ์ฌ์ฉํ์ฌ NVLink๋ฅผ ์ฌ์ฉํ์ง ์๋๋ก ์ค์ ํ์ต๋๋ค.
์ ์ฒด ๋ฒค์น๋งํฌ ์ฝ๋์ ๊ฒฐ๊ณผ๋ ๋ค์๊ณผ ๊ฐ์ต๋๋ค:
```bash
# DDP w/ NVLink
rm -r /tmp/test-clm; CUDA_VISIBLE_DEVICES=0,1 torchrun \
--nproc_per_node 2 examples/pytorch/language-modeling/run_clm.py --model_name_or_path openai-community/gpt2 \
--dataset_name wikitext --dataset_config_name wikitext-2-raw-v1 --do_train \
--output_dir /tmp/test-clm --per_device_train_batch_size 4 --max_steps 200
{'train_runtime': 101.9003, 'train_samples_per_second': 1.963, 'epoch': 0.69}
# DDP w/o NVLink
rm -r /tmp/test-clm; CUDA_VISIBLE_DEVICES=0,1 NCCL_P2P_DISABLE=1 torchrun \
--nproc_per_node 2 examples/pytorch/language-modeling/run_clm.py --model_name_or_path openai-community/gpt2 \
--dataset_name wikitext --dataset_config_name wikitext-2-raw-v1 --do_train
--output_dir /tmp/test-clm --per_device_train_batch_size 4 --max_steps 200
{'train_runtime': 131.4367, 'train_samples_per_second': 1.522, 'epoch': 0.69}
```
ํ๋์จ์ด: ๊ฐ๊ฐ 2๊ฐ์ TITAN RTX 24GB + 2๊ฐ์ NVLink (`NV2` in `nvidia-smi topo -m`)
์ํํธ์จ์ด: `pytorch-1.8-to-be` + `cuda-11.0` / `transformers==4.3.0.dev0`
| 0 |
mavonic_private_repos/transformers/docs/source | mavonic_private_repos/transformers/docs/source/ko/contributing.md | <!---
Copyright 2020 The HuggingFace Team. All rights reserved.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
-->
# ๐ค Transformers์ ๊ธฐ์ฌํ๊ธฐ [[contribute-to-transformers]]
๋๊ตฌ๋ ๐ค Transformers์ ๊ธฐ์ฌํ ์ ์์ผ๋ฉฐ, ์ฐ๋ฆฌ๋ ๋ชจ๋ ์ฌ๋์ ๊ธฐ์ฌ๋ฅผ ์์คํ ์๊ฐํฉ๋๋ค. ์ฝ๋ ๊ธฐ์ฌ๋ ์ปค๋ฎค๋ํฐ๋ฅผ ๋๋ ์ ์ผํ ๋ฐฉ๋ฒ์ด ์๋๋๋ค. ์ง๋ฌธ์ ๋ตํ๊ฑฐ๋ ๋ค๋ฅธ ์ฌ๋์ ๋์ ๋ฌธ์๋ฅผ ๊ฐ์ ํ๋ ๊ฒ๋ ๋งค์ฐ ๊ฐ์น๊ฐ ์์ต๋๋ค.
๐ค Transformers๋ฅผ ๋๋ฆฌ ์๋ฆฌ๋ ๊ฒ๋ ํฐ ๋์์ด ๋ฉ๋๋ค! ๋ฉ์ง ํ๋ก์ ํธ๋ค์ ๊ฐ๋ฅํ๊ฒ ํ ๐ค Transformers ๋ผ์ด๋ธ๋ฌ๋ฆฌ์ ๋ํด ๋ธ๋ก๊ทธ ๊ฒ์๊ธ์ ์ธ๊ธํ๊ฑฐ๋, ๋์์ด ๋์์ ๋๋ง๋ค Twitter์ ์๋ฆฌ๊ฑฐ๋, ์ ์ฅ์์ โญ๏ธ ๋ฅผ ํ์ํ์ฌ ๊ฐ์ฌ ์ธ์ฌ๋ฅผ ์ ํด์ฃผ์ธ์.
์ด๋ค ๋ฐฉ์์ผ๋ก ๊ธฐ์ฌํ๋ [ํ๋ ๊ท์น](https://github.com/huggingface/transformers/blob/main/CODE_OF_CONDUCT.md)์ ์์งํ๊ณ ์กด์คํด์ฃผ์ธ์.
**์ด ์๋ด์๋ ๋ฉ์ง [scikit-learn ๊ธฐ์ฌ ์๋ด์](https://github.com/scikit-learn/scikit-learn/blob/main/CONTRIBUTING.md)์์ ํฐ ์๊ฐ์ ๋ฐ์์ต๋๋ค.**
## ๊ธฐ์ฌํ๋ ๋ฐฉ๋ฒ [[ways-to-contribute]]
์ฌ๋ฌ ๊ฐ์ง ๋ฐฉ๋ฒ์ผ๋ก ๐ค Transformers์ ๊ธฐ์ฌํ ์ ์์ต๋๋ค:
* ๊ธฐ์กด ์ฝ๋์ ๋ฏธํด๊ฒฐ๋ ๋ฌธ์ ๋ฅผ ์์ ํฉ๋๋ค.
* ๋ฒ๊ทธ ๋๋ ์๋ก ์ถ๊ฐ๋๊ธธ ์ํ๋ ๊ธฐ๋ฅ๊ณผ ๊ด๋ จ๋ ์ด์๋ฅผ ์ ์ถํฉ๋๋ค.
* ์๋ก์ด ๋ชจ๋ธ์ ๊ตฌํํฉ๋๋ค.
* ์์ ๋ ๋ฌธ์์ ๊ธฐ์ฌํฉ๋๋ค.
์ด๋์๋ถํฐ ์์ํ ์ง ๋ชจ๋ฅด๊ฒ ๋ค๋ฉด, [Good First Issue](https://github.com/huggingface/transformers/contribute) ๋ชฉ๋ก์ ํ์ธํด๋ณด์ธ์. ์ด ๋ชฉ๋ก์ ์ด๋ณด์๋ ์ฐธ์ฌํ๊ธฐ ์ฌ์ด ์คํ ์ด์ ๋ชฉ๋ก์ ์ ๊ณตํ๋ฉฐ, ๋น์ ์ด ์คํ์์ค์ ์ฒ์์ผ๋ก ๊ธฐ์ฌํ๋ ๋ฐ ํฐ ๋์์ด ๋ ๊ฒ์
๋๋ค. ๊ทธ์ ์์
ํ๊ณ ์ถ์ ์ด์์ ๋๊ธ๋ง ๋ฌ์์ฃผ๋ฉด ๋ฉ๋๋ค.
์กฐ๊ธ ๋ ๋์ ์ ์ธ ์์
์ ์ํ๋ค๋ฉด, [Good Second Issue](https://github.com/huggingface/transformers/labels/Good%20Second%20Issue) ๋ชฉ๋ก๋ ํ์ธํด๋ณด์ธ์. ์ด๋ฏธ ๋น์ ์ด ์ ํ๊ณ ์๋ค๊ณ ์๊ฐ๋๋๋ผ๋, ํ ๋ฒ ์๋ํด๋ณด์ธ์! ์ฐ๋ฆฌ๋ ์ฌ๋ฌ๋ถ์ ๋์ธ ๊ฒ์
๋๋ค. ๐
> ์ปค๋ฎค๋ํฐ์ ์ด๋ฃจ์ด์ง๋ ๋ชจ๋ ๊ธฐ์ฌ๋ ๋๊ฐ์ด ์์คํฉ๋๋ค. ๐ฅฐ
## ๋ฏธํด๊ฒฐ๋ ๋ฌธ์ ์์ ํ๊ธฐ [[fixing-outstanding-issues]]
๊ธฐ์กด ์ฝ๋์์ ๋ฐ๊ฒฌํ ๋ฌธ์ ์ ์ ๋ํ ํด๊ฒฐ์ฑ
์ด ๋ ์ค๋ฅธ ๊ฒฝ์ฐ, ์ธ์ ๋ ์ง [๊ธฐ์ฌ๋ฅผ ์์](https://github.com/huggingface/transformers/blob/main/CONTRIBUTING.md/#create-a-pull-request)ํ๊ณ Pull Request๋ฅผ ์์ฑํด์ฃผ์ธ์!
## ๋ฒ๊ทธ ๊ด๋ จ ์ด์๋ฅผ ์ ๊ธฐํ๊ฑฐ๋ ์๋ก์ด ๊ธฐ๋ฅ ์์ฒญํ๊ธฐ [[submitting-a-bugrelated-issue-or-feature-request]]
๋ฒ๊ทธ ๊ด๋ จ ์ด์๋ฅผ ์ ๊ธฐํ๊ฑฐ๋ ์๋ก์ด ๊ธฐ๋ฅ์ ์์ฒญํ ๋๋ ๋ค์ ๊ฐ์ด๋๋ผ์ธ์ ์ต๋ํ ์ค์ํด์ฃผ์ธ์. ์ด๋ ๊ฒ ํ๋ฉด ์ข์ ํผ๋๋ฐฑ๊ณผ ํจ๊ป ๋น ๋ฅด๊ฒ ๋ต๋ณํด ๋๋ฆด ์ ์์ต๋๋ค.
### ๋ฒ๊ทธ๋ฅผ ๋ฐ๊ฒฌํ์
จ๋์? [[did-you-find-a-bug]]
๐ค Transformers ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ ์ฌ์ฉ ์ค์ ๊ฒช๋ ๋ฌธ์ ๋ฅผ ๋ณด๊ณ ํด์ฃผ๋ ์ฌ์ฉ์๋ค ๋๋ถ์ ๋์ฑ ๊ฒฌ๊ณ ํด์ง๊ณ ์ ๋ขฐํ ์ ์๊ฒ ๋์์ต๋๋ค.
์ด์๋ฅผ ๋ณด๊ณ ํ๊ธฐ ์ ์, ๋ฒ๊ทธ๊ฐ ์ด๋ฏธ **๋ณด๊ณ ๋์ง ์์๋์ง** ํ์ธํด์ฃผ์ธ์. (GitHub์ ์ด์ ํญ ์๋์ ๊ฒ์ ๋ฐ๋ฅผ ์ฌ์ฉํ์ธ์). ์ด์๋ ๋ผ์ด๋ธ๋ฌ๋ฆฌ ์์ฒด์์ ๋ฐ์ํ ๋ฒ๊ทธ์ด์ผ ํ๋ฉฐ, ์ฝ๋์ ๋ค๋ฅธ ๋ถ๋ถ๊ณผ ๊ด๋ จ๋ ๊ฒ์ด ์๋์ด์ผ ํฉ๋๋ค. ๋ฒ๊ทธ๊ฐ ๋ผ์ด๋ธ๋ฌ๋ฆฌ์ ๋ฌธ์ ๋ก ๋ฐ์ํ์๋์ง ํ์คํ์ง ์์ ๊ฒฝ์ฐ ๋จผ์ [ํฌ๋ผ](https://discuss.huggingface.co/)์์ ์ง๋ฌธํด ์ฃผ์ธ์. ์ด๋ ๊ฒ ํ๋ฉด ์ผ๋ฐ์ ์ธ ์ง๋ฌธ๋ณด๋ค ๋ผ์ด๋ธ๋ฌ๋ฆฌ์ ๊ด๋ จ๋ ๋ฌธ์ ๋ฅผ ๋ ๋น ๋ฅด๊ฒ ํด๊ฒฐํ ์ ์์ต๋๋ค.
๋ฒ๊ทธ๊ฐ ์ด๋ฏธ ๋ณด๊ณ ๋์ง ์์๋ค๋ ๊ฒ์ ํ์ธํ๋ค๋ฉด, ๋ค์ ์ ๋ณด๋ฅผ ํฌํจํ์ฌ ์ด์๋ฅผ ์ ์ถํด ์ฃผ์ธ์. ๊ทธ๋ฌ๋ฉด ์ฐ๋ฆฌ๊ฐ ๋น ๋ฅด๊ฒ ํด๊ฒฐํ ์ ์์ต๋๋ค:
* ์ฌ์ฉ ์ค์ธ **์ด์์ฒด์ ์ข
๋ฅ์ ๋ฒ์ **, ๊ทธ๋ฆฌ๊ณ **Python**, **PyTorch** ๋๋ **TensorFlow** ๋ฒ์ .
* ๋ฒ๊ทธ๋ฅผ 30์ด ์ด๋ด๋ก ์ฌํํ ์ ์๋ ๊ฐ๋จํ๊ณ ๋
๋ฆฝ์ ์ธ ์ฝ๋ ์ค๋ํซ.
* ์์ธ๊ฐ ๋ฐ์ํ ๊ฒฝ์ฐ *์ ์ฒด* ํธ๋ ์ด์ค๋ฐฑ.
* ์คํฌ๋ฆฐ์ท๊ณผ ๊ฐ์ด ๋์์ด ๋ ๊ฒ์ผ๋ก ์๊ฐ๋๋ ์ถ๊ฐ ์ ๋ณด๋ฅผ ์ฒจ๋ถํด ์ฃผ์ธ์.
์ด์์ฒด์ ์ ์ํํธ์จ์ด ๋ฒ์ ์ ์๋์ผ๋ก ๊ฐ์ ธ์ค๋ ค๋ฉด ๋ค์ ๋ช
๋ น์ ์คํํ์ธ์:
```bash
transformers-cli env
```
์ ์ฅ์์ ๋ฃจํธ ๋๋ ํฐ๋ฆฌ์์๋ ๊ฐ์ ๋ช
๋ น์ ์คํํ ์ ์์ต๋๋ค:
```bash
python src/transformers/commands/transformers_cli.py env
```
### ์๋ก์ด ๊ธฐ๋ฅ์ ์ํ์๋์? [[do-you-want-a-new-feature]]
๐ค Transformers์์ ์ฌ์ฉํ๊ณ ์ถ์ ์๋ก์ด ๊ธฐ๋ฅ์ด ์๋ค๋ฉด, ๋ค์ ๋ด์ฉ์ ํฌํจํ์ฌ ์ด์๋ฅผ ์ ์ถํด ์ฃผ์ธ์:
1. ์ด ๊ธฐ๋ฅ์ด ํ์ํ *์ด์ *๋ ๋ฌด์์ธ๊ฐ์? ๋ผ์ด๋ธ๋ฌ๋ฆฌ์ ๋ํ ๋ฌธ์ ๋ ๋ถ๋ง๊ณผ ๊ด๋ จ์ด ์๋์? ํ๋ก์ ํธ์ ํ์ํ ๊ธฐ๋ฅ์ธ๊ฐ์? ์ปค๋ฎค๋ํฐ์ ๋์์ด ๋ ๋งํ ๊ธฐ๋ฅ์ธ๊ฐ์?
์ด๋ค ๋ด์ฉ์ด๋ ์ฌ๋ฌ๋ถ์ ์ด์ผ๊ธฐ๋ฅผ ๋ฃ๊ณ ์ถ์ต๋๋ค!
2. ์์ฒญํ๋ ๊ธฐ๋ฅ์ ์ต๋ํ ์์ธํ ์ค๋ช
ํด ์ฃผ์ธ์. ๋ ๋ง์ ์ ๋ณด๋ฅผ ์ ๊ณตํ ์๋ก ๋ ๋์ ๋์์ ๋๋ฆด ์ ์์ต๋๋ค.
3. ํด๋น ๊ธฐ๋ฅ์ ์ฌ์ฉ๋ฒ์ ๋ณด์ฌ์ฃผ๋ *์ฝ๋ ์ค๋ํซ*์ ์ ๊ณตํด ์ฃผ์ธ์.
4. ๊ธฐ๋ฅ๊ณผ ๊ด๋ จ๋ ๋
ผ๋ฌธ์ด ์๋ ๊ฒฝ์ฐ ๋งํฌ๋ฅผ ํฌํจํด ์ฃผ์ธ์.
์ด์๊ฐ ์ ์์ฑ๋์๋ค๋ฉด ์ด์๊ฐ ์์ฑ๋ ์๊ฐ, ์ด๋ฏธ 80% ์ ๋์ ์์
์ด ์๋ฃ๋ ๊ฒ์
๋๋ค.
์ด์๋ฅผ ์ ๊ธฐํ๋ ๋ฐ ๋์์ด ๋ ๋งํ [ํ
ํ๋ฆฟ](https://github.com/huggingface/transformers/tree/main/templates)๋ ์ค๋น๋์ด ์์ต๋๋ค.
## ์๋ก์ด ๋ชจ๋ธ์ ๊ตฌํํ๊ณ ์ถ์ผ์ ๊ฐ์? [[do-you-want-to-implement-a-new-model]]
์๋ก์ด ๋ชจ๋ธ์ ๊ณ์ํด์ ์ถ์๋ฉ๋๋ค. ๋ง์ฝ ์ฌ๋ฌ๋ถ์ด ์๋ก์ด ๋ชจ๋ธ์ ๊ตฌํํ๊ณ ์ถ๋ค๋ฉด ๋ค์ ์ ๋ณด๋ฅผ ์ ๊ณตํด ์ฃผ์ธ์:
* ๋ชจ๋ธ์ ๋ํ ๊ฐ๋จํ ์ค๋ช
๊ณผ ๋
ผ๋ฌธ ๋งํฌ.
* ๊ตฌํ์ด ๊ณต๊ฐ๋์ด ์๋ค๋ฉด ๊ตฌํ ๋งํฌ.
* ๋ชจ๋ธ ๊ฐ์ค์น๊ฐ ์ฌ์ฉ ๊ฐ๋ฅํ๋ค๋ฉด ๊ฐ์ค์น ๋งํฌ.
๋ง์ฝ ๋ชจ๋ธ์ ์ง์ ๊ธฐ์ฌํ๊ณ ์ถ์ผ์๋ค๋ฉด, ์๋ ค์ฃผ์ธ์. ๐ค Transformers์ ์ถ๊ฐํ ์ ์๋๋ก ๋์๋๋ฆฌ๊ฒ ์ต๋๋ค!
[๐ค Transformers์ ์๋ก์ด ๋ชจ๋ธ์ ์ถ๊ฐํ๋ ๋ฐฉ๋ฒ](https://huggingface.co/docs/transformers/add_new_model)์ ๋ํ ๊ธฐ์ ์ ์ธ ์๋ด์๋ ์์ต๋๋ค.
## ๋ฌธ์๋ฅผ ์ถ๊ฐํ๊ณ ์ถ์ผ์ ๊ฐ์? [[do-you-want-to-add-documentation]]
์ฐ๋ฆฌ๋ ์ธ์ ๋ ๋ ๋ช
ํํ๊ณ ์ ํํ ๋ฌธ์๋ฅผ ์ ๊ณตํ๊ธฐ ์ํ์ฌ ๊ฐ์ ์ ์ ์ฐพ๊ณ ์์ต๋๋ค. ์คํ์๋ ๋ถ์กฑํ ๋ด์ฉ, ๋ถ๋ช
ํ์ง ์๊ฑฐ๋ ๋ถ์ ํํ ๋ด์ฉ ๋ฑ์ ์๋ ค์ฃผ์๋ฉด ๊ฐ์ ํ๋ ๋ฐ ๋์์ด ๋ฉ๋๋ค. ๊ด์ฌ์ด ์์ผ์๋ค๋ฉด ๋ณ๊ฒฝํ๊ฑฐ๋ ๊ธฐ์ฌํ์ค ์ ์๋๋ก ๋์๋๋ฆฌ๊ฒ ์ต๋๋ค!
๋ฌธ์๋ฅผ ์์ฑ, ๋น๋ ๋ฐ ์์ฑํ๋ ๋ฐฉ๋ฒ์ ๋ํ ์์ธํ ๋ด์ฉ์ [README](https://github.com/huggingface/transformers/tree/main/docs) ๋ฌธ์๋ฅผ ํ์ธํด ์ฃผ์ธ์.
## ํ ๋ฆฌํ์คํธ(Pull Request) ์์ฑํ๊ธฐ [[create-a-pull-request]]
์ฝ๋๋ฅผ ์์ฑํ๊ธฐ ์ ์ ๊ธฐ์กด์ Pull Request๋ ์ด์๋ฅผ ๊ฒ์ํ์ฌ ๋๊ตฐ๊ฐ ์ด๋ฏธ ๋์ผํ ์์
์ ํ๊ณ ์๋์ง ํ์ธํ๋ ๊ฒ์ด ์ข์ต๋๋ค. ํ์คํ์ง ์๋ค๋ฉด ํผ๋๋ฐฑ์ ๋ฐ๊ธฐ ์ํด ์ด์๋ฅผ ์ด์ด๋ณด๋ ๊ฒ์ด ์ข์ต๋๋ค.
๐ค Transformers์ ๊ธฐ์ฌํ๊ธฐ ์ํด์๋ ๊ธฐ๋ณธ์ ์ธ `git` ์ฌ์ฉ ๋ฅ๋ ฅ์ด ํ์ํฉ๋๋ค. `git`์ ์ฌ์ฉํ๊ธฐ ์ฌ์ด ๋๊ตฌ๋ ์๋์ง๋ง, ๋งค์ฐ ํ๋ฅญํ ๋งค๋ด์ผ์ ์ ๊ณตํฉ๋๋ค. ์(shell)์์ `git --help`์ ์
๋ ฅํ์ฌ ํ์ธํด๋ณด์ธ์! ๋ง์ฝ ์ฑ
์ ์ ํธํ๋ค๋ฉด, [Pro Git](https://git-scm.com/book/en/v2)์ ๋งค์ฐ ์ข์ ์ฐธ๊ณ ์๋ฃ๊ฐ ๋ ๊ฒ์
๋๋ค.
๐ค Transformers์ ๊ธฐ์ฌํ๋ ค๋ฉด **[Python 3.8](https://github.com/huggingface/transformers/blob/main/setup.py#L426)** ์ด์์ ๋ฒ์ ์ด ํ์ํฉ๋๋ค. ๊ธฐ์ฌ๋ฅผ ์์ํ๋ ค๋ฉด ๋ค์ ๋จ๊ณ๋ฅผ ๋ฐ๋ฅด์ธ์:
1. ์ ์ฅ์ ํ์ด์ง์์ **[Fork](https://github.com/huggingface/transformers/fork)** ๋ฒํผ์ ํด๋ฆญํ์ฌ ์ ์ฅ์๋ฅผ ํฌํฌํ์ธ์. ์ด๋ ๊ฒ ํ๋ฉด ์ฝ๋์ ๋ณต์ฌ๋ณธ์ด ์ฌ๋ฌ๋ถ์ GitHub ์ฌ์ฉ์ ๊ณ์ ์๋์ ์์ฑ๋ฉ๋๋ค.
2. ํฌํฌํ ์ ์ฅ์๋ฅผ ๋ก์ปฌ ๋์คํฌ๋ก ํด๋ก ํ๊ณ , ๊ธฐ๋ณธ ์ ์ฅ์๋ฅผ ์๊ฒฉ(remote)์ผ๋ก ์ถ๊ฐํ์ธ์:
```bash
git clone git@github.com:<your Github handle>/transformers.git
cd transformers
git remote add upstream https://github.com/huggingface/transformers.git
```
3. ๊ฐ๋ฐ ๋ณ๊ฒฝ ์ฌํญ์ ์ ์ฅํ ์ ๋ธ๋์น๋ฅผ ์์ฑํ์ธ์:
```bash
git checkout -b a-descriptive-name-for-my-changes
```
๐จ ์ ๋ `main` ๋ธ๋์น์์ ์์
ํ์ง **๋ง์ธ์!**
4. ๊ฐ์ ํ๊ฒฝ์์ ๋ค์ ๋ช
๋ น์ ์คํํ์ฌ ๊ฐ๋ฐ ํ๊ฒฝ์ ์ค์ ํ์ธ์:
```bash
pip install -e ".[dev]"
```
๋ง์ฝ ์ด๋ฏธ ๊ฐ์ ํ๊ฒฝ์ ๐ค Transformers๊ฐ ์ค์น๋์ด ์๋ค๋ฉด, `-e` ํ๋๊ทธ๋ฅผ ์ฌ์ฉํ์ฌ ์ค์นํ๊ธฐ ์ ์ `pip uninstall transformers`๋ก ์ ๊ฑฐํด์ฃผ์ธ์.
์ฌ๋ฌ๋ถ์ ์ด์์ฒด์ ์ ๋ฐ๋ผ์, ๊ทธ๋ฆฌ๊ณ ๐ค Transformers์ ์ ํ์ ์์กด์ฑ์ ์๊ฐ ์ฆ๊ฐํ๋ฉด์, ์ด ๋ช
๋ น์ด ์คํจํ ์๋ ์์ต๋๋ค. ๊ทธ๋ด ๊ฒฝ์ฐ ์ฌ์ฉํ๋ ค๋ ๋ฅ๋ฌ๋ ํ๋ ์์ํฌ(PyTorch, TensorFlow, ๊ทธ๋ฆฌ๊ณ /๋๋ Flax)๋ฅผ ์ค์นํ ํ ์๋ ๋ช
๋ น์ ์คํํด์ฃผ์ธ์:
```bash
pip install -e ".[quality]"
```
๋๋ถ๋ถ์ ๊ฒฝ์ฐ ์ด๊ฒ์ผ๋ก ์ถฉ๋ถํ ๊ฒ์
๋๋ค.
5. ๋ธ๋์น์์ ๊ธฐ๋ฅ์ ๊ฐ๋ฐํ์ธ์.
์ฝ๋๋ฅผ ์์
ํ๋ ๋์ ํ
์คํธ ์ค์ํธ(test suite)๊ฐ ํต๊ณผํ๋์ง ํ์ธํ์ธ์. ๋ค์๊ณผ ๊ฐ์ด ๋ณ๊ฒฝ ์ฌํญ์ ์ํฅ์ ๋ฐ๋ ํ
์คํธ๋ฅผ ์คํํ์ธ์:
```bash
pytest tests/<TEST_TO_RUN>.py
```
ํ
์คํธ์ ๋ํ ๋ ๋ง์ ์ ๋ณด๋ [ํ
์คํธ](https://huggingface.co/docs/transformers/testing) ๊ฐ์ด๋๋ฅผ ํ์ธํ์ธ์.
๐ค Transformers๋ `black`๊ณผ `ruff`๋ฅผ ์ฌ์ฉํ์ฌ ์์ค ์ฝ๋์ ํ์์ ์ผ๊ด๋๊ฒ ์ ์งํฉ๋๋ค. ๋ณ๊ฒฝ ์ฌํญ์ ์ ์ฉํ ํ์๋ ๋ค์ ๋ช
๋ น์ผ๋ก ์๋์ผ๋ก ์คํ์ผ ๊ต์ ๋ฐ ์ฝ๋ ๊ฒ์ฆ์ ์ํํ์ธ์:
```bash
make fixup
```
์ด๊ฒ์ ๋ํ ์์
์ค์ธ PR์์ ์์ ํ ํ์ผ์์๋ง ์๋ํ๋๋ก ์ต์ ํ๋์ด ์์ต๋๋ค.
๊ฒ์ฌ๋ฅผ ํ๋์ฉ ์คํํ๋ ค๋ ๊ฒฝ์ฐ, ๋ค์ ๋ช
๋ น์ผ๋ก ์คํ์ผ ๊ต์ ์ ์ ์ฉํ ์ ์์ต๋๋ค:
```bash
make style
```
๐ค Transformers๋ ๋ํ `ruff`์ ๋ช ๊ฐ์ง ์ฌ์ฉ์ ์ ์ ์คํฌ๋ฆฝํธ๋ฅผ ์ฌ์ฉํ์ฌ ์ฝ๋ฉ ์ค์๋ฅผ ํ์ธํฉ๋๋ค. CI๋ฅผ ํตํด ํ์ง ๊ด๋ฆฌ๊ฐ ์ํ๋์ง๋ง, ๋ค์ ๋ช
๋ น์ผ๋ก ๋์ผํ ๊ฒ์ฌ๋ฅผ ์คํํ ์ ์์ต๋๋ค:
```bash
make quality
```
๋ง์ง๋ง์ผ๋ก, ์ ๋ชจ๋ธ์ ์ถ๊ฐํ ๋ ์ผ๋ถ ํ์ผ์ ์
๋ฐ์ดํธํ๋ ๊ฒ์ ์์ง ์๋๋ก ํ๊ธฐ ์ํ ๋ง์ ์คํฌ๋ฆฝํธ๊ฐ ์์ต๋๋ค. ๋ค์ ๋ช
๋ น์ผ๋ก ์ด๋ฌํ ์คํฌ๋ฆฝํธ๋ฅผ ์คํํ ์ ์์ต๋๋ค:
```bash
make repo-consistency
```
์ด๋ฌํ ๊ฒ์ฌ์ ๋ํด ์์ธํ ์์๋ณด๊ณ ๊ด๋ จ ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ๋ ๋ฐฉ๋ฒ์ [Pull Request์ ๋ํ ๊ฒ์ฌ](https://huggingface.co/docs/transformers/pr_checks) ๊ฐ์ด๋๋ฅผ ํ์ธํ์ธ์.
๋ง์ฝ `docs/source` ๋๋ ํฐ๋ฆฌ ์๋์ ๋ฌธ์๋ฅผ ์์ ํ๋ ๊ฒฝ์ฐ, ๋ฌธ์๊ฐ ๋น๋๋ ์ ์๋์ง ํ์ธํ์ธ์. ์ด ๊ฒ์ฌ๋ Pull Request๋ฅผ ์ด ๋๋ CI์์ ์คํ๋ฉ๋๋ค. ๋ก์ปฌ ๊ฒ์ฌ๋ฅผ ์คํํ๋ ค๋ฉด ๋ฌธ์ ๋น๋๋ฅผ ์ค์นํด์ผ ํฉ๋๋ค:
```bash
pip install ".[docs]"
```
์ ์ฅ์์ ๋ฃจํธ ๋๋ ํฐ๋ฆฌ์์ ๋ค์ ๋ช
๋ น์ ์คํํ์ธ์:
```bash
doc-builder build transformers docs/source/en --build_dir ~/tmp/test-build
```
์ด ๋ช
๋ น์ `~/tmp/test-build` ํด๋์ ๋ฌธ์๋ฅผ ๋น๋ํ๋ฉฐ, ์์ฑ๋ Markdown ํ์ผ์ ์ ํธํ๋ ํธ์ง๊ธฐ๋ก ํ์ธํ ์ ์์ต๋๋ค. Pull Request๋ฅผ ์ด ๋ GitHub์์ ๋ฌธ์๋ฅผ ๋ฏธ๋ฆฌ ๋ณผ ์๋ ์์ต๋๋ค.
๋ณ๊ฒฝ ์ฌํญ์ ๋ง์กฑํ๋ฉด `git add`๋ก ๋ณ๊ฒฝ๋ ํ์ผ์ ์ถ๊ฐํ๊ณ , `git commit`์ผ๋ก ๋ณ๊ฒฝ ์ฌํญ์ ๋ก์ปฌ์ ๊ธฐ๋กํ์ธ์:
```bash
git add modified_file.py
git commit
```
[์ข์ ์ปค๋ฐ ๋ฉ์์ง](https://chris.beams.io/posts/git-commit/)๋ฅผ ์์ฑํ์ฌ ๋ณ๊ฒฝ ์ฌํญ์ ๋ช
ํํ๊ฒ ์ ๋ฌํ์ธ์!
๋ณ๊ฒฝ ์ฌํญ์ ํ๋ก์ ํธ ์๋ณธ ์ ์ฅ์์ ๋๊ธฐํํ๋ ค๋ฉด, PR์ *์ด๊ธฐ ์ ์* ๋ธ๋์น๋ฅผ `upstream/branch`๋ก ๋ฆฌ๋ฒ ์ด์ค(rebase)ํ์ธ์. ๋๋ ๊ด๋ฆฌ์์ ์์ฒญ์ ์ด ์์
์ด ํ์ํ ์ ์์ต๋๋ค:
```bash
git fetch upstream
git rebase upstream/main
```
๋ณ๊ฒฝ ์ฌํญ์ ๋ธ๋์น์ ํธ์ํ์ธ์:
```bash
git push -u origin a-descriptive-name-for-my-changes
```
์ด๋ฏธ PR์ ์ด์๋ค๋ฉด, `--force` ํ๋๊ทธ์ ํจ๊ป ๊ฐ์ ํธ์ํด์ผ ํฉ๋๋ค. ์์ง PR์ด ์ด๋ฆฌ์ง ์์๋ค๋ฉด ์ ์์ ์ผ๋ก ๋ณ๊ฒฝ ์ฌํญ์ ํธ์ํ๋ฉด ๋ฉ๋๋ค.
6. ์ด์ GitHub์์ ํฌํฌํ ์ ์ฅ์๋ก ์ด๋ํ๊ณ **Pull request(ํ ๋ฆฌํ์คํธ)**๋ฅผ ํด๋ฆญํ์ฌ Pull Request๋ฅผ ์ด ์ ์์ต๋๋ค. ์๋์ [์ฒดํฌ๋ฆฌ์คํธ](https://github.com/huggingface/transformers/blob/main/CONTRIBUTING.md/#pull-request-checklist)์์ ๋ชจ๋ ํญ๋ชฉ์ ์ฒดํฌ ํ์๋ฅผ ํ์ธ์. ์ค๋น๊ฐ ์๋ฃ๋๋ฉด ํ๋ก์ ํธ ๊ด๋ฆฌ์์๊ฒ ๋ณ๊ฒฝ ์ฌํญ์ ๋ณด๋ด ๊ฒํ ๋ฅผ ์์ฒญํ ์ ์์ต๋๋ค.
7. ๊ด๋ฆฌ์๊ฐ ๋ณ๊ฒฝ ์ฌํญ์ ์์ฒญํด๋ ๊ด์ฐฎ์ต๋๋ค. ํต์ฌ ๊ธฐ์ฌ์๋ค๋ ๋์ผํ ์ํฉ์ ๊ฒช์ต๋๋ค! ๋ชจ๋๊ฐ ๋ณ๊ฒฝ ์ฌํญ์ Pull Request์์ ๋ณผ ์ ์๋๋ก, ๋ก์ปฌ ๋ธ๋์น์์ ์์
ํ๊ณ ๋ณ๊ฒฝ ์ฌํญ์ ํฌํฌํ ์ ์ฅ์๋ก ํธ์ํ์ธ์. ๊ทธ๋ฌ๋ฉด ๋ณ๊ฒฝ ์ฌํญ์ด ์๋์ผ๋ก Pull Request์ ๋ํ๋ฉ๋๋ค.
### Pull Request ์ฒดํฌ๋ฆฌ์คํธ [[pull-request-checklist]]
โ Pull Request ์ ๋ชฉ์ ๊ธฐ์ฌ ๋ด์ฉ์ ์์ฝํด์ผ ํฉ๋๋ค.<br>
โ Pull Request๊ฐ ์ด์๋ฅผ ํด๊ฒฐํ๋ ๊ฒฝ์ฐ, Pull Request ์ค๋ช
์ ์ด์ ๋ฒํธ๋ฅผ ์ธ๊ธํ์ฌ ์ฐ๊ด๋์ด ์์์ ์๋ ค์ฃผ์ธ์. (์ด์๋ฅผ ํ์ธํ๋ ์ฌ๋๋ค์ด ํด๋น ์ด์์ ๋ํ ์์
์ด ์งํ ์ค์์ ์ ์ ์๊ฒ ํฉ๋๋ค).<br>
โ ์์
์ด ์งํ์ค์ด๋ผ๋ฉด ์ ๋ชฉ ์์ `[WIP]`๋ฅผ ๋ถ์ฌ์ฃผ์ธ์. ์ค๋ณต ์์
์ ํผํ๊ณ ๋ณํฉํ ์ค๋น๊ฐ ๋ PR๊ณผ ๊ตฌ๋ถํ๊ธฐ์ ์ ์ฉํฉ๋๋ค.<br>
โ ๊ธฐ์กด ํ
์คํธ๋ฅผ ํต๊ณผํ๋์ง ํ์ธํ์ธ์.<br>
โ ์๋ก์ด ๊ธฐ๋ฅ์ ์ถ๊ฐํ๋ ๊ฒฝ์ฐ, ํด๋น ๊ธฐ๋ฅ์ ๋ํ ํ
์คํธ๋ ์ถ๊ฐํ์ธ์.<br>
- ์ ๋ชจ๋ธ์ ์ถ๊ฐํ๋ ๊ฒฝ์ฐ, `ModelTester.all_model_classes = (MyModel, MyModelWithLMHead,...)`์ ์ฌ์ฉํ์ฌ ์ผ๋ฐ์ ์ธ ํ
์คํธ๋ฅผ ํ์ฑํํ์ธ์.
- ์ `@slow` ํ
์คํธ๋ฅผ ์ถ๊ฐํ๋ ๊ฒฝ์ฐ, ๋ค์ ๋ช
๋ น์ผ๋ก ํ
์คํธ๋ฅผ ํต๊ณผํ๋์ง ํ์ธํ์ธ์: `RUN_SLOW=1 python -m pytest tests/models/my_new_model/test_my_new_model.py`.
- ์ ํ ํฌ๋์ด์ ๋ฅผ ์ถ๊ฐํ๋ ๊ฒฝ์ฐ, ํ
์คํธ๋ฅผ ์์ฑํ๊ณ ๋ค์ ๋ช
๋ น์ผ๋ก ํ
์คํธ๋ฅผ ํต๊ณผํ๋์ง ํ์ธํ์ธ์: `RUN_SLOW=1 python -m pytest tests/models/{your_model_name}/test_tokenization_{your_model_name}.py`.
- CircleCI์์๋ ๋๋ฆฐ ํ
์คํธ๋ฅผ ์คํํ์ง ์์ง๋ง, GitHub Actions์์๋ ๋งค์ผ ๋ฐค ์คํ๋ฉ๋๋ค!<br>
โ ๋ชจ๋ ๊ณต๊ฐ ๋ฉ์๋๋ ์ ์ฉํ ๊ธฐ์ ๋ฌธ์๋ฅผ ๊ฐ์ ธ์ผ ํฉ๋๋ค (์๋ฅผ ๋ค์ด [`modeling_bert.py`](https://github.com/huggingface/transformers/blob/main/src/transformers/models/bert/modeling_bert.py) ์ฐธ์กฐ).<br>
โ ์ ์ฅ์๊ฐ ๋น ๋ฅด๊ฒ ์ฑ์ฅํ๊ณ ์์ผ๋ฏ๋ก ์ ์ฅ์์ ์๋นํ ๋ถ๋ด์ ์ฃผ๋ ์ด๋ฏธ์ง, ๋์์ ๋ฐ ๊ธฐํ ํ
์คํธ๊ฐ ์๋ ํ์ผ์ ์ถ๊ฐํ์ง ๋ง์ธ์. ๋์ [`hf-internal-testing`](https://huggingface.co/hf-internal-testing)๊ณผ ๊ฐ์ Hub ์ ์ฅ์๋ฅผ ์ฌ์ฉํ์ฌ ์ด๋ฌํ ํ์ผ์ ํธ์คํ
ํ๊ณ URL๋ก ์ฐธ์กฐํ์ธ์. ๋ฌธ์์ ๊ด๋ จ๋ ์ด๋ฏธ์ง๋ ๋ค์ ์ ์ฅ์์ ๋ฐฐ์นํ๋ ๊ฒ์ ๊ถ์ฅํฉ๋๋ค: [huggingface/documentation-images](https://huggingface.co/datasets/huggingface/documentation-images). ์ด ๋ฐ์ดํฐ์
์ ์ฅ์์์ PR์ ์ด์ด์ Hugging Face ๋ฉค๋ฒ์๊ฒ ๋ณํฉ์ ์์ฒญํ ์ ์์ต๋๋ค.
Pull Request์์ ์คํ๋๋ ๊ฒ์ฌ์ ๋ํ ์์ธํ ์ ๋ณด๋ [Pull Request์ ๋ํ ๊ฒ์ฌ](https://huggingface.co/docs/transformers/pr_checks) ๊ฐ์ด๋๋ฅผ ํ์ธํ์ธ์.
### ํ
์คํธ [[tests]]
๋ผ์ด๋ธ๋ฌ๋ฆฌ ๋์๊ณผ ์ฌ๋ฌ ์์ ๋ฅผ ํ
์คํธํ ์ ์๋ ๊ด๋ฒ์ํ ํ
์คํธ ์ค์ํธ๊ฐ ํฌํจ๋์ด ์์ต๋๋ค. ๋ผ์ด๋ธ๋ฌ๋ฆฌ ํ
์คํธ๋ [tests](https://github.com/huggingface/transformers/tree/main/tests) ํด๋์, ์์ ํ
์คํธ๋ [examples](https://github.com/huggingface/transformers/tree/main/examples) ํด๋์ ์์ต๋๋ค.
์๋๊ฐ ๋น ๋ฅธ `pytest`์ `pytest-xdist`๋ฅผ ์ ํธํฉ๋๋ค. ์ ์ฅ์์ ๋ฃจํธ ๋๋ ํฐ๋ฆฌ์์ ํ
์คํธ๋ฅผ ์คํํ *ํ์ ํด๋ ๊ฒฝ๋ก ๋๋ ํ
์คํธ ํ์ผ ๊ฒฝ๋ก*๋ฅผ ์ง์ ํ์ธ์:
```bash
python -m pytest -n auto --dist=loadfile -s -v ./tests/models/my_new_model
```
๋ง์ฐฌ๊ฐ์ง๋ก `examples` ๋๋ ํฐ๋ฆฌ์์๋ *ํ์ ํด๋ ๊ฒฝ๋ก ๋๋ ํ
์คํธ ํ์ผ ๊ฒฝ๋ก*๋ฅผ ์ง์ ํ์ธ์. ์๋ฅผ ๋ค์ด, ๋ค์ ๋ช
๋ น์ PyTorch `examples` ๋๋ ํฐ๋ฆฌ์ ํ
์คํธ ๋ถ๋ฅ ํ์ ํด๋๋ฅผ ํ
์คํธํฉ๋๋ค:
```bash
pip install -r examples/xxx/requirements.txt # only needed the first time
python -m pytest -n auto --dist=loadfile -s -v ./examples/pytorch/text-classification
```
์ด๊ฒ์ด ์ค์ ๋ก `make test` ๋ฐ `make test-examples` ๋ช
๋ น์ด ๊ตฌํ๋๋ ๋ฐฉ์์
๋๋ค (`pip install`์ ์ ์ธํฉ๋๋ค)!
๋ํ ํน์ ๊ธฐ๋ฅ๋ง ํ
์คํธํ๊ธฐ ์ํ ๋ ์์ ํ
์คํธ๋ฅผ ์ง์ ํ ์ ์์ต๋๋ค.
๊ธฐ๋ณธ์ ์ผ๋ก ๋๋ฆฐ ํ
์คํธ๋ ๊ฑด๋๋ฐ์ง๋ง `RUN_SLOW` ํ๊ฒฝ ๋ณ์๋ฅผ `yes`๋ก ์ค์ ํ์ฌ ์คํํ ์ ์์ต๋๋ค. ์ด๋ ๊ฒ ํ๋ฉด ๋ง์ ๊ธฐ๊ฐ๋ฐ์ดํธ ๋จ์์ ๋ชจ๋ธ์ด ๋ค์ด๋ก๋๋๋ฏ๋ก ์ถฉ๋ถํ ๋์คํฌ ๊ณต๊ฐ, ์ข์ ์ธํฐ๋ท ์ฐ๊ฒฐ๊ณผ ๋ง์ ์ธ๋ด๊ฐ ํ์ํฉ๋๋ค!
<Tip warning={true}>
ํ
์คํธ๋ฅผ ์คํํ๋ ค๋ฉด *ํ์ ํด๋ ๊ฒฝ๋ก ๋๋ ํ
์คํธ ํ์ผ ๊ฒฝ๋ก*๋ฅผ ์ง์ ํ์ธ์. ๊ทธ๋ ์ง ์์ผ๋ฉด `tests` ๋๋ `examples` ํด๋์ ๋ชจ๋ ํ
์คํธ๋ฅผ ์คํํ๊ฒ ๋์ด ๋งค์ฐ ๊ธด ์๊ฐ์ด ๊ฑธ๋ฆฝ๋๋ค!
</Tip>
```bash
RUN_SLOW=yes python -m pytest -n auto --dist=loadfile -s -v ./tests/models/my_new_model
RUN_SLOW=yes python -m pytest -n auto --dist=loadfile -s -v ./examples/pytorch/text-classification
```
๋๋ฆฐ ํ
์คํธ์ ๋ง์ฐฌ๊ฐ์ง๋ก, ๋ค์๊ณผ ๊ฐ์ด ํ
์คํธ ์ค์ ๊ธฐ๋ณธ์ ์ผ๋ก ํ์ฑํ๋์ง ์๋ ๋ค๋ฅธ ํ๊ฒฝ ๋ณ์๋ ์์ต๋๋ค:
- `RUN_CUSTOM_TOKENIZERS`: ์ฌ์ฉ์ ์ ์ ํ ํฌ๋์ด์ ํ
์คํธ๋ฅผ ํ์ฑํํฉ๋๋ค.
- `RUN_PT_FLAX_CROSS_TESTS`: PyTorch + Flax ํตํฉ ํ
์คํธ๋ฅผ ํ์ฑํํฉ๋๋ค.
- `RUN_PT_TF_CROSS_TESTS`: TensorFlow + PyTorch ํตํฉ ํ
์คํธ๋ฅผ ํ์ฑํํฉ๋๋ค.
๋ ๋ง์ ํ๊ฒฝ ๋ณ์์ ์ถ๊ฐ ์ ๋ณด๋ [testing_utils.py](src/transformers/testing_utils.py)์์ ์ฐพ์ ์ ์์ต๋๋ค.
๐ค Transformers๋ ํ
์คํธ ์คํ๊ธฐ๋ก `pytest`๋ฅผ ์ฌ์ฉํฉ๋๋ค. ๊ทธ๋ฌ๋ ํ
์คํธ ์ค์ํธ ์์ฒด์์๋ `pytest` ๊ด๋ จ ๊ธฐ๋ฅ์ ์ฌ์ฉํ์ง ์์ต๋๋ค.
์ด๊ฒ์ `unittest`๊ฐ ์์ ํ ์ง์๋๋ค๋ ๊ฒ์ ์๋ฏธํฉ๋๋ค. ๋ค์์ `unittest`๋ก ํ
์คํธ๋ฅผ ์คํํ๋ ๋ฐฉ๋ฒ์
๋๋ค:
```bash
python -m unittest discover -s tests -t . -v
python -m unittest discover -s examples -t examples -v
```
### ์คํ์ผ ๊ฐ์ด๋ [[style-guide]]
๋ฌธ์๋ [Google Python ์คํ์ผ ๊ฐ์ด๋](https://google.github.io/styleguide/pyguide.html)๋ฅผ ๋ฐ๋ฆ
๋๋ค. ์์ธํ ์ ๋ณด๋ [๋ฌธ์ ์์ฑ ๊ฐ์ด๋](https://github.com/huggingface/transformers/tree/main/docs#writing-documentation---specification)๋ฅผ ํ์ธํ์ธ์.
### Windows์์ ๊ฐ๋ฐ [[develop-on-windows]]
Windows์์ ๊ฐ๋ฐํ ๊ฒฝ์ฐ([Windows Subsystem for Linux](https://learn.microsoft.com/en-us/windows/wsl/) ๋๋ WSL์์ ์์
ํ์ง ์๋ ํ) Windows `CRLF` ์ค ๋ฐ๊ฟ์ Linux `LF` ์ค ๋ฐ๊ฟ์ผ๋ก ๋ณํํ๋๋ก git์ ๊ตฌ์ฑํด์ผ ํฉ๋๋ค:
```bash
git config core.autocrlf input
```
Windows์์ `make` ๋ช
๋ น์ ์คํํ๋ ํ ๊ฐ์ง ๋ฐฉ๋ฒ์ MSYS2๋ฅผ ์ฌ์ฉํ๋ ๊ฒ์
๋๋ค:
1. [MSYS2](https://www.msys2.org/)๋ฅผ ๋ค์ด๋ก๋ํฉ๋๋ค. `C:\msys64`์ ์ค์น๋์๋ค๊ณ ๊ฐ์ ํฉ๋๋ค.
2. CLI์์ `C:\msys64\msys2.exe`๋ฅผ ์ฝ๋๋ค (์์ ๋ฉ๋ด์์ ์ฌ์ฉ ๊ฐ๋ฅํด์ผ ํจ).
3. ์์์ ๋ค์์ ์คํํ์ฌ: `pacman -Syu` ๋ฐ `pacman -S make`๋ก `make`๋ฅผ ์ค์นํฉ๋๋ค.
4. ํ๊ฒฝ ๋ณ์ PATH์ `C:\msys64\usr\bin`์ ์ถ๊ฐํ์ธ์.
์ด์ ๋ชจ๋ ํฐ๋ฏธ๋ (PowerShell, cmd.exe ๋ฑ)์์ `make`๋ฅผ ์ฌ์ฉํ ์ ์์ต๋๋ค! ๐
### ํฌํฌํ ์ ์ฅ์๋ฅผ ์์ ์๋ณธ ๋ธ๋์น(main)๊ณผ ๋๊ธฐํํ๊ธฐ (Hugging Face ์ ์ฅ์) [[sync-a-forked-repository-with-upstream-main-the-hugging-face-repository]]
ํฌํฌํ ์ ์ฅ์์ main ๋ธ๋์น๋ฅผ ์
๋ฐ์ดํธํ ๋, ๋ค์ ๋จ๊ณ๋ฅผ ๋ฐ๋ผ ์ํํด์ฃผ์ธ์. ์ด๋ ๊ฒ ํ๋ฉด ๊ฐ upstream PR์ ์ฐธ์กฐ ๋
ธํธ๊ฐ ์ถ๊ฐ๋๋ ๊ฒ์ ํผํ๊ณ ์ด๋ฌํ PR์ ๊ด์ฌํ๋ ๊ฐ๋ฐ์๋ค์๊ฒ ๋ถํ์ํ ์๋ฆผ์ด ์ ์ก๋๋ ๊ฒ์ ๋ฐฉ์งํ ์ ์์ต๋๋ค.
1. ๊ฐ๋ฅํ๋ฉด ํฌํฌ๋ ์ ์ฅ์์ ๋ธ๋์น ๋ฐ PR์ ์ฌ์ฉํ์ฌ upstream๊ณผ ๋๊ธฐํํ์ง ๋ง์ธ์. ๋์ ํฌํฌ๋ main ์ ์ฅ์์ ์ง์ ๋ณํฉํ์ธ์.
2. PR์ด ๋ฐ๋์ ํ์ํ ๊ฒฝ์ฐ, ๋ธ๋์น๋ฅผ ํ์ธํ ํ ๋ค์ ๋จ๊ณ๋ฅผ ์ฌ์ฉํ์ธ์:
```bash
git checkout -b your-branch-for-syncing
git pull --squash --no-commit upstream main
git commit -m '<your message without GitHub references>'
git push --set-upstream origin your-branch-for-syncing
```
| 0 |