Spaces:
Paused
AutoClass๋ก ์ฌ์ ํ์ต๋ ์ธ์คํด์ค ๋ก๋[[load-pretrained-instances-with-an-autoclass]]
ํธ๋์คํฌ๋จธ ์ํคํ
์ฒ๊ฐ ๋งค์ฐ ๋ค์ํ๊ธฐ ๋๋ฌธ์ ์ฒดํฌํฌ์ธํธ์ ๋ง๋ ์ํคํ
์ฒ๋ฅผ ์์ฑํ๋ ๊ฒ์ด ์ด๋ ค์ธ ์ ์์ต๋๋ค. ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ฅผ ์ฝ๊ณ ๊ฐ๋จํ๋ฉฐ ์ ์ฐํ๊ฒ ์ฌ์ฉํ๊ธฐ ์ํ Transformer ํต์ฌ ์ฒ ํ์ ์ผํ์ผ๋ก, AutoClass
๋ ์ฃผ์ด์ง ์ฒดํฌํฌ์ธํธ์์ ์ฌ๋ฐ๋ฅธ ์ํคํ
์ฒ๋ฅผ ์๋์ผ๋ก ์ถ๋ก ํ์ฌ ๋ก๋ํฉ๋๋ค. from_pretrained()
๋ฉ์๋๋ฅผ ์ฌ์ฉํ๋ฉด ๋ชจ๋ ์ํคํ
์ฒ์ ๋ํด ์ฌ์ ํ์ต๋ ๋ชจ๋ธ์ ๋น ๋ฅด๊ฒ ๋ก๋ํ ์ ์์ผ๋ฏ๋ก ๋ชจ๋ธ์ ์ฒ์๋ถํฐ ํ์ตํ๋ ๋ฐ ์๊ฐ๊ณผ ๋ฆฌ์์ค๋ฅผ ํฌ์
ํ ํ์๊ฐ ์์ต๋๋ค.
์ฒดํฌํฌ์ธํธ์ ๊ตฌ์ ๋ฐ์ง ์๋ ์ฝ๋๋ฅผ ์์ฑํ๋ค๋ ๊ฒ์ ์ฝ๋๊ฐ ํ ์ฒดํฌํฌ์ธํธ์์ ์๋ํ๋ฉด ์ํคํ
์ฒ๊ฐ ๋ค๋ฅด๋๋ผ๋ ๋ค๋ฅธ ์ฒดํฌํฌ์ธํธ(์ ์ฌํ ์์
์ ๋ํด ํ์ต๋ ๊ฒฝ์ฐ)์์๋ ์๋ํ๋ค๋ ๊ฒ์ ์๋ฏธํฉ๋๋ค.
์ํคํ
์ฒ๋ ๋ชจ๋ธ์ ๊ณจ๊ฒฉ์ ์๋ฏธํ๋ฉฐ ์ฒดํฌํฌ์ธํธ๋ ์ฃผ์ด์ง ์ํคํ
์ฒ์ ๋ํ ๊ฐ์ค์น์
๋๋ค. ์๋ฅผ ๋ค์ด, BERT๋ ์ํคํ
์ฒ์ด๊ณ , bert-base-uncased
๋ ์ฒดํฌํฌ์ธํธ์
๋๋ค. ๋ชจ๋ธ์ ์ํคํ
์ฒ ๋๋ ์ฒดํฌํฌ์ธํธ๋ฅผ ์๋ฏธํ ์ ์๋ ์ผ๋ฐ์ ์ธ ์ฉ์ด์
๋๋ค.
์ด ํํ ๋ฆฌ์ผ์์๋ ๋ค์์ ํ์ตํฉ๋๋ค:
- ์ฌ์ ํ์ต๋ ํ ํฌ๋์ด์ ๋ก๋ํ๊ธฐ.
- ์ฌ์ ํ์ต๋ ์ด๋ฏธ์ง ํ๋ก์ธ์ ๋ก๋ํ๊ธฐ.
- ์ฌ์ ํ์ต๋ ํน์ง ์ถ์ถ๊ธฐ ๋ก๋ํ๊ธฐ.
- ์ฌ์ ํ๋ จ๋ ํ๋ก์ธ์ ๋ก๋ํ๊ธฐ.
- ์ฌ์ ํ์ต๋ ๋ชจ๋ธ ๋ก๋ํ๊ธฐ.
AutoTokenizer[[autotokenizer]]
๊ฑฐ์ ๋ชจ๋ NLP ์์
์ ํ ํฌ๋์ด์ ๋ก ์์๋ฉ๋๋ค. ํ ํฌ๋์ด์ ๋ ์ฌ์ฉ์์ ์
๋ ฅ์ ๋ชจ๋ธ์์ ์ฒ๋ฆฌํ ์ ์๋ ํ์์ผ๋ก ๋ณํํฉ๋๋ค.
[AutoTokenizer.from_pretrained
]๋ก ํ ํฌ๋์ด์ ๋ฅผ ๋ก๋ํฉ๋๋ค:
>>> from transformers import AutoTokenizer
>>> tokenizer = AutoTokenizer.from_pretrained("bert-base-uncased")
๊ทธ๋ฆฌ๊ณ ์๋์ ๊ฐ์ด ์ ๋ ฅ์ ํ ํฐํํฉ๋๋ค:
>>> 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]]
๋น์ ์์ ์ ๊ฒฝ์ฐ ์ด๋ฏธ์ง ํ๋ก์ธ์๊ฐ ์ด๋ฏธ์ง๋ฅผ ์ฌ๋ฐ๋ฅธ ์ ๋ ฅ ํ์์ผ๋ก ์ฒ๋ฆฌํฉ๋๋ค.
>>> from transformers import AutoImageProcessor
>>> image_processor = AutoImageProcessor.from_pretrained("google/vit-base-patch16-224")
AutoFeatureExtractor[[autofeatureextractor]]
์ค๋์ค ์์ ์ ๊ฒฝ์ฐ ํน์ง ์ถ์ถ๊ธฐ๊ฐ ์ค๋์ค ์ ํธ๋ฅผ ์ฌ๋ฐ๋ฅธ ์ ๋ ฅ ํ์์ผ๋ก ์ฒ๋ฆฌํฉ๋๋ค.
[AutoFeatureExtractor.from_pretrained
]๋ก ํน์ง ์ถ์ถ๊ธฐ๋ฅผ ๋ก๋ํฉ๋๋ค:
>>> from transformers import AutoFeatureExtractor
>>> feature_extractor = AutoFeatureExtractor.from_pretrained(
... "ehcalabres/wav2vec2-lg-xlsr-en-speech-emotion-recognition"
... )
AutoProcessor[[autoprocessor]]
๋ฉํฐ๋ชจ๋ฌ ์์ ์๋ ๋ ๊ฐ์ง ์ ํ์ ์ ์ฒ๋ฆฌ ๋๊ตฌ๋ฅผ ๊ฒฐํฉํ ํ๋ก์ธ์๊ฐ ํ์ํฉ๋๋ค. ์๋ฅผ ๋ค์ด LayoutLMV2 ๋ชจ๋ธ์๋ ์ด๋ฏธ์ง๋ฅผ ์ฒ๋ฆฌํ๋ ์ด๋ฏธ์ง ํ๋ก์ธ์์ ํ ์คํธ๋ฅผ ์ฒ๋ฆฌํ๋ ํ ํฌ๋์ด์ ๊ฐ ํ์ํ๋ฉฐ, ํ๋ก์ธ์๋ ์ด ๋ ๊ฐ์ง๋ฅผ ๊ฒฐํฉํฉ๋๋ค.
[AutoProcessor.from_pretrained()
]๋ก ํ๋ก์ธ์๋ฅผ ๋ก๋ํฉ๋๋ค:
>>> from transformers import AutoProcessor
>>> processor = AutoProcessor.from_pretrained("microsoft/layoutlmv2-base-uncased")
AutoModel[[automodel]]
๋ง์ง๋ง์ผ๋ก AutoModelForํด๋์ค๋ฅผ ์ฌ์ฉํ๋ฉด ์ฃผ์ด์ง ์์ ์ ๋ํด ๋ฏธ๋ฆฌ ํ์ต๋ ๋ชจ๋ธ์ ๋ก๋ํ ์ ์์ต๋๋ค (์ฌ์ฉ ๊ฐ๋ฅํ ์์ ์ ์ ์ฒด ๋ชฉ๋ก์ [์ฌ๊ธฐ](model_doc/auto)๋ฅผ ์ฐธ์กฐํ์ธ์). ์๋ฅผ ๋ค์ด, [`AutoModelForSequenceClassification.from_pretrained`]๋ฅผ ์ฌ์ฉํ์ฌ ์ํ์ค ๋ถ๋ฅ์ฉ ๋ชจ๋ธ์ ๋ก๋ํ ์ ์์ต๋๋ค:>>> from transformers import AutoModelForSequenceClassification
>>> model = AutoModelForSequenceClassification.from_pretrained("distilbert-base-uncased")
๋์ผํ ์ฒดํฌํฌ์ธํธ๋ฅผ ์ฝ๊ฒ ์ฌ์ฌ์ฉํ์ฌ ๋ค๋ฅธ ์์ ์ ์ํคํ ์ฒ๋ฅผ ๋ก๋ํ ์ ์์ต๋๋ค:
>>> from transformers import AutoModelForTokenClassification
>>> model = AutoModelForTokenClassification.from_pretrained("distilbert-base-uncased")
PyTorch๋ชจ๋ธ์ ๊ฒฝ์ฐ from_pretrained()
๋ฉ์๋๋ ๋ด๋ถ์ ์ผ๋ก ํผํด์ ์ฌ์ฉํ์ฌ ์์ ํ์ง ์์ ๊ฒ์ผ๋ก ์๋ ค์ง torch.load()
๋ฅผ ์ฌ์ฉํฉ๋๋ค.
์ผ๋ฐ์ ์ผ๋ก ์ ๋ขฐํ ์ ์๋ ์์ค์์ ๊ฐ์ ธ์๊ฑฐ๋ ๋ณ์กฐ๋์์ ์ ์๋ ๋ชจ๋ธ์ ๋ก๋ํ์ง ๋ง์ธ์. ํ๊น
ํ์ด์ค ํ๋ธ์์ ํธ์คํ
๋๋ ๊ณต๊ฐ ๋ชจ๋ธ์ ๊ฒฝ์ฐ ์ด๋ฌํ ๋ณด์ ์ํ์ด ๋ถ๋ถ์ ์ผ๋ก ์ํ๋๋ฉฐ, ๊ฐ ์ปค๋ฐ ์ ๋ฉ์จ์ด๋ฅผ ๊ฒ์ฌํฉ๋๋ค. GPG๋ฅผ ์ฌ์ฉํด ์๋ช
๋ ์ปค๋ฐ ๊ฒ์ฆ๊ณผ ๊ฐ์ ๋ชจ๋ฒ์ฌ๋ก๋ ๋ฌธ์๋ฅผ ์ฐธ์กฐํ์ธ์.
ํ
์ํ๋ก์ฐ์ Flax ์ฒดํฌํฌ์ธํธ๋ ์ํฅ์ ๋ฐ์ง ์์ผ๋ฉฐ, from_pretrained
๋ฉ์๋์ from_tf
์ from_flax
ํค์๋ ๊ฐ๋ณ ์ธ์๋ฅผ ์ฌ์ฉํ์ฌ ์ด ๋ฌธ์ ๋ฅผ ์ฐํํ ์ ์์ต๋๋ค.
์ผ๋ฐ์ ์ผ๋ก AutoTokenizer ํด๋์ค์ AutoModelFor ํด๋์ค๋ฅผ ์ฌ์ฉํ์ฌ ๋ฏธ๋ฆฌ ํ์ต๋ ๋ชจ๋ธ ์ธ์คํด์ค๋ฅผ ๋ก๋ํ๋ ๊ฒ์ด ์ข์ต๋๋ค. ์ด๋ ๊ฒ ํ๋ฉด ๋งค๋ฒ ์ฌ๋ฐ๋ฅธ ์ํคํ
์ฒ๋ฅผ ๋ก๋ํ ์ ์์ต๋๋ค. ๋ค์ ํํ ๋ฆฌ์ผ์์๋ ์๋กญ๊ฒ ๋ก๋ํ ํ ํฌ๋์ด์ , ์ด๋ฏธ์ง ํ๋ก์ธ์, ํน์ง ์ถ์ถ๊ธฐ๋ฅผ ์ฌ์ฉํ์ฌ ๋ฏธ์ธ ํ๋์ฉ ๋ฐ์ดํฐ ์ธํธ๋ฅผ ์ ์ฒ๋ฆฌํ๋ ๋ฐฉ๋ฒ์ ๋ํด ์์๋ด
๋๋ค.
๋ง์ง๋ง์ผ๋ก TFAutoModelFor
ํด๋์ค๋ฅผ ์ฌ์ฉํ๋ฉด ์ฃผ์ด์ง ์์
์ ๋ํด ์ฌ์ ํ๋ จ๋ ๋ชจ๋ธ์ ๋ก๋ํ ์ ์์ต๋๋ค. (์ฌ์ฉ ๊ฐ๋ฅํ ์์
์ ์ ์ฒด ๋ชฉ๋ก์ ์ฌ๊ธฐ๋ฅผ ์ฐธ์กฐํ์ธ์. ์๋ฅผ ๋ค์ด, [TFAutoModelForSequenceClassification.from_pretrained
]๋ก ์ํ์ค ๋ถ๋ฅ๋ฅผ ์ํ ๋ชจ๋ธ์ ๋ก๋ํฉ๋๋ค:
>>> from transformers import TFAutoModelForSequenceClassification
>>> model = TFAutoModelForSequenceClassification.from_pretrained("distilbert-base-uncased")
์ฝ๊ฒ ๋์ผํ ์ฒดํฌํฌ์ธํธ๋ฅผ ์ฌ์ฌ์ฉํ์ฌ ๋ค๋ฅธ ์์ ์ ์ํคํ ์ฒ๋ฅผ ๋ก๋ํ ์ ์์ต๋๋ค:
>>> from transformers import TFAutoModelForTokenClassification
>>> model = TFAutoModelForTokenClassification.from_pretrained("distilbert-base-uncased")
์ผ๋ฐ์ ์ผ๋ก, AutoTokenizer
ํด๋์ค์ TFAutoModelFor
ํด๋์ค๋ฅผ ์ฌ์ฉํ์ฌ ๋ฏธ๋ฆฌ ํ์ต๋ ๋ชจ๋ธ ์ธ์คํด์ค๋ฅผ ๋ก๋ํ๋ ๊ฒ์ด ์ข์ต๋๋ค. ์ด๋ ๊ฒ ํ๋ฉด ๋งค๋ฒ ์ฌ๋ฐ๋ฅธ ์ํคํ
์ฒ๋ฅผ ๋ก๋ํ ์ ์์ต๋๋ค. ๋ค์ ํํ ๋ฆฌ์ผ์์๋ ์๋กญ๊ฒ ๋ก๋ํ ํ ํฌ๋์ด์ , ์ด๋ฏธ์ง ํ๋ก์ธ์, ํน์ง ์ถ์ถ๊ธฐ๋ฅผ ์ฌ์ฉํ์ฌ ๋ฏธ์ธ ํ๋์ฉ ๋ฐ์ดํฐ ์ธํธ๋ฅผ ์ ์ฒ๋ฆฌํ๋ ๋ฐฉ๋ฒ์ ๋ํด ์์๋ด
๋๋ค.