Apabila menggunakan DataLoader Pytorch untuk latihan model, jika label (sasaran) dikembalikan oleh kaedah __getItem__ dataset adalah senarai python dan bukannya obor.tensor, mekanisme pemprosesan batch lalai DataLoader boleh menyebabkan bentuk tensor label menjadi abnormal, ditunjukkan sebagai dimensi yang ditransmisikan. Artikel ini akan memberikan penjelasan yang mendalam tentang punca masalah ini dan memberikan amalan terbaik untuk menukar label ke obor.

Pemahaman yang mendalam mengenai DataLoader Pytorch dan Pemprosesan Batch Data

Dalam pytorch, obor.utils.data.dataset dan obor.utils.data.Dataloader adalah komponen teras yang mengendalikan pemuatan data. Dataset bertanggungjawab untuk menentukan cara mendapatkan sampel data individu dan label yang sepadan, sementara Dataloader bertanggungjawab untuk menganjurkan sampel individu ini ke dalam batch supaya mereka dapat dimasukkan ke dalam model untuk latihan.

Apabila DataLoader mengambil beberapa sampel dari dataset dan cuba untuk menggabungkannya ke dalam kumpulan, ia memanggil fungsi COLLATE_FN. Default collate_fn secara bijak boleh mengendalikan pelbagai jenis data, seperti penyusun obor.

Fenomena Masalah: Bentuk tensor sasaran tidak normal

Pertimbangkan senario berikut: Dalam kaedah dataset __getItem__, data imej dikembalikan dalam bentuk obor.tensor, tetapi label yang sepadan adalah senarai python, seperti [0.0, 1.0, 0.0, 0.0] yang mewakili pengekodan satu panas.

 obor import
dari Obor.utils.Data Dataset Import, DataLoader

Kelas CustomImagedAset (dataset):
    def __init __ (diri, num_samples = 100):
        self.num_samples = num_samples

    def __len __ (diri):
        kembali self.num_samples

    def __getitem __ (diri, idx):
        # Anggap Prosesed_Images adalah urutan imej bentuk (5, 224, 224, 3) # NOTA: Pytorch biasanya mengharapkan saluran imej pertama (c, h, w) atau (b, c, h, w)
        # Untuk menghasilkan semula masalah di sini, kita menggunakan bentuk dalam keterangan asal, tetapi dalam aplikasi sebenar kita perlu menyesuaikan imej = obor.randn ((5, 224, 224, 3), dType = obor.float32)
        # Label adalah sasaran senarai python = [0.0, 1.0, 0.0, 0.0]
        Imej kembali, sasaran

# Instantiate dataset dan loader data kereta api_dataset = customImageDataset ()
batch_size = 22 # Anggapkan saiz batch ialah 22
train_dataloader = dataloader (
    kereta api_dataset,
    batch_size = batch_size,
    shuffle = benar,
    drop_last = palsu,
    berterusan_ pekerja = palsu,
    timeout = 0,
)

# Melepasi pemuat data dan periksa cetakan bentuk batch ("--- pembiakan masalah asal ---")
Untuk batch_ind, batch_data dalam enumerate (train_dataloader):
    datas, sasaran = batch_data
    cetak (f "bentuk batch data (datas.shape): {datas.shape}")
    cetak (f "panjang label batch (len (sasaran)): {len (sasaran)}")
    cetak (f "panjang elemen pertama kumpulan label (len (sasaran [0]))): {len (sasaran [0])}")
    cetak (f "kandungan batch tag (paparan separa): {sasaran [0] [: 5]}, {sasaran [1] [: 5]}, ...")
    rehat

Menjalankan kod di atas, kita mungkin melihat output berikut:

 --- pembiakan masalah asal ---
Bentuk batch data (datas.shape): obor.size ([22, 5, 224, 224, 3])
Panjang batch label (len (sasaran)): 4
Panjang elemen pertama batch label (len (sasaran [0])): 22
Kandungan batch label (paparan separa): tensor ([0., 0., 0., 0., 0.]), tensor ([1., 1., 1., 1., 1.]), ...

Seperti yang anda lihat, bentuk datas adalah [batch_size, 5, 224, 224, 3], seperti yang diharapkan. Walau bagaimanapun, sasaran adalah senarai panjang 4, setiap elemen yang merupakan tensor panjang batch_size (22). Ini agak berbeza dari bentuk yang kami harapkan untuk (batch_size, target_dim), iaitu (22, 4). Malah, "transposisi" berlaku di sini: dimensi batch_size yang asalnya dijangka menjadi dimensi dalaman.

Sumber Masalah: Pengendalian lalai Collate_FN Senarai Python

Apabila __getItem__ mengembalikan senarai python (seperti [0.0, 1.0, 0.0, 0.0]) sebagai label, collate dataloader collate_fn cuba menyusun semua senarai ini dalam kumpulan "elemen-bijak".

Anggapkan batch_size = n, dan setiap __getItem__ mengembalikan sasaran = [t_0, t_1, ..., t_k]. collate_fn akan mengumpul n senarai sasaran tersebut: [t_0_sample0, t_1_sample0, ..., t_k_sample0] [t_0_sample1, t_1_sample1, ..., t_k_sample1]

Kemudian, ia mengumpul unsur-unsur J-th dari semua sampel (t_j_sample0, t_j_sample1, ..., t_j_samplen-1) untuk membentuk tensor baru. Akhirnya, pembolehubah sasaran akan menjadi senarai tensor k 1, setiap tensor panjang N. Inilah sebabnya kita melihat len ??(sasaran) = 4 dan len (sasaran [0]) = 22.

Penyelesaian: kembali obor.tensor di __getitem__

