# 데이터

이 페이지에는 `timm.data` 서브패키지의 API 참조 문서와 해당 서브패키지가 제공하는 입력 파이프라인 개요가 포함되어 있습니다. 모델의 전처리 구성 해석, 변환 구성, 데이터셋 및 로더 생성, Mixup / CutMix, NaFlex 가변 해상도 로더를 다룹니다.

## 사용

Pipeline은 네 단계로 구성됩니다: [`resolve_model_data_config`](#timm.data.resolve_model_data_config)은 모델의 전처리 구성을 읽고, [`create_transform`](#timm.data.create_transform)은 학습 또는 평가 변환을 구성하며, [`create_dataset`](#timm.data.create_dataset)은 이름과 루트를 기반으로 데이터셋을 생성하고, [`create_loader`](#timm.data.create_loader)은 데이터셋에 대한 변환과 데이터 로더를 구성합니다.

```python
import os
import tempfile

import torch
from PIL import Image

import timm
from timm.data import create_dataset, create_loader, create_transform, resolve_model_data_config

model = timm.create_model('resnet50', pretrained=False).eval()

# Preprocessing config from the model's pretrained_cfg, the default pretrained tag's config is attached to the model
# with or without pretrained weights.
data_config = resolve_model_data_config(model)
print(data_config)
# {'input_size': (3, 224, 224), 'interpolation': 'bicubic', 'mean': (0.485, 0.456, 0.406),
#  'std': (0.229, 0.224, 0.225), 'crop_pct': 0.95, 'crop_mode': 'center'}

# Eval transform for a PIL image, resize to 224 / crop_pct, center crop 224, to tensor and normalize.
transform = create_transform(**data_config, is_training=False)
img = Image.new('RGB', (320, 240), color=(200, 120, 40))
with torch.no_grad():
    output = model(transform(img).unsqueeze(0))  # (1, 1000)

# A folder dataset, <root>/<split>/<class>/<image>, two classes w/ four generated images each.
root = tempfile.mkdtemp()
for i, cls in enumerate(('cat', 'dog')):
    os.makedirs(os.path.join(root, 'validation', cls))
    for j in range(4):
        path = os.path.join(root, 'validation', cls, f'{j}.jpg')
        Image.new('RGB', (300, 200), color=(60 * i, 40 * j, 128)).save(path)

dataset = create_dataset('', root=root, split='validation')  # finds the 'validation' sub-folder
print(len(dataset), dataset.reader.class_to_idx)  # 8 {'cat': 0, 'dog': 1}

# The loader creates the transform from the same config and assigns it to the dataset.
loader = create_loader(dataset, **data_config, batch_size=4, use_prefetcher=False, num_workers=0)
with torch.no_grad():
    for images, targets in loader:
        output = model(images)  # images (4, 3, 224, 224), targets (4,)
```

[quickstart](../quickstart#image-augmentation)에서는 추론을 위한 config에서 transform 단계까지를 안내합니다.

학습 스크립트(`train.py`)는 파이프라인의 각 부분에 대해 이러한 옵션을 제공합니다.

입력 구성 오버라이드(`resolve_input_data_config`):

- **`--input-size`**는 입력 형상 `(C, H, W)`를 설정합니다.
- **`--img-size`**은 `--input-size`의 정사각형 단축형으로, 모델의 채널 수는 유지합니다.
- **`--in-chans`**는 입력 채널을 설정합니다.
- **`--interpolation`**은 리사이즈 보간법을 설정합니다.
- **`--mean`**은 정규화 평균을 설정합니다.
- **`--std`**은 정규화 표준편차를 설정합니다.
- **`--crop-pct`**는 평가 크롭 비율을 설정합니다.

데이터셋 생성(`create_dataset`) 및 대상 설정:

- **`--dataset`**은 데이터셋과 리더를 선택합니다.
- **`--data-dir`**은 데이터셋 루트를 설정합니다.
- **`--train-split`**은 학습용 분할을 선택합니다.
- **`--val-split`**은 검증 분할을 선택합니다.
- **`--class-map`**은 클래스 매핑을 제공합니다.
- **`--input-img-mode`**는 이미지 색상 변환 모드를 설정합니다.
- **`--input-key`**는 이미지 필드를 선택합니다.
- **`--target-key`**는 라벨 필드 하나 또는 여러 개를 선택합니다.
- **`--target-format`**은 클래스 인덱스 또는 dense multi-hot target을 선택합니다.

로더 및 증강 옵션(`create_loader`)에는 다음이 포함됩니다:

- **`--aa`**는 자동 증강 정책을 선택합니다.
- **`--reprob`**는 랜덤 에레이징 확률을 설정합니다.
- **`--remode`**는 랜덤 에레이징 채우기 모드를 선택합니다.
- **`--scale`**는 무작위 리사이즈 크롭의 스케일 범위를 설정합니다.
- **`--ratio`**는 무작위 리사이즈 크롭의 종횡비 범위를 설정합니다.
- **`--hflip`**은 수평 플립 확률을 설정합니다.
- **`--color-jitter`**는 컬러 지터 강도를 설정합니다.
- **`--train-interpolation`**은 학습 리사이즈 보간을 설정합니다.
- **`--workers`**는 로더 워커의 수를 설정합니다.
- **`--no-prefetcher`**는 prefetcher를 비활성화합니다.

Mixup 및 CutMix ([`Mixup`](#timm.data.Mixup)):

- **`--mixup`**은 Mixup 알파를 설정합니다.
- **`--cutmix`**는 CutMix 알파를 설정합니다.
- **`--cutmix-minmax`**는 CutMix 박스 크기 범위를 설정합니다.
- **`--mixup-prob`**은 혼합 확률을 설정합니다.
- **`--mixup-switch-prob`**는 두 가지 방법이 모두 활성화된 경우 CutMix를 선택할 확률을 설정합니다.
- **`--mixup-mode`**는 배치, 페어 또는 요소별 믹싱을 선택합니다.
- **`--smoothing`**은 label smoothing을 설정합니다.

예제는 [Scripts](../training_script)를 참조하세요.

### 데이터 구성

[`resolve_data_config`](#timm.data.resolve_data_config)는 아래 키를 가진 dict를 반환하며, 이 키들은 `create_transform`와 `create_loader`의 인수와 일치합니다. `args`(dict, 예를 들어 파싱된 커맨드 라인 인수의 `vars(args)`)에 설정된 값은 `pretrained_cfg` 인자보다 우선하며, `pretrained_cfg`의 기본값은 `model.pretrained_cfg`입니다. [`resolve_model_data_config`](#timm.data.resolve_model_data_config)는 첫 번째 인수로 model을 받는 것을 제외하면 동일합니다.

둘 다 사전 학습된 cfg에서 입력 크기 및 채널을 읽으며, 이 cfg는 다른 `img_size` 또는 `in_chans`를 사용하도록 생성되거나 변경된 모델이 아닌 소스 체크포인트를 설명합니다. 학습, 검증 및 추론 스크립트에서 사용되는 [`resolve_input_data_config`](#timm.data.resolve_input_data_config)는 모델의 현재 입력 기준으로 해결합니다. 고정 입력 크기 모델은 항상 현재 크기를 가져오며, 모델의 채널 또는 고정 크기와 충돌하는 명시적 `args`는 오류를 발생시키고, 채널 수와 일치하지 않는 mean / std는 그 평균으로 대체됩니다(경고와 함께).

| 키 | `args` 키 | 설명 | 기본값 |
|---|---|---|---|
| `input_size` | `input_size`, `img_size`, `in_chans` | `(C, H, W)` 입력 크기. `use_test_size=True`인 경우, 설정에 `test_input_size`가 있으면 이를 사용합니다 | `(3, 224, 224)` |
| `interpolation` | `interpolation` | 리사이즈 보간, `bilinear`, `bicubic`, ... | `bicubic` |
| `mean`, `std` | `mean`, `std` | Normalization, 각 채널마다 하나의 값이 반복됩니다 | ImageNet 평균 / 표준편차 |
| `crop_pct` | `crop_pct` | Eval crop의 경우, 이미지는 `size`로 크롭하기 전에 `size / crop_pct`로 리사이즈됩니다 (`use_test_size=True`인 경우 `test_crop_pct` 사용). | `0.875` |
| `crop_mode` | `crop_mode` | 평가 크롭 모드, `center`, `squash` 또는 `border` | `center` |

출력 `size`와 `scale_size = floor(size / crop_pct)`에 대한 eval crop 모드:

| `crop_mode` | 동작 |
|---|---|
| `center` | 가장 짧은 변을 `scale_size`로 리사이즈(종횡비 유지)한 후, 중앙에서 `size` 크기로 크롭 |
| `squash` | 양쪽 가장자리를 `scale_size`로 리사이즈한 후(종횡비 유지 안 함), `size`로 중앙 크롭 |
| `border` | 가장 긴 변을 `scale_size`로 리사이즈한 뒤, 중앙 크롭 및 평균 색상 패딩을 적용하며, `crop_pct=1.0`로 전체 이미지가 유지됩니다 |

### 변형

[`create_transform`](#timm.data.create_transform)은 torchvision의 `Compose`를 반환합니다. 평가 변환은 위에서 설명한 대로 리사이즈 및 크롭을 수행한 후, 텐서로 변환하고 정규화합니다. 학습 변환은 랜덤 리사이즈드 크롭(기본값 `scale=(0.08, 1.0)`, `ratio=(3/4, 4/3)`), 수평 플립(`hflip=0.5`), 컬러 지터(`color_jitter=0.4`), 선택적 `auto_augment` 정책, 텐서 변환 및 정규화, 랜덤 이레이징을 포함합니다.

- **`train_crop_mode='rkrc'` 또는 `'rkrr'`**는 무작위 리사이즈 크롭을 종횡비를 유지하는 무작위 리사이즈로 대체한 뒤, 중앙(`rkrc`) 또는 무작위(`rkrr`) 크롭 또는 패딩을 수행합니다.
- **`interpolation='random'`** (학습을 위한 `train.py`의 기본값)는 이미지별로 bilinear 또는 bicubic을 선택합니다.
- **`no_aug=True`**는 학습을 리사이즈와 중앙 크롭으로만 줄입니다.

| `auto_augment` | 증강 |
|---|---|
| `rand-m9-mstd0.5-inc1` | [`rand_augment_transform`](#timm.data.rand_augment_transform)를 통한 [`RandAugment`](https://arxiv.org/abs/1909.13719) |
| `augmix-m5-w4-d2` | [AugMix](https://arxiv.org/abs/1912.02781) via [`augment_and_mix_transform`](#timm.data.auto_augment.augment_and_mix_transform) |
| `original`, `originalr`, `v0`, `v0r`, `3a` | [AutoAugment](https://arxiv.org/abs/1805.09501) policy via [`auto_augment_transform`](#timm.data.auto_augment_transform) |

RandAugment 옵션 토큰:

- **`m`**은 크기를 설정합니다(기본값 10).
- **`n`**은 이미지당 연산 수를 설정합니다(기본값 2).
- **`p`**은 연산별 확률을 설정합니다(기본값 0.5).
- **`mstd`**는 크기 노이즈 표준편차를 설정합니다.
- **`inc1`**은 크기가 커질수록 심각도가 증가하는 연산을 선택합니다.
- **`t<name>`**는 op set(`weights`, `3a`, `3aw`)을 선택합니다.

AugMix 옵션 토큰:

- **`m`**은 심각도를 설정합니다(기본값 3).
- **`w`**은 너비를 설정합니다(기본값 3).
- **`d`**는 깊이(기본값 -1, 무작위 1-3)를 설정합니다.
- **`b1`**은 혼합 증강을 활성화합니다.
- **`mstd`**는 크기 노이즈 표준편차를 설정합니다.

AutoAugment은 `mstd`를 허용하며, 예를 들어 `original-mstd0.5`입니다.

Transform 동작:

- `auto_augment`이 설정된 경우, 문자열에 `3a`가 포함되어 있지 않으면 Color jitter가 비활성화됩니다.
- [`RandomErasing`](#timm.data.random_erasing.RandomErasing)(`re_prob`, `re_count`)는 정규화된 텐서에서 실행됩니다. `re_mode`는 영으로 채우기(`const`, 기본값), 영역별 무작위 정규 색상(`rand`), 무작위 정규 픽셀(`pixel`, `train.py`의 기본값) 중 하나를 선택합니다.
- `use_prefetcher=True`를 사용하면 변환이 `uint8` 텐서에서 끝나고, 정규화와 랜덤 이레이징은 로더가 디바이스에서 수행합니다.
- `create_transform`과 `create_loader`는 기본적으로 모델의 값이 아닌 `bilinear` 보간과 ImageNet 평균 / 표준편차를 사용합니다. 모델의 사전 학습과 일치하도록 해결된 데이터 구성을 전달하세요.

### 데이터셋

[`create_dataset`](#timm.data.create_dataset)은 `name`의 접두사를 기반으로 데이터셋 구현체와 리더를 선택합니다:

| `name` | 데이터셋 | `root` | 필요 사항 |
|---|---|---|---|
| `''` 또는 접두사 없음 | [`ImageDataset`](#timm.data.ImageDataset), 클래스 하위 폴더에 있는 이미지(재귀적으로 검색되며, 리프 폴더 이름이 클래스가 됨), 또는 동일한 구조의 단일 `.tar` 파일 | Dataset 폴더 또는 `.tar` 파일 | |
| `torch/<name>` | torchvision `cifar10`, `cifar100`, `mnist`, `kmnist`, `fashion_mnist`, `qmnist`, `inaturalist` (`inat`), `places365`, `imagenet` 또는 `image_folder` (`folder`) | torchvision 데이터셋 루트 | |
| `hfds/<name>` | Hugging Face Hub 데이터셋(또는 로컬 경로)에서 `datasets.load_dataset`를 통해 [`ImageDataset`](#timm.data.ImageDataset) | 캐시 디렉터리 (선택 사항) | `datasets` |
| `hfids/<name>` | Hugging Face 데이터셋을 스트리밍하거나 `download=True`로 먼저 다운로드 및 준비한 [`IterableImageDataset`](#timm.data.IterableImageDataset) | 캐시 디렉터리 (선택 사항) | `datasets` |
| `tfds/<name>` | TensorFlow Datasets의 [`IterableImageDataset`](#timm.data.IterableImageDataset)에서 `download=True`를 사용하면 다운로드 및 빌드 | TFDS 데이터 디렉터리 | `tensorflow`, `tensorflow-datasets` |
| `wds/<name>` | WebDataset tar shards의 [`IterableImageDataset`](#timm.data.IterableImageDataset) | `_info.json`(또는 `info.json`) 파일로 스플릿을 설명하는 샤드 폴더 | `webdataset` |

데이터셋 옵션:

- **`split`**은 데이터셋 분할을 선택합니다(기본값 `validation`). WebDataset의 경우 샘플 수를 포함한 샤드 패턴, `'imagenet-train-{0000..1023}.tar|1281167'`도 사용할 수 있습니다.
- **`search_split=True`**(기본값)는 폴더 데이터셋이 `root`의 `split` 이름의 하위 폴더를 찾도록 하며, 해당 폴더가 없으면 train(`train`, `training`) 또는 eval(`val`, `valid`, `validation`, `eval`, `evaluation`) 스플릿의 동의어 이름을 가진 폴더를 찾습니다.
- **`add_img_extensions`**은 기본 이미지 확장자(`.png`, `.jpg`, `.jpeg`)에 추가합니다.
- **`class_map`**은 dict, `.txt`(한 줄에 하나의 클래스) 또는 `.pkl` 파일을 사용하여 클래스 이름을 인덱스로 재매핑합니다.

Iterable 데이터셋(`hfids`, `tfds`, `wds`)도 다음을 받습니다:

- **`is_training`**이 쉐플링을 활성화합니다.
- **`batch_size`**는 학습 시 각 워커가 담당하는 샘플 수를 정수 배치 단위로 올림합니다.
- **`num_samples`**은 샘플 수를 설정하며, 리더가 이를 결정할 수 없는 경우(`hfids`에 split 정보가 없는 경우) 필수입니다.
- **`seed`**은 랜덤 시드를 설정합니다.
- **`repeats`**는 에포크당 샘플 수를 곱하여, 리더가 해당 횟수만큼 데이터를 반복적으로 읽도록 합니다.

각 epoch마다 `dataset.set_epoch()`을 호출하여 다시 섞습니다.

기타 키워드 인수는 리더로 그대로 전달됩니다. Hugging Face, TFDS 및 WebDataset 리더의 경우:

- **`input_key`**는 이미지 필드를 선택합니다(기본값은 `image`이며, `wds`의 경우 `jpg`, `png` 또는 `webp` 이미지입니다).
- **`target_key`**는 라벨 필드를 선택합니다(기본값은 `label`이며, `wds`의 경우 `.cls` 파일 또는 `target_key`로 지정된 이름의 `.json` 사이드카 필드입니다). 쉼표로 구분된 값은 클래스별로 하나의 바이너리 필드를 읽습니다.
- **`target_format='multihot'`**는 다중 레이블 데이터의 클래스 인덱스 목록 대신 밀집형 멀티핫 벡터를 읽습니다.
- **`target_transform=MultiLabelTarget(num_classes)`**은 타깃을 float multi-hot 텐서로 인코딩합니다. multi-hot 필드의 경우 [`MultiLabelTarget`](#timm.data.MultiLabelTarget)에 `dense=True`를 전달하세요.

폴더 및 tar 리더는 단일 클래스 인덱스를 반환합니다. 자세한 내용은 [다중 레이블 분류](../training_script#multi-label-classification)를 참조하세요.

### 로더

[`create_loader`](#timm.data.create_loader)는 자체 인수를 사용하여 `create_transform`로 transform을 생성하고, 이를 `dataset.transform`에 할당(기존 transform이 있으면 교체)한 뒤 `DataLoader`를 반환합니다. 학습용 로더(`is_training=True`)는 데이터를 섞고 마지막 불완전한 배치의 데이터를 제거합니다.

- **프리페처.** `use_prefetcher=True`(기본값)인 경우 데이터셋은 `uint8` 텐서를 반환하며, 배치들은 `device`(기본값 `cuda`, CUDA의 경우 사이드 스트림에서)로 이동된 뒤 `img_dtype`으로 변환되고 정규화 및 랜덤 어레이징이 해당 위치에서 수행됩니다. `device`를 학습 장치로 설정하거나, 정규화된 텐서의 일반 `DataLoader`를 사용하려면 `use_prefetcher=False`를 설정하세요.
- **분산.** `distributed=True`는 map-style 학습 데이터셋에 `DistributedSampler`(또는 `num_aug_repeats`를 사용한 반복 증강 샘플러)를, 평가에는 각 프로세스의 샘플 수를 동일하게 패딩하는 순서 샘플러를 사용합니다. 이로 인해 검증 결과가 약간 달라질 수 있습니다. Iterable 데이터셋은 프로세스와 워커 간에 자체적으로 샤딩됩니다.
- **Collate.** `collate_fn`는 기본값(prefetcher 사용 시 `fast_collate`, 미사용 시 `default_collate`)을 [`FastCollateMixup`](#timm.data.FastCollateMixup) 등으로 대체합니다.
- **증강 분할.** JSD 손실을 사용하는 AugMix(`--aug-splits`)의 경우, 데이터셋을 [`AugMixDataset`](#timm.data.AugMixDataset)`(dataset, num_splits=n)`으로 감싸고 `num_aug_splits=n`을 전달합니다. 각 배치에는 클린 분할과 `n - 1`개의 증강 분할이 포함되며, prefetcher가 배치 차원을 따라 이를 연결합니다.
- **예약된 해상도.** `input_size_choices` (`--train-img-sizes`)는 배치별로 입력 크기를 선택하며, 선택 사항으로 각 선택 항목에 대한 배치 크기(`batch_size_choices`)와 첫 번째 선택 항목부터 마지막 선택 항목까지의 `progressive` 스케줄을 지정할 수 있습니다.

### Mixup 및 CutMix

[`Mixup`](#timm.data.Mixup)는 로더 이후에 디바이스에서 정규화된 이미지 배치의 혼합을 수행합니다. [`FastCollateMixup`](#timm.data.FastCollateMixup)는 동일한 인수를 받아 로더 워커에서 collating하는 동안 `uint8` 이미지를 혼합하며, prefetcher가 필요합니다. 둘 다 `label_smoothing`(기본값 `0.1`)가 적용된 dense `(batch_size, num_classes)` targets를 반환하며, `timm.loss.SoftTargetCrossEntropy`와 같은 soft target loss와 함께 사용하도록 설계되어 있고, 짝수 batch size를 요구합니다.

```python
from timm.data import Mixup, FastCollateMixup

# Continuing the example above.
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
mixup_args = dict(mixup_alpha=0.8, cutmix_alpha=1.0, label_smoothing=0.1, num_classes=1000)

# Prefetcher enabled (default), mixed in the loader's collate.
loader = create_loader(
    dataset,
    **data_config,
    batch_size=4,
    is_training=True,
    collate_fn=FastCollateMixup(**mixup_args),
    device=device,
)
for images, targets in loader:
    ...  # images normalized on device, targets (4, 1000)

# Prefetcher disabled, mixed in the training loop.
loader = create_loader(dataset, **data_config, batch_size=4, is_training=True, use_prefetcher=False)
mixup_fn = Mixup(**mixup_args)
for images, targets in loader:
    images, targets = mixup_fn(images.to(device), targets.to(device))
```

Mixup 및 CutMix 컨트롤:

- **`mixup_alpha > 0`**를 설정하면 Mixup이 활성화됩니다.
- **`cutmix_alpha > 0`**를 설정하면 CutMix가 활성화됩니다.
- **`cutmix_minmax`**는 박스 크기 범위를 지정하여 CutMix를 활성화합니다.
- **`switch_prob`**은 두 가지 방법이 모두 활성화된 경우 CutMix를 선택할 확률을 설정합니다.
- **`prob`**은 혼합을 수행할 확률을 설정합니다.
- **`mode`**는 `batch`당, 요소 `pair`당 또는 `elem`(element)당 매개변수를 한 번씩 추출합니다.
- **`multi_label=True`**는 밀집형 다중 레이블 타깃을 혼합하며, 각 레이블을 0.5 방향으로 부드럽게 조정합니다.
- **`mixup_enabled = False`**는 혼합을 끕니다. 예를 들어 마지막 에포크(`--mixup-off-epoch`)에서 사용할 수 있습니다. `FastCollateMixup`의 경우 워커 프로세스에서 이 값을 읽으며, 영속 워커는 시작 시점에 설정된 값을 유지합니다.

### NaFlex 가변 해상도

[`create_naflex_loader`](#timm.data.create_naflex_loader)는 고정된 정사각형 크기로 리사이즈하지 않고 가변 길이의 패치 시퀀스로 이미지를 로드하여, NaFlex 패치 입력을 받는 모델(예: `naflexvit_*` 모델)에 사용합니다. 각 배치에는 `patches`, `patch_coord`, `patch_valid`, `seq_len`이 포함된 딕셔너리이며, 배치의 시퀀스 길이로 패딩됩니다.

- **학습.** 데이터셋은 [`NaFlexMapDatasetWrapper`](#timm.data.NaFlexMapDatasetWrapper)(map-style 데이터셋만 해당)로 감싸지며, 이는 배치마다 `train_seq_lens` 중 하나를 선택하고 각 이미지를 해당 패치 수에 맞게 무작위 리사이즈 크롭합니다. `batch_size`는 가장 긴 시퀀스 길이에 대한 배치 크기이며, 더 짧은 길이의 경우 토큰 수를 대략 일정하게 유지하기 위해 8의 배수로 반올림하여 비례적으로 더 큰 배치를 사용합니다. `patch_size_choices`(`patch_size_choice_probs`와 함께)는 이를 지원하는 모델의 경우 배치마다 패치 크기도 다양하게 변경합니다.
- **평가.** 이미지는 주어진 `patch_size` 기준으로 `max_seq_len`개의 패치에 맞게 리사이즈되고(평가에 필수), `max_seq_len`까지 패딩됩니다.
- **Mixup.** `mixup_fn`에 [`NaFlexMixup`](#timm.data.NaFlexMixup)를 전달하면 각 배치 내에서 혼합을 수행하며, `mode` 또는 `cutmix_minmax`를 지원하지 않습니다.

`train.py` 옵션은 다음과 같습니다:

- **`--naflex-loader`**는 NaFlex 로더를 활성화합니다.
- **`--naflex-train-seq-lens`**는 학습 시퀀스 길이를 설정합니다.
- **`--naflex-max-seq-len`**은 최대 평가 시퀀스 길이를 설정합니다.
- **`--naflex-patch-sizes`**는 가변 패치 크기 학습을 위한 패치 크기를 설정합니다.
- **`--naflex-patch-size-probs`**는 해당 patch size의 확률을 설정합니다.
- **`--naflex-loss-scale`**는 배치 크기에 따라 손실 스케일링을 선택합니다(`none`, `sqrt` 또는 `linear`).

## API

### 데이터 구성[[timm.data.resolve_data_config]]

#### timm.data.resolve_data_config[[timm.data.resolve_data_config]]

```python
timm.data.resolve_data_config(args = None, pretrained_cfg = None, model = None, use_test_size = False, verbose = False)
```

[소스](https://github.com/huggingface/pytorch-image-models/blob/v1.0.31/timm/data/config.py#L8)

#### timm.data.resolve_model_data_config[[timm.data.resolve_model_data_config]]

```python
timm.data.resolve_model_data_config(model, args = None, pretrained_cfg = None, use_test_size = False, verbose = False)
```

[소스](https://github.com/huggingface/pytorch-image-models/blob/v1.0.31/timm/data/config.py#L103)

**매개변수:**

model (nn.Module) : 모델 인스턴스

args (dict) : dict 형식의 커맨드 라인 인자 / 구성 (pretrained_cfg를 덮어씀)

pretrained_cfg (dict) : 사전 학습된 모델 설정 (모델에 연결된 pretrained_cfg를 덮어씀)

use_test_size (bool) : 기본 학습 해상도 대신 테스트 시간 입력 해상도(존재하는 경우)를 사용합니다

verbose (bool) : 해석된 값의 추가 로깅 활성화

**반환값:**

config 사전

Resolve Model Data Config resolve_data_config()와 동일하지만, 모델이 먼저 오도록 인자 순서가 재배열되었습니다.

#### timm.data.resolve_input_data_config[[timm.data.resolve_input_data_config]]

```python
timm.data.resolve_input_data_config(model, args: typing.Optional[typing.Dict[str, typing.Any]] = None, pretrained_cfg: typing.Optional[typing.Dict[str, typing.Any]] = None, use_test_size: bool = False, verbose: bool = False)
```

[소스](https://github.com/huggingface/pytorch-image-models/blob/v1.0.31/timm/data/model_config.py#L17)

현재 모델의 입력 제약 조건에 따라 전처리 문제를 해결합니다.

고정된 차원과 채널은 명시적인 요청과 일치해야 합니다. 유연한 모델은 오버라이드되지 않는 한 학습/테스트 전처리 권장 사항을 유지합니다. 정규화는 프리페치 로더의 기존 채널 적응 정책을 사용합니다.

### 변형[[timm.data.create_transform]]

#### timm.data.create_transform[[timm.data.create_transform]]

```python
timm.data.create_transform(input_size: typing.Union[int, typing.Tuple[int, int], typing.Tuple[int, int, int]] = 224, is_training: bool = False, no_aug: bool = False, train_crop_mode: typing.Optional[str] = None, scale: typing.Optional[typing.Tuple[float, float]] = None, ratio: typing.Optional[typing.Tuple[float, float]] = None, hflip: float = 0.5, vflip: float = 0.0, color_jitter: typing.Union[float, typing.Tuple[float, ...]] = 0.4, color_jitter_prob: typing.Optional[float] = None, grayscale_prob: float = 0.0, gaussian_blur_prob: float = 0.0, auto_augment: typing.Optional[str] = None, interpolation: str = 'bilinear', mean: typing.Tuple[float, ...] = (0.485, 0.456, 0.406), std: typing.Tuple[float, ...] = (0.229, 0.224, 0.225), re_prob: float = 0.0, re_mode: str = 'const', re_count: int = 1, re_num_splits: int = 0, crop_pct: typing.Optional[float] = None, crop_mode: typing.Optional[str] = None, crop_border_pixels: typing.Optional[int] = None, tf_preprocessing: bool = False, use_prefetcher: bool = False, normalize: bool = True, separate: bool = False, naflex: bool = False, patch_size: typing.Union[int, typing.Tuple[int, int]] = 16, max_seq_len: int = 576, patchify: bool = False, patchify_channels_last: bool = True, patchify_flatten: bool = True)
```

[소스](https://github.com/huggingface/pytorch-image-models/blob/v1.0.31/timm/data/transforms_factory.py#L387)

**매개변수:**

input_size : 대상 입력 크기 (채널, 높이, 너비) 튜플 또는 크기 스칼라.

is_training : 학습(랜덤) 변환을 반환합니다.

no_aug : 학습 시 증강을 비활성화합니다(디버깅에 유용합니다).

train_crop_mode : 무작위 크롭 모드('rrc', 'rkrc', 'rkrr') 학습.

scale : 무작위 리사이즈 스케일 범위 (크롭 영역, < 1.0 => 확대).

ratio : 무작위 종횡비 범위 (RRC의 크롭 비율, RKR의 비율 조정 계수).

hflip : 수평 플립 확률.

vflip : 세로 방향 뒤집기 확률.

color_jitter : 무작위 색상 지터 컴포넌트 계수(밝기, 대비, 채도, 색조). 스칼라 값은 (scalar,) * 3으로 적용되며(색조 제외).

color_jitter_prob : None이 아닌 경우, 이 확률로 색상 지터를 적용합니다 (SimCLR 유사 증강을 위해).

grayscale_prob : 이미지를 회색조로 변환할 확률 (SimCLR 유사 증강을 위한 것).

gaussian_blur_prob : 가우시안 블러를 적용할 확률 (SimCLR 유사 증강을 위한 것).

auto_augment : 자동 증강 구성 문자열 (auto_augment.py 참조).

interpolation : 이미지 보간 모드.

mean : 이미지 정규화 평균.

std : 이미지 정규화 표준 편차.

re_prob : 랜덤 이레이징 확률.

re_mode : Random erasing 채움 모드.

re_count : 랜덤 에라싱 영역의 수.

re_num_splits : 배치 크기 내에서 랜덤 이레이징의 분할을 제어합니다.

crop_pct : 추론 크롭 비율 (출력 크기 / 리사이즈 크기).

crop_mode : 추론 크롭 모드. ['squash', 'border', 'center'] 중 하나입니다. None인 경우 기본값은 'center'입니다.

crop_border_pixels : 추론 시 원본 이미지의 가장자리 주위에 지정된 # 픽셀 크기의 경계 영역을 잘라냅니다.

tf_preprocessing : 모델 포트 테스트를 위해 TF 1.0 추론 전처리 사용

use_prefetcher : Pre-fetcher가 활성화되었습니다. 이미지를 tensor로 변환하거나 정규화하지 마세요.

normalize : prefetcher를 사용하지 않는 경우, 제공된 mean/std를 사용한 정규화 텐서 출력.

separate : 출력 변환을 3단계 튜플로 수행합니다.

patchify : prefetcher에 의존하지 않고 출력을 Patchify합니다.

patchify_channels_last : 각 패치 내에서 channels-last 레이아웃을 사용합니다.

patchify_flatten : 평가 패치를 벡터로 평탄화합니다. 모델이 패치 크기 보간에 공간 차원이 필요할 경우 비활성화합니다.

**반환값:**

Composed transforms 또는 그 튜플

#### timm.data.rand_augment_transform[[timm.data.rand_augment_transform]]

```python
timm.data.rand_augment_transform(config_str: str, hparams: typing.Optional[typing.Dict] = None, transforms: typing.Union[str, typing.Dict, typing.List, NoneType] = None)
```

[소스](https://github.com/huggingface/pytorch-image-models/blob/v1.0.31/timm/data/auto_augment.py#L762)

**매개변수:**

config_str (str) : 랜덤 증강 구성을 정의하는 문자열. 대시('-')로 구분된 여러 섹션으로 구성됩니다. 첫 번째 섹션은 rand augment의 특정 변형을 정의합니다(현재 'rand'만 지원). 나머지 섹션은 순서에 구애받지 않으며 다음을 결정합니다. * 'm' - rand augment의 정수 크기(magnitude) * 'n' - 정수 레이어 수(이미지당 선택되는 변환 연산의 수) * 'p' - 각 레이어를 적용할 부동소수점 확률(기본값 0.5) * 'mstd' - 적용할 크기 노이즈의 부동소수점 표준편차, 무한대(또는 > 100)인 경우 균등 샘플링 * 'mmax' - 크기의 상한을 기본값인 _LEVEL_DENOM(10)이 아닌 다른 값으로 설정 * 'inc' - 정수(부울), 크기가 커질수록 심각도가 증가하는 증강을 사용할지 여부(기본값: 0) * 't' - 사용할 변환 세트의 문자열 이름

hparams (dict) : RandAugmentation 스킴에 대한 기타 hparams (kwargs)

**반환값:**

PyTorch 호환 Transform

RandAugment 변환 생성

예:
- `'rand-m9-n3-mstd0.5'`는 magnitude 9, 3개의 layer, magnitude std 0.5를 가진 RandAugment입니다.
- `'rand-mstd1-tweights'`는 magnitude std가 1.0이고 가중 변환 선택을 사용하는 RandAugment이며, 기본 magnitude 10과 2개의 레이어를 사용합니다.

#### timm.data.auto_augment_transform[[timm.data.auto_augment_transform]]

```python
timm.data.auto_augment_transform(config_str: str, hparams: typing.Optional[typing.Dict] = None)
```

[소스](https://github.com/huggingface/pytorch-image-models/blob/v1.0.31/timm/data/auto_augment.py#L586)

**매개변수:**

config_str : 자동 증강 구성을 정의하는 문자열. 대시('-')로 구분된 여러 섹션으로 구성됩니다. 첫 번째 섹션은 AutoAugment 정책('v0', 'v0r', 'original', 'originalr' 중 하나)을 정의합니다. 나머지 섹션은 다른 인수를 정의합니다. * 'mstd' - 적용되는 크기 노이즈의 부동 소수점 표준 편차

hparams : AutoAugmentation 스킴에 대한 기타 hparams (kwargs)

**반환값:**

PyTorch 호환 Transform

AutoAugment 변환 생성

예:
- `'original-mstd0.5'`는 원래 정책과 0.5의 magnitude std를 가진 AutoAugment입니다.

#### timm.data.auto_augment.augment_and_mix_transform[[timm.data.auto_augment.augment_and_mix_transform]]

```python
timm.data.auto_augment.augment_and_mix_transform(config_str: str, hparams: typing.Optional[typing.Dict] = None)
```

[소스](https://github.com/huggingface/pytorch-image-models/blob/v1.0.31/timm/data/auto_augment.py#L948)

**매개변수:**

config_str (str) : 랜덤 증강 구성을 정의하는 문자열. 대시('-')로 구분된 여러 섹션으로 구성됩니다. 첫 번째 섹션은 rand augment의 특정 변형을 정의합니다(현재 'rand'만 지원). 나머지 섹션은 순서에 구애받지 않으며, 'm' - 증강 믹스의 정수 크기(심도)(기본값: 3) 'w' - 증강 체인의 정수 폭(기본값: 3) 'd' - 증강 체인의 정수 깊이(-1은 [1, 3] 범위에서 랜덤, 기본값: -1) 'b' - 정수(불리언), 최종 블렌딩 없이 체인의 각 분기를 최종 결과에 블렌딩하여 CPU 사용량 감소(기본값: 0) 'mstd' - 적용되는 크기 노이즈의 부동소수점 표준편차(기본값: 0) 예: 'augmix-m5-w4-d2'는 심도 5, 체인 폭 4, 체인 깊이 2인 AugMix를 생성합니다

hparams : Augmentation 변환에 대한 기타 hparams(kwargs)

**반환값:**

PyTorch 호환 Transform

AugMix PyTorch 변환 생성

#### timm.data.random_erasing.RandomErasing[[timm.data.random_erasing.RandomErasing]]

```python
timm.data.random_erasing.RandomErasing(probability = 0.5, min_area = 0.02, max_area = 0.3333333333333333, min_aspect = 0.3, max_aspect = None, mode = 'const', min_count = 1, max_count = None, num_splits = 0, device = 'cuda')
```

[소스](https://github.com/huggingface/pytorch-image-models/blob/v1.0.31/timm/data/random_erasing.py#L26)

**매개변수:**

probability : Random Erasing 작업이 수행될 확률.

min_area : 입력 이미지 영역 대비 지워진 영역의 최소 비율.

max_area : 입력 이미지 영역 대비 지워진 영역의 최대 비율.

min_aspect : 지워진 영역의 최소 가로 세로 비율.

mode : 픽셀 색상 모드, 'const', 'rand', 'pixel' 중 하나 'const' - 지우기 블록은 모든 채널에서 0인 상수 색상 'rand' - 지우기 블록은 채널별 동일한 무작위(정규) 색상 'pixel' - 지우기 블록은 픽셀별 무작위(정규) 색상

이미지에서 사각형 영역을 무작위로 선택하고 해당 픽셀을 지웁니다. Zhong et al.의 'Random Erasing Data Augmentation'을 참고하세요. https://arxiv.org/pdf/1708.04896.pdf

이 RandomErasing 변형은 dataset의 mean과 std로 정규화된 후, 배치 또는 단일 이미지 텐서에 적용하도록 설계되었습니다.

max_count: 이미지당 최대 지우기 블록 수, 박스당 면적은 count에 의해 스케일링됩니다. 이미지당 count는 1과 이 값 사이에서 무작위로 선택됩니다.

### 데이터셋[[timm.data.create_dataset]]

#### timm.data.create_dataset[[timm.data.create_dataset]]

```python
timm.data.create_dataset(name: str, root: typing.Optional[str] = None, split: str = 'validation', search_split: bool = True, class_map: dict = None, load_bytes: bool = False, is_training: bool = False, download: bool = False, batch_size: int = 1, num_samples: typing.Optional[int] = None, seed: int = 42, repeats: int = 0, input_img_mode: str = 'RGB', trust_remote_code: bool = False, **kwargs)
```

[소스](https://github.com/huggingface/pytorch-image-models/blob/v1.0.31/timm/data/dataset_factory.py#L63)

**매개변수:**

name : Dataset 이름입니다. 폴더 기반 dataset의 경우 비워 둘 수 있습니다. 접두사(예: `hfds/`)는 대소문자를 구분하지 않으며, `torch/` 이름은 제외하고 나머지는 그대로(대소문자 구분) 전달됩니다.

root : 데이터셋 루트 폴더 (All)

split : 데이터셋 분할(전체)

search_split : 루트에서 분할별 하위 폴드를 검색하여, 커맨드 라인/설정에서 `/imagenet/val` 대신 `imagenet/` 등을 지정할 수 있습니다. (폴더, Torch)

class_map : 텍스트 파일 또는 dict를 통해 클래스 -> 인덱스 매핑을 지정 (Folder)

load_bytes : 데이터를 로드하고 이미지를 디코딩되지 않은 바이트로 반환(Folder)

download : 데이터셋이 존재하지 않고 지원되는 경우(HFIDS, TFDS, Torch) 다운로드

is_training : train 모드로 dataset을 생성합니다. 이는 split과 다릅니다. Iterable / TDFS의 경우 shuffle을 활성화하며, 다른 dataset(TFDS, WDS, HFIDS)에서는 무시됩니다.

batch_size : 반복 가능 데이터셋(TFDS, WDS, HFIDS)에 대한 배치 크기 힌트

seed : 반복 가능한 데이터셋(TFDS, WDS, HFIDS)의 시드

repeats : 반복(에포크)마다 데이터셋이 반복되는 경우 (TFDS, WDS, HFIDS)

input_img_mode : 입력 이미지의 색상 변환 모드, 예: 'RGB', 'L' (폴더, TFDS, WDS, HFDS, HFIDS)

trust_remote_code : True인 경우 Hugging Face Datasets에서 원격 코드를 신뢰합니다 (HFDS, HFIDS)

- ****kwargs** : 기본 Dataset 및/또는 Reader 클래스에 전달할 기타 인자

**반환값:**

Dataset 객체

Dataset 팩토리 메서드

각 인자 뒤에 괄호로 표시된 것은 해당 인자가 지원하는 데이터셋의 유형이며, 다음 중 하나입니다:
* 폴더 - 기본, timm 폴더(또는 tar) 기반 ImageDataset
* Torch - torchvision 기반 데이터셋
* HFDS - Hugging Face Datasets
* HFIDS - Hugging Face Datasets 반복 가능(스트리밍 모드, IterableDataset 사용)
* TFDS - IterableImageDataset를 통해 IterableDataset 인터페이스로 제공되는 Tensorflow-datasets 래퍼
* WDS - Webdataset
* All - 위의 항목 중 하나

#### timm.data.ImageDataset[[timm.data.ImageDataset]]

```python
timm.data.ImageDataset(root, reader = None, split = 'train', class_map = None, load_bytes = False, input_img_mode = 'RGB', transform = None, target_transform = None, additional_features = None, **kwargs)
```

[소스](https://github.com/huggingface/pytorch-image-models/blob/v1.0.31/timm/data/dataset.py#L23)

#### timm.data.IterableImageDataset[[timm.data.IterableImageDataset]]

```python
timm.data.IterableImageDataset(root, reader = None, split = 'train', class_map = None, is_training = False, batch_size = 1, num_samples = None, seed = 42, repeats = 0, download = False, input_img_mode = 'RGB', input_key = None, target_key = None, transform = None, target_transform = None, max_steps = None, **kwargs)
```

[소스](https://github.com/huggingface/pytorch-image-models/blob/v1.0.31/timm/data/dataset.py#L95)

#### timm.data.AugMixDataset[[timm.data.AugMixDataset]]

```python
timm.data.AugMixDataset(dataset, num_splits = 2)
```

[소스](https://github.com/huggingface/pytorch-image-models/blob/v1.0.31/timm/data/dataset.py#L175)

AugMix 또는 기타 clean/augmentation mix를 수행하기 위한 Dataset wrapper

#### timm.data.MultiLabelTarget[[timm.data.MultiLabelTarget]]

```python
timm.data.MultiLabelTarget(num_classes: int, dense: bool = False)
```

[소스](https://github.com/huggingface/pytorch-image-models/blob/v1.0.31/timm/data/target_transforms.py#L5)

num_classes 길이의 float32 multi-hot 텐서로 다중 레이블 타깃을 인코딩합니다.

기본적으로 target은 양의 클래스 인덱스 시퀀스입니다. 빈 시퀀스는 양의 라벨이 없음을 의미하며, 중복은 허용됩니다. 음수, 범위 밖의 값, 또는 정수가 아닌 값은 거부됩니다. dense=True인 경우 target은 이미 num_classes 길이의 벡터이며, [0, 1] 범위의 bool, int, 또는 float 값을 포함합니다. 이 값은 검증된 후 float32로 캐스팅되며, 소프트 값은 유지됩니다.

### 로더[[timm.data.create_loader]]

#### timm.data.create_loader[[timm.data.create_loader]]

```python
timm.data.create_loader(dataset: typing.Union[timm.data.dataset.ImageDataset, timm.data.dataset.IterableImageDataset], input_size: typing.Union[int, typing.Tuple[int, int], typing.Tuple[int, int, int]], batch_size: int, is_training: bool = False, no_aug: bool = False, re_prob: float = 0.0, re_mode: str = 'const', re_count: int = 1, re_split: bool = False, train_crop_mode: typing.Optional[str] = None, scale: typing.Optional[typing.Tuple[float, float]] = None, ratio: typing.Optional[typing.Tuple[float, float]] = None, hflip: float = 0.5, vflip: float = 0.0, color_jitter: float = 0.4, color_jitter_prob: typing.Optional[float] = None, grayscale_prob: float = 0.0, gaussian_blur_prob: float = 0.0, auto_augment: typing.Optional[str] = None, num_aug_repeats: int = 0, num_aug_splits: int = 0, interpolation: str = 'bilinear', mean: typing.Tuple[float, ...] = (0.485, 0.456, 0.406), std: typing.Tuple[float, ...] = (0.229, 0.224, 0.225), num_workers: int = 1, distributed: bool = False, crop_pct: typing.Optional[float] = None, crop_mode: typing.Optional[str] = None, crop_border_pixels: typing.Optional[int] = None, collate_fn: typing.Optional[typing.Callable] = None, pin_memory: bool = False, fp16: bool = False, img_dtype: dtype = torch.float32, device: device = torch.device(), use_prefetcher: bool = True, use_multi_epochs_loader: bool = False, persistent_workers: bool = True, worker_seeding: str = 'all', tf_preprocessing: bool = False, input_size_choices: typing.Optional[typing.Sequence[typing.Union[int, typing.Tuple[int, int], typing.Tuple[int, int, int]]]] = None, batch_size_choices: typing.Optional[typing.Sequence[int]] = None, batch_choice_weights: typing.Optional[typing.Sequence[float]] = None, batch_choice_seed: int = 0, batch_choice_schedule: str = 'constant', batch_schedule_epochs: typing.Optional[int] = None, batch_schedule_spread: float = 0.65, batch_schedule_random_mix: float = 0.1, num_batches: typing.Optional[int] = None)
```

[소스](https://github.com/huggingface/pytorch-image-models/blob/v1.0.31/timm/data/loader.py#L223)

**매개변수:**

dataset : 로드할 이미지 데이터셋.

input_size : 대상 입력 크기 (채널, 높이, 너비) 튜플 또는 크기 스칼라.

batch_size : 배치 내 샘플 수.

is_training : 학습(랜덤) 변환을 반환합니다.

no_aug : 학습 시 증강을 비활성화합니다(디버깅에 유용합니다).

re_prob : 랜덤 이레이징 확률.

re_mode : Random erasing 채움 모드.

re_count : 랜덤 에라싱 영역의 수.

re_split : 배치 크기 내에서 랜덤 이레이징의 분할을 제어합니다.

scale : 무작위 리사이즈 스케일 범위 (크롭 영역, &amp;lt; 1.0 => 확대).

ratio : 무작위 종횡비 범위 (RRC의 크롭 비율, RKR의 비율 조정 계수).

hflip : 수평 플립 확률.

vflip : 세로 방향 뒤집기 확률.

color_jitter : 무작위 색상 지터 컴포넌트 계수(밝기, 대비, 채도, 색조). 스칼라 값은 (scalar,) * 3으로 적용되며(색조 제외).

color_jitter_prob : None이 아닌 경우, 이 확률로 색상 지터를 적용합니다 (SimCLR 유사 증강

grayscale_prob : 이미지를 회색조로 변환할 확률 (SimCLR 유사 증강을 위한 것).

gaussian_blur_prob : 가우시안 블러를 적용할 확률 (SimCLR 유사 증강을 위한 것).

auto_augment : 자동 증강 구성 문자열 (auto_augment.py 참조).

num_aug_repeats : 동일한 증강을 분산 GPU에 걸쳐 반복하도록 특수 샘플러를 활성화합니다.

num_aug_splits : 증강이 배치에 걸쳐 분할될 수 있는 모드를 활성화합니다.

interpolation : 이미지 보간 모드.

mean : 이미지 정규화 평균.

std : 이미지 정규화 표준 편차.

num_workers : DataLoader당 워커 프로세스 수.

distributed : 분산 학습을 위한 데이터 로딩을 활성화합니다.

crop_pct : 추론 크롭 비율 (출력 크기 / 리사이즈 크기).

crop_mode : 추론 크롭 모드. ['squash', 'border', 'center'] 중 하나입니다. None인 경우 기본값은 'center'입니다.

crop_border_pixels : 추론 시 원본 이미지의 가장자리 주위에 지정된 # 픽셀 크기의 경계 영역을 잘라냅니다.

collate_fn : 기본 collate_fn을 재정의합니다.

pin_memory : 장치 전송을 위해 메모리를 고정합니다.

fp16 : 반정밀 입력 dtype를 위한 비추천 인자. img_dtype을 사용하세요.

img_dtype : 입력 이미지의 데이터 유형.

device : 입력과 타깃을 전송할 장치.

use_prefetcher : 효율적인 pre-fetcher를 사용하여 샘플을 장치로 로드합니다.

use_multi_epochs_loader --

persistent_workers : `num_workers`가 0보다 큰 경우 영속 워커 프로세스를 활성화합니다.

worker_seeding : 초기화 시 워커의 무작위 시드를 제어합니다.

tf_preprocessing : 모델 포트 테스트를 위해 TF 1.0 추론 전처리 사용.

input_size_choices : 예약된 해상도 학습을 위한 배치별 입력 크기 선택 사항.

batch_size_choices : 각 입력 크기 선택에 해당하는 배치 크기. 지정되지 않은 경우 모든 선택에 대해 `batch_size`를 사용합니다.

batch_choice_weights : 입력 크기 선택에 대한 샘플링 가중치. 지정되지 않으면 균등 분포를 사용합니다.

batch_choice_seed : 배치 스케줄을 생성하고 섞는 데 사용되는 랜덤 시드.

batch_choice_schedule : 일정 스케줄 모드를 선택합니다. `constant` 또는 `progressive` 중 하나를 선택할 수 있습니다.

batch_schedule_epochs : 점진적 스케줄이 선택지를 순회하는 에포크 수.

batch_schedule_spread : 선택 인덱스 단위로 표현된 점진적 선택 창(progressive choice window)의 표준 편차.

batch_schedule_random_mix : 점진적 스케줄에서 0이 아닌 가중치를 가진 선택지에 대한 균일한 무작위 탐색의 비율.

num_batches : 에포당 로더 배치의 고정된 개수. 지정되지 않은 경우, 점진적 스케줄의 경우 스케줄 평균 배치 크기에서 추론됩니다.

**반환값:**

DataLoader

### Mixup 및 CutMix[[timm.data.Mixup]]

#### timm.data.Mixup[[timm.data.Mixup]]

```python
timm.data.Mixup(mixup_alpha = 1.0, cutmix_alpha = 0.0, cutmix_minmax = None, prob = 1.0, switch_prob = 0.5, mode = 'batch', correct_lam = True, label_smoothing = 0.1, num_classes = 1000, multi_label = False)
```

[소스](https://github.com/huggingface/pytorch-image-models/blob/v1.0.31/timm/data/mixup.py#L96)

**매개변수:**

mixup_alpha (float) : mixup alpha 값, > 0이면 mixup이 활성화됩니다.

cutmix_alpha (float) : cutmix alpha 값, cutmix은 0보다 크면 활성화됩니다.

cutmix_minmax (List[float]) : cutmix 최소/최대 이미지 비율, cutmix가 활성화되어 있고 None이 아닌 경우 이 값이 alpha 대신 사용됩니다.

prob (float) : 배치 또는 요소별로 mixup 또는 cutmix를 적용할 확률

switch_prob (float) : 둘 다 활성화된 경우 mixup 대신 cutmix로 전환할 확률

mode (str) : mixup/cutmix 파라미터를 적용하는 방법 ('batch', 'pair' (요소 쌍), 'elem' (요소)

correct_lam (bool) : cutmix bbox가 이미지 경계에 의해 잘릴 때 lambda 보정을 적용합니다

label_smoothing (float) : 혼합된 대상 텐서에 라벨 스무딩을 적용합니다

num_classes (int) : 대상의 클래스 수

multi_label (bool) : 밀집형 다중 레이블 타깃을 혼합하며, 각 레이블을 0.5 방향으로 스무딩합니다.

각 요소 또는 전체 배치에 서로 다른 매개변수를 적용하는 Mixup/Cutmix

#### timm.data.FastCollateMixup[[timm.data.FastCollateMixup]]

```python
timm.data.FastCollateMixup(mixup_alpha = 1.0, cutmix_alpha = 0.0, cutmix_minmax = None, prob = 1.0, switch_prob = 0.5, mode = 'batch', correct_lam = True, label_smoothing = 0.1, num_classes = 1000, multi_label = False)
```

[소스](https://github.com/huggingface/pytorch-image-models/blob/v1.0.31/timm/data/mixup.py#L229)

각 요소 또는 전체 배치에 서로 다른 매개변수를 적용하는 Mixup/Cutmix를 지원하는 빠른 Collate

collate하는 동안 수행되는 Mixup 구현입니다.

### NaFlex[[timm.data.create_naflex_loader]]

#### timm.data.create_naflex_loader[[timm.data.create_naflex_loader]]

```python
timm.data.create_naflex_loader(dataset, patch_size: typing.Union[int, typing.Tuple[int, int], NoneType] = None, patch_size_choices: typing.Optional[typing.List[int]] = None, patch_size_choice_probs: typing.Optional[typing.List[float]] = None, train_seq_lens: typing.Tuple[int, ...] = (128, 256, 576, 784, 1024), max_seq_len: int = 576, batch_size: int = 32, is_training: bool = False, mixup_fn: typing.Optional[typing.Callable] = None, no_aug: bool = False, re_prob: float = 0.0, re_mode: str = 'const', re_count: int = 1, re_split: bool = False, train_crop_mode: typing.Optional[str] = None, scale: typing.Optional[typing.Tuple[float, float]] = None, ratio: typing.Optional[typing.Tuple[float, float]] = None, hflip: float = 0.5, vflip: float = 0.0, color_jitter: float = 0.4, color_jitter_prob: typing.Optional[float] = None, grayscale_prob: float = 0.0, gaussian_blur_prob: float = 0.0, auto_augment: typing.Optional[str] = None, num_aug_repeats: int = 0, num_aug_splits: int = 0, interpolation: str = 'bilinear', mean: typing.Tuple[float, ...] = (0.485, 0.456, 0.406), std: typing.Tuple[float, ...] = (0.229, 0.224, 0.225), channels: int = 3, crop_pct: typing.Optional[float] = None, crop_mode: typing.Optional[str] = None, crop_border_pixels: typing.Optional[int] = None, num_workers: int = 4, distributed: bool = False, rank: int = 0, world_size: int = 1, seed: int = 42, epoch: int = 0, use_prefetcher: bool = True, pin_memory: bool = True, img_dtype: dtype = torch.float32, device: typing.Union[str, torch.device] = torch.device(), persistent_workers: bool = True, worker_seeding: str = 'all', patchify_channels_last: bool = True)
```

[소스](https://github.com/huggingface/pytorch-image-models/blob/v1.0.31/timm/data/naflex_loader.py#L239)

**매개변수:**

dataset : 로드할 데이터셋.

patch_size : 사용할 단일 패치 크기.

patch_size_choices : 가변 패치 크기 학습을 위한 패치 크기 목록.

patch_size_choice_probs : 각 패치 크기 선택에 대한 확률.

train_seq_lens : 동적 배치(batching)를 위한 학습 시퀀스 길이.

max_seq_len : 검증용 고정 시퀀스 길이.

batch_size : 검증용 배치 크기 및 최대 학습 시퀀스 길이.

is_training : 학습용인지 여부(동적 배치 처리를 활성화합니다).

mixup_fn : 선택 사항인 mixup 함수.

no_aug : 증강을 비활성화합니다.

re_prob : 랜덤 이레이징 확률.

re_mode : 랜덤 지우기 모드.

re_count : 지우개 사각형의 최대 개수.

re_split : 랜덤 지우기 분할 플래그.

train_crop_mode : 학습 크롭 모드.

scale : 무작위 리사이즈 크롭의 스케일 범위.

ratio : 무작위 리사이즈 크롭의 종횡비 범위.

hflip : 수평 플립 확률.

vflip : 세로 방향 뒤집기 확률.

color_jitter : Color jitter 계수.

color_jitter_prob : Color jitter 확률.

grayscale_prob : 회색 변환 확률.

gaussian_blur_prob : 가우시안 블러 확률.

auto_augment : AutoAugment 정책.

num_aug_repeats : 증강 반복 횟수.

num_aug_splits : 증강 분할의 수.

interpolation : 보간 방법.

mean : 정규화 평균 값.

std : 정규화 표준 편차 값.

channels : 이미지 채널 수. prefetcher에서 채널별 정규화에 사용됩니다.

crop_pct : 검증용 크롭 비율.

crop_mode : Crop 모드.

crop_border_pixels : Crop border pixels.

num_workers : 데이터 로딩 워커의 수.

distributed : 분산 학습을 사용할지 여부.

rank : 분산 학습을 위한 프로세스 랭크.

world_size : 프로세스의 총 개수.

seed : 랜덤 시드.

epoch : 시작 epoch.

use_prefetcher : 프리페칭을 사용할지 여부.

pin_memory : 메모리를 고정할지 여부.

img_dtype : 이미지 데이터 유형.

device : 텐서를 이동할 대상 장치.

persistent_workers : `num_workers`가 0보다 큰 경우 영속적 워커를 사용할지 여부.

worker_seeding : Worker 시딩 모드.

patchify_channels_last : 패치별 평탄한 레이아웃. `True`(기본값): 채널 인덱스가 가장 빠르게 변합니다(NaFlex 기본값). `False`: C-P-P(채널 우선 — Gemma4 / HF 네이티브 레이아웃). 상위 `Patchify` 및 프리페처의 정규화 레이아웃으로 전달됩니다.

**반환값:**

DataLoader 또는 NaFlexPrefetchLoader 인스턴스.

학습을 위해 동적 시퀀스 길이 샘플링을 사용하는 데이터 로더를 생성합니다.

#### timm.data.NaFlexMapDatasetWrapper[[timm.data.NaFlexMapDatasetWrapper]]

```python
timm.data.NaFlexMapDatasetWrapper(base_dataset: Dataset, patch_size: typing.Union[int, typing.Tuple[int, int], NoneType] = None, patch_size_choices: typing.Optional[typing.List[int]] = None, patch_size_choice_probs: typing.Optional[typing.List[float]] = None, seq_lens: typing.Tuple[int, ...] = (128, 256, 576, 784, 1024), max_tokens_per_batch: int = 16384, transform_factory: typing.Optional[typing.Callable] = None, mixup_fn: typing.Optional[typing.Callable] = None, seed: int = 42, shuffle: bool = True, distributed: bool = False, rank: int = 0, world_size: int = 1, epoch: int = 0, batch_divisor: int = 8, patchify_channels_last: bool = True)
```

[소스](https://github.com/huggingface/pytorch-image-models/blob/v1.0.31/timm/data/naflex_dataset.py#L200)

map 스타일 기반 데이터셋을 위한 IterableDataset 래퍼.

가변 시퀀스 길이를 가진 배치(yields batches)를 생성합니다. 전체 데이터셋 크기(분배를 위해 패딩된 값)를 기준으로 정준 배치 스케줄(시퀀스 길이, 배치 크기 쌍)을 한 번만 계산합니다. 각 에포크마다 이 정준 스케줄의 순서와 데이터셋 인덱스를 섞습니다. 이를 통해 모든 랭크에서 에포크당 배치 수와 샘플 수가 일관되게 유지됩니다. 분산 학습과 여러 워커를 처리합니다.

#### set_epoch[[timm.data.NaFlexMapDatasetWrapper.set_epoch]]

```python
set_epoch(epoch: int)
```

[소스](https://github.com/huggingface/pytorch-image-models/blob/v1.0.31/timm/data/naflex_dataset.py#L479)

**매개변수:**

epoch : 새로운 epoch 번호.

DataLoader 워커가 읽는 multiprocessing-safe epoch을 설정합니다.

#### timm.data.NaFlexMixup[[timm.data.NaFlexMixup]]

```python
timm.data.NaFlexMixup(num_classes: int, mixup_alpha: float = 0.8, cutmix_alpha: float = 1.0, switch_prob: float = 0.5, prob: float = 1.0, local_shuffle: int = 4, label_smoothing: float = 0.0, mixup_off_epoch: int = 0, multi_label: bool = False)
```

[소스](https://github.com/huggingface/pytorch-image-models/blob/v1.0.31/timm/data/naflex_mixup.py#L168)

혼합과 대상 생성을 결합하는 콜러블 래퍼입니다.

#### set_epoch[[timm.data.NaFlexMixup.set_epoch]]

```python
set_epoch(epoch: int)
```

[소스](https://github.com/huggingface/pytorch-image-models/blob/v1.0.31/timm/data/naflex_mixup.py#L209)

epoch에 대한 mixup 상태를 업데이트합니다.