Menyesuaikan model

Model Transformers dirancang agar dapat dikustomisasi. Kode model sepenuhnya terkandung dalam subfolder model dari repositori Transformers. Setiap folder berisi file modeling.py dan configuration.py. Salin file-file ini untuk mulai mengustomisasi model.

Mungkin lebih mudah untuk memulai dari awal jika Anda membuat model yang sepenuhnya baru. Namun, untuk model yang sangat mirip dengan model yang sudah ada di Transformers, lebih cepat untuk menggunakan ulang atau membuat subkelas dari kelas konfigurasi dan model yang sama.

Panduan ini akan menunjukkan cara menyesuaikan model ResNet, mengaktifkan dukungan AutoClass, dan membagikannya di Hub.

Konfigurasi

Konfigurasi, yang diberikan oleh kelas dasar PreTrainedConfig, berisi semua informasi yang diperlukan untuk membangun model. Di sinilah Anda akan mengonfigurasi atribut dari model ResNet kustom. Atribut yang berbeda menghasilkan tipe model ResNet yang berbeda.

Aturan utama untuk menyesuaikan konfigurasi adalah:

1. Konfigurasi kustom harus menjadi subkelas dari PreTrainedConfig. Hal ini memastikan bahwa model kustom memiliki semua fungsionalitas model Transformers, seperti from_pretrained(), save_pretrained(), dan push_to_hub().
2. PreTrainedConfig __init__ harus menerima kwargs apa pun dan meneruskannya ke __init__ superclass. PreTrainedConfig memiliki lebih banyak field daripada yang disetel dalam konfigurasi kustom Anda, sehingga saat Anda memuat konfigurasi dengan from_pretrained(), field-field tersebut perlu diterima oleh konfigurasi Anda dan diteruskan ke superclass.

Memeriksa validitas beberapa parameter berguna. Pada contoh di bawah, sebuah pemeriksaan diimplementasikan untuk memastikan block_type dan stem_type termasuk salah satu dari nilai yang telah ditentukan sebelumnya.

Tambahkan model_type ke kelas konfigurasi untuk mengaktifkan dukungan AutoClass.

from transformers import PreTrainedConfig
from typing import List

class ResnetConfig(PreTrainedConfig):
    model_type = "resnet"

    def __init__(
        self,
        block_type="bottleneck",
        layers: list[int] = [3, 4, 6, 3],
        num_classes: int = 1000,
        input_channels: int = 3,
        cardinality: int = 1,
        base_width: int = 64,
        stem_width: int = 64,
        stem_type: str = "",
        avg_down: bool = False,
        **kwargs,
    ):
        if block_type not in ["basic", "bottleneck"]:
            raise ValueError(f"`block_type` must be 'basic' or bottleneck', got {block_type}.")
        if stem_type not in ["", "deep", "deep-tiered"]:
            raise ValueError(f"`stem_type` must be '', 'deep' or 'deep-tiered', got {stem_type}.")

        self.block_type = block_type
        self.layers = layers
        self.num_classes = num_classes
        self.input_channels = input_channels
        self.cardinality = cardinality
        self.base_width = base_width
        self.stem_width = stem_width
        self.stem_type = stem_type
        self.avg_down = avg_down
        super().__init__(**kwargs)

Simpan konfigurasi ke file JSON di folder model kustom Anda, custom-resnet, dengan save_pretrained().

resnet50d_config = ResnetConfig(block_type="bottleneck", stem_width=32, stem_type="deep", avg_down=True)
resnet50d_config.save_pretrained("custom-resnet")

Model

Dengan konfigurasi ResNet kustom, Anda sekarang dapat membuat dan menyesuaikan model. Model ini merupakan subkelas dari kelas dasar PreTrainedModel. Sama seperti PreTrainedConfig, mewarisi dari PreTrainedModel dan menginisialisasi superclass dengan konfigurasi memperluas fungsionalitas Transformers seperti penyimpanan dan pemuatan ke model kustom.

Model-model Transformers mengikuti konvensi menerima objek config di metode __init__. Ini meneruskan seluruh config ke sublayer model, alih-alih memecah objek config menjadi beberapa argumen yang diteruskan secara individual ke sublayer.

Menulis model dengan cara ini menghasilkan kode yang lebih sederhana dengan sumber kebenaran yang jelas untuk setiap hiperparameter. Hal ini juga memudahkan penggunaan kembali kode dari model Transformers lainnya.

Anda akan membuat dua model ResNet, yaitu model ResNet sederhana yang mengoutputkan hidden states dan model ResNet dengan kepala klasifikasi gambar.

from transformers import PreTrainedModel
from timm.models.resnet import BasicBlock, Bottleneck, ResNet
from .configuration_resnet import ResnetConfig

BLOCK_MAPPING = {"basic": BasicBlock, "bottleneck": Bottleneck}

class ResnetModel(PreTrainedModel):
    config_class = ResnetConfig

    def __init__(self, config):
        super().__init__(config)
        block_layer = BLOCK_MAPPING[config.block_type]
        self.model = ResNet(
            block_layer,
            config.layers,
            num_classes=config.num_classes,
            in_chans=config.input_channels,
            cardinality=config.cardinality,
            base_width=config.base_width,
            stem_width=config.stem_width,
            stem_type=config.stem_type,
            avg_down=config.avg_down,
        )

    def forward(self, tensor):
        return self.model.forward_features(tensor)

import torch