Cara yang paling langsung dan disyorkan untuk menyelesaikan masalah ini adalah untuk memastikan bahawa tag yang dikembalikan oleh kaedah __getItem__ sudah menjadi jenis obor.tensor. Apabila collate_fn menerima senarai obor.tensors, ia tahu bagaimana untuk menyusunnya dengan betul ke dalam tensor dimensi yang lebih tinggi, biasanya dalam dimensi batch baru.

Hanya menukar label dalam __getItem__ dari senarai python ke obor.tensors:

 obor import
dari Obor.utils.Data Dataset Import, DataLoader

Kelas diperbetulkanCustomimageDataset (dataset):
    def __init __ (diri, num_samples = 100):
        self.num_samples = num_samples

    def __len __ (diri):
        kembali self.num_samples

    def __getitem __ (diri, idx):
        # Anggaplah bahawa Processed_Images adalah urutan imej dengan bentuk (5, 224, 224, 3) # Begitu juga, dalam aplikasi sebenar, mungkin perlu menyesuaikan bentuk imej ke (c, h, w)
        imej = obor.randn ((5, 224, 224, 3), dType = obor.float32)
        # Perubahan Utama: Tentukan label sebagai obor.tensor
        sasaran = obor.tensor ([0.0, 1.0, 0.0, 0.0], dtype = obor.float32) # tentukan dtype lebih ketat kembali imej, sasaran

# Instantiate dataset dan loader data kereta api_dataset_corrected = diperbetulkanCustomimagedAset ()
batch_size = 22 # menyimpan saiz batch yang tidak berubah kereta api_dataloader_corrected = dataloader (
    train_dataset_corrected,
    batch_size = batch_size,
    shuffle = benar,
    drop_last = palsu,
    berterusan_ pekerja = palsu,
    timeout = 0,
)

# Melangkah ke atas pemuat data dan periksa cetakan bentuk batch ("\ n --- tingkah laku tetap ---")
Untuk batch_ind, batch_data dalam enumerate (train_dataloader_corrected):
    datas, sasaran = batch_data
    cetak (f "bentuk batch data (datas.shape): {datas.shape}")
    Cetak (f "Label Batch Bentuk (Targets.shape): {Targets.shape}")
    cetak (f "label kandungan batch (paparan separa): \ n {sasaran [: 5]}") # paparkan label 5 sampel pertama

Sekarang, menjalankan kod yang diperbetulkan, output akan seperti yang diharapkan:

 --- tingkah laku yang diperbetulkan ---
Bentuk batch data (datas.shape): obor.size ([22, 5, 224, 224, 3])
Bentuk batch label (sasaran.shape): obor.size ([22, 4])
Kandungan batch tag (paparan separa):
tensor ([[0., 1., 0., 0.],
        [0., 1., 0., 0.],
        [0., 1., 0., 0.],
        [0., 1., 0., 0.],
        [0., 1., 0., 0.]]))

Sasaran kini menjadi obor.tensor bentuk (batch_size, target_dim), yang betul -betul apa yang kita harapkan dari pemprosesan batch.

Perkara yang perlu diperhatikan dan amalan terbaik

1. Jenis Data Konsistensi : Sentiasa mengembalikan obsor.Tensor Objek dalam __getItem__, sama ada data atau label. Ini memastikan bahawa colle_fn DataLoader berfungsi dengan cara yang paling berkesan dan boleh diramal.
2. Secara eksplisit menentukan dtype : Apabila membuat obor.tensor, ia adalah amalan yang baik untuk secara jelas menentukan jenis data (seperti obor.float32 untuk terapung, obor.long untuk indeks kategori) untuk mengelakkan masalah ketidakcocokan jenis yang berpotensi.
3. Pesanan Saluran Imej : Pytorch biasanya mengharapkan tensor imej mempunyai dimensi saluran di tempat kedua (iaitu (batch, saluran, ketinggian, lebar)). Dalam aplikasi praktikal, jika imej asal anda (h, w, c) atau (n, h, w, c), sila lakukan operasi permute atau transpose yang sesuai di __getitem__. Dalam contoh di atas, untuk menghasilkan semula masalah, kita mengekalkan bentuk (5, 224, 224, 3), tetapi sebelum latihan sebenar, ia biasanya ditukar kepada (5, 3, 224, 224).
4. Custom collate_fn : Jika struktur data anda sangat kompleks, atau collate_fn lalai tidak dapat memenuhi keperluan anda, anda boleh melaksanakan COLLATE_FN tersuai dan lulus ke DataLoader. Ini memberikan fleksibiliti yang hebat, tetapi pada umumnya tidak diperlukan untuk isu -isu bentuk label yang disebutkan di atas.

Meringkaskan

Apabila data Pytorch DataLoader membatalkan data, lalai COLLATE_FN mempunyai strategi pemprosesan yang berbeza untuk jenis data yang berbeza. Apabila kaedah __getItem__ dataset mengembalikan senarai python sebagai label, COLLATE_FN cuba menyusun elemen-bijak, menyebabkan dimensi label batch menjadi "dipindahkan." Kunci untuk menyelesaikan masalah ini adalah untuk memastikan bahawa label yang dikembalikan oleh kaedah __getItem__ sudah menjadi jenis obor.tensor. Dengan pengubahsuaian mudah ini, DataLoader betul menyusun label sampel individu ke dalam tensor dengan bentuk yang diharapkan (batch_size, target_dim), dengan itu mengelakkan kesilapan yang berpotensi semasa latihan. Berikutan amalan terbaik ini akan membantu membina saluran pemuatan data pytorch yang lebih mantap dan cekap.

Atas ialah kandungan terperinci Penjelasan dan Pembetulan Terperinci Pytorch DataLoader Tenaga Tensor Batch Pemprosesan Tingkah Laku. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!