Peta prasyarat

Topik ini memetakan prasyarat jalur PyTorch secara utuh: kemampuan Python dan NumPy yang dituntut, aliran data dari array NumPy ke tensor, dan batasan situasi ketika deep learning bukan alat yang tepat. Peta semacam ini berguna untuk menilai kesiapan membaca materi inti sekaligus menahan keputusan tergesa menggunakan deep learning pada masalah yang sudah selesai dipecahkan oleh metode yang lebih sederhana.

Python dan NumPy sebagai fondasi#

PyTorch bukan bahasa pemrograman tersendiri, melainkan pustaka yang berjalan di atas Python. Kemampuan Python tingkat dasar menjadi prasyarat mutlak, yaitu definisi fungsi, kelas dan pewarisan, percabangan, perulangan, penanganan error dengan try dan except, serta pengimporan modul. Hampir seluruh contoh pada jalur ini adalah kode Python biasa yang memanggil fungsi PyTorch, sehingga kebingungan yang menimpa pemula biasanya berasal dari Python, bukan dari PyTorch.

Prasyarat kedua adalah NumPy, pustaka komputasi numerik yang menyediakan array N dimensi beserta operasi vektorisasi atasnya. Relevansinya bukan sekadar kesejarahan. Tensor PyTorch meniru konvensi NumPy dengan setia, mulai dari atribut shape dan dtype, pengindeksan dan slicing, pengubahan bentuk, hingga aturan broadcasting, yaitu mekanisme yang memperluas array berukuran berbeda secara otomatis saat dioperasikan bersama. Konsep NumPy yang sudah dikuasai berpindah ke PyTorch nyaris tanpa biaya.

Tabel berikut merangkum padanan yang paling sering digunakan.

Tabel tersebut bukan daftar yang harus dihafal, melainkan peta terjemahan. Apabila perilaku tensor terasa mengejutkan, mencari padanan NumPy-nya adalah cara tercepat untuk memahaminya. Yang benar-benar baru hanya tiga hal: tensor dapat berada di GPU, tensor dapat merekam gradien, dan operasinya terikat pada device, yaitu perangkat komputasi tempat tensor itu berada.

Dari array NumPy ke tensor#

Data nyata jarang lahir sebagai tensor. File CSV dibaca menjadi array NumPy, citra dibuka menjadi array, sinyal sensor terekam sebagai array, lalu array itulah yang dikonversi menjadi tensor sebelum diproses. Aliran satu arah dari NumPy ke tensor merupakan pola kerja yang paling sering ditemui, dan PyTorch menyediakan dua cara untuk itu: torch.from_numpy menggunakan memori array asal tanpa menyalin, sedangkan torch.tensor menyalin data ke buffer miliknya sendiri.

Contoh berikut memperlihatkan aliran lengkap, mulai dari konversi array NumPy menjadi tensor, perhitungan di atasnya, hingga hasil yang dikembalikan menjadi array NumPy:

import numpy as np
import torch

# data tabular kecil: tiga sampel, dua fitur
data_numpy = np.array([[10.0, 20.0],
                       [30.0, 40.0],
                       [50.0, 60.0]], dtype=np.float32)

# array NumPy menjadi tensor, memori tetap dipakai bersama
data = torch.from_numpy(data_numpy)
print(data)

# operasi tensor: pembagian skalar
skala = data / 10.0
print(skala)

# hasil operasi kembali menjadi array NumPy
hasil = skala.numpy()
print(type(hasil))
print(hasil)

tensor([[10., 20.],
        [30., 40.],
        [50., 60.]])
tensor([[1., 2.],
        [3., 4.],
        [5., 6.]])
<class 'numpy.ndarray'>
[[1. 2.]
 [3. 4.]
 [5. 6.]]

Tiga tahap pada keluaran mengikuti aliran yang sama dengan penjelasan di atas. torch.from_numpy menghasilkan tensor yang nilainya identik dengan array asal tanpa penyalinan. Operasi pembagian kemudian menghasilkan tensor baru. Terakhir, pemanggilan numpy() pada tensor mengembalikan hasil menjadi array NumPy biasa, sebagaimana ditunjukkan baris <class 'numpy.ndarray'>. Analisis selanjutnya, misalnya perhitungan statistik atau pembuatan grafik, dapat dilanjutkan dengan perkakas NumPy yang sudah dikenal.

Kapan deep learning bukan alat yang tepat#

Deep learning menuntut biaya yang tinggi, yaitu data dalam jumlah besar, waktu pelatihan yang tidak pendek, dan model yang sulit dijelaskan isinya. Biaya tersebut hanya terbayar bila masalahnya memang menuntut. Tiga situasi berikut adalah kandidat terkuat untuk menolak deep learning.

Situasi pertama adalah data tabular berukuran kecil, misalnya beberapa ribu baris dengan puluhan kolom numerik dan kategorikal. Pada ranah ini, metode klasik seperti regresi logistik atau pohon keputusan umumnya memberi kinerja yang setara dengan jaringan saraf kecil, dilatih dalam hitungan detik, dan alasan keputusannya dapat dibaca. Situasi kedua adalah data yang terlalu sedikit. Model deep learning membawa parameter hingga jutaan, dan parameter sebanyak itu hanya bermakna bila contoh pelatihannya juga banyak. Pada data berjumlah puluhan sampel, model cenderung menghafal alih-alih belajar pola, yaitu perilaku yang disebut overfitting. Situasi ketiga adalah masalah yang sudah terpecahkan aturan eksplisit. Konversi satuan, pemeriksaan format tanggal, dan penyaringan nilai di luar rentang tidak membutuhkan model, karena fungsi sepuluh baris memberi hasil yang lebih cepat, tepat, dan dapat dipercaya.

Sebaliknya, deep learning menjadi pilihan alami apabila data berlimpah, polanya tersembunyi di dalam struktur yang sulit dirumuskan secara manual, dan toleransi terhadap error masih longgar. Citra, suara, dan teks adalah contoh ranahnya. Kebiasaan yang sehat sebelum memilih deep learning adalah menjalankan metode klasik terlebih dahulu sebagai pembanding, sehingga tambahan kompleksitasnya dapat dipertanggungjawabkan.

Kesalahan umum#

Dua error berikut paling sering muncul saat aliran NumPy ke tensor dipraktikkan pertama kali.

Yang pertama adalah memberi list Python kepada torch.from_numpy. Fungsi ini menuntut masukan berupa numpy.ndarray, sehingga panggilan torch.from_numpy([1.0, 2.0]) menghentikan program dengan pesan TypeError: expected np.ndarray (got list). Perbaikannya bergantung pada niat. Gunakan torch.tensor([1.0, 2.0]) bila data memang berupa list, atau bungkus terlebih dahulu dengan np.array bila alur data tetap melalui NumPy.

Yang kedua adalah membawa tipe float64 bawaan NumPy ke model PyTorch yang bertipe float32. Array NumPy yang dibuat tanpa argumen dtype membawa float64, sedangkan layer PyTorch lazim bertipe float32. Perhitungan keduanya tidak digabungkan secara otomatis dan berakhir dengan RuntimeError, sebagaimana ditunjukkan contoh berikut:

import numpy as np
import torch

lin = torch.nn.Linear(2, 1)
x = torch.from_numpy(np.array([[1.0, 2.0]]))  # float64 bawaan NumPy
try:
    lin(x)
except RuntimeError as e:
    print("RuntimeError:", e)

RuntimeError: mat1 and mat2 must have the same dtype, but got Double and Float

Perbaikannya adalah menyamakan tipe sebelum perhitungan, misalnya data_numpy.astype(np.float32) sebelum konversi atau tensor.float() setelahnya. Kebiasaan memeriksa dtype di awal alur data menghemat waktu penelusuran yang jauh lebih panjang.

Ringkasan#

• Prasyarat jalur adalah Python dasar dan NumPy, karena konsep shape, dtype, pengindeksan, dan broadcasting berpindah dari array NumPy ke tensor nyaris tanpa perubahan.
• Data mengalir dari array NumPy ke tensor melalui torch.from_numpy yang menggunakan memori bersama atau torch.tensor yang menyalin, dan mengalir kembali melalui numpy().
• Deep learning bukan alat yang tepat untuk data tabular kecil, data yang terlalu sedikit, dan masalah yang selesai dengan aturan eksplisit.

Referensi#

• Learn the Basics — PyTorch — Seri pengenalan resmi yang mencakup tensor, termasuk perbandingannya dengan array NumPy.
• PyTorch documentation — PyTorch — Rujukan lengkap API konversi antara NumPy dan tensor.