# TimmWrapper

## Ikhtisar

Kelas bantu untuk memungkinkan model timm dimuat agar dapat digunakan dengan pustaka transformers dan autoclasses-nya.

```python
from urllib.request import urlopen

import torch
from PIL import Image

from transformers import AutoImageProcessor, AutoModelForImageClassification

# Load image
image = Image.open(urlopen(
    'https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/beignets-task-guide.png'
))

# Load model and image processor
checkpoint = "timm/resnet50.a1_in1k"
image_processor = AutoImageProcessor.from_pretrained(checkpoint)
model = AutoModelForImageClassification.from_pretrained(checkpoint).eval( device_map="auto")

# Preprocess image
inputs = image_processor(image)

# Forward pass
with torch.no_grad():
    logits = model(**inputs).logits

# Get top 5 predictions
top5_probabilities, top5_class_indices = torch.topk(logits.softmax(dim=1) * 100, k=5)
```

## Sumber daya

Daftar sumber resmi Hugging Face dan komunitas (ditandai dengan 🌎) untuk membantu Anda memulai dengan TimmWrapper.

- [Kumpulan Contoh Notebook](https://github.com/ariG23498/timm-wrapper-examples) 🌎

> [!TIP]
> Untuk ringkasan yang lebih detail, silakan baca [artikel blog resmi](https://huggingface.co/blog/timm-transformers) tentang integrasi timm.

## TimmWrapperConfig[[transformers.TimmWrapperConfig]]

#### transformers.TimmWrapperConfig[[transformers.TimmWrapperConfig]]

```python
transformers.TimmWrapperConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, is_encoder_decoder: bool = False, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, architecture: str = 'resnet50', initializer_range: float = 0.02, do_pooling: bool = True, model_args: dict[str, typing.Any] | None = None)
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/models/timm_wrapper/configuration_timm_wrapper.py#L31)

**Parameter:**

architecture (`str`, *opsional*, defaultnya `"resnet50"`) : Arsitektur timm yang akan dimuat.

initializer_range (`float`, *opsional*, defaultnya `0.02`) : Deviasi standar dari truncated_normal_initializer untuk menginisialisasi semua matriks bobot.

do_pooling (`bool`, *opsional*, defaultnya `True`) : Apakah akan melakukan pooling untuk last_hidden_state di `TimmWrapperModel` atau tidak.

model_args (`dict[str, Any]`, *opsional*) : Argumen kata kunci tambahan untuk diteruskan ke fungsi `timm.create_model`. Misalnya, `model_args={"depth": 3}` untuk `timm/vit_base_patch32_clip_448.laion2b_ft_in12k_in1k` untuk membuat model dengan 3 blok. Bawaan adalah `None`.

Ini adalah kelas konfigurasi untuk menyimpan konfigurasi dari TimmWrapperModel. Kelas ini digunakan untuk membuat instans model Timm Wrapper sesuai dengan argumen yang ditentukan, yang mendefinisikan arsitektur model. Membuat instans konfigurasi dengan nilai bawaan akan menghasilkan konfigurasi yang serupa dengan konfigurasi [resnet50](https://huggingface.co/resnet50)

Objek konfigurasi mewarisi dari [PreTrainedConfig](/docs/transformers/main/id/main_classes/configuration#transformers.PreTrainedConfig) dan dapat digunakan untuk mengontrol keluaran model. Baca dokumentasi dari [PreTrainedConfig](/docs/transformers/main/id/main_classes/configuration#transformers.PreTrainedConfig) untuk informasi lebih lanjut.

Contoh:
```python
>>> from transformers import TimmWrapperModel

>>> # Initializing a timm model
>>> model = TimmWrapperModel.from_pretrained("timm/resnet18.a1_in1k")

>>> # Accessing the model configuration
>>> configuration = model.config
```

## TimmWrapperImageProcessor[[transformers.TimmWrapperImageProcessor]]

#### transformers.TimmWrapperImageProcessor[[transformers.TimmWrapperImageProcessor]]

```python
transformers.TimmWrapperImageProcessor(pretrained_cfg: dict, architecture: str | None = None, **kwargs)
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/models/timm_wrapper/image_processing_timm_wrapper.py#L38)

**Parameter:**

pretrained_cfg (`dict[str, Any]`) : Konfigurasi model pretrained yang digunakan untuk menyelesaikan transformasi evaluasi dan pelatihan.

architecture (`Optional[str]`, *opsional*) : Nama arsitektur model.

Kelas pembungkus untuk model timm yang digunakan di dalam transformers.

#### preprocess[[transformers.TimmWrapperImageProcessor.preprocess]]

```python
preprocess(images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor']], return_tensors: str | transformers.utils.generic.TensorType | None = 'pt')
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/models/timm_wrapper/image_processing_timm_wrapper.py#L96)

**Parameter:**

images (`ImageInput`) : Gambar untuk dipreprocess. Mengharapkan satu gambar atau batch gambar

return_tensors (`str` atau `TensorType`, *opsional*) : Jenis tensor yang akan dikembalikan.

Praproses sebuah gambar atau kumpulan gambar.

## TimmWrapperModel[[transformers.TimmWrapperModel]]

#### transformers.TimmWrapperModel[[transformers.TimmWrapperModel]]

```python
transformers.TimmWrapperModel(config: TimmWrapperConfig)
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/models/timm_wrapper/modeling_timm_wrapper.py#L163)

Kelas pembungkus untuk model timm yang akan digunakan di transformers.

#### forward[[transformers.TimmWrapperModel.forward]]

```python
forward(pixel_values: Tensor, output_attentions: bool | None = None, output_hidden_states: bool | list[int] | None = None, return_dict: bool | None = None, do_pooling: bool | None = None, use_cache: bool | None = None, **kwargs)
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/models/timm_wrapper/modeling_timm_wrapper.py#L177)

**Parameter:**

pixel_values (`torch.Tensor` dengan bentuk `(batch_size, num_channels, image_size, image_size)`) : Tensor yang sesuai dengan gambar input. Nilai piksel dapat diperoleh menggunakan [TimmWrapperImageProcessor](/docs/transformers/main/id/model_doc/timm_wrapper#transformers.TimmWrapperImageProcessor). Lihat [TimmWrapperImageProcessor.__call__()](/docs/transformers/main/id/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) untuk detailnya (`processor_class` menggunakan [TimmWrapperImageProcessor](/docs/transformers/main/id/model_doc/timm_wrapper#transformers.TimmWrapperImageProcessor) untuk memproses gambar).

output_attentions (`bool`, *opsional*) : Apakah akan mengembalikan tensor perhatian dari semua lapisan perhatian atau tidak. Tidak kompatibel dengan model yang dibungkus timm.

output_hidden_states (`bool`, *opsional*) : Apakah akan mengembalikan hidden states dari semua lapisan. Tidak kompatibel dengan model yang dibungkus timm.

return_dict (`bool`, *opsional*) : Apakah akan mengembalikan [ModelOutput](/docs/transformers/main/id/main_classes/output#transformers.utils.ModelOutput) alih-alih tuple biasa.

do_pooling (`bool`, *opsional*) : Apakah akan melakukan pooling untuk last_hidden_state di `TimmWrapperModel` atau tidak. Jika `None` diberikan, nilai `do_pooling` dari config akan digunakan.

use_cache (`bool`, *opsional*) : Jika diatur ke `True`, state kunci-nilai `past_key_values` akan dikembalikan dan dapat digunakan untuk mempercepat decoding (lihat `past_key_values`).

**Mengembalikan:** `TimmWrapperModelOutput` atau `tuple(torch.Tensor)`

Sebuah `TimmWrapperModelOutput` atau tuple dari `torch.Tensor` (jika `return_dict=False` dilewatkan atau ketika `config.return_dict=False`) yang terdiri dari berbagai elemen tergantung pada konfigurasi ([TimmWrapperConfig](/docs/transformers/main/id/model_doc/timm_wrapper#transformers.TimmWrapperConfig)) dan input.

Metode forward dari [TimmWrapperModel](/docs/transformers/main/id/model_doc/timm_wrapper#transformers.TimmWrapperModel) menimpa metode khusus `__call__`.

Meskipun resep untuk forward pass perlu didefinisikan di dalam fungsi ini, sebaiknya panggil instance `Module` setelahnya alih-alih fungsi ini, karena yang pertama menangani langkah-langkah pra-pemrosesan dan pasca-pemrosesan, sedangkan yang kedua mengabaikannya secara diam-diam.

- **last_hidden_state** (`torch.Tensor`) -- State tersembunyi terakhir dari model, yang dihasilkan sebelum menerapkan kepala klasifikasi.
- **pooler_output** (`torch.Tensor`, *opsional*) -- Output yang telah di-pool dari hidden state terakhir, jika berlaku.
- **hidden_states** (`tuple(torch.Tensor)`, *opsional*, dikembalikan jika `output_hidden_states=True` disetel atau jika `config.output_hidden_states=True`) -- Tuple yang berisi hidden states antara dari model pada output setiap layer atau layer yang ditentukan.
- **attentions** (`tuple(torch.Tensor)`, *opsional*, dikembalikan jika `output_attentions=True` disetel atau jika `config.output_attentions=True`.) -- Tuple yang berisi bobot perhatian antara dari model pada keluaran setiap lapisan. Catatan: Saat ini, model Timm tidak mendukung keluaran attentions.

Contoh:
```python
>>> import torch
>>> from PIL import Image
>>> from urllib.request import urlopen
>>> from transformers import AutoModel, AutoImageProcessor

>>> # Load image
>>> image = Image.open(urlopen(
...     'https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/beignets-task-guide.png'
... ))

>>> # Load model and image processor
>>> checkpoint = "timm/resnet50.a1_in1k"
>>> image_processor = AutoImageProcessor.from_pretrained(checkpoint)
>>> model = AutoModel.from_pretrained(checkpoint).eval()

>>> # Preprocess image
>>> inputs = image_processor(image)

>>> # Forward pass
>>> with torch.no_grad():
...     outputs = model(**inputs)

>>> # Get pooled output
>>> pooled_output = outputs.pooler_output

>>> # Get last hidden state
>>> last_hidden_state = outputs.last_hidden_state
```

## TimmWrapperForImageClassification[[transformers.TimmWrapperForImageClassification]]

#### transformers.TimmWrapperForImageClassification[[transformers.TimmWrapperForImageClassification]]

```python
transformers.TimmWrapperForImageClassification(config: TimmWrapperConfig)
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/models/timm_wrapper/modeling_timm_wrapper.py#L280)

Kelas pembungkus untuk model timm yang digunakan di transformers untuk klasifikasi gambar.

#### forward[[transformers.TimmWrapperForImageClassification.forward]]

```python
forward(pixel_values: Tensor, labels: typing.Optional[torch.LongTensor] = None, output_attentions: bool | None = None, output_hidden_states: bool | list[int] | None = None, return_dict: bool | None = None, **kwargs)
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/models/timm_wrapper/modeling_timm_wrapper.py#L303)

**Parameter:**

pixel_values (`torch.Tensor` dengan bentuk `(batch_size, num_channels, image_size, image_size)`) : Tensor yang sesuai dengan gambar input. Nilai piksel dapat diperoleh menggunakan [TimmWrapperImageProcessor](/docs/transformers/main/id/model_doc/timm_wrapper#transformers.TimmWrapperImageProcessor). Lihat [TimmWrapperImageProcessor.__call__()](/docs/transformers/main/id/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) untuk detailnya (`processor_class` menggunakan [TimmWrapperImageProcessor](/docs/transformers/main/id/model_doc/timm_wrapper#transformers.TimmWrapperImageProcessor) untuk memproses gambar).

labels (`torch.LongTensor` dengan bentuk `(batch_size,)`, *opsional*) : Label untuk menghitung loss klasifikasi/regresi gambar. Indeks harus berada dalam `[0, ..., config.num_labels - 1]`. Jika `config.num_labels == 1`, loss regresi dihitung (Mean-Square loss). Jika `config.num_labels > 1`, loss klasifikasi dihitung (Cross-Entropy).

output_attentions (`bool`, *opsional*) : Apakah akan mengembalikan tensor perhatian dari semua lapisan perhatian atau tidak. Tidak kompatibel dengan model yang dibungkus timm.

output_hidden_states (`bool`, *opsional*) : Apakah akan mengembalikan hidden states dari semua lapisan. Tidak kompatibel dengan model yang dibungkus timm.

return_dict (`bool`, *opsional*) : Apakah akan mengembalikan [ModelOutput](/docs/transformers/main/id/main_classes/output#transformers.utils.ModelOutput) alih-alih tuple biasa. **kwargs: Argumen kata kunci tambahan yang diteruskan ke forward model `timm`.

**Mengembalikan:** [ImageClassifierOutput](/docs/transformers/main/id/main_classes/output#transformers.modeling_outputs.ImageClassifierOutput) atau `tuple(torch.Tensor)`

[ImageClassifierOutput](/docs/transformers/main/id/main_classes/output#transformers.modeling_outputs.ImageClassifierOutput) atau tuple dari `torch.Tensor` (jika `return_dict=False` diteruskan atau ketika `config.return_dict=False`) yang terdiri dari berbagai elemen tergantung pada konfigurasi ([TimmWrapperConfig](/docs/transformers/main/id/model_doc/timm_wrapper#transformers.TimmWrapperConfig)) dan input.

Metode forward dari [TimmWrapperForImageClassification](/docs/transformers/main/id/model_doc/timm_wrapper#transformers.TimmWrapperForImageClassification) menimpa metode khusus `__call__`.

Meskipun resep untuk forward pass perlu didefinisikan di dalam fungsi ini, sebaiknya panggil instance `Module` setelahnya alih-alih fungsi ini, karena yang pertama menangani langkah-langkah pra-pemrosesan dan pasca-pemrosesan, sedangkan yang kedua mengabaikannya secara diam-diam.

- **loss** (`torch.Tensor` dengan bentuk `(1,)`, *opsional*, dikembalikan saat `labels` disediakan) -- Loss klasifikasi (atau regresi jika config.num_labels==1).
- **logits** (`torch.Tensor` dengan bentuk `(batch_size, config.num_labels)`) -- Skor klasifikasi (atau regresi jika config.num_labels==1) (sebelum SoftMax).
- **hidden_states** (`tuple(torch.Tensor)`, *opsional*, dikembalikan saat `output_hidden_states=True` dilewatkan atau saat `config.output_hidden_states=True`) -- Tuple dari `torch.Tensor` (satu untuk output dari embeddings, jika model memiliki lapisan embedding, + satu untuk output dari setiap tahap) dengan bentuk `(batch_size, sequence_length, hidden_size)`. Hidden-states (juga disebut feature maps) dari model pada output dari setiap tahap.
- **attentions** (`tuple(torch.Tensor)`, *opsional*, dikembalikan ketika `output_attentions=True` dilewatkan atau ketika `config.output_attentions=True`) -- Tuple dari `torch.Tensor` (satu untuk setiap layer) dengan bentuk `(batch_size, num_heads, patch_size, sequence_length)`.

  Bobot perhatian setelah softmax perhatian, digunakan untuk menghitung rata-rata berbobot di kepala self-attention.

Contoh:
```python
>>> import torch
>>> from PIL import Image
>>> from urllib.request import urlopen
>>> from transformers import AutoModelForImageClassification, AutoImageProcessor

>>> # Load image
>>> image = Image.open(urlopen(
...     'https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/beignets-task-guide.png'
... ))

>>> # Load model and image processor
>>> checkpoint = "timm/resnet50.a1_in1k"
>>> image_processor = AutoImageProcessor.from_pretrained(checkpoint)
>>> model = AutoModelForImageClassification.from_pretrained(checkpoint).eval()

>>> # Preprocess image
>>> inputs = image_processor(image)

>>> # Forward pass
>>> with torch.no_grad():
...     logits = model(**inputs).logits

>>> # Get top 5 predictions
>>> top5_probabilities, top5_class_indices = torch.topk(logits.softmax(dim=1) * 100, k=5)
```