class ResnetModelForImageClassification(PreTrainedModel):
    config_class = ResnetConfig

    def __init__(self, config):
        super().__init__(config)
        block_layer = BLOCK_MAPPING[config.block_type]
        self.model = ResNet(
            block_layer,
            config.layers,
            num_classes=config.num_classes,
            in_chans=config.input_channels,
            cardinality=config.cardinality,
            base_width=config.base_width,
            stem_width=config.stem_width,
            stem_type=config.stem_type,
            avg_down=config.avg_down,
        )

    def forward(self, tensor, labels=None):
        logits = self.model(tensor)
        if labels is not None:
            loss = torch.nn.functional.cross_entropy(logits, labels)
            return {"loss": loss, "logits": logits}
        return {"logits": logits}

Model dapat mengembalikan format output apa pun. Mengembalikan dictionary (seperti ResnetModelForImageClassification) dengan losses ketika label tersedia membuat model kustom kompatibel dengan Trainer. Untuk format output lainnya, Anda akan memerlukan training loop Anda sendiri atau pustaka lain untuk pelatihan.

Instansiasi kelas model kustom dengan konfigurasi.

resnet50d = ResnetModelForImageClassification(resnet50d_config)

Pada titik ini, Anda dapat memuat bobot terlatih ke dalam model atau melatihnya dari awal. Dalam panduan ini, Anda akan memuat bobot terlatih.

Muat bobot terlatih dari pustaka timm, lalu pindahkan bobot tersebut ke model kustom dengan load_state_dict.

import timm

pretrained_model = timm.create_model("resnet50d", pretrained=True)
resnet50d.model.load_state_dict(pretrained_model.state_dict())

AutoClass

API AutoClass adalah jalan pintas untuk memuat arsitektur yang benar secara otomatis untuk model tertentu. Fitur ini memudahkan pengguna yang memuat model kustom Anda.

Pastikan Anda memiliki atribut model_type (harus berbeda dari tipe model yang ada) di kelas konfigurasi dan atribut config_class di kelas model. Gunakan metode register() untuk menambahkan konfigurasi dan model kustom ke API AutoClass.

Argumen pertama untuk AutoConfig.register() harus cocok dengan atribut model_type di kelas konfigurasi kustom, dan argumen pertama untuk AutoModel.register() harus cocok dengan config_class dari kelas model kustom.

from transformers import AutoConfig, AutoModel, AutoModelForImageClassification

AutoConfig.register("resnet", ResnetConfig)
AutoModel.register(ResnetConfig, ResnetModel)
AutoModelForImageClassification.register(ResnetConfig, ResnetModelForImageClassification)

Kode model kustom Anda kini kompatibel dengan API AutoClass. Pengguna dapat memuat model dengan kelas AutoModel atau AutoModelForImageClassification.

Unggah

Unggah model kustom ke Hub agar pengguna lain dapat dengan mudah memuat dan menggunakannya.

Pastikan direktori model terstruktur dengan benar seperti yang ditunjukkan di bawah ini. Direktori harus berisi:

• modeling.py: Berisi kode untuk ResnetModel dan ResnetModelForImageClassification. File ini dapat mengandalkan impor relatif ke file lain selama file-file tersebut berada di direktori yang sama.

Saat menyalin file model Transformers, ganti semua impor relatif di bagian atas file modeling.py untuk mengimpor dari Transformers.

• configuration.py: Mengandung kode untuk ResnetConfig.
• __init__.py: Bisa kosong, file ini memungkinkan Python resnet_model digunakan sebagai modul.

.
└── resnet_model
    ├── __init__.py
    ├── configuration_resnet.py
    └── modeling_resnet.py

Untuk membagikan model, impor model dan konfigurasi ResNet.

from resnet_model.configuration_resnet import ResnetConfig
from resnet_model.modeling_resnet import ResnetModel, ResnetModelForImageClassification

Salin kode dari file model dan konfigurasi. Untuk memastikan objek AutoClass disimpan dengan save_pretrained(), panggil metode register_for_auto_class(). Ini memodifikasi file JSON konfigurasi untuk menyertakan objek AutoClass dan pemetaan.

Untuk sebuah model, pilih kelas AutoModelFor yang sesuai berdasarkan tugasnya.

ResnetConfig.register_for_auto_class()
ResnetModel.register_for_auto_class("AutoModel")
ResnetModelForImageClassification.register_for_auto_class("AutoModelForImageClassification")

Untuk memetakan lebih dari satu tugas ke model, edit auto_map langsung di file konfigurasi JSON.

"auto_map": {
    "AutoConfig": "<your-repo-name>--<config-name>",
    "AutoModel": "<your-repo-name>--<config-name>",
    "AutoModelFor<Task>": "<your-repo-name>--<config-name>",    
},

Buat konfigurasi dan model, lalu muat bobot terlatih ke dalamnya.

resnet50d_config = ResnetConfig(block_type="bottleneck", stem_width=32, stem_type="deep", avg_down=True)
resnet50d = ResnetModelForImageClassification(resnet50d_config)

pretrained_model = timm.create_model("resnet50d", pretrained=True)
resnet50d.model.load_state_dict(pretrained_model.state_dict())

Model sudah siap untuk didorong ke Hub sekarang. Masuk ke akun Hugging Face Anda dari baris perintah atau notebook.

hf auth login

from huggingface_hub import notebook_login

notebook_login()

Panggil push_to_hub() pada model untuk mengunggah model ke Hub.

resnet50d.push_to_hub("custom-resnet50d")

Bobot pra-terlatih, konfigurasi, dan file modeling.py serta configuration.py harus diunggah ke Hub sekarang dalam sebuah repository di bawah namespace Anda.

Karena model kustom tidak menggunakan kode pemodelan yang sama dengan model Transformers, Anda perlu menambahkan trust_remote_code=True di from_pretrained() untuk memuatnya. Lihat bagian memuat model kustom untuk informasi lebih lanjut.