๐ค Datasets ๋น ๋ฅธ ์์
๐ค Datasets ๋น ๋ฅธ ์์ (Quickstart)
์ด ํต์คํํธ๋ ์ฝ๋๋ฅผ ๋ฐ๋ก ๋ง์ ธ๋ณด๊ณ ์ถ์ ๊ฐ๋ฐ์๋ฅผ ์ํ ๊ฐ์ด๋์์. ๋ชจ๋ธ ํ๋ จ ์ํฌํ๋ก์ ๐ค Datasets์ ์ด๋ป๊ฒ ํตํฉํ๋์ง ์์๋ก ํ์ธํด ๋ณผ ์ ์์ด์. ์ฒ์ ๋ฐฐ์ฐ๋ ๋ถ์ด๋ผ๋ฉด ํํ ๋ฆฌ์ผ๋ถํฐ ์์ํ๋ ๊ฑธ ์ถ์ฒํด์. ๋ ์ฐจ๊ทผ์ฐจ๊ทผ ์๊ฐํด ์ฃผ๊ฑฐ๋ ์.
๊ฐ์ฅ ๋น ๋ฅด๊ณ ์ฌ์ด ์์ ๋ฐฉ๋ฒ์ Hugging Face Hub์ ์๋ ๊ธฐ์กด ๋ฐ์ดํฐ์ ์ ๋ถ๋ฌ์ค๋ ๊ฑฐ์์. ์์ฒ ๊ฐ์ ๋ฐ์ดํฐ์ ์ด ๋ค์ํ ํ์คํฌ์ ๊ฑธ์ณ ์ค๋น๋์ด ์์ผ๋๊น, ์์ ํ๊ณ ์ถ์ ์ ํ์ ๊ณ ๋ฅด๋ฉด ๋ฉ๋๋ค.
- Audio: ์ค๋์ค ๋ฐ์ดํฐ์ ์ ๋ฆฌ์ํ๋งํด์ ๋ชจ๋ธ์ด ์ํ ์ ๋ฌด ์ ํ์ ๋ถ๋ฅํ๋๋ก ์ค๋น
- Vision: ์ด๋ฏธ์ง ๋ฐ์ดํฐ์ ์ ๋ฐ์ดํฐ ์ฆ๊ฐ(augmentation)์ ์ ์ฉํด์ ๋ณ ์ง๋จ ๋ชจ๋ธ ์ค๋น
- NLP: ๋ฐ์ดํฐ์ ์ ํ ํฐํํด์ ๋ ๋ฌธ์ฅ์ ์๋ฏธ๊ฐ ๊ฐ์์ง ํ๋ณํ๋ ๋ชจ๋ธ ์ค๋น
๋จผ์ ๐ค Datasets์ ์ค์นํฉ๋๋ค.
pip install datasets
- ์ค๋์ค ๋ฐ์ดํฐ์
์ ๋ค๋ฃจ๋ ค๋ฉด Audio ๊ธฐ๋ฅ์ ์ค์นํด์:
pip install datasets[audio] - ์ด๋ฏธ์ง ๋ฐ์ดํฐ์
์ ๋ค๋ฃจ๋ ค๋ฉด Image ๊ธฐ๋ฅ์ ์ค์นํ๋ฉด ๋ผ์:
pip install datasets[vision]
Audio
์ค๋์ค ๋ฐ์ดํฐ์ ์ ํ ์คํธ ๋ฐ์ดํฐ์ ๊ณผ ๋๊ฐ์ ๋ฐฉ์์ผ๋ก ๋ถ๋ฌ์์. ๋ค๋ง ์ ์ฒ๋ฆฌ ๋ฐฉ์์ ์กฐ๊ธ ๋ฌ๋ผ์. ํ ํฌ๋์ด์ ๋์ feature extractor๊ฐ ํ์ํ๊ฑฐ๋ ์.
์ค๋์ค ์ ๋ ฅ์ ๋ชจ๋ธ์ ๋ง๊ฒ ์ํ๋ง ๋ ์ดํธ(sampling rate)๋ฅผ ๋ฆฌ์ํ๋งํด์ผ ํ ์๋ ์์ด์. ์ด ํต์คํํธ์์๋ MInDS-14 ๋ฐ์ดํฐ์ ์ ์ค๋นํด์, ๊ณ ๊ฐ์ด ๊ฒช๋ ์ํ ์ ๋ฌด ๋ฌธ์ ๋ฅผ ๋ถ๋ฅํ๋ ๋ชจ๋ธ์ ํ๋ จํด ๋ณผ๊ฒ์.
1. load_dataset() ํจ์์ ๋ฐ์ดํฐ์ ์ด๋ฆ, ๋ฐ์ดํฐ์ ์ค์ (configuration, ๋ชจ๋ ๋ฐ์ดํฐ์ ์ ์๋ ๊ฑด ์๋), ๋ฐ์ดํฐ์ ๋ถํ (split)์ ๋๊ฒจ MInDS-14๋ฅผ ๋ถ๋ฌ์ต๋๋ค.
>>> from datasets import load_dataset, Audio
>>> dataset = load_dataset("PolyAI/minds14", "en-US", split="train")
2. ๋ค์์ผ๋ก ๐ค Transformers ๋ผ์ด๋ธ๋ฌ๋ฆฌ์์ ์ฌ์ ํ๋ จ๋ Wav2Vec2 ๋ชจ๋ธ๊ณผ ๊ทธ์ ๋ง๋ feature extractor๋ฅผ ๋ถ๋ฌ์์. ๋ชจ๋ธ์ ๋ถ๋ฌ์จ ๋ค ์ผ๋ถ ๊ฐ์ค์น๊ฐ ์ด๊ธฐํ๋์ง ์์๋ค๋ ๊ฒฝ๊ณ ๊ฐ ๋์ค๋ ๊ฑด ์ ์์ด์์.
>>> from transformers import AutoModelForAudioClassification, AutoFeatureExtractor
>>> model = AutoModelForAudioClassification.from_pretrained("facebook/wav2vec2-base")
>>> feature_extractor = AutoFeatureExtractor.from_pretrained("facebook/wav2vec2-base")
3. ๋ชจ๋ธ์ ์ํ๋ง ๋ ์ดํธ์ ๋ง์ถ๋ ค๋ฉด cast_column() ํจ์์ Audio feature๋ก audio ์ปฌ๋ผ์ ์
์ํ๋งํด์ผ ํด์.
>>> dataset = dataset.cast_column("audio", Audio(sampling_rate=16000))
>>> dataset[0]["audio"]
4. feature extractor๋ก ์ค๋์ค array๋ฅผ ์ ์ฒ๋ฆฌํ๋ ํจ์๋ฅผ ๋ง๋ค๊ณ , ์ํ์ค๋ฅผ ์๋ผ๋ด๊ณ (truncate) ํจ๋ฉํด์ ๊น๋ํ ์ง์ฌ๊ฐํ ํ
์๋ก ๋ง๋ค์ด์. ๊ฐ์ฅ ์ค์ํ ์ ์ feature extractor์ ์ค๋์ค array๋ฅผ ๋๊ธฐ๋ ๊ฑฐ์์. array โ ์ค์ ์์ฑ ์ ํธ โ ๊ฐ ๋ชจ๋ธ ์
๋ ฅ์ด ๋๊ฑฐ๋ ์.
์ ์ฒ๋ฆฌ ํจ์๋ฅผ ๋ง๋ค์๋ค๋ฉด map() ํจ์๋ก ํจ์๋ฅผ ๋ฐ์ดํฐ์ ์ ์์ ๋ฐฐ์น(batch)์ ์ ์ฉํด์ ์ฒ๋ฆฌ๋ฅผ ๋น ๋ฅด๊ฒ ํ ์ ์์ด์.
>>> def preprocess_function(examples):
... audio_arrays = [x.get_all_samples().data for x in examples["audio"]]
... inputs = feature_extractor(
... audio_arrays,
... sampling_rate=16000,
... padding=True,
... max_length=100000,
... truncation=True,
... )
... return inputs
>>> dataset = dataset.map(preprocess_function, batched=True)
5. rename_column() ํจ์๋ก intent_class ์ปฌ๋ผ์ labels๋ก ์ด๋ฆ์ ๋ฐ๊ฟ์. labels๋ ๋ชจ๋ธ์ด ๊ธฐ๋ํ๋ ์
๋ ฅ ์ด๋ฆ์ด๊ธฐ ๋๋ฌธ์ด์์.
set_format() ํจ์๋ก ๋ฐ์ดํฐ์
ํฌ๋งท์ torch๋ก ์ค์ ํ๊ณ , ํฌ๋งทํ ์ปฌ๋ผ์ ์ง์ ํด์. ์ด ํจ์๋ ํฌ๋งท์ ์ฆ์(on-the-fly) ์ ์ฉํด์.
PyTorch ํ
์๋ก ๋ฐ๊พผ ๋ค์๋ ๋ฐ์ดํฐ์
์ torch.utils.data.DataLoader๋ก ๊ฐ์๋๋ค.
>>> from torch.utils.data import DataLoader
>>> dataset.set_format(type="torch", columns=["input_values", "labels"])
>>> dataloader = DataLoader(dataset, batch_size=4)
TensorFlow๋ฅผ ์ด๋ค๋ฉด ๐ค Transformers์ prepare_tf_dataset ๋ฉ์๋๋ฅผ ์ฌ์ฉํด์. ์ด ๋ฉ์๋๋ HuggingFace Dataset์ tf.data.Dataset๋ก ๊ฐ์ธ์ ๋ชจ๋ธ ํ๋ จ/๋ฏธ์ธ์กฐ์ ์ ๋ฐ๋ก ์ธ ์ ์๊ฒ ์ค๋นํด ์ค์.
>>> import tensorflow as tf
>>> tf_dataset = model.prepare_tf_dataset(
... dataset,
... batch_size=4,
... shuffle=True,
... )
Vision
์ด๋ฏธ์ง ๋ฐ์ดํฐ์ ๋ ํ ์คํธ ๋ฐ์ดํฐ์ ์ฒ๋ผ ๋ถ๋ฌ์์. ๋ค๋ง ํ ํฌ๋์ด์ ๋์ feature extractor๋ก ๋ฐ์ดํฐ์ ์ ์ ์ฒ๋ฆฌํด์ผ ํด์.
์ด ํต์คํํธ์์๋ Beans ๋ฐ์ดํฐ์ ์ ๋ถ๋ฌ์์ ์์ฌ๊ท ์ด๋ฏธ์ง๋ก ์ง๋ณ์ ํ๋ณํ๋ ๋ชจ๋ธ์ ํ๋ จ์์ผ ๋ณผ๊ฒ์.
1. load_dataset() ํจ์์ ๋ฐ์ดํฐ์ ์ด๋ฆ๊ณผ ๋ฐ์ดํฐ์ ๋ถํ ์ ๋๊ฒจ Beans ๋ฐ์ดํฐ์ ์ ๋ถ๋ฌ์ต๋๋ค.
>>> from datasets import load_dataset, Image
>>> dataset = load_dataset("AI-Lab-Makerere/beans", split="train")
2. ๐ค Transformers ๋ผ์ด๋ธ๋ฌ๋ฆฌ์์ ์ฌ์ ํ๋ จ๋ ViT ๋ชจ๋ธ๊ณผ ๊ทธ์ ๋ง๋ feature extractor๋ฅผ ๋ถ๋ฌ์์.
>>> from transformers import AutoModelForImageClassification, AutoFeatureExtractor
>>> model = AutoModelForImageClassification.from_pretrained("google/vit-base-patch16-224-in21k")
>>> feature_extractor = AutoFeatureExtractor.from_pretrained("google/vit-base-patch16-224-in21k")
3. ์ด๋ฏธ์ง๋ฅผ ํ ์๋ก ๋ณํํ๋ ์ ์ฒ๋ฆฌ ํจ์๋ฅผ ๋ง๋ ๋ค map() ํจ์๋ก ๋ฐ์ดํฐ์ ์ ๋ฐฐ์น์ ์ ์ฉํด์ ์ฒ๋ฆฌ๋ฅผ ๋น ๋ฅด๊ฒ ํด์.
>>> def transforms(examples):
... examples["pixel_values"] = [feature_extractor(image, return_tensors="pt")["pixel_values"][0] for image in examples["image"]]
... return examples
>>> dataset = dataset.map(transforms, batched=True)
4. rename_column() ํจ์๋ก labels ์ปฌ๋ผ์ label๋ก ์ด๋ฆ์ ๋ฐ๊ฟ์.
with_format() ํจ์๋ก ๋ฐ์ดํฐ์
ํฌ๋งท์ torch๋ก ์ค์ ํฉ๋๋ค.
>>> import torch
>>> dataset = dataset.rename_column("labels", "label")
>>> dataset = dataset.with_format(type="torch", columns=["pixel_values", "label"])
>>> dataloader = torch.utils.data.DataLoader(dataset, batch_size=4)
TensorFlow์ฉ์ผ๋ก๋ prepare_tf_dataset ๋ฉ์๋๋ก tf.data.Dataset์ ์ค๋นํด์.
>>> import tensorflow as tf
>>> tf_dataset = model.prepare_tf_dataset(
... dataset,
... batch_size=4,
... shuffle=True,
... )
NLP
ํ ์คํธ๋ tokenizer๋ก ๊ฐ๋ณ ํ ํฐ์ผ๋ก ๋ถ์ ํด์ผ ํด์.
์ด ํต์คํํธ์์๋ Microsoft Research Paraphrase Corpus (MRPC) ํ๋ จ ๋ฐ์ดํฐ์ ์ ๋ถ๋ฌ์์ ๋ ๋ฌธ์ฅ์ ์๋ฏธ๊ฐ ๊ฐ์์ง ํ๋ณํ๋ ๋ชจ๋ธ์ ํ๋ จ์ํฌ ๊ฑฐ์์.
1. load_dataset() ํจ์์ ๋ฐ์ดํฐ์ ์ด๋ฆ, ๋ฐ์ดํฐ์ ์ค์ , ๋ฐ์ดํฐ์ ๋ถํ ์ ๋๊ฒจ MRPC ๋ฐ์ดํฐ์ ์ ๋ถ๋ฌ์ต๋๋ค.
>>> from datasets import load_dataset
>>> dataset = load_dataset("nyu-mll/glue", "mrpc", split="train")
2. ๐ค Transformers ๋ผ์ด๋ธ๋ฌ๋ฆฌ์์ ์ฌ์ ํ๋ จ๋ BERT ๋ชจ๋ธ๊ณผ ๊ทธ์ ๋ง๋ ํ ํฌ๋์ด์ ๋ฅผ ๋ถ๋ฌ์์. ๋ชจ๋ธ์ ๋ถ๋ฌ์จ ๋ค ์ผ๋ถ ๊ฐ์ค์น๊ฐ ์ด๊ธฐํ๋์ง ์์๋ค๋ ๊ฒฝ๊ณ ๊ฐ ๋์ค๋ ๊ฑด ์ ์์ด์์.
>>> from transformers import AutoModelForSequenceClassification, AutoTokenizer
>>> model = AutoModelForSequenceClassification.from_pretrained("bert-base-uncased")
>>> tokenizer = AutoTokenizer.from_pretrained("bert-base-uncased")
TensorFlow๋ฅผ ์ด๋ค๋ฉด:
>>> from transformers import TFAutoModelForSequenceClassification, AutoTokenizer
>>> model = TFAutoModelForSequenceClassification.from_pretrained("bert-base-uncased")
>>> tokenizer = AutoTokenizer.from_pretrained("bert-base-uncased")
3. ๋ฐ์ดํฐ์
์ ํ ํฐํํ๋ ํจ์๋ฅผ ๋ง๋ค๊ณ , ํ
์คํธ๋ฅผ ์๋ผ๋ด๊ณ ํจ๋ฉํด์ ๊น๋ํ ์ง์ฌ๊ฐํ ํ
์๋ก ๋ง๋ค์ด์. ํ ํฌ๋์ด์ ๋ ๋ฐ์ดํฐ์
์ input_ids, token_type_ids, attention_mask๋ผ๋ ์ธ ๊ฐ์ ์ ์ปฌ๋ผ์ ์์ฑํด์. ์ด๋ค์ด ๋ชจ๋ธ ์
๋ ฅ์ด์์.
map() ํจ์๋ก ํ ํฐํ ํจ์๋ฅผ ๋ฐ์ดํฐ์ ์ ๋ฐฐ์น์ ์ ์ฉํด์ ์ฒ๋ฆฌ๋ฅผ ๋น ๋ฅด๊ฒ ํด์.
>>> def encode(examples):
... return tokenizer(examples["sentence1"], examples["sentence2"], truncation=True, padding="max_length")
>>> dataset = dataset.map(encode, batched=True)
>>> dataset[0]
{'sentence1': 'Amrozi accused his brother , whom he called " the witness " , of deliberately distorting his evidence .',
...
4. label ์ปฌ๋ผ์ labels๋ก ์ด๋ฆ์ ๋ฐ๊ฟ์. labels๋ BertForSequenceClassification์ด ๊ธฐ๋ํ๋ ์
๋ ฅ ์ด๋ฆ์ด์์.
>>> dataset = dataset.map(lambda examples: {"labels": examples["label"]}, batched=True)
with_format() ํจ์๋ก ๋ฐ์ดํฐ์
ํฌ๋งท์ torch๋ก ์ค์ ํ๊ณ , ํฌ๋งทํ ์ปฌ๋ผ์ ์ง์ ํด์.
PyTorch ํ
์๋ก ๋ณํํ ๋ค์๋ ๋ฐ์ดํฐ์
์ torch.utils.data.DataLoader๋ก ๊ฐ์๋๋ค.
>>> import torch
>>> dataset = dataset.select_columns(["input_ids", "token_type_ids", "attention_mask", "labels"])
>>> dataset = dataset.with_format(type="torch")
>>> dataloader = torch.utils.data.DataLoader(dataset, batch_size=32)
TensorFlow์ฉ์ผ๋ก๋ prepare_tf_dataset ๋ฉ์๋๋ก tf.data.Dataset์ ์ค๋นํด์.
>>> import tensorflow as tf
>>> tf_dataset = model.prepare_tf_dataset(
... dataset,
... batch_size=4,
... shuffle=True,
... )
๋ค์์ ๋ฌด์์?
์ฌ๊ธฐ๊น์ง ๐ค Datasets ํต์คํํธ๋ฅผ ๋ง์ณค์ด์. ์ด์ ๋จ ํ๋์ ํจ์๋ก ํ ์คํธยท์ค๋์คยท์ด๋ฏธ์ง ๋ฐ์ดํฐ์ ์ ๋ถ๋ฌ์ค๊ณ , ๋ชจ๋ธ์ด ํ๋ จํ ์ ์๊ฒ ์ค๋นํ ์ ์์ด์.
์ถ์ฒ: ๊ณต์๋ฌธ์