개발자로서 현장에서 일하면서 새로 접하는 기술들이나 알게된 정보 등을 정리하기 위한 블로그입니다. 운 좋게 미국에서 큰 회사들의 프로젝트에서 컬설턴트로 일하고 있어서 새로운 기술들을 접할 기회가 많이 있습니다. 미국의 IT 프로젝트에서 사용되는 툴들에 대해 많은 분들과 정보를 공유하고 싶습니다.
Installing Microk8s on Windows 11 Home is not directly supported. However, you can install Microk8s using the Windows Subsystem for Linux (WSL). Here are the steps to do so on Windows 11 Home:
Install WSL:
To use Linux on Windows, you must first install WSL. Run PowerShell as an administrator and enter the following command:
wsl --install
This command installs WSL and typically installs a default Linux distribution, such as Ubuntu.
Update and Set Up WSL:
WSL2 offers better performance for running Docker and Kubernetes. To upgrade to WSL2, execute:
wsl --set-default-version 2
After installing WSL, you can install your preferred Linux distribution from the Microsoft Store, such as Ubuntu.
Prepare to Install Microk8s:
Launch your Linux distribution and update your system:
sudo apt update&& sudo apt upgrade
Install Snap:
If Snap is not pre-installed in Ubuntu, install it with:
sudo apt install snapd
Install Microk8s:
Install Microk8s using the following command:
sudo snap install microk8s --classic
After installation, add your user to the microk8s group to run Microk8s commands without sudo:
Windows 11 Home에서 Microk8s를 직접 설치하는 것은 지원되지 않습니다. 그러나 Windows Subsystem for Linux (WSL)을 사용하여 Microk8s를 설치할 수 있습니다. 다음은 Windows 11 Home에서 Microk8s를 설치하는 단계입니다:
WSL 설치하기:
Windows에서 Linux 환경을 사용하기 위해 PowerShell을 관리자 권한으로 실행한 후 다음 명령어를 입력합니다:
wsl --install
이 명령어는 WSL을 설치하고 일반적으로 Ubuntu와 같은 기본 Linux 배포판을 자동으로 설치합니다.
WSL 업데이트 및 설정:
Docker와 Kubernetes를 실행하기 위한 더 나은 성능을 제공하는 WSL2로 업데이트하려면 다음 명령을 실행합니다:
wsl --set-default-version 2
WSL 설치가 완료된 후, Microsoft Store에서 선호하는 Linux 배포판을 설치할 수 있습니다.
Microk8s 설치 준비:
Linux 배포판을 실행하고, 시스템을 최신 상태로 업데이트합니다:
sudo apt update&& sudo apt upgrade
Snap 설치:
Ubuntu에 Snap이 기본적으로 설치되어 있지 않을 수 있으므로, Snap을 설치합니다:
sudo apt install snapd
Microk8s 설치:
다음 명령어를 사용하여 Microk8s를 설치합니다:
sudo snap install microk8s --classic
Microk8s 설치 후, 사용자를 microk8s 그룹에 추가하여 sudo 없이 microk8s 명령을 실행할 수 있도록 합니다:
This is the end of the first part of the course! Part 2 will be released on November 15th with a big community event, see more informationhere.
이것으로 강좌의 첫 번째 부분이 끝났습니다! 파트 2는 대규모 커뮤니티 이벤트와 함께 11월 15일에 출시될 예정입니다. 자세한 내용은 여기에서 확인하세요.
You should now be able to fine-tune a pretrained model on a text classification problem (single or pairs of sentences) and upload the result to the Model Hub. To make sure you mastered this first section, you should do exactly that on a problem that interests you (and not necessarily in English if you speak another language)! You can find help in theHugging Face forumsand share your project inthis topiconce you’re finished.
이제 텍스트 분류 문제(단일 또는 쌍의 문장)에 대해 사전 학습된 모델을 미세 조정하고 결과를 모델 허브에 업로드할 수 있습니다. 이 첫 번째 섹션을 완전히 마스터하려면 관심 있는 문제에 대해 정확하게 해당 섹션을 완료해야 합니다(다른 언어를 사용하는 경우 반드시 영어로 할 필요는 없음)! Hugging Face 포럼에서 도움을 찾을 수 있으며 작업이 끝나면 이 주제에서 프로젝트를 공유할 수 있습니다.
We can’t wait to see what you will build with this!
The model card is a file which is arguably as important as the model and tokenizer files in a model repository. It is the central definition of the model, ensuring reusability by fellow community members and reproducibility of results, and providing a platform on which other members may build their artifacts.
모델 카드는 모델 저장소의 모델 및 토크나이저 파일만큼 중요한 파일입니다. 이는 모델의 핵심 정의로, 동료 커뮤니티 구성원의 재사용성과 결과 재현성을 보장하고 다른 구성원이 아티팩트를 구축할 수 있는 플랫폼을 제공합니다.
Documenting the training and evaluation process helps others understand what to expect of a model — and providing sufficient information regarding the data that was used and the preprocessing and postprocessing that were done ensures that the limitations, biases, and contexts in which the model is and is not useful can be identified and understood.
교육 및 평가 프로세스를 문서화하면 다른 사람들이 모델에 대해 기대하는 바를 이해하는 데 도움이 됩니다. 사용된 데이터와 수행된 전처리 및 후처리에 대한 충분한 정보를 제공하면 모델이 존재하는 한계, 편향 및 맥락을 보장할 수 있습니다. 유용하지 않은 것을 식별하고 이해할 수 있습니다.
Therefore, creating a model card that clearly defines your model is a very important step. Here, we provide some tips that will help you with this. Creating the model card is done through theREADME.mdfile you saw earlier, which is a Markdown file.
따라서 모델을 명확하게 정의하는 모델 카드를 만드는 것은 매우 중요한 단계입니다. 여기서는 이에 도움이 될 몇 가지 팁을 제공합니다. 모델 카드 생성은 앞서 본 Markdown 파일인 README.md 파일을 통해 이루어집니다.
The “model card” concept originates from a research direction from Google, first shared in the paper“Model Cards for Model Reporting”by Margaret Mitchell et al. A lot of information contained here is based on that paper, and we recommend you take a look at it to understand why model cards are so important in a world that values reproducibility, reusability, and fairness.
"모델 카드" 개념은 Margaret Mitchell 외 연구진이 "모델 보고를 위한 모델 카드" 논문에서 처음 공유한 Google의 연구 방향에서 비롯되었습니다. 여기에 포함된 많은 정보는 해당 논문을 기반으로 하며, 재현성, 재사용성 및 공정성을 중시하는 세계에서 모델 카드가 왜 그토록 중요한지 이해하기 위해 이 문서를 살펴보는 것이 좋습니다.
The model card usually starts with a very brief, high-level overview of what the model is for, followed by additional details in the following sections:
모델 카드는 일반적으로 모델의 용도에 대한 매우 간단하고 높은 수준의 개요로 시작하고 다음 섹션의 추가 세부정보가 이어집니다.
Model description. 모델 설명
Intended uses & limitations 용도 및 제한 사항
How to use 사용하는 방법
Limitations and bias 한계와 편견
Training data 훈련 데이터
Training procedure 훈련 절차
Evaluation results 평가 결과
Let’s take a look at what each of these sections should contain.
각 섹션에 어떤 내용이 포함되어야 하는지 살펴보겠습니다.
Model description
The model description provides basic details about the model. This includes the architecture, version, if it was introduced in a paper, if an original implementation is available, the author, and general information about the model. Any copyright should be attributed here. General information about training procedures, parameters, and important disclaimers can also be mentioned in this section.
모델 설명은 모델에 대한 기본 세부정보를 제공합니다. 여기에는 아키텍처, 버전, 논문에 소개된 경우, 원래 구현이 가능한 경우, 작성자 및 모델에 대한 일반 정보가 포함됩니다. 모든 저작권은 여기에 귀속되어야 합니다. 훈련 절차, 매개변수 및 중요한 면책 조항에 대한 일반 정보도 이 섹션에서 언급될 수 있습니다.
Intended uses & limitations
Here you describe the use cases the model is intended for, including the languages, fields, and domains where it can be applied. This section of the model card can also document areas that are known to be out of scope for the model, or where it is likely to perform suboptimally.
여기서는 모델이 적용될 수 있는 언어, 필드 및 도메인을 포함하여 모델의 사용 사례를 설명합니다. 모델 카드의 이 섹션은 모델의 범위를 벗어나는 것으로 알려진 영역이나 최적이 아닌 성능을 발휘할 가능성이 있는 영역을 문서화할 수도 있습니다.
How to use
This section should include some examples of how to use the model. This can showcase usage of thepipeline()function, usage of the model and tokenizer classes, and any other code you think might be helpful.
이 섹션에는 모델 사용 방법에 대한 몇 가지 예가 포함되어야 합니다. 이는 파이프라인() 함수의 사용법, 모델 및 토크나이저 클래스의 사용법, 도움이 될 수 있다고 생각되는 기타 코드를 보여줄 수 있습니다.
Training data
This part should indicate which dataset(s) the model was trained on. A brief description of the dataset(s) is also welcome.
이 부분은 모델이 훈련된 데이터세트를 나타내야 합니다. 데이터 세트에 대한 간략한 설명도 환영합니다.
Training procedure
In this section you should describe all the relevant aspects of training that are useful from a reproducibility perspective. This includes any preprocessing and postprocessing that were done on the data, as well as details such as the number of epochs the model was trained for, the batch size, the learning rate, and so on.
이 섹션에서는 재현성 관점에서 유용한 훈련의 모든 관련 측면을 설명해야 합니다. 여기에는 데이터에 대해 수행된 전처리 및 후처리뿐만 아니라 모델이 훈련된 시대 수, 배치 크기, 학습 속도 등과 같은 세부 정보도 포함됩니다.
Variable and metrics
Here you should describe the metrics you use for evaluation, and the different factors you are mesuring. Mentioning which metric(s) were used, on which dataset and which dataset split, makes it easy to compare you model’s performance compared to that of other models. These should be informed by the previous sections, such as the intended users and use cases.
여기에서는 평가에 사용하는 측정항목과 측정하는 다양한 요소를 설명해야 합니다. 어떤 측정항목이 사용되었는지, 어떤 데이터세트에 어떤 데이터세트가 분할되었는지 언급하면 모델의 성능을 다른 모델의 성능과 쉽게 비교할 수 있습니다. 이는 의도된 사용자 및 사용 사례와 같은 이전 섹션을 통해 알려야 합니다.
Evaluation results
Finally, provide an indication of how well the model performs on the evaluation dataset. If the model uses a decision threshold, either provide the decision threshold used in the evaluation, or provide details on evaluation at different thresholds for the intended uses.
마지막으로 모델이 평가 데이터 세트에서 얼마나 잘 수행되는지 표시합니다. 모델이 결정 임계값을 사용하는 경우 평가에 사용되는 결정 임계값을 제공하거나 의도된 용도에 대해 다양한 임계값에서의 평가에 대한 세부 정보를 제공합니다.
Example
Check out the following for a few examples of well-crafted model cards:
More examples from different organizations and companies are availablehere.
여기에서 다양한 조직 및 회사의 더 많은 사례를 확인할 수 있습니다.
Note
Model cards are not a requirement when publishing models, and you don’t need to include all of the sections described above when you make one. However, explicit documentation of the model can only benefit future users, so we recommend that you fill in as many of the sections as possible to the best of your knowledge and ability.
모델을 게시할 때 모델 카드는 필수 사항이 아니며, 모델을 만들 때 위에 설명된 모든 섹션을 포함할 필요는 없습니다. 그러나 모델에 대한 명시적인 문서화는 미래의 사용자에게만 도움이 될 수 있으므로 귀하의 지식과 능력을 최대한 활용하여 가능한 한 많은 섹션을 작성하는 것이 좋습니다.
Model card metadata
If you have done a little exploring of the Hugging Face Hub, you should have seen that some models belong to certain categories: you can filter them by tasks, languages, libraries, and more. The categories a model belongs to are identified according to the metadata you add in the model card header.
Hugging Face Hub를 조금 탐색했다면 일부 모델이 특정 범주에 속한다는 것을 알았을 것입니다. 작업, 언어, 라이브러리 등을 기준으로 필터링할 수 있습니다. 모델이 속한 카테고리는 모델 카드 헤더에 추가한 메타데이터에 따라 식별됩니다.
For example, if you take a look at thecamembert-basemodel card, you should see the following lines in the model card header:
---
language: fr
license: mit
datasets:
- oscar
---
This metadata is parsed by the Hugging Face Hub, which then identifies this model as being a French model, with an MIT license, trained on the Oscar dataset.
이 메타데이터는 Hugging Face Hub에 의해 구문 분석되며, 그런 다음 이 모델을 Oscar 데이터 세트에서 훈련된 MIT 라이선스를 갖춘 프랑스 모델로 식별합니다.
Thefull model card specificationallows specifying languages, licenses, tags, datasets, metrics, as well as the evaluation results the model obtained when training.
The full model card specification allows specifying languages, licenses, tags, datasets, metrics, as well as the evaluation results the model obtained when training.
In the steps below, we’ll take a look at the easiest ways to share pretrained models to the 🤗 Hub. There are tools and utilities available that make it simple to share and update models directly on the Hub, which we will explore below.
아래 단계에서는 사전 학습된 모델을 🤗 허브에 공유하는 가장 쉬운 방법을 살펴보겠습니다. 허브에서 직접 모델을 간단하게 공유하고 업데이트할 수 있는 도구와 유틸리티가 있습니다. 이에 대해서는 아래에서 살펴보겠습니다.
We encourage all users that train models to contribute by sharing them with the community — sharing models, even when trained on very specific datasets, will help others, saving them time and compute resources and providing access to useful trained artifacts. In turn, you can benefit from the work that others have done!
우리는 모델을 훈련하는 모든 사용자가 커뮤니티와 공유함으로써 기여하도록 권장합니다. 모델을 공유하면 매우 특정한 데이터 세트에 대해 훈련을 받은 경우에도 다른 사람에게 도움이 되고 시간을 절약하며 리소스를 계산하고 유용한 훈련된 아티팩트에 대한 액세스를 제공할 수 있습니다. 그러면 당신도 다른 사람들이 한 일로부터 유익을 얻을 수 있습니다!
There are three ways to go about creating new model repositories:
새 모델 리포지토리를 만드는 방법에는 세 가지가 있습니다.
Using thepush_to_hubAPI
push_to_hub API 사용
Using thehuggingface_hubPython library
Huggingface_hub Python 라이브러리 사용
Using the web interface
웹 인터페이스 사용
Once you’ve created a repository, you can upload files to it via git and git-lfs. We’ll walk you through creating model repositories and uploading files to them in the following sections.
저장소를 생성한 후에는 git 및 git-lfs를 통해 파일을 업로드할 수 있습니다. 다음 섹션에서는 모델 리포지토리를 생성하고 여기에 파일을 업로드하는 과정을 안내합니다.
The simplest way to upload files to the Hub is by leveraging thepush_to_hubAPI.
허브에 파일을 업로드하는 가장 간단한 방법은 push_to_hub API를 활용하는 것입니다.
Before going further, you’ll need to generate an authentication token so that thehuggingface_hubAPI knows who you are and what namespaces you have write access to. Make sure you are in an environment where you havetransformersinstalled (seeSetup). If you are in a notebook, you can use the following function to login:
더 진행하기 전에, Huggingface_hub API가 당신 누구인지, 어떤 네임스페이스에 쓰기 액세스 권한이 있는지 알 수 있도록 인증 토큰을 생성해야 합니다. 변압기가 설치된 환경에 있는지 확인하십시오(설정 참조). 노트북에 있는 경우 다음 기능을 사용하여 로그인할 수 있습니다.
from huggingface_hub import notebook_login
notebook_login()
In a terminal, you can run:
huggingface-cli login
In both cases, you should be prompted for your username and password, which are the same ones you use to log in to the Hub. If you do not have a Hub profile yet, you should create onehere.
두 경우 모두 허브에 로그인하는 데 사용하는 것과 동일한 사용자 이름과 비밀번호를 입력하라는 메시지가 표시됩니다. 아직 허브 프로필이 없다면 여기에서 생성해야 합니다.
Great! You now have your authentication token stored in your cache folder. Let’s create some repositories!
Great ! 이제 인증 토큰이 캐시 폴더에 저장되었습니다. 저장소를 만들어 봅시다!
If you have played around with theTrainerAPI to train a model, the easiest way to upload it to the Hub is to setpush_to_hub=Truewhen you define yourTrainingArguments:
모델을 훈련하기 위해 Trainer API를 사용해 본 경우 이를 허브에 업로드하는 가장 쉬운 방법은 TrainingArguments를 정의할 때 push_to_hub=True를 설정하는 것입니다.
When you calltrainer.train(), theTrainerwill then upload your model to the Hub each time it is saved (here every epoch) in a repository in your namespace. That repository will be named like the output directory you picked (herebert-finetuned-mrpc) but you can choose a different name withhub_model_id = "a_different_name".
Trainer.train()을 호출하면 Trainer는 모델이 네임스페이스의 저장소에 저장될 때마다(여기에서는 매 에포크마다) 모델을 허브에 업로드합니다. 해당 저장소의 이름은 선택한 출력 디렉터리(여기서는 bert-finetuned-mrpc)와 같이 지정되지만,hub_model_id = "a_ Different_name"을 사용하여 다른 이름을 선택할 수 있습니다.
To upload your model to an organization you are a member of, just pass it withhub_model_id = "my_organization/my_repo_name".
당신이 소속된 organization 에 모델을 업로드하려면, Hub_model_id = "my_organization/my_repo_name"으로 전달하세요.
Once your training is finished, you should do a finaltrainer.push_to_hub()to upload the last version of your model. It will also generate a model card with all the relevant metadata, reporting the hyperparameters used and the evaluation results! Here is an example of the content you might find in a such a model card:
훈련이 완료되면 최종 training.push_to_hub()를 수행하여 모델의 마지막 버전을 업로드해야 합니다. 또한 사용된 하이퍼파라미터와 평가 결과를 보고하는 모든 관련 메타데이터가 포함된 모델 카드를 생성합니다! 다음은 이러한 모델 카드에서 찾을 수 있는 콘텐츠의 예입니다.
At a lower level, accessing the Model Hub can be done directly on models, tokenizers, and configuration objects via theirpush_to_hub()method. This method takes care of both the repository creation and pushing the model and tokenizer files directly to the repository. No manual handling is required, unlike with the API we’ll see below.
낮은 수준에서는 모델 허브에 대한 액세스가 push_to_hub() 메서드를 통해 모델, 토크나이저 및 구성 개체에서 직접 수행될 수 있습니다. 이 방법은 저장소 생성과 모델 및 토크나이저 파일을 저장소에 직접 푸시하는 작업을 모두 처리합니다. 아래에서 볼 API와 달리 수동 처리가 필요하지 않습니다.
To get an idea of how it works, let’s first initialize a model and a tokenizer:
작동 방식에 대한 아이디어를 얻으려면 먼저 모델과 토크나이저를 초기화해 보겠습니다.
from transformers import AutoModelForMaskedLM, AutoTokenizer
checkpoint = "camembert-base"
model = AutoModelForMaskedLM.from_pretrained(checkpoint)
tokenizer = AutoTokenizer.from_pretrained(checkpoint)
You’re free to do whatever you want with these — add tokens to the tokenizer, train the model, fine-tune it. Once you’re happy with the resulting model, weights, and tokenizer, you can leverage thepush_to_hub()method directly available on themodelobject:
토크나이저에 토큰을 추가하고, 모델을 훈련하고, 미세 조정하는 등 원하는 대로 무엇이든 자유롭게 할 수 있습니다. 결과 모델, 가중치 및 토크나이저에 만족하면 모델 객체에서 직접 사용할 수 있는 push_to_hub() 메서드를 활용할 수 있습니다.
model.push_to_hub("dummy-model")
This will create the new repositorydummy-modelin your profile, and populate it with your model files. Do the same with the tokenizer, so that all the files are now available in this repository:
그러면 프로필에 새 저장소 더미 모델이 생성되고 모델 파일이 채워집니다. 이제 토크나이저에서도 동일한 작업을 수행하여 이제 이 저장소에서 모든 파일을 사용할 수 있습니다.
tokenizer.push_to_hub("dummy-model")
If you belong to an organization, simply specify theorganizationargument to upload to that organization’s namespace:
Click on the “Files and versions” tab, and you should see the files visible in the following screenshot:
"파일 및 버전" 탭을 클릭하면 다음 스크린샷에 표시된 파일을 볼 수 있습니다.
✏️Try it out!Take the model and tokenizer associated with thebert-base-casedcheckpoint and upload them to a repo in your namespace using thepush_to_hub()method. Double-check that the repo appears properly on your page before deleting it.
✏️ 한번 사용해 보세요! bert-base 케이스 체크포인트와 연관된 모델 및 토크나이저를 가져와서 push_to_hub() 메소드를 사용하여 네임스페이스의 저장소에 업로드하십시오. 저장소를 삭제하기 전에 페이지에 저장소가 제대로 나타나는지 다시 확인하세요.
As you’ve seen, thepush_to_hub()method accepts several arguments, making it possible to upload to a specific repository or organization namespace, or to use a different API token. We recommend you take a look at the method specification available directly in the🤗 Transformers documentationto get an idea of what is possible.
본 것처럼 push_to_hub() 메서드는 여러 인수를 허용하므로 특정 저장소나 조직 네임스페이스에 업로드하거나 다른 API 토큰을 사용할 수 있습니다. 무엇이 가능한지에 대한 아이디어를 얻으려면 🤗 Transformers 문서에서 직접 제공되는 메서드 사양을 살펴보는 것이 좋습니다.
Thepush_to_hub()method is backed by thehuggingface_hubPython package, which offers a direct API to the Hugging Face Hub. It’s integrated within 🤗 Transformers and several other machine learning libraries, likeallenlp. Although we focus on the 🤗 Transformers integration in this chapter, integrating it into your own code or library is simple.
push_to_hub() 메서드는 Hugging Face Hub에 직접 API를 제공하는 Huggingface_hub Python 패키지의 지원을 받습니다. 이는 🤗 Transformers 및 AllenLP와 같은 기타 여러 기계 학습 라이브러리 내에 통합되어 있습니다. 이 장에서는 🤗 Transformers 통합에 중점을 두지만 이를 자신의 코드나 라이브러리에 통합하는 것은 간단합니다.
Jump to the last section to see how to upload files to your newly created repository!
새로 생성된 저장소에 파일을 업로드하는 방법을 보려면 마지막 섹션으로 이동하세요!
Using thehuggingface_hubPython library
Thehuggingface_hubPython library is a package which offers a set of tools for the model and datasets hubs. It provides simple methods and classes for common tasks like getting information about repositories on the hub and managing them. It provides simple APIs that work on top of git to manage those repositories’ content and to integrate the Hub in your projects and libraries.
Huggingface_hub Python 라이브러리는 모델 및 데이터 세트 허브를 위한 도구 세트를 제공하는 패키지입니다. 허브의 리포지토리에 대한 정보 가져오기 및 관리와 같은 일반적인 작업을 위한 간단한 메서드와 클래스를 제공합니다. git 위에서 작동하여 해당 리포지토리의 콘텐츠를 관리하고 프로젝트 및 라이브러리에 허브를 통합하는 간단한 API를 제공합니다.
Similarly to using thepush_to_hubAPI, this will require you to have your API token saved in your cache. In order to do this, you will need to use thelogincommand from the CLI, as mentioned in the previous section (again, make sure to prepend these commands with the!character if running in Google Colab):
push_to_hub API를 사용하는 것과 마찬가지로 API 토큰을 캐시에 저장해야 합니다. 이렇게 하려면 이전 섹션에서 언급한 대로 CLI에서 로그인 명령을 사용해야 합니다(Google Colab에서 실행하는 경우 이 명령 앞에 ! 문자를 추가해야 합니다).
huggingface-cli login
Thehuggingface_hubpackage offers several methods and classes which are useful for our purpose. Firstly, there are a few methods to manage repository creation, deletion, and others:
Huggingface_hub 패키지는 우리의 목적에 유용한 여러 메서드와 클래스를 제공합니다. 첫째, 저장소 생성, 삭제 등을 관리하는 몇 가지 방법이 있습니다.
from huggingface_hub import (
# User management
login,
logout,
whoami,
# Repository creation and management
create_repo,
delete_repo,
update_repo_visibility,
# And some methods to retrieve/change information about the content
list_models,
list_datasets,
list_metrics,
list_repo_files,
upload_file,
delete_file,
)
Additionally, it offers the very powerfulRepositoryclass to manage a local repository. We will explore these methods and that class in the next few section to understand how to leverage them.
또한 로컬 저장소를 관리할 수 있는 매우 강력한 Repository 클래스를 제공합니다. 다음 몇 섹션에서 이러한 메서드와 해당 클래스를 살펴보고 이를 활용하는 방법을 이해할 것입니다.
Thecreate_repomethod can be used to create a new repository on the hub:
create_repo 메소드를 사용하여 허브에 새 저장소를 생성할 수 있습니다.
from huggingface_hub import create_repo
create_repo("dummy-model")
This will create the repositorydummy-modelin your namespace. If you like, you can specify which organization the repository should belong to using theorganizationargument:
그러면 네임스페이스에 저장소 더미 모델이 생성됩니다. 원하는 경우 조직 인수를 사용하여 저장소가 속해야 하는 조직을 지정할 수 있습니다.
from huggingface_hub import create_repo
create_repo("dummy-model", organization="huggingface")
This will create thedummy-modelrepository in thehuggingfacenamespace, assuming you belong to that organization. Other arguments which may be useful are:
그러면 귀하가 해당 조직에 속해 있다는 가정 하에 Huggingface 네임스페이스에 더미 모델 저장소가 생성됩니다. 유용할 수 있는 다른 인수는 다음과 같습니다.
private, in order to specify if the repository should be visible from others or not.
비공개, 저장소가 다른 사람에게 표시되어야 하는지 여부를 지정합니다.
token, if you would like to override the token stored in your cache by a given token.
토큰: 특정 토큰으로 캐시에 저장된 토큰을 재정의하려는 경우.
repo_type, if you would like to create adatasetor aspaceinstead of a model. Accepted values are"dataset"and"space".
repo_type, 모델 대신 데이터 세트나 공간을 생성하려는 경우. 허용되는 값은 "dataset" 및 "space"입니다.
Once the repository is created, we should add files to it! Jump to the next section to see the three ways this can be handled.
저장소가 생성되면 여기에 파일을 추가해야 합니다! 이 문제를 처리할 수 있는 세 가지 방법을 보려면 다음 섹션으로 이동하세요.
Using the web interface
The web interface offers tools to manage repositories directly in the Hub. Using the interface, you can easily create repositories, add files (even large ones!), explore models, visualize diffs, and much more.
웹 인터페이스는 허브에서 직접 저장소를 관리할 수 있는 도구를 제공합니다. 인터페이스를 사용하면 저장소 생성, 파일 추가(큰 파일도 포함), 모델 탐색, 차이점 시각화 등을 쉽게 수행할 수 있습니다.
새 저장소를 만들려면 Huggingface.co/new를 방문하세요.
First, specify the owner of the repository: this can be either you or any of the organizations you’re affiliated with. If you choose an organization, the model will be featured on the organization’s page and every member of the organization will have the ability to contribute to the repository.
먼저 저장소의 소유자를 지정하십시오. 이는 귀하 또는 귀하가 소속된 조직일 수 있습니다. 조직을 선택하면 해당 모델이 해당 조직의 페이지에 표시되며 조직의 모든 구성원은 저장소에 기여할 수 있습니다.
Next, enter your model’s name. This will also be the name of the repository. Finally, you can specify whether you want your model to be public or private. Private models are hidden from public view.
다음으로 모델 이름을 입력하세요. 이는 저장소의 이름이기도 합니다. 마지막으로 모델을 공개할지 비공개할지 지정할 수 있습니다. 비공개 모델은 공개적으로 표시되지 않습니다.
After creating your model repository, you should see a page like this:
모델 리포지토리를 생성하면 다음과 같은 페이지가 표시됩니다.
This is where your model will be hosted. To start populating it, you can add a README file directly from the web interface.
이곳이 귀하의 모델이 호스팅되는 곳입니다. 채우기를 시작하려면 웹 인터페이스에서 직접 README 파일을 추가하면 됩니다.
The README file is in Markdown — feel free to go wild with it! The third part of this chapter is dedicated to building a model card. These are of prime importance in bringing value to your model, as they’re where you tell others what it can do.
README 파일은 Markdown에 있습니다. 마음껏 사용해 보세요! 이 장의 세 번째 부분은 모델 카드를 만드는 데 전념합니다. 이는 모델이 무엇을 할 수 있는지 다른 사람에게 알려주기 때문에 모델에 가치를 부여하는 데 가장 중요합니다.
If you look at the “Files and versions” tab, you’ll see that there aren’t many files there yet — just theREADME.mdyou just created and the.gitattributesfile that keeps track of large files.
"파일 및 버전" 탭을 보면 아직 파일이 많지 않다는 것을 알 수 있습니다. 방금 생성한 README.md와 대용량 파일을 추적하는 .gitattributes 파일만 있습니다.
We’ll take a look at how to add some new files next.
다음에는 새 파일을 추가하는 방법을 살펴보겠습니다.
Uploading the model files
The system to manage files on the Hugging Face Hub is based on git for regular files, and git-lfs (which stands forGit Large File Storage) for larger files.
Hugging Face Hub의 파일 관리 시스템은 일반 파일은 git, 대용량 파일은 git-lfs(Git Large File Storage의 약자)를 기반으로 합니다.
In the next section, we go over three different ways of uploading files to the Hub: throughhuggingface_huband through git commands.
다음 섹션에서는 Huggingface_hub 및 git 명령을 통해 허브에 파일을 업로드하는 세 가지 방법을 살펴보겠습니다.
Theupload_fileapproach
Usingupload_filedoes not require git and git-lfs to be installed on your system. It pushes files directly to the 🤗 Hub using HTTP POST requests. A limitation of this approach is that it doesn’t handle files that are larger than 5GB in size. If your files are larger than 5GB, please follow the two other methods detailed below.
upload_file을 사용하면 시스템에 git 및 git-lfs를 설치할 필요가 없습니다. HTTP POST 요청을 사용하여 파일을 🤗 허브에 직접 푸시합니다. 이 접근 방식의 한계는 크기가 5GB보다 큰 파일을 처리하지 못한다는 것입니다. 파일이 5GB보다 큰 경우 아래에 설명된 두 가지 다른 방법을 따르세요.
The API may be used as follows:
API는 다음과 같이 사용될 수 있습니다:
from huggingface_hub import upload_file
upload_file(
"<path_to_file>/config.json",
path_in_repo="config.json",
repo_id="<namespace>/dummy-model",
)
This will upload the fileconfig.jsonavailable at<path_to_file>to the root of the repository asconfig.json, to thedummy-modelrepository. Other arguments which may be useful are:
그러면 <path_to_file>에서 사용 가능한 config.json 파일이 저장소 루트에 config.json으로 더미 모델 저장소에 업로드됩니다. 유용할 수 있는 다른 인수는 다음과 같습니다.
token, if you would like to override the token stored in your cache by a given token.
토큰: 특정 토큰으로 캐시에 저장된 토큰을 재정의하려는 경우.
repo_type, if you would like to upload to adatasetor aspaceinstead of a model. Accepted values are"dataset"and"space".
repo_type, 모델 대신 데이터세트나 공간에 업로드하려는 경우. 허용되는 값은 "dataset" 및 "space"입니다.
TheRepositoryclass
TheRepositoryclass manages a local repository in a git-like manner. It abstracts most of the pain points one may have with git to provide all features that we require.
Repository 클래스는 Git과 같은 방식으로 로컬 저장소를 관리합니다. 이는 필요한 모든 기능을 제공하기 위해 git에서 발생할 수 있는 대부분의 문제점을 추상화합니다.
Using this class requires having git and git-lfs installed, so make sure you have git-lfs installed (seeherefor installation instructions) and set up before you begin.
이 클래스를 사용하려면 git 및 git-lfs가 설치되어 있어야 하므로 시작하기 전에 git-lfs가 설치되어 있는지 확인하고(설치 지침은 여기 참조) 설정하세요.
In order to start playing around with the repository we have just created, we can start by initialising it into a local folder by cloning the remote repository:
방금 생성한 저장소를 가지고 놀기 위해 원격 저장소를 복제하여 로컬 폴더로 초기화하는 것부터 시작할 수 있습니다.
from huggingface_hub import Repository
repo = Repository("<path_to_dummy_folder>", clone_from="<namespace>/dummy-model")
This created the folder<path_to_dummy_folder>in our working directory. This folder only contains the.gitattributesfile as that’s the only file created when instantiating the repository throughcreate_repo.
그러면 작업 디렉터리에 <path_to_dummy_folder> 폴더가 생성되었습니다. 이 폴더에는 create_repo를 통해 저장소를 인스턴스화할 때 생성되는 유일한 파일인 .gitattributes 파일만 포함됩니다.
From this point on, we may leverage several of the traditional git methods:
And others! We recommend taking a look at theRepositorydocumentation availableherefor an overview of all available methods.
다른 사람! 사용 가능한 모든 방법에 대한 개요를 보려면 여기에서 제공되는 리포지토리 문서를 살펴보는 것이 좋습니다.
At present, we have a model and a tokenizer that we would like to push to the hub. We have successfully cloned the repository, we can therefore save the files within that repository.
현재 우리는 허브에 푸시하려는 모델과 토크나이저를 보유하고 있습니다. 저장소를 성공적으로 복제했으므로 해당 저장소 내에 파일을 저장할 수 있습니다.
We first make sure that our local clone is up to date by pulling the latest changes:
먼저 최신 변경 사항을 가져와서 로컬 클론이 최신 상태인지 확인합니다.
repo.git_pull()
Once that is done, we save the model and tokenizer files:
The<path_to_dummy_folder>now contains all the model and tokenizer files. We follow the usual git workflow by adding files to the staging area, committing them and pushing them to the hub:
이제 <path_to_dummy_folder>에는 모든 모델 및 토크나이저 파일이 포함됩니다. 우리는 스테이징 영역에 파일을 추가하고 커밋한 후 허브에 푸시하는 방식으로 일반적인 git 워크플로를 따릅니다.
repo.git_add()
repo.git_commit("Add model and tokenizer files")
repo.git_push()
Congratulations! You just pushed your first files on the hub.
축하해요! 방금 첫 번째 파일을 허브에 푸시했습니다.
The git-based approach
This is the very barebones approach to uploading files: we’ll do so with git and git-lfs directly. Most of the difficulty is abstracted away by previous approaches, but there are a few caveats with the following method so we’ll follow a more complex use-case.
이것은 파일 업로드에 대한 매우 기본적인 접근 방식입니다. git 및 git-lfs를 직접 사용하여 수행합니다. 대부분의 어려움은 이전 접근 방식으로 추상화되지만 다음 방법에는 몇 가지 주의 사항이 있으므로 보다 복잡한 사용 사례를 따르겠습니다.
Using this class requires having git and git-lfs installed, so make sure you havegit-lfsinstalled (see here for installation instructions) and set up before you begin.
이 클래스를 사용하려면 git 및 git-lfs가 설치되어 있어야 하므로 시작하기 전에 git-lfs가 설치되어 있는지 확인하고(설치 지침은 여기 참조) 설정하세요.
First start by initializing git-lfs: 먼저 git-lfs를 초기화하여 시작하세요:
git lfs install
Updated git hooks.
Git LFS initialized.
Once that’s done, the first step is to clone your model repository:
My username islysandreand I’ve used the model namedummy, so for me the command ends up looking like the following:
내 사용자 이름은 lysandre이고 모델 이름은 dummy를 사용했기 때문에 명령은 다음과 같이 표시됩니다.
git clone https://huggingface.co/lysandre/dummy
I now have a folder nameddummyin my working directory. I cancdinto the folder and have a look at the contents:
이제 작업 디렉터리에 dummy라는 폴더가 생겼습니다. 폴더에 CD를 넣고 내용을 볼 수 있습니다.
cd dummy && ls
README.md
If you just created your repository using Hugging Face Hub’screate_repomethod, this folder should only contain a hidden.gitattributesfile. If you followed the instructions in the previous section to create a repository using the web interface, the folder should contain a singleREADME.mdfile alongside the hidden.gitattributesfile, as shown here.
Hugging Face Hub의 create_repo 메소드를 사용하여 저장소를 방금 생성한 경우 이 폴더에는 숨겨진 .gitattributes 파일만 포함되어야 합니다. 이전 섹션의 지침에 따라 웹 인터페이스를 사용하여 저장소를 만든 경우 폴더에는 여기에 표시된 것처럼 숨겨진 .gitattributes 파일과 함께 단일 README.md 파일이 포함되어야 합니다.
Adding a regular-sized file, such as a configuration file, a vocabulary file, or basically any file under a few megabytes, is done exactly as one would do it in any git-based system. However, bigger files must be registered through git-lfs in order to push them tohuggingface.co.
구성 파일, 어휘 파일 또는 기본적으로 몇 메가바이트 미만의 파일과 같은 일반 크기의 파일을 추가하는 것은 모든 git 기반 시스템에서 수행하는 것과 똑같이 수행됩니다. 그러나 더 큰 파일을 Huggingface.co로 푸시하려면 git-lfs를 통해 등록해야 합니다.
Let’s go back to Python for a bit to generate a model and tokenizer that we’d like to commit to our dummy repository:
Python으로 돌아가서 더미 저장소에 커밋할 모델과 토크나이저를 생성해 보겠습니다.
from transformers import AutoModelForMaskedLM, AutoTokenizer
checkpoint = "camembert-base"
model = AutoModelForMaskedLM.from_pretrained(checkpoint)
tokenizer = AutoTokenizer.from_pretrained(checkpoint)
# Do whatever with the model, train it, fine-tune it...
model.save_pretrained("<path_to_dummy_folder>")
tokenizer.save_pretrained("<path_to_dummy_folder>")
Now that we’ve saved some model and tokenizer artifacts, let’s take another look at thedummyfolder:
If you look at the file sizes (for example, withls -lh), you should see that the model state dict file (pytorch_model.bin) is the only outlier, at more than 400 MB.
파일 크기(예: ls -lh 사용)를 살펴보면 모델 상태 dict 파일(pytorch_model.bin)이 400MB를 초과하는 유일한 이상값임을 알 수 있습니다.
✏️ When creating the repository from the web interface, the *.gitattributes* file is automatically set up to consider files with certain extensions, such as *.bin* and *.h5*, as large files, and git-lfs will track them with no necessary setup on your side.
✏️ 웹 인터페이스에서 저장소를 생성할 때 *.gitattributes* 파일은 *.bin* 및 *.h5*와 같은 특정 확장자를 가진 파일을 대용량 파일로 간주하도록 자동으로 설정되며 git-lfs는 이를 추적합니다. 귀하 측에서 필요한 설정이 필요하지 않습니다.
We can now go ahead and proceed like we would usually do with traditional Git repositories. We can add all the files to Git’s staging environment using thegit addcommand:
이제 기존 Git 리포지토리에서 일반적으로 하던 것처럼 진행할 수 있습니다. git add 명령을 사용하여 Git의 스테이징 환경에 모든 파일을 추가할 수 있습니다.
git add .
We can then have a look at the files that are currently staged:
그런 다음 현재 준비된 파일을 살펴볼 수 있습니다.
git status
On branch main
Your branch is up to date with 'origin/main'.
Changes to be committed:
(use "git restore --staged <file>..." to unstage)
modified: .gitattributes
new file: config.json
new file: pytorch_model.bin
new file: sentencepiece.bpe.model
new file: special_tokens_map.json
new file: tokenizer.json
new file: tokenizer_config.json
Similarly, we can make sure that git-lfs is tracking the correct files by using itsstatuscommand:
마찬가지로, status 명령을 사용하여 git-lfs가 올바른 파일을 추적하고 있는지 확인할 수 있습니다.
git lfs status
On branch main
Objects to be pushed to origin/main:
Objects to be committed:
config.json (Git: bc20ff2)
pytorch_model.bin (LFS: 35686c2)
sentencepiece.bpe.model (LFS: 988bc5a)
special_tokens_map.json (Git: cb23931)
tokenizer.json (Git: 851ff3e)
tokenizer_config.json (Git: f0f7783)
Objects not staged for commit:
We can see that all files haveGitas a handler, exceptpytorch_model.binandsentencepiece.bpe.model, which haveLFS. Great!
LFS가 있는 pytorch_model.bin 및 문장 조각.bpe.model을 제외하고 모든 파일에는 핸들러로 Git이 있는 것을 볼 수 있습니다. Great !
Let’s proceed to the final steps, committing and pushing to thehuggingface.coremote repository:
Huggingface.co 원격 저장소에 커밋하고 푸시하는 마지막 단계를 진행해 보겠습니다.
The Model Hub makes selecting the appropriate model simple, so that using it in any downstream library can be done in a few lines of code. Let’s take a look at how to actually use one of these models, and how to contribute back to the community.
모델 허브를 사용하면 적절한 모델을 간단하게 선택할 수 있으므로 다운스트림 라이브러리에서 몇 줄의 코드만으로 모델을 사용할 수 있습니다. 이러한 모델 중 하나를 실제로 사용하는 방법과 커뮤니티에 다시 기여하는 방법을 살펴보겠습니다.
Let’s say we’re looking for a French-based model that can perform mask filling.
마스크 채우기를 수행할 수 있는 프랑스 기반 모델을 찾고 있다고 가정해 보겠습니다.
We select thecamembert-basecheckpoint to try it out. The identifiercamembert-baseis all we need to start using it! As you’ve seen in previous chapters, we can instantiate it using thepipeline()function:
이를 시험해 보기 위해 카망베르 기반 체크포인트를 선택합니다. 식별자 camembert-base만 사용하면 됩니다! 이전 장에서 본 것처럼 파이프라인() 함수를 사용하여 인스턴스화할 수 있습니다.
from transformers import pipeline
camembert_fill_mask = pipeline("fill-mask", model="camembert-base")
results = camembert_fill_mask("Le camembert est <mask> :)")
해당 코드는 Hugging Face의 Transformers 라이브러리를 사용하여 CamemBERT 모델을 활용하여 문장 내의 마스킹된 단어를 예측하는 코드입니다. 간단히 설명하면, 주어진 문장에서 <mask>로 표시된 부분을 모델이 예측하도록 하는 파이프라인을 설정하고, 그 결과를 확인하는 코드입니다.
"fill-mask" 태스크를 수행하는 파이프라인을 설정합니다. 여기서는 CamemBERT 모델을 사용하고 있습니다.
문장의 마스킹된 부분 예측:
results = camembert_fill_mask("Le camembert est <mask> :)")
설정한 파이프라인을 사용하여 주어진 문장에서 <mask>로 표시된 부분을 모델이 예측하고, 결과를 results 변수에 저장합니다.
위 코드에서는 "Le camembert est <mask> :)"라는 문장에서 <mask> 부분을 모델이 예측한 결과를 확인할 수 있습니다. 결과는 results 변수에 저장되어 있습니다.
참고: 코드는 CamemBERT 모델의 미세 조정 및 특정한 데이터셋에 따라 결과가 달라질 수 있습니다.
Some weights of the model checkpoint at camembert-base were not used when initializing CamembertForMaskedLM: ['roberta.pooler.dense.bias', 'roberta.pooler.dense.weight']
- This IS expected if you are initializing CamembertForMaskedLM from the checkpoint of a model trained on another task or with another architecture (e.g. initializing a BertForSequenceClassification model from a BertForPreTraining model).
- This IS NOT expected if you are initializing CamembertForMaskedLM from the checkpoint of a model that you expect to be exactly identical (initializing a BertForSequenceClassification model from a BertForSequenceClassification model).
[{'score': 0.9632076025009155, 'token': 2117, 'token_str': 'capitale', 'sequence': 'Paris est la capitale de la France.'}, {'score': 0.031002620235085487, 'token': 22013, 'token_str': 'Capitale', 'sequence': 'Paris est la Capitale de la France.'}, {'score': 0.0011895311763510108, 'token': 10431, 'token_str': 'préfecture', 'sequence': 'Paris est la préfecture de la France.'}, {'score': 0.0006761185941286385, 'token': 8529, 'token_str': 'métropole', 'sequence': 'Paris est la métropole de la France.'}, {'score': 0.0005724380607716739, 'token': 285, 'token_str': 'ville', 'sequence': 'Paris est la ville de la France.'}]
As you can see, loading a model within a pipeline is extremely simple. The only thing you need to watch out for is that the chosen checkpoint is suitable for the task it’s going to be used for. For example, here we are loading thecamembert-basecheckpoint in thefill-maskpipeline, which is completely fine. But if we were to load this checkpoint in thetext-classificationpipeline, the results would not make any sense because the head ofcamembert-baseis not suitable for this task! We recommend using the task selector in the Hugging Face Hub interface in order to select the appropriate checkpoints:
보시다시피 파이프라인 내에서 모델을 로드하는 것은 매우 간단합니다. 주의해야 할 유일한 점은 선택한 체크포인트가 사용할 작업에 적합한지 여부입니다. 예를 들어, 여기서는 채우기 마스크 파이프라인에 카망베르 기반 체크포인트를 로드하고 있는데, 이는 전혀 문제가 없습니다. 하지만 텍스트 분류 파이프라인에 이 체크포인트를 로드하면 Camembert-base의 헤드가 이 작업에 적합하지 않기 때문에 결과가 의미가 없습니다! 적절한 체크포인트를 선택하려면 Hugging Face Hub 인터페이스의 task selector 를 사용하는 것이 좋습니다.
You can also instantiate the checkpoint using the model architecture directly:
모델 아키텍처를 직접 사용하여 체크포인트를 인스턴스화할 수도 있습니다.
from transformers import CamembertTokenizer, CamembertForMaskedLM
tokenizer = CamembertTokenizer.from_pretrained("camembert-base")
model = CamembertForMaskedLM.from_pretrained("camembert-base")
해당 코드는 Hugging Face의 Transformers 라이브러리를 사용하여 CamemBERT 모델의 토크나이저와 마스킹 언어 모델을 불러와 초기화하는 코드입니다. 간단히 설명하면, CamemBERT 모델의 토크나이저와 마스킹 언어 모델을 설정하여 활용할 수 있도록 하는 과정입니다.
라이브러리 임포트:
from transformers import CamembertTokenizer, CamembertForMaskedLM
Transformers 라이브러리에서 CamemBERT 모델의 토크나이저와 마스킹 언어 모델을 사용하기 위해 필요한 모듈을 임포트합니다.
토크나이저 및 마스킹 언어 모델 초기화:
tokenizer = CamembertTokenizer.from_pretrained("camembert-base")
model = CamembertForMaskedLM.from_pretrained("camembert-base")
from_pretrained 메서드를 사용하여 "camembert-base"라는 사전 학습된 모델을 불러오고, 이를 초기화하여 tokenizer와 model 변수에 할당합니다. CamembertTokenizer는 문장을 토큰으로 분할하는 역할을 하며, CamembertForMaskedLM은 마스킹 언어 모델의 인스턴스를 생성합니다.
이제 위의 코드를 사용하여 CamemBERT 모델의 토크나이저와 마스킹 언어 모델을 활용할 수 있습니다. 예를 들어, 문장을 토큰화하거나 마스킹된 부분을 예측하는 작업 등을 수행할 수 있습니다.
However, we recommend using theAuto*classesinstead, as these are by design architecture-agnostic. While the previous code sample limits users to checkpoints loadable in the CamemBERT architecture, using theAuto*classes makes switching checkpoints simple:
그러나 Auto* 클래스는 설계상 아키텍처에 구애받지 않으므로 대신 사용하는 것이 좋습니다. 이전 코드 샘플에서는 사용자가 CamemBERT 아키텍처에서 로드할 수 있는 체크포인트로 제한했지만 Auto* 클래스를 사용하면 체크포인트 전환이 간단해졌습니다.
from transformers import AutoTokenizer, AutoModelForMaskedLM
tokenizer = AutoTokenizer.from_pretrained("camembert-base")
model = AutoModelForMaskedLM.from_pretrained("camembert-base")
해당 코드는 Hugging Face의 Transformers 라이브러리를 사용하여 CamemBERT 모델의 토크나이저와 마스킹 언어 모델을 불러와 초기화하는 코드입니다. AutoTokenizer와 AutoModelForMaskedLM 클래스를 사용하면 모델의 종류를 명시적으로 지정하지 않고 자동으로 적절한 모델을 불러올 수 있습니다.
라이브러리 임포트:
from transformers import AutoTokenizer, AutoModelForMaskedLM
tokenizer = AutoTokenizer.from_pretrained("camembert-base")
model = AutoModelForMaskedLM.from_pretrained("camembert-base")
from_pretrained 메서드를 사용하여 "camembert-base"라는 사전 학습된 모델을 불러오고, 이를 초기화하여 tokenizer와 model 변수에 할당합니다. AutoTokenizer는 문장을 토큰으로 분할하는 역할을 하며, AutoModelForMaskedLM은 마스킹 언어 모델의 인스턴스를 생성합니다.
이 코드는 특정 모델의 이름을 명시하지 않고도 자동으로 적절한 모델을 불러오기 때문에 편리하게 사용할 수 있습니다. 위의 코드를 사용하면 CamemBERT 모델의 토크나이저와 마스킹 언어 모델을 초기화할 수 있습니다.
When using a pretrained model, make sure to check how it was trained, on which datasets, its limits, and its biases. All of this information should be indicated on its model card.
사전 학습된 모델을 사용할 때는 모델이 어떻게 학습되었는지, 어떤 데이터세트에 대해, 한계, 편향이 있는지 확인하세요. 이 모든 정보는 모델 카드에 표시되어야 합니다.
Korean example.
from transformers import pipeline
camembert_fill_mask = pipeline("fill-mask", model="kykim/bert-kor-base")
results = camembert_fill_mask("한국의 수도는 [MASK] 입니다.")
print(results)
[{'score': 0.1914387047290802, 'token': 14328, 'token_str': '서울', 'sequence': '한국의 수도는 서울 입니다.'},
{'score': 0.10752367973327637, 'token': 14147, 'token_str': '한국', 'sequence': '한국의 수도는 한국 입니다.'},
{'score': 0.07457706332206726, 'token': 21793, 'token_str': '로마', 'sequence': '한국의 수도는 로마 입니다.'},
{'score': 0.07277032732963562, 'token': 16809, 'token_str': '대한민국', 'sequence': '한국의 수도는 대한민국 입니다.'},
{'score': 0.022880734875798225, 'token': 25738, 'token_str': '필리핀', 'sequence': '한국의 수도는 필리핀 입니다.'}]
TheHugging Face Hub–- our main website –- is a central platform that enables anyone to discover, use, and contribute new state-of-the-art models and datasets. It hosts a wide variety of models, with more than 10,000 publicly available. We’ll focus on the models in this chapter, and take a look at the datasets in Chapter 5.
당사의 메인 웹사이트인 Hugging Face Hub는 누구나 새로운 최첨단 모델과 데이터 세트를 발견, 사용 및 기여할 수 있는 중앙 플랫폼입니다. 공개적으로 사용 가능한 모델이 10,000개 이상인 다양한 모델을 호스팅합니다. 이번 장에서는 모델에 중점을 두고, 5장에서는 데이터세트를 살펴보겠습니다.
The models in the Hub are not limited to 🤗 Transformers or even NLP. There are models fromFlairandAllenNLPfor NLP,Asteroidandpyannotefor speech, andtimmfor vision, to name a few.
허브의 모델은 🤗 Transformers나 NLP에만 국한되지 않습니다. NLP를 위한 Flair 및 AllenNLP 모델, 음성을 위한 Asteroid 및 pyannote, 비전을 위한 timm 등의 모델이 있습니다.
Each of these models is hosted as a Git repository, which allows versioning and reproducibility. Sharing a model on the Hub means opening it up to the community and making it accessible to anyone looking to easily use it, in turn eliminating their need to train a model on their own and simplifying sharing and usage.
이러한 각 모델은 버전 관리 및 재현성을 허용하는 Git 저장소로 호스팅됩니다. 허브에서 모델을 공유한다는 것은 해당 모델을 커뮤니티에 공개하고 쉽게 사용하려는 모든 사람이 액세스할 수 있게 함으로써 스스로 모델을 교육할 필요가 없어지고 공유 및 사용이 단순화된다는 의미입니다.
Additionally, sharing a model on the Hub automatically deploys a hosted Inference API for that model. Anyone in the community is free to test it out directly on the model’s page, with custom inputs and appropriate widgets.
또한 허브에서 모델을 공유하면 해당 모델에 대해 호스팅된 추론 API가 자동으로 배포됩니다. 커뮤니티의 누구든지 사용자 정의 입력 및 적절한 위젯을 사용하여 모델 페이지에서 직접 자유롭게 테스트할 수 있습니다.
The best part is that sharing and using any public model on the Hub is completely free!Paid plansalso exist if you wish to share models privately.
가장 좋은 점은 허브에서 공개 모델을 공유하고 사용하는 것이 완전히 무료라는 것입니다! 모델을 개인적으로 공유하려는 경우 유료 플랜도 있습니다.
Having a huggingface.co account is required to follow along this part, as we’ll be creating and managing repositories on the Hugging Face Hub:create an account
Hugging Face Hub에서 리포지토리를 생성하고 관리할 것이므로 이 부분을 수행하려면 Huggingface.co 계정이 필요합니다. 계정을 만드세요.
That was fun! In the first two chapters you learned about models and tokenizers, and now you know how to fine-tune them for your own data. To recap, in this chapter you:
재미있었어요! 처음 두 장에서는 모델과 토크나이저에 대해 배웠고 이제 자신의 데이터에 맞게 미세 조정하는 방법을 알게 되었습니다. 요약하면 이 장에서는 다음을 수행합니다.
Now we’ll see how to achieve the same results as we did in the last section without using theTrainerclass. Again, we assume you have done the data processing in section 2. Here is a short summary covering everything you will need:
이제 Trainer 클래스를 사용하지 않고 마지막 섹션에서와 동일한 결과를 얻는 방법을 살펴보겠습니다. 다시 한 번 섹션 2에서 데이터 처리를 완료했다고 가정합니다. 다음은 필요한 모든 내용을 다루는 간단한 요약입니다.
from datasets import load_dataset
from transformers import AutoTokenizer, DataCollatorWithPadding
# "glue" 데이터셋의 "mrpc" 태스크를 로드
raw_datasets = load_dataset("glue", "mrpc")
# BERT의 사전 훈련된 토크나이저를 불러오기
checkpoint = "bert-base-uncased"
tokenizer = AutoTokenizer.from_pretrained(checkpoint)
# 사용자 정의 토큰화 함수 정의
def tokenize_function(example):
return tokenizer(example["sentence1"], example["sentence2"], truncation=True)
# 토큰화된 데이터셋 생성 (batched=True로 설정하여 배치 단위로 토큰화)
tokenized_datasets = raw_datasets.map(tokenize_function, batched=True)
# 데이터 콜레이터 생성 (패딩 추가)
data_collator = DataCollatorWithPadding(tokenizer=tokenizer)
이 코드는 Hugging Face Transformers 라이브러리를 사용하여 데이터셋을 로드하고 토큰화하는 과정을 나타냅니다. 코드를 단계별로 설명하겠습니다.
해석:
load_dataset("glue", "mrpc"): Hugging Face의 datasets 라이브러리를 사용하여 GLUE 벤치마크의 MRPC(Microsoft Research Paraphrase Corpus) 태스크를 로드합니다.
AutoTokenizer.from_pretrained(checkpoint): BERT 모델의 사전 훈련된 토크나이저를 불러옵니다. 여기서는 "bert-base-uncased"를 사용합니다.
tokenize_function(example): 사용자 정의 토큰화 함수를 정의합니다. 이 함수는 입력으로 문장1(sentence1)과 문장2(sentence2)를 받아 토큰화한 결과를 반환합니다. truncation=True는 문장이 일정 길이를 초과할 경우 자르도록 설정한 것입니다.
raw_datasets.map(tokenize_function, batched=True): 토큰화 함수를 사용하여 데이터셋을 토큰화합니다. batched=True로 설정하여 배치 단위로 토큰화합니다.
DataCollatorWithPadding(tokenizer=tokenizer): 데이터 콜레이터를 생성합니다. 이 객체는 배치를 처리하여 패딩을 추가하고 동일한 길이로 만들어주는 역할을 합니다. 여기서는 BERT의 토크나이저를 사용하여 패딩을 추가하도록 설정했습니다.
이렇게 토큰화된 데이터셋과 데이터 콜레이터는 모델을 훈련하거나 평가할 때 사용됩니다. 데이터셋은 토큰화된 형태로 모델에 입력되고, 데이터 콜레이터는 배치를 처리하여 패딩을 추가하여 모델이 일관된 형태로 데이터를 처리할 수 있도록 도와줍니다.
Prepare for training
Before actually writing our training loop, we will need to define a few objects. The first ones are the dataloaders we will use to iterate over batches. But before we can define those dataloaders, we need to apply a bit of postprocessing to ourtokenized_datasets, to take care of some things that theTrainerdid for us automatically. Specifically, we need to:
실제로 훈련 루프를 작성하기 전에 몇 가지 객체를 정의해야 합니다. 첫 번째는 배치를 반복하는 데 사용할 데이터로더입니다. 하지만 이러한 데이터로더를 정의하기 전에 Trainer가 자동으로 수행한 일부 작업을 처리하기 위해 tokenized_datasets에 약간의 후처리를 적용해야 합니다. 구체적으로 다음을 수행해야 합니다.
Remove the columns corresponding to values the model does not expect (like thesentence1andsentence2columns).
모델이 예상하지 않는 값(예: 문장1 및 문장2 열)에 해당하는 열을 제거합니다.
Rename the columnlabeltolabels(because the model expects the argument to be namedlabels).
열 레이블의 이름을 labels 로 바꿉니다(모델에서는 인수 이름이 labels 로 지정될 것으로 예상하기 때문입니다).
Set the format of the datasets so they return PyTorch tensors instead of lists.
목록 대신 PyTorch 텐서를 반환하도록 데이터 세트의 형식을 설정합니다.
Ourtokenized_datasetshas one method for each of those steps:
이 코드는 Hugging Face의 datasets 라이브러리에서 사용되는 데이터셋 객체의 몇 가지 조작을 수행하는 부분입니다. 코드를 단계별로 설명하겠습니다.
해석:
tokenized_datasets.remove_columns(["sentence1", "sentence2", "idx"]): "sentence1", "sentence2", 그리고 "idx" 열을 삭제합니다. 이 열들은 토큰화 이전에 원시 데이터셋에서 가져온 열일 것으로 예상됩니다.
tokenized_datasets.rename_column("label", "labels"): "label" 열의 이름을 "labels"로 변경합니다. 일반적으로 Hugging Face Transformers 라이브러리에서 모델 훈련을 위해 사용되는 레이블 열의 이름은 "labels"입니다.
tokenized_datasets.set_format("torch"): 데이터셋의 형식을 "torch"로 설정합니다. 이렇게 설정하면 PyTorch 텐서 형식으로 데이터셋이 변환됩니다.
tokenized_datasets["train"].column_names: "train" 부분의 데이터셋에 있는 열의 이름들을 반환합니다. 이를 통해 현재 데이터셋에 어떤 열들이 있는지 확인할 수 있습니다.
따라서 최종적으로 "sentence1", "sentence2", "idx" 열이 삭제되고, "label"이 "labels"로 이름이 변경되며, 데이터셋의 형식이 PyTorch 텐서로 변경된 상태의 데이터셋이 만들어집니다.
We can then check that the result only has columns that our model will accept:
Now that this is done, we can easily define our dataloaders:
이제 이 작업이 완료되었으므로 데이터로더를 쉽게 정의할 수 있습니다.
from torch.utils.data import DataLoader
# 훈련 데이터 로더 생성
train_dataloader = DataLoader(
tokenized_datasets["train"], # 훈련 데이터셋
shuffle=True, # 에폭마다 데이터를 섞을지 여부
batch_size=8, # 배치 크기
collate_fn=data_collator # 데이터 콜레이터 함수 (패딩 추가)
)
# 검증 데이터 로더 생성
eval_dataloader = DataLoader(
tokenized_datasets["validation"], # 검증 데이터셋
batch_size=8, # 배치 크기
collate_fn=data_collator # 데이터 콜레이터 함수 (패딩 추가)
)
이 코드는 PyTorch의 DataLoader를 사용하여 훈련 및 검증 데이터셋에 대한 데이터 로더를 만드는 부분입니다. 코드를 단계별로 설명하겠습니다.
해석:
DataLoader: PyTorch의 데이터 로더 클래스로, 데이터셋에서 샘플을 미니배치로 효율적으로 로드하는 데 사용됩니다.
tokenized_datasets["train"] 및 tokenized_datasets["validation"]: 각각 훈련 및 검증 데이터셋을 나타냅니다.
shuffle=True: 훈련 데이터셋을 에폭(epoch)마다 섞을지 여부를 나타내는 매개변수입니다. 훈련 데이터셋을 섞어 모델이 다양한 샘플을 학습하도록 도웁니다.
batch_size=8: 미니배치의 크기를 나타내는 매개변수로, 각 미니배치에 포함될 샘플의 수를 결정합니다.
collate_fn=data_collator: 데이터 콜레이터 함수를 지정합니다. 이 함수는 배치의 샘플을 처리하여 패딩을 추가하고 동일한 길이로 만들어주는 역할을 합니다. 여기서는 앞서 생성한 DataCollatorWithPadding 객체를 사용합니다.
이렇게 생성된 train_dataloader와 eval_dataloader는 각각 훈련 및 검증 단계에서 사용됩니다. 모델 훈련 시에는 train_dataloader를 이용하여 미니배치 단위로 데이터를 모델에 공급하고, 검증 시에는 eval_dataloader를 사용하여 검증 데이터셋에 대한 예측을 수행합니다.
To quickly check there is no mistake in the data processing, we can inspect a batch like this:
데이터 처리에 실수가 없는지 빠르게 확인하기 위해 다음과 같은 배치를 검사할 수 있습니다.
for batch in train_dataloader:
break
{k: v.shape for k, v in batch.items()}
이 코드는 train_dataloader에서 첫 번째 미니배치를 가져와서 그 구조와 크기를 출력하는 부분입니다. 코드를 단계별로 설명하겠습니다.
해석:
for batch in train_dataloader:: train_dataloader에서 미니배치를 순회합니다.
break: 첫 번째 미니배치를 가져오고 반복문을 종료합니다. 이 부분에서는 첫 번째 미니배치만 확인합니다.
{k: v.shape for k, v in batch.items()}: 미니배치의 각 텐서의 크기(shape)를 딕셔너리 형태로 출력합니다. 이 딕셔너리는 각 텐서의 키와 크기를 보여줍니다.
k는 텐서의 키를 나타내며, 여기서는 "input_ids," "attention_mask," "labels" 등이 될 수 있습니다.
v.shape는 텐서의 크기를 나타내며, 예를 들어 (배치 크기, 최대 시퀀스 길이)와 같은 형태일 것입니다.
이 코드를 실행하면 첫 번째 미니배치의 구조와 크기를 확인할 수 있습니다. 이는 데이터 처리 및 토큰화가 올바르게 이루어졌는지 확인하는 데 도움이 됩니다.
Note that the actual shapes will probably be slightly different for you since we setshuffle=Truefor the training dataloader and we are padding to the maximum length inside the batch.
훈련 데이터로더에 shuffle=True를 설정하고 배치 내부의 최대 길이까지 패딩하기 때문에 실제 모양은 약간 다를 수 있습니다.
Now that we’re completely finished with data preprocessing (a satisfying yet elusive goal for any ML practitioner), let’s turn to the model. We instantiate it exactly as we did in the previous section:
이제 데이터 전처리(ML 실무자에게는 달성하기 어려운 목표이지만 그래도 만족스러)가 완전히 완료되었으므로 모델을 살펴보겠습니다. 이전 섹션에서 했던 것과 똑같이 인스턴스화합니다.
from transformers import AutoModelForSequenceClassification
model = AutoModelForSequenceClassification.from_pretrained(checkpoint, num_labels=2)
이 코드는 Hugging Face Transformers 라이브러리를 사용하여 시퀀스 분류 모델을 로드하는 부분입니다. 코드를 단계별로 설명하겠습니다.
해석:
from transformers import AutoModelForSequenceClassification: 시퀀스 분류 모델을 불러오기 위해 Hugging Face Transformers 라이브러리에서 AutoModelForSequenceClassification 클래스를 가져옵니다.
AutoModelForSequenceClassification.from_pretrained(checkpoint, num_labels=2): 미리 훈련된 모델을 로드합니다. checkpoint는 로드하려는 모델의 이름 또는 경로를 나타냅니다. num_labels=2는 출력 레이블의 수를 나타내며, 이 경우 이진 분류를 위해 2로 설정되었습니다.
로드된 모델은 텍스트 시퀀스를 입력으로 받아 각 클래스에 대한 로짓을 출력하는 시퀀스 분류 모델입니다. 이 모델은 이미 사전 훈련된 가중치를 가지고 있으며, 특정 작업에 맞게 조정할 수 있습니다. 이러한 모델을 훈련하거나 텍스트 분류 작업에 활용할 수 있습니다.
To make sure that everything will go smoothly during training, we pass our batch to this model:
이 코드는 시퀀스 분류 모델에 입력 데이터를 주입하고, 모델의 출력인 손실 값(loss)과 로짓(logits)의 형태(shape)를 출력하는 부분입니다. 코드를 단계별로 설명하겠습니다.
해석:
model(**batch): batch에 있는 입력 데이터를 모델에 전달합니다. batch에는 토큰화된 입력 데이터가 있으며, 모델은 이를 처리하여 예측을 수행합니다.
outputs: 모델의 출력 결과를 저장한 객체입니다. 이 객체에는 여러 속성이 포함되어 있습니다.
outputs.loss: 모델의 출력 손실 값입니다. 이 값은 훈련 중에 사용되며, 손실을 최소화하기 위해 모델의 가중치가 업데이트됩니다.
outputs.logits: 모델의 출력으로, 각 클래스에 대한 로짓 값입니다. 로짓은 softmax 함수를 거친 후 확률로 변환되어 예측 클래스가 결정됩니다. logits.shape는 로짓 텐서의 크기를 나타냅니다.
print(outputs.loss, outputs.logits.shape): 모델의 출력인 손실 값과 로짓 텐서의 크기를 출력합니다.
이 코드는 모델이 입력 데이터를 처리하고 그 결과를 확인하는 데 사용됩니다. 특히, 훈련할 때는 손실 값이 중요하며, 추론 및 평가 단계에서는 로짓을 통해 예측 결과를 확인할 수 있습니다.
All 🤗 Transformers models will return the loss whenlabelsare provided, and we also get the logits (two for each input in our batch, so a tensor of size 8 x 2).
모든 🤗 Transformers 모델은 레이블이 제공되면 손실을 반환하며 로지트도 얻습니다(배치의 각 입력에 대해 2개이므로 크기가 8 x 2인 텐서).
We’re almost ready to write our training loop! We’re just missing two things: an optimizer and a learning rate scheduler. Since we are trying to replicate what theTrainerwas doing by hand, we will use the same defaults. The optimizer used by theTrainerisAdamW, which is the same as Adam, but with a twist for weight decay regularization (see“Decoupled Weight Decay Regularization”by Ilya Loshchilov and Frank Hutter):
훈련 루프를 작성할 준비가 거의 다 되었습니다! 우리는 최적화 프로그램과 학습률 스케줄러라는 두 가지를 놓치고 있습니다. Trainer가 직접 수행한 작업을 복제하려고 하므로 동일한 기본값을 사용하겠습니다. Trainer에서 사용하는 최적화 프로그램은 AdamW입니다. 이는 Adam과 동일하지만 체중 감소 정규화에 대한 변형이 있습니다(Ilya Loshchilov 및 Frank Hutter의 "De커플링된 체중 감소 정규화" 참조).
from transformers import AdamW
# 모델의 파라미터에 AdamW 옵티마이저를 설정
optimizer = AdamW(model.parameters(), lr=5e-5)
이 코드는 Hugging Face Transformers 라이브러리에서 제공하는 AdamW 옵티마이저를 설정하는 부분입니다. 코드를 단계별로 설명하겠습니다.
해석:
from transformers import AdamW: Hugging Face Transformers 라이브러리에서 AdamW 옵티마이저를 가져옵니다.
optimizer = AdamW(model.parameters(), lr=5e-5): 모델의 파라미터를 가져와서 이를 AdamW 옵티마이저에 전달합니다. lr=5e-5는 학습률(learning rate)을 나타내며, 이 값은 학습 과정에서 가중치를 업데이트하는 정도를 조절합니다.
AdamW는 Adam 옵티마이저에 가중치 감쇠(weight decay)를 추가한 버전입니다. 가중치 감쇠는 모델의 가중치가 너무 커지지 않도록 제한하고, 오버피팅을 방지하는 데 도움을 줍니다.
이렇게 설정된 옵티마이저는 모델의 가중치를 업데이트할 때 사용되며, 이후에 이 옵티마이저를 통해 모델을 최적화하는 학습 과정을 진행할 수 있습니다.
Finally, the learning rate scheduler used by default is just a linear decay from the maximum value (5e-5) to 0. To properly define it, we need to know the number of training steps we will take, which is the number of epochs we want to run multiplied by the number of training batches (which is the length of our training dataloader). TheTraineruses three epochs by default, so we will follow that:
마지막으로, 기본적으로 사용되는 학습률 스케줄러는 최대값(5e-5)에서 0까지의 선형 감쇠일 뿐입니다. 이를 올바르게 정의하려면 수행할 학습 단계 수, 즉 에포크 수를 알아야 합니다. 훈련 배치 수(훈련 데이터로더의 길이)를 곱하여 실행하려고 합니다. Trainer는 기본적으로 세 가지 에포크를 사용하므로 다음을 따릅니다.
from transformers import get_scheduler
# 학습 에폭 수와 전체 학습 단계 수 설정
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,
)
# 전체 학습 단계 수 출력
print(num_training_steps)
1377
이 코드는 Hugging Face Transformers 라이브러리에서 제공하는 학습률 스케줄러를 설정하는 부분입니다. 코드를 단계별로 설명하겠습니다.
해석:
from transformers import get_scheduler: Hugging Face Transformers 라이브러리에서 학습률 스케줄러를 가져옵니다.
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): 선형 학습률 스케줄러를 설정합니다. "linear"는 선형 스케줄러를 의미하며, 학습률이 선형으로 감소하도록 만듭니다. num_warmup_steps=0은 워머핑 단계 수를 0으로 설정하며, num_training_steps는 총 학습 단계 수입니다.
print(num_training_steps): 전체 학습 단계 수를 출력합니다.
이렇게 설정된 선형 학습률 스케줄러는 학습률을 일정한 비율로 감소시키면서 학습을 진행합니다. 설정된 값들은 Trainer 클래스에서 사용되는 기본값을 따르도록 설정되어 있습니다.
The training loop
One last thing: we will want to use the GPU if we have access to one (on a CPU, training might take several hours instead of a couple of minutes). To do this, we define adevicewe will put our model and our batches on:
마지막으로, GPU에 액세스할 수 있는 경우 GPU를 사용하고 싶을 것입니다(CPU에서는 훈련에 몇 분이 아닌 몇 시간이 걸릴 수 있습니다). 이를 위해 모델과 배치를 배치할 장치를 정의합니다.
import torch
# CUDA가 사용 가능한 경우 GPU를, 그렇지 않은 경우 CPU를 선택
device = torch.device("cuda") if torch.cuda.is_available() else torch.device("cpu")
# 모델을 선택한 디바이스로 이동
model.to(device)
# 선택한 디바이스 출력
device
device(type='cuda')
이 코드는 PyTorch를 사용하여 모델을 GPU 또는 CPU로 이동하는 부분입니다. 코드를 단계별로 설명하겠습니다.
해석:
import torch: PyTorch 라이브러리를 가져옵니다.
device = torch.device("cuda") if torch.cuda.is_available() else torch.device("cpu"): GPU(CUDA)가 사용 가능한 경우 GPU를 선택하고, 그렇지 않은 경우 CPU를 선택합니다. 이를 위해 torch.cuda.is_available() 함수를 사용하여 GPU 사용 가능 여부를 확인합니다.
model.to(device): 모델을 선택한 디바이스로 이동시킵니다. 이로써 모델의 연산이 선택한 디바이스에서 수행되게 됩니다.
device: 선택한 디바이스를 출력합니다. 이는 모델이 현재 어떤 디바이스에서 실행되고 있는지 확인할 수 있습니다.
이 코드는 모델을 GPU로 이동시키는데 사용되며, GPU가 없거나 사용이 불가능한 경우 CPU에서 모델을 실행하게 됩니다. GPU를 사용하면 모델의 연산이 병렬로 처리되어 훨씬 빠른 학습이 가능합니다.
CoLab에서는 GPU 사용은 안되고 CPU 를 사용해야 합니다.
We are now ready to train! To get some sense of when training will be finished, we add a progress bar over our number of training steps, using thetqdmlibrary:
이제 훈련할 준비가 되었습니다! 훈련이 언제 완료되는지 알아보기 위해 tqdm 라이브러리를 사용하여 훈련 단계 수에 진행률 표시줄을 추가합니다.
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)
이 코드는 모델을 훈련하기 위한 학습 루프를 나타냅니다. 코드를 단계별로 설명하겠습니다.
해석:
from tqdm.auto import tqdm: 훈련 과정에서 진행 상황을 시각적으로 확인하기 위해 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): 프로그레스 바를 업데이트하여 진행 상황을 시각적으로 확인합니다.
이렇게 훈련 루프를 통해 모델은 주어진 에폭 수에 대해 훈련되고, 손실이 감소하도록 파라미터가 업데이트됩니다.
You can see that the core of the training loop looks a lot like the one in the introduction. We didn’t ask for any reporting, so this training loop will not tell us anything about how the model fares. We need to add an evaluation loop for that.
훈련 루프의 핵심이 소개 부분과 매우 유사하다는 것을 알 수 있습니다. 우리는 보고를 요청하지 않았으므로 이 훈련 루프는 모델이 어떻게 진행되는지에 대해 아무 것도 알려주지 않습니다. 이를 위해 평가 루프를 추가해야 합니다.
The evaluation loop
As we did earlier, we will use a metric provided by the 🤗 Evaluate library. We’ve already seen themetric.compute()method, but metrics can actually accumulate batches for us as we go over the prediction loop with the methodadd_batch(). Once we have accumulated all the batches, we can get the final result withmetric.compute(). Here’s how to implement all of this in an evaluation loop:
이전과 마찬가지로 🤗 Evaluate library 에서 제공하는 측정항목을 사용하겠습니다. 우리는 이미 metric.compute() 메소드를 보았지만 add_batch() 메소드를 사용하여 예측 루프를 진행하면서 메트릭은 실제로 배치를 누적할 수 있습니다. 모든 배치를 누적한 후에는 metric.compute()를 사용하여 최종 결과를 얻을 수 있습니다. 평가 루프에서 이 모든 것을 구현하는 방법은 다음과 같습니다.
import evaluate
# GLUE 메트릭을 로드
metric = evaluate.load("glue", "mrpc")
# 모델을 평가 모드로 설정
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()
metric.add_batch(predictions=predictions, references=batch["labels"]): 메트릭에 현재 미니배치의 예측값과 레이블을 추가합니다.
metric.compute(): 메트릭을 통해 최종 평가를 수행합니다.
이를 통해 모델이 검증 데이터에 대해 얼마나 좋은 성능을 보이는지를 측정하고, GLUE 벤치마크에서 정의된 평가 메트릭을 계산합니다.
Again, your results will be slightly different because of the randomness in the model head initialization and the data shuffling, but they should be in the same ballpark.
다시 말하지만, 모델 헤드 초기화 및 데이터 셔플링의 무작위성으로 인해 결과가 약간 다르지만 동일한 기준점에 있어야 합니다.
✏️Try it out!Modify the previous training loop to fine-tune your model on the SST-2 dataset.
✏️ 한번 사용해 보세요! 이전 훈련 루프를 수정하여 SST-2 데이터세트에서 모델을 미세 조정하세요.
TPU(Tensor Processing Unit)는 구글에서 개발한 특수한 하드웨어로, 딥러닝 작업을 가속화하기 위해 설계되었습니다. TPU는 주로 텐서플로우(TensorFlow) 딥러닝 프레임워크와 함께 사용되며, 딥러닝 모델의 학습과 추론 속도를 높이는 데 중점을 둡니다.
TPU의 주요 특징은 다음과 같습니다:
고성능 병렬 처리: TPU는 텐서 연산에 특화된 구조로 구성되어 있어, 행렬 곱셈 및 기타 텐서 연산을 효율적으로 수행할 수 있습니다. 이는 딥러닝 모델의 대규모 연산에 적합합니다.
낮은 전력 소모: TPU는 높은 성능에도 불구하고 상대적으로 낮은 전력을 소비합니다. 이는 에너지 효율성 면에서 우수한 성능을 제공합니다.
TensorFlow와의 통합: TPU는 주로 텐서플로우와 함께 사용되며, 텐서플로우에서 제공하는 TPU 지원 기능을 활용하여 모델을 효율적으로 실행할 수 있습니다.
대규모 딥러닝 모델 지원: TPU는 대규모 딥러닝 모델의 학습에 적합하며, 대규모 데이터셋에서의 훈련 작업에 특히 유용합니다.
TPU는 클라우드 기반의 딥러닝 작업에 많이 사용되며, 구글 클라우드(Google Cloud)와 같은 클라우드 서비스 제공업체에서 TPU를 사용할 수 있는 환경을 제공하고 있습니다. TPU는 GPU와 비교하여 특정 딥러닝 워크로드에서 높은 성능을 발휘할 수 있으며, 딥러닝 연구 및 응용 분야에서 중요한 역할을 하고 있습니다.
The training loop we defined earlier works fine on a single CPU or GPU. But using the🤗 Acceleratelibrary, with just a few adjustments we can enable distributed training on multiple GPUs or TPUs. Starting from the creation of the training and validation dataloaders, here is what our manual training loop looks like:
이전에 정의한 훈련 루프는 단일 CPU 또는 GPU에서 잘 작동합니다. 하지만 🤗 Accelerate 라이브러리를 사용하면 몇 가지 조정만으로 여러 GPU 또는 TPU에서 분산 교육을 활성화할 수 있습니다. 교육 및 검증 데이터로더 생성부터 시작하여 수동 교육 루프는 다음과 같습니다.
from transformers import AdamW, AutoModelForSequenceClassification, get_scheduler
# 사전 훈련된 모델과 함께 시퀀스 분류 모델을 불러옴
model = AutoModelForSequenceClassification.from_pretrained(checkpoint, num_labels=2)
# AdamW 옵티마이저를 정의하고 모델의 파라미터를 전달
optimizer = AdamW(model.parameters(), lr=3e-5)
# 사용 가능한 GPU가 있다면 GPU로 모델을 이동
device = torch.device("cuda") if torch.cuda.is_available() else torch.device("cpu")
model.to(device)
# 훈련 설정: 에폭 수 및 훈련 스텝 수 설정
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,
)
# 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()
# tqdm 업데이트
progress_bar.update(1)
이 코드는 딥러닝 모델의 훈련을 위한 기본적인 스크립트를 나타냅니다. 코드를 단계별로 설명하겠습니다.
해석:
모델, 옵티마이저, 디바이스 설정: 사전 훈련된 모델을 불러오고, AdamW 옵티마이저를 정의하며, 사용 가능한 GPU가 있다면 GPU로 모델을 이동시킵니다.
훈련 설정: 에폭 수 및 훈련 스텝 수 설정합니다.
러닝 레이트 스케줄러 설정: 러닝 레이트 스케줄러를 설정하여 훈련 동안 러닝 레이트를 동적으로 조절합니다.
tqdm을 사용한 진행 표시: tqdm은 훈련 진행 상황을 시각적으로 표시하는 도구입니다.
모델 훈련: 훈련 데이터로더에서 미니배치를 가져와 모델에 전달하고, 손실을 계산하여 역전파를 수행하며, 옵티마이저를 사용하여 모델 파라미터를 업데이트합니다. 러닝 레이트 스케줄러를 사용하여 러닝 레이트를 조절하고, tqdm을 업데이트하여 훈련 진행 상황을 표시합니다.
이러한 훈련 스크립트는 특정 모델과 데이터에 맞게 조정될 수 있으며, 주로 Hugging Face의 Transformers 라이브러리를 사용하여 딥러닝 모델을 훈련하는 일반적인 흐름을 나타냅니다.
And here are the changes: 변경 사항은 다음과 같습니다.
from accelerate import Accelerator
from transformers import AdamW, AutoModelForSequenceClassification, get_scheduler
# Accelerator 객체 생성
accelerator = Accelerator()
# AutoModelForSequenceClassification 모델 및 AdamW 옵티마이저 초기화
model = AutoModelForSequenceClassification.from_pretrained(checkpoint, num_labels=2)
optimizer = AdamW(model.parameters(), lr=3e-5)
# 훈련 및 검증 데이터로더, 모델, 옵티마이저를 Accelerator로 준비
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)
이 코드는 accelerate 라이브러리를 사용하여 GPU 가속을 적용한 딥러닝 모델의 훈련 스크립트를 나타냅니다. 코드의 변경점에 대해 설명하겠습니다.
변경된 부분:
Accelerator 사용: Accelerator 객체를 생성하고, prepare 메서드를 사용하여 훈련 데이터로더, 검증 데이터로더, 모델, 옵티마이저를 가속화합니다.
Device 설정 제거: GPU 디바이스 설정 부분이 삭제되었습니다. Accelerator가 내부적으로 디바이스 관리를 수행합니다.
Gradient 계산 변경: loss.backward() 대신 accelerator.backward(loss)를 사용하여 gradient 계산을 가속화합니다. Accelerator는 내부적으로 gradient 계산 및 관리를 처리합니다.
이러한 변경으로 코드는 GPU 가속을 사용하면서도 간소화되었고, 가속화 라이브러리를 통해 더욱 효율적으로 딥러닝 모델을 훈련할 수 있습니다.
The first line to add is the import line. The second line instantiates anAcceleratorobject that will look at the environment and initialize the proper distributed setup. 🤗 Accelerate handles the device placement for you, so you can remove the lines that put the model on the device (or, if you prefer, change them to useaccelerator.deviceinstead ofdevice).
추가할 첫 번째 줄은 import 줄입니다. 두 번째 줄은 환경을 살펴보고 적절한 분산 설정을 초기화하는 Accelerator 개체를 인스턴스화합니다. 🤗 Accelerate가 장치 배치를 자동으로 처리하므로 장치에 모델을 배치하는 줄을 제거할 수 있습니다(또는 원하는 경우 장치 대신 accelerator.device를 사용하도록 변경).
Then the main bulk of the work is done in the line that sends the dataloaders, the model, and the optimizer toaccelerator.prepare(). This will wrap those objects in the proper container to make sure your distributed training works as intended. The remaining changes to make are removing the line that puts the batch on thedevice(again, if you want to keep this you can just change it to useaccelerator.device) and replacingloss.backward()withaccelerator.backward(loss).
그런 다음 데이터로더, 모델 및 최적화 프로그램을 accelerator.prepare()로 보내는 라인에서 주요 작업이 수행됩니다. 이렇게 하면 분산 교육이 의도한 대로 작동하는지 확인하기 위해 해당 개체를 적절한 컨테이너에 래핑합니다. 나머지 변경 사항은 장치에 배치를 배치하는 줄을 제거하고(다시 말하지만 이를 유지하려면 accelerator.device를 사용하도록 변경하면 됩니다) loss.backward()를 accelerator.backward(loss)로 바꾸는 것입니다. .
⚠️ In order to benefit from the speed-up offered by Cloud TPUs, we recommend padding your samples to a fixed length with the `padding="max_length"` and `max_length` arguments of the tokenizer.
⚠️ Cloud TPU가 제공하는 속도 향상의 이점을 활용하려면 토크나이저의 `padding="max_length"` 및 `max_length` 인수를 사용하여 샘플을 고정 길이로 패딩하는 것이 좋습니다.
If you’d like to copy and paste it to play around, here’s what the complete training loop looks like with 🤗 Accelerate:
복사하여 붙여넣고 놀고 싶다면 🤗 Accelerate를 사용한 전체 훈련 루프는 다음과 같습니다.
from accelerate import Accelerator
from transformers import AdamW, AutoModelForSequenceClassification, get_scheduler
# Accelerator 객체 생성
accelerator = Accelerator()
# AutoModelForSequenceClassification 모델 및 AdamW 옵티마이저 초기화
model = AutoModelForSequenceClassification.from_pretrained(checkpoint, num_labels=2)
optimizer = AdamW(model.parameters(), lr=3e-5)
# 훈련 및 검증 데이터로더, 모델, 옵티마이저를 Accelerator로 준비
train_dl, eval_dl, model, optimizer = accelerator.prepare(
train_dataloader, eval_dataloader, model, optimizer
)
# 훈련 설정: 에폭 수 및 훈련 스텝 수 설정
num_epochs = 3
num_training_steps = num_epochs * len(train_dl)
# 러닝 레이트 스케줄러 설정
lr_scheduler = get_scheduler(
"linear",
optimizer=optimizer,
num_warmup_steps=0,
num_training_steps=num_training_steps,
)
# tqdm을 사용하여 훈련 진행 상황을 시각적으로 표시
progress_bar = tqdm(range(num_training_steps))
# 모델을 훈련 모드로 설정
model.train()
# 에폭 수 만큼 반복
for epoch in range(num_epochs):
# 훈련 데이터로더에서 미니배치를 가져와 반복
for batch in train_dl:
# 모델에 미니배치를 전달하여 출력을 얻음
outputs = model(**batch)
# 손실을 얻고 역전파
loss = outputs.loss
accelerator.backward(loss)
# 옵티마이저를 사용하여 모델 파라미터 업데이트
optimizer.step()
# 러닝 레이트 스케줄러를 사용하여 러닝 레이트 조절
lr_scheduler.step()
# 기울기 초기화
optimizer.zero_grad()
# tqdm 업데이트
progress_bar.update(1)
이 코드는 accelerate 라이브러리를 사용하여 GPU 가속을 적용한 딥러닝 모델의 훈련 스크립트를 나타냅니다.
변경된 부분:
Accelerator 사용: Accelerator 객체를 생성하고, prepare 메서드를 사용하여 훈련 데이터로더, 검증 데이터로더, 모델, 옵티마이저를 가속화합니다.
변수 명칭 변경: train_dl 및 eval_dl로 변수명을 변경하여 가속화된 데이터로더를 사용합니다.
나머지 코드는 이전과 동일하게 유지되며, 가속화 라이브러리를 사용하여 GPU 가속을 적용한 효율적인 딥러닝 모델 훈련을 수행합니다.
Putting this in atrain.pyscript will make that script runnable on any kind of distributed setup. To try it out in your distributed setup, run the command:
이것을 train.py 스크립트에 넣으면 모든 종류의 분산 설정에서 해당 스크립트를 실행할 수 있습니다. 분산 설정에서 사용해 보려면 다음 명령을 실행하세요.
accelerate config
accelerate config 명령어는 accelerate 라이브러리의 환경 설정을 확인하는 명령어입니다. 이 명령어를 사용하면 현재 가속화 환경에 대한 설정 정보를 확인할 수 있습니다. 아래는 해당 명령어에 대한 설명입니다.
위 명령어를 실행하면, 현재 사용 중인 환경에 대한 다양한 설정이 출력됩니다. 주로 다음과 같은 정보를 확인할 수 있습니다.
accelerator 설정: 현재 사용 중인 가속화 기술, 예를 들어, cuda 또는 tpu 등이 표시됩니다.
num_processes 및 num_gpus 설정: 병렬 처리에 사용되는 프로세스 수와 GPU 수가 표시됩니다.
fp16 설정: 16-bit 부동 소수점 사용 여부에 대한 설정이 표시됩니다.
fp16_backend 설정: 16-bit 부동 소수점 연산을 처리하는 백엔드(예: apex 또는 amp)가 표시됩니다.
ddp 설정: 분산 데이터 병렬 설정이 표시됩니다.
이 명령어를 사용하면 가속화 환경에 대한 자세한 설정을 확인할 수 있어, 딥러닝 모델을 효율적으로 훈련하기 위해 가속화 라이브러리를 조정하는 데 도움이 됩니다.
which will prompt you to answer a few questions and dump your answers in a configuration file used by this command:
그러면 몇 가지 질문에 대답하고 이 명령에서 사용하는 구성 파일에 답변을 덤프하라는 메시지가 표시됩니다.
accelerate launch train.py
accelerate launch train.py 명령어는 accelerate 라이브러리를 사용하여 딥러닝 모델을 훈련하는 스크립트인 train.py를 실행하는 명령어입니다. 이 명령어를 사용하면 가속화 환경에서 훈련을 수행할 수 있습니다. 아래는 해당 명령어에 대한 설명입니다.
해당 명령어를 실행하면, train.py 스크립트가 가속화 라이브러리의 환경 설정에 맞게 실행됩니다. 이때, 여러 GPU 또는 TPU 등을 활용하여 훈련을 가속화할 수 있습니다.
이 명령어를 사용하는 주요 이점은:
분산 훈련 지원: accelerate는 분산 훈련을 지원하며, 여러 GPU 또는 TPU에서 모델을 효율적으로 훈련할 수 있도록 도와줍니다.
Mixed Precision 훈련: 16-bit 부동 소수점 연산을 사용하여 모델의 훈련 속도를 향상시킵니다.
간편한 사용: accelerate를 사용하면 분산 훈련 및 가속화 설정에 대한 복잡한 부분을 자동으로 처리하여 간편하게 활용할 수 있습니다.
따라서, accelerate launch 명령어를 사용하면 train.py를 가속화된 환경에서 간편하게 실행할 수 있습니다.
which will launch the distributed training. 분산 교육이 시작됩니다.
If you want to try this in a Notebook (for instance, to test it with TPUs on Colab), just paste the code in atraining_function()and run a last cell with:
노트북에서 이 작업을 시도하려면(예: Colab의 TPU로 테스트) training_function()에 코드를 붙여넣고 다음을 사용하여 마지막 셀을 실행하세요.
from accelerate import notebook_launcher
notebook_launcher(training_function)
from accelerate import notebook_launcher와 notebook_launcher(training_function) 코드는 Jupyter Notebook 환경에서 accelerate 라이브러리를 사용하여 모델 훈련 함수(training_function)를 가속화하여 실행하는 코드입니다. 이 코드를 사용하면 Jupyter Notebook에서 간편하게 모델 훈련을 가속화할 수 있습니다.
해당 코드를 단계별로 설명하겠습니다:
notebook_launcher 임포트:
from accelerate import notebook_launcher
accelerate 라이브러리에서 notebook_launcher 모듈을 임포트합니다. 이 모듈은 Jupyter Notebook에서 가속화된 훈련을 지원합니다.
notebook_launcher 사용:
notebook_launcher(training_function)
notebook_launcher 함수에 모델을 훈련시키는 함수(training_function)를 전달하여 사용합니다. 이 함수는 가속화된 환경에서 모델 훈련을 시작합니다. notebook_launcher는 분산 훈련 및 Mixed Precision 훈련을 처리하는 등 가속화에 필요한 설정을 자동으로 수행합니다.
이 코드를 사용하면 Jupyter Notebook에서 간편하게 training_function을 실행할 수 있으며, accelerate 라이브러리의 기능을 활용하여 가속화된 딥러닝 모델 훈련을 수행할 수 있습니다.
🤗 Transformers provides aTrainerclass to help you fine-tune any of the pretrained models it provides on your dataset. Once you’ve done all the data preprocessing work in the last section, you have just a few steps left to define theTrainer. The hardest part is likely to be preparing the environment to runTrainer.train(), as it will run very slowly on a CPU. If you don’t have a GPU set up, you can get access to free GPUs or TPUs onGoogle Colab.
🤗 Transformers는 데이터세트에서 제공하는 사전 훈련된 모델을 미세 조정하는 데 도움이 되는 Trainer 클래스를 제공합니다. 마지막 섹션에서 모든 데이터 전처리 작업을 완료하고 나면 Trainer를 정의하기 위한 몇 단계만 남았습니다. 가장 어려운 부분은 Trainer.train()을 실행하기 위한 환경을 준비하는 것입니다. 왜냐하면 Trainer.train()은 CPU에서 매우 느리게 실행되기 때문입니다. GPU가 설정되어 있지 않은 경우 Google Colab에서 무료 GPU 또는 TPU에 액세스할 수 있습니다.
The code examples below assume you have already executed the examples in the previous section. Here is a short summary recapping what you need:
아래 코드 예제에서는 이전 섹션의 예제를 이미 실행했다고 가정합니다. 다음은 필요한 사항을 간략하게 요약한 것입니다.
from datasets import load_dataset
from transformers import AutoTokenizer, DataCollatorWithPadding
# MRPC 데이터셋 로드
raw_datasets = load_dataset("glue", "mrpc")
# BERT 모델의 체크포인트를 "bert-base-uncased"로 지정하여 토크나이저 초기화
checkpoint = "bert-base-uncased"
tokenizer = AutoTokenizer.from_pretrained(checkpoint)
# 사용자 정의 토크나이즈 함수 정의
def tokenize_function(example):
return tokenizer(example["sentence1"], example["sentence2"], truncation=True)
# 토큰화된 데이터셋 생성
tokenized_datasets = raw_datasets.map(tokenize_function, batched=True)
# 데이터 콜레이터 초기화
data_collator = DataCollatorWithPadding(tokenizer=tokenizer)
이 코드는 Hugging Face Transformers 라이브러리를 사용하여 MRPC(Microsoft Research Paraphrase Corpus) 데이터셋을 로드하고, BERT 모델의 토크나이저를 초기화하며, 토큰화 함수와 데이터 콜레이터를 정의하는 예제입니다. 코드를 단계별로 설명하겠습니다.
해석:
load_dataset("glue", "mrpc"): Hugging Face의 datasets 라이브러리를 사용하여 MRPC 데이터셋을 로드합니다.
AutoTokenizer.from_pretrained(checkpoint): BERT 모델의 체크포인트를 지정하여 해당 모델에 대한 토크나이저를 초기화합니다.
def tokenize_function(example): MRPC 데이터셋의 각 예시에 대한 사용자 정의 토크나이즈 함수를 정의합니다. 이 함수는 "sentence1"과 "sentence2" 필드의 문장을 토큰화합니다.
raw_datasets.map(tokenize_function, batched=True): map 함수를 사용하여 데이터셋의 각 예시에 대해 토크나이즈 함수를 적용하고, 배치(batch) 단위로 토큰화된 데이터셋을 생성합니다.
DataCollatorWithPadding(tokenizer=tokenizer): 데이터 콜레이터를 초기화합니다. 이 데이터 콜레이터는 패딩을 적용하여 배치의 모든 입력 시퀀스를 동일한 길이로 만들어주는 역할을 합니다.
이렇게 초기화된 토크나이저, 토큰화 함수, 데이터 콜레이터는 이후 모델 훈련 또는 추론을 위해 사용될 수 있습니다.
Training
The first step before we can define ourTraineris to define aTrainingArgumentsclass that will contain all the hyperparameters theTrainerwill use for training and evaluation. The only argument you have to provide is a directory where the trained model will be saved, as well as the checkpoints along the way. For all the rest, you can leave the defaults, which should work pretty well for a basic fine-tuning.
Trainer를 정의하기 전 첫 번째 단계는 Trainer가 훈련 및 평가에 사용할 모든 하이퍼파라미터를 포함는 TrainingArguments 클래스를 정의하는 것입니다. 제공해야 하는 유일한 인수는 학습된 모델이 저장될 디렉터리와 그 과정에서 체크포인트입니다. 나머지 모든 사항에 대해서는 기본값을 그대로 두면 기본 미세 조정에 매우 적합합니다.
from transformers import TrainingArguments
training_args = TrainingArguments("test-trainer")
이 코드는 Hugging Face Transformers 라이브러리를 사용하여 모델 훈련에 필요한 훈련 인자(Training Arguments)를 설정하는 예제입니다. 코드를 단계별로 설명하겠습니다.
해석:
TrainingArguments: Hugging Face Transformers 라이브러리에서 제공하는 모델 훈련을 위한 인자를 설정하는 클래스입니다.
TrainingArguments("test-trainer"): 훈련 인자 객체를 초기화합니다. 여기서 "test-trainer"는 훈련의 이름(디렉토리 이름)을 나타냅니다.
이렇게 초기화된 training_args 객체에는 모델 훈련에 필요한 다양한 설정이 포함되어 있습니다. 훈련 스크립트에서 이 인자들을 참조하여 모델 훈련을 조절할 수 있습니다. 이 예제에서는 가장 기본적인 훈련 인자만 설정되었습니다. 나중에 필요에 따라 추가적인 설정을 적용할 수 있습니다.
CoLab에서는 아래와 같은 에러가 남
pip install transformers[torch] 를 한 후 CoLab을 Restart 한 후 다시 실행하면 됨
💡 If you want to automatically upload your model to the Hub during training, pass alongpush_to_hub=Truein theTrainingArguments. We will learn more about this inChapter 4
💡 훈련 중에 모델을 허브에 자동으로 업로드하려면 TrainingArguments에 push_to_hub=True를 전달하세요. 이에 대한 자세한 내용은 4장에서 알아보겠습니다.
The second step is to define our model. As in theprevious chapter, we will use theAutoModelForSequenceClassificationclass, with two labels:
두 번째 단계는 모델을 정의하는 것입니다. 이전 장에서와 마찬가지로 두 개의 레이블이 있는 AutoModelForSequenceClassification 클래스를 사용합니다.
from transformers import AutoModelForSequenceClassification
model = AutoModelForSequenceClassification.from_pretrained(checkpoint, num_labels=2)
이 코드는 Hugging Face Transformers 라이브러리를 사용하여 사전 훈련된 모델을 불러오거나 새로운 모델을 초기화하는 예제입니다. 코드를 단계별로 설명하겠습니다.
해석:
AutoModelForSequenceClassification: Hugging Face Transformers 라이브러리에서 제공하는 시퀀스 분류(sequence classification) 모델을 초기화하는 클래스입니다.
from_pretrained(checkpoint, num_labels=2): from_pretrained 메서드를 사용하여 사전 훈련된 모델을 불러오거나 새로운 모델을 초기화합니다. checkpoint는 모델의 체크포인트를 지정하고, num_labels=2는 모델의 출력 클래스의 개수를 나타냅니다. 이 경우에는 이진 분류를 수행하는 모델로서 출력 클래스가 2개인 경우입니다.
이 코드를 실행하면 model 변수에는 초기화된 모델이 저장되어 있습니다. 이 모델은 이진 분류를 수행할 수 있으며, 사전 훈련된 모델을 사용하여 특정 작업에 미세 조정(fine-tuning)을 할 수 있습니다.
You will notice that unlike inChapter 2, you get a warning after instantiating this pretrained model. This is because BERT has not been pretrained on classifying pairs of sentences, so the head of the pretrained model has been discarded and a new head suitable for sequence classification has been added instead. The warnings indicate that some weights were not used (the ones corresponding to the dropped pretraining head) and that some others were randomly initialized (the ones for the new head). It concludes by encouraging you to train the model, which is exactly what we are going to do now.
2장과 달리 사전 훈련된 모델을 인스턴스화한 후 경고가 표시된다는 점을 알 수 있습니다. 이는 BERT가 문장 쌍을 분류하는 데 사전 학습되지 않았기 때문에 사전 학습된 모델의 헤드를 삭제하고 대신 시퀀스 분류에 적합한 새로운 헤드를 추가했기 때문입니다. 경고는 일부 가중치(삭제된 사전 훈련 헤드에 해당하는 가중치)가 사용되지 않았으며 일부 가중치(새 헤드에 대한 가중치)가 무작위로 초기화되었음을 나타냅니다. 우리가 지금 하려고 하는 것이 바로 모델 훈련을 권장하는 것으로 마무리됩니다.
Once we have our model, we can define aTrainerby passing it all the objects constructed up to now — themodel, thetraining_args, the training and validation datasets, ourdata_collator, and ourtokenizer:
모델이 있으면 지금까지 구성한 모든 개체(모델, training_args, 훈련 및 검증 데이터 세트, data_collator 및 토크나이저)를 전달하여 Trainer를 정의할 수 있습니다.
이 코드는 Hugging Face Transformers 라이브러리를 사용하여 모델을 훈련하기 위한 Trainer를 초기화하는 예제입니다. 코드를 단계별로 설명하겠습니다.
해석:
Trainer: Hugging Face Transformers 라이브러리에서 제공하는 훈련을 관리하는 클래스입니다.
model: 훈련에 사용될 모델 객체입니다.
training_args: 앞서 설정한 모델 훈련 인자(Training Arguments) 객체입니다.
train_dataset=tokenized_datasets["train"]: 훈련에 사용될 데이터셋을 지정합니다. 여기서는 토큰화된 훈련 데이터셋을 사용합니다.
eval_dataset=tokenized_datasets["validation"]: 모델의 성능을 평가할 때 사용될 검증 데이터셋을 지정합니다.
data_collator=data_collator: 데이터 콜레이터 객체를 지정합니다. 이 객체는 배치를 처리하여 패딩을 추가하고 동일한 길이로 만들어주는 역할을 합니다.
tokenizer=tokenizer: 토크나이저 객체를 지정합니다. 이 토크나이저는 모델 입력을 토큰화하는 데 사용됩니다.
이렇게 초기화된 Trainer 객체를 사용하면 지정된 모델과 데이터셋으로 모델을 훈련하고 평가할 수 있습니다. Trainer 객체를 사용하여 모델 훈련에 관련된 다양한 작업을 수행할 수 있습니다.
Note that when you pass thetokenizeras we did here, the defaultdata_collatorused by theTrainerwill be aDataCollatorWithPaddingas defined previously, so you can skip the linedata_collator=data_collatorin this call. It was still important to show you this part of the processing in section 2!
여기에서 했던 것처럼 토크나이저를 전달하면 Trainer에서 사용하는 기본 data_collator는 이전에 정의한 대로 DataCollatorWithPadding이 되므로 이 호출에서 data_collator=data_collator 줄을 건너뛸 수 있습니다. 섹션 2에서 처리 중 이 부분을 보여주는 것이 여전히 중요했습니다!
To fine-tune the model on our dataset, we just have to call thetrain()method of ourTrainer:
데이터 세트의 모델을 미세 조정하려면 Trainer의 train() 메서드를 호출하기만 하면 됩니다.
trainer.train()
이 코드는 Hugging Face Transformers 라이브러리의 Trainer 객체를 사용하여 모델을 훈련하는 메서드를 호출하는 예제입니다.
해석:
trainer: 앞서 초기화한 Trainer 객체입니다.
train(): Trainer 객체의 train 메서드를 호출합니다. 이 메서드는 모델을 실제로 훈련시키는 역할을 합니다. 메서드가 실행되면 지정된 횟수만큼 모델이 훈련되며, 각 에폭(epoch)마다 훈련 손실(training loss) 및 검증 손실(validation loss) 등의 정보가 출력됩니다.
이 코드를 실행하면 모델이 지정된 횟수만큼 데이터셋에 대해 훈련되며, 훈련 손실 및 검증 손실이 출력됩니다. Trainer 객체는 앞서 설정한 훈련 인자(Training Arguments)에 따라 훈련이 진행되며, 필요한 경우 추가적인 설정을 적용할 수 있습니다.
CoLab에서 train() 을 하면 두시간이 걸린다.
This will start the fine-tuning (which should take a couple of minutes on a GPU) and report the training loss every 500 steps. It won’t, however, tell you how well (or badly) your model is performing. This is because:
그러면 미세 조정(GPU에서는 몇 분 정도 소요)이 시작되고 500단계마다 훈련 손실이 보고됩니다. 그러나 모델의 성능이 얼마나 좋은지(또는 나쁜지) 알려주지는 않습니다. 그 이유는 아래와 같습니다.
We didn’t tell theTrainerto evaluate during training by settingevaluation_strategyto either"steps"(evaluate everyeval_steps) or"epoch"(evaluate at the end of each epoch).
training_strategy를 "steps"(모든 eval_steps 평가) 또는 "epoch"(각 epoch 끝에서 평가)로 설정하여 훈련 중에 평가하도록 트레이너에게 지시하지 않았습니다.
We didn’t provide theTrainerwith acompute_metrics()function to calculate a metric during said evaluation (otherwise the evaluation would just have printed the loss, which is not a very intuitive number).
우리는 평가 중에 메트릭을 계산하기 위해 Compute_metrics() 함수를 Trainer에 제공하지 않았습니다(그렇지 않으면 평가에서 매우 직관적인 숫자가 아닌 손실만 인쇄했을 것입니다).
Evaluation
Let’s see how we can build a usefulcompute_metrics()function and use it the next time we train. The function must take anEvalPredictionobject (which is a named tuple with apredictionsfield and alabel_idsfield) and will return a dictionary mapping strings to floats (the strings being the names of the metrics returned, and the floats their values). To get some predictions from our model, we can use theTrainer.predict()command:
유용한 Compute_metrics() 함수를 어떻게 구축하고 다음 훈련에 사용할 수 있는지 살펴보겠습니다. 함수는 EvalPrediction 객체(예측 필드와 label_ids 필드가 있는 명명된 튜플)를 가져와야 하며 문자열을 부동 소수점(문자열은 반환된 측정항목의 이름이고 부동 소수점 값)에 매핑하는 사전을 반환합니다. 모델에서 몇 가지 예측을 얻으려면 Trainer.predict() 명령을 사용할 수 있습니다.
이 코드는 Hugging Face Transformers 라이브러리의 Trainer 객체를 사용하여 검증 데이터셋에 대한 예측을 수행하고, 그 결과를 출력하는 예제입니다.
해석:
trainer: 앞서 초기화한 Trainer 객체입니다.
predict(tokenized_datasets["validation"]): Trainer 객체의 predict 메서드를 호출하여 검증 데이터셋에 대한 예측을 수행합니다. tokenized_datasets["validation"]은 검증 데이터셋의 토큰화된 버전을 나타냅니다.
predictions.predictions.shape: 예측된 결과의 모양(shape)을 나타냅니다. 예측된 결과는 모델의 출력으로, 각 클래스에 대한 확률 값이 포함된 텐서입니다.
predictions.label_ids.shape: 실제 레이블(ground truth)의 모양(shape)을 나타냅니다. 이는 검증 데이터셋의 실제 클래스 레이블을 나타내는 텐서입니다.
결과로 출력되는 predictions.predictions.shape와 predictions.label_ids.shape은 각각 예측된 결과의 모양과 실제 레이블의 모양을 나타내므로, 모델의 성능 평가 및 분석에 활용할 수 있습니다. 이를 통해 모델이 얼마나 잘 예측했는지를 확인할 수 있습니다.
The output of thepredict()method is another named tuple with three fields:predictions,label_ids, andmetrics. Themetricsfield will just contain the loss on the dataset passed, as well as some time metrics (how long it took to predict, in total and on average). Once we complete ourcompute_metrics()function and pass it to theTrainer, that field will also contain the metrics returned bycompute_metrics().
predict () 메서드의 출력은 predict , label_ids 및 메트릭이라는 세 가지 필드가 있는 또 다른 명명된 튜플입니다. 측정항목 필드에는 전달된 데이터 세트의 손실과 일부 시간 측정항목(전체 및 평균으로 예측하는 데 걸린 시간)만 포함됩니다. Compute_metrics() 함수를 완성하고 이를 Trainer에 전달하면 해당 필드에는 Compute_metrics()에서 반환된 측정항목도 포함됩니다.
As you can see,predictionsis a two-dimensional array with shape 408 x 2 (408 being the number of elements in the dataset we used). Those are the logits for each element of the dataset we passed topredict()(as you saw in theprevious chapter, all Transformer models return logits). To transform them into predictions that we can compare to our labels, we need to take the index with the maximum value on the second axis:
보시다시피 예측은 408 x 2 모양의 2차원 배열입니다(408은 우리가 사용한 데이터세트의 요소 수입니다). 이는 우리가 predict ()에 전달한 데이터 세트의 각 요소에 대한 로짓입니다(이전 장에서 보았듯이 모든 Transformer 모델은 로짓을 반환합니다). 이를 레이블과 비교할 수 있는 predict 으로 변환하려면 두 번째 축에서 최대값을 갖는 인덱스를 가져와야 합니다.
import numpy as np
preds = np.argmax(predictions.predictions, axis=-1)
이 코드는 NumPy 라이브러리를 사용하여 모델의 예측 결과에서 각 샘플에 대한 최대값을 찾아 클래스를 선택하는 예제입니다.
해석:
predictions.predictions: 모델의 예측 결과로, 각 클래스에 대한 확률 값이 담긴 텐서입니다.
np.argmax(predictions.predictions, axis=-1): NumPy의 argmax 함수를 사용하여 각 샘플에 대해 가장 높은 확률 값을 가진 클래스의 인덱스를 찾습니다. axis=-1는 가장 안쪽(마지막) 차원을 기준으로 최댓값을 찾도록 지정합니다.
결과로 얻어지는 preds는 각 샘플에 대해 모델이 예측한 클래스의 인덱스를 담은 배열이 됩니다. 이를 통해 각 샘플에 대한 최종 예측 클래스를 확인할 수 있습니다. 예를 들어, 이 배열의 첫 번째 원소는 첫 번째 샘플의 예측 클래스를 나타냅니다.
We can now compare thosepredsto the labels. To build ourcompute_metric()function, we will rely on the metrics from the 🤗Evaluatelibrary. We can load the metrics associated with the MRPC dataset as easily as we loaded the dataset, this time with theevaluate.load()function. The object returned has acompute()method we can use to do the metric calculation:
이제 해당 pred를 레이블과 비교할 수 있습니다. Compute_metric() 함수를 빌드하기 위해 🤗 Evaluate 라이브러리의 메트릭을 사용합니다. 이번에는 estimate.load() 함수를 사용하여 데이터세트를 로드한 것처럼 쉽게 MRPC 데이터세트와 관련된 측정항목을 로드할 수 있습니다. 반환된 객체에는 측정항목 계산을 수행하는 데 사용할 수 있는 Compute() 메서드가 있습니다.
이 코드는 Hugging Face의 evaluate 모듈을 사용하여 모델의 성능 지표를 계산하는 예제입니다. 코드를 단계별로 설명하겠습니다.
해석:
import evaluate: Hugging Face에서 제공하는 evaluate 모듈을 가져옵니다.
evaluate.load("glue", "mrpc"): "glue" 데이터셋의 "mrpc" 태스크에 해당하는 성능 지표 메트릭을 로드합니다. 이 메트릭은 해당 태스크에 대한 평가 지표를 계산하는 데 사용됩니다.
metric.compute(predictions=preds, references=predictions.label_ids): compute 메서드를 사용하여 모델의 예측값 (preds)과 실제 레이블 (predictions.label_ids)을 입력으로 주어 성능 지표를 계산합니다. 이 메서드는 정확도(accuracy) 및 기타 태스크별 지표를 반환할 수 있습니다.
결과로 얻어지는 값은 해당 데이터셋 및 태스크에 대한 모델의 성능을 나타내며, 필요에 따라 이를 기반으로 모델을 평가하고 비교할 수 있습니다.
The exact results you get may vary, as the random initialization of the model head might change the metrics it achieved. Here, we can see our model has an accuracy of 85.78% on the validation set and an F1 score of 89.97. Those are the two metrics used to evaluate results on the MRPC dataset for the GLUE benchmark. The table in theBERT paperreported an F1 score of 88.9 for the base model. That was theuncasedmodel while we are currently using thecasedmodel, which explains the better result.
모델 헤드의 무작위 초기화로 인해 얻은 측정항목이 변경될 수 있으므로 얻을 수 있는 정확한 결과는 다를 수 있습니다. 여기서 우리 모델의 검증 세트 정확도는 85.78%이고 F1 점수는 89.97임을 알 수 있습니다. 이는 GLUE 벤치마크에 대한 MRPC 데이터 세트의 결과를 평가하는 데 사용되는 두 가지 측정항목입니다. BERT 논문의 표는 기본 모델의 F1 점수가 88.9라고 보고했습니다. 우리가 현재 케이스를 씌운 모델을 사용하고 있는 동안 그것은 케이스가 없는 모델이었습니다. 이것이 더 나은 결과를 설명합니다.
Wrapping everything together, we get ourcompute_metrics()function:
이 코드는 Hugging Face Transformers 라이브러리를 사용하여 모델 훈련을 설정하는 부분입니다. 코드를 단계별로 설명하겠습니다.
해석:
TrainingArguments("test-trainer", evaluation_strategy="epoch"): 훈련 인자(Training Arguments) 객체를 초기화합니다. 여기서는 훈련의 이름(디렉토리 이름)을 "test-trainer"로 지정하고, evaluation_strategy="epoch"를 통해 검증을 에폭(epoch) 단위로 수행하도록 설정합니다.
AutoModelForSequenceClassification.from_pretrained(checkpoint, num_labels=2): 사전 훈련된 모델을 불러오거나 새로운 모델을 초기화합니다. checkpoint는 모델의 체크포인트를 지정하고, num_labels=2는 모델의 출력 클래스의 개수를 나타냅니다. 이 경우에는 이진 분류를 수행하는 모델로서 출력 클래스가 2개인 경우입니다.
Trainer(...): 훈련을 관리하는 Trainer 객체를 초기화합니다.
model: 훈련에 사용될 모델 객체입니다.
training_args: 앞서 초기화한 훈련 인자 객체입니다.
train_dataset=tokenized_datasets["train"]: 훈련에 사용될 데이터셋을 지정합니다. 여기서는 토큰화된 훈련 데이터셋을 사용합니다.
eval_dataset=tokenized_datasets["validation"]: 모델의 성능을 평가할 때 사용될 검증 데이터셋을 지정합니다.
data_collator=data_collator: 데이터 콜레이터 객체를 지정합니다. 이 객체는 배치를 처리하여 패딩을 추가하고 동일한 길이로 만들어주는 역할을 합니다.
tokenizer=tokenizer: 토크나이저 객체를 지정합니다. 이 토크나이저는 모델 입력을 토큰화하는 데 사용됩니다.
compute_metrics=compute_metrics: 사용자 정의 메트릭을 계산하는 함수를 지정합니다.
이렇게 초기화된 Trainer 객체를 사용하면 모델을 지정된 횟수만큼 데이터셋에 대해 훈련하고, 검증을 에폭 단위로 수행할 수 있습니다. 필요에 따라 추가적인 설정을 적용할 수 있습니다.
Note that we create a newTrainingArgumentswith itsevaluation_strategyset to"epoch"and a new model — otherwise, we would just be continuing the training of the model we have already trained. To launch a new training run, we execute:
Evaluation_strategy가 "epoch"로 설정된 새로운 TrainingArguments와 새 모델을 생성합니다. 그렇지 않으면 이미 훈련한 모델의 훈련을 계속할 것입니다. 새로운 훈련 실행을 시작하기 위해 다음을 실행합니다.
trainer.train()
This time, it will report the validation loss and metrics at the end of each epoch on top of the training loss. Again, the exact accuracy/F1 score you reach might be a bit different from what we found, because of the random head initialization of the model, but it should be in the same ballpark.
이번에는 훈련 손실 외에 각 에포크가 끝날 때마다 검증 손실과 측정항목을 보고합니다. 다시 말하지만, 도달한 정확한 정확도/F1 점수는 모델의 무작위 헤드 초기화로 인해 우리가 찾은 것과 약간 다를 수 있지만 동일한 기준점에 있어야 합니다.
TheTrainerwill work out of the box on multiple GPUs or TPUs and provides lots of options, like mixed-precision training (usefp16 = Truein your training arguments). We will go over everything it supports in Chapter 10.
Trainer는 여러 GPU 또는 TPU에서 즉시 작동하며 혼합 정밀도 교육과 같은 다양한 옵션을 제공합니다(교육 인수에서 fp16 = True 사용). 10장에서 지원되는 모든 내용을 살펴보겠습니다.
This concludes the introduction to fine-tuning using theTrainerAPI. An example of doing this for most common NLP tasks will be given inChapter 7, but for now let’s look at how to do the same thing in pure PyTorch.
이것으로 Trainer API를 사용한 미세 조정에 대한 소개를 마칩니다. 가장 일반적인 NLP 작업에 대해 이 작업을 수행하는 예는 7장에서 제공되지만 지금은 순수한 PyTorch에서 동일한 작업을 수행하는 방법을 살펴보겠습니다.
✏️Try it out!Fine-tune a model on the GLUE SST-2 dataset, using the data processing you did in section 2.
✏️ 한번 사용해 보세요! 섹션 2에서 수행한 데이터 처리를 사용하여 GLUE SST-2 데이터 세트에서 모델을 미세 조정합니다.
Summary
지난 단원에서는 데이터를 로드하고 미세조정 하기 위해 텍스트 데이터를 토큰화하고 정수화 하고 길이 등을 맞춰 training을 준비 했다면 이번 단원에서는 그 준비된 데이터로 실제 training을 진행하는 과정을 설명 함.
Training을 하기 위해서는 Huggingface의 Trainer class를 사용한다.
처음으로 TrainingArguments를 사용해 Arguments를 세팅하고 Trainer를 사용해 지금까지 준비한 모든 것을 Model에 전달하기 위한 정의를 마친다.
그 다음 train() 메소드를 실행하면 실제로 training이 이루어 진다.
training이 끝나면 validation 데이터로 predict을 한다. predict()
그리고 이 predict 한 내용을 evaluate 한다.
이것이 전체 training 과정 임.
참고로 training() 은 시간이 오래 걸리는데 이 때 더 자세한 정보가 나오도록 하기 위해 compute_metrics() 함수를 만들어 Trainer() 에 추가 했음. (compute() 메소드를 사용해서 추가 정보가 나오도록 했음)