Tutorial PyTorch dengan Regresi Linier

PyTorch adalah paket ilmiah berbasis Python yang menyediakan pengganti NumPy ndarrays sebagai Tensor yang memanfaatkan sepenuhnya GPU. Poin positif lainnya tentang kerangka kerja PyTorch adalah kecepatan dan fleksibilitas yang diberikannya selama komputasi. PyTorch adalah alternatif yang efisien untuk bekerja dengan Tensor menggunakan Tensorflow yang telah kita pelajari sebelumnya.

PyTorch memiliki beberapa keuntungan besar sebagai paket komputasi, seperti:

Dimungkinkan untuk membangun grafik komputasi sambil berjalan. Ini berarti bahwa tidak perlu mengetahui terlebih dahulu tentang persyaratan memori grafik. Kami dapat dengan bebas membuat jaringan saraf dan mengevaluasinya selama runtime.
Mudah untuk Python API yang mudah diintegrasikan
Didukung oleh Facebook, sehingga dukungan komunitas sangat kuat
Menyediakan dukungan multi-GPU secara asli

PyTorch terutama dianut oleh komunitas Ilmu Data karena kemampuannya untuk mendefinisikan jaringan saraf dengan mudah. Mari kita lihat paket komputasi ini beraksi dalam pelajaran ini.

Menginstal PyTorch

Sekedar catatan sebelum memulai, Anda dapat menggunakan lingkungan virtual untuk pelajaran ini yang dapat kita buat dengan perintah berikut:

python -m virtualenv pytorch
sumber pytorch/bin/aktifkan

Setelah lingkungan virtual aktif, Anda dapat menginstal pustaka PyTorch di dalam virtual env sehingga contoh yang kita buat selanjutnya dapat dieksekusi:

pip instal pytorch

Kami akan menggunakan Anaconda dan Jupyter dalam pelajaran ini. Jika Anda ingin menginstalnya di mesin Anda, lihat pelajaran yang menjelaskan "Cara Menginstal Anaconda Python di Ubuntu 18".04 LTS” dan bagikan umpan balik Anda jika Anda menghadapi masalah apa pun. Untuk menginstal PyTorch dengan Anaconda, gunakan perintah berikut di terminal dari Anaconda:

conda install -c pytorch pytorch

Kami melihat sesuatu seperti ini ketika kami menjalankan perintah di atas:

Setelah semua paket yang diperlukan diinstal dan selesai, kita dapat mulai menggunakan pustaka PyTorch dengan pernyataan impor berikut:

impor obor

Mari kita mulai dengan contoh dasar PyTorch sekarang setelah kita menginstal paket prasyarat.

Memulai dengan PyTorch

Seperti yang kita ketahui bahwa jaringan saraf dapat secara fundamental terstruktur karena Tensor dan PyTorch dibangun di sekitar tensor, cenderung ada peningkatan kinerja yang signifikan. Kami akan memulai dengan PyTorch dengan terlebih dahulu memeriksa jenis Tensor yang disediakannya. Untuk memulainya, impor paket yang diperlukan:

impor obor

Selanjutnya, kita dapat mendefinisikan Tensor yang tidak diinisialisasi dengan ukuran yang ditentukan:

x = obor.kosong(4, 4)
print("Tipe Array: ".format(x.jenis)) # jenis
print("Bentuk Array: ".format(x.bentuk)) # bentuk
cetak (x)

Kami melihat sesuatu seperti ini ketika kami menjalankan skrip di atas:

Kami baru saja membuat Tensor yang tidak diinisialisasi dengan ukuran yang ditentukan dalam skrip di atas. Untuk mengulangi dari pelajaran Tensorflow kami, tensor dapat disebut sebagai array n-dimensi yang memungkinkan kita untuk merepresentasikan data dalam dimensi yang kompleks.

Mari kita jalankan contoh lain di mana kita menginisialisasi tensor Torched dengan nilai acak:

random_tensor = obor.rand(5, 4)
cetak (tensor_acak)

Ketika kita menjalankan kode di atas, kita akan melihat objek tensor acak tercetak:

Harap dicatat bahwa output untuk Tensor acak di atas dapat berbeda untuk Anda karena, yah, itu acak !

Konversi antara NumPy dan PyTorch

NumPy dan PyTorch sepenuhnya kompatibel satu sama lain. Itulah sebabnya, mudah untuk mengubah array NumPy menjadi tensor dan sebaliknya. Terlepas dari kemudahan yang disediakan API, mungkin lebih mudah untuk memvisualisasikan tensor dalam bentuk array NumPy daripada Tensor, atau sebut saja cinta saya untuk NumPy!

Sebagai contoh, kami akan mengimpor NumPy ke dalam skrip kami dan mendefinisikan array acak sederhana:

impor numpy sebagai np
larik = np.acak.rand(4, 3)
transform_tensor = obor.from_numpy(array)
print("\n".format(tensor_transformed))

Ketika kita menjalankan kode di atas, kita akan melihat objek tensor yang diubah tercetak:

Sekarang, mari kita coba mengonversi tensor ini kembali ke array NumPy:

numpy_arr = berubah_tensor.mati rasa()
print(" \n".format(type(numpy_arr), numpy_arr))

Ketika kita menjalankan kode di atas, kita akan melihat array NumPy yang diubah tercetak:

Jika kita perhatikan lebih dekat, bahkan presisi konversi dipertahankan saat mengonversi array menjadi tensor dan kemudian mengubahnya kembali menjadi array NumPy.

Operasi Tensor

Sebelum kita memulai diskusi tentang jaringan saraf, kita harus mengetahui operasi yang dapat dilakukan pada Tensor saat melatih jaringan saraf. Kami juga akan menggunakan modul NumPy secara ekstensif.

Mengiris Tensor

Kami telah melihat cara membuat Tensor baru, mari kita buat sekarang dan mengiris saya t:

vektor = obor.tensor([1, 2, 3, 4, 5, 6])
cetak(vektor[1:4])

Cuplikan kode di atas akan memberi kami output berikut:

tensor([2, 3, 4])

Kita dapat mengabaikan indeks terakhir:

cetak(vektor[1:])

Dan kami akan mendapatkan kembali apa yang diharapkan dengan daftar Python juga:

tensor([2, 3, 4, 5, 6])

Membuat Tensor Mengambang

Sekarang mari kita membuat Tensor mengambang:

float_vector = obor.FloatTensor([1, 2, 3, 4, 5, 6])
cetak(float_vector)

Cuplikan kode di atas akan memberi kami output berikut:

tensor([1., 2., 3., 4., 5., 6.])

Jenis Tensor ini adalah:

cetak(float_vector.tipe d)

Memberikan kembali:

obor.mengapung32

Operasi Aritmatika pada Tensor

Kita dapat menambahkan dua tensor seperti elemen matematika lainnya, seperti:

tensor_1 = obor.tensor([2, 3, 4])
tensor_2 = obor.tensor([3, 4, 5])
tensor_1 + tensor_2

Cuplikan kode di atas akan memberi kita:

Kita dapat berkembang biak tensor dengan skalar:

tensor_1 * 5

Ini akan memberi kita:

Kita bisa melakukan produk titik antara dua tensor juga:

d_produk = obor.titik(tensor_1, tensor_2)
d_produk

Cuplikan kode di atas akan memberi kami output berikut:

Di bagian selanjutnya, kita akan melihat dimensi yang lebih tinggi dari Tensor dan matriks.

Perkalian Matriks

Di bagian ini, kita akan melihat bagaimana kita dapat mendefinisikan metrik sebagai tensor dan mengalikannya, seperti yang biasa kita lakukan di matematika sekolah menengah.

Kami akan mendefinisikan matriks untuk memulai dengan:

matriks = obor.tensor([1, 3, 5, 6, 8, 0]).lihat(2, 3)

Dalam cuplikan kode di atas, kami mendefinisikan matriks dengan fungsi tensor dan kemudian ditentukan dengan fungsi tampilan bahwa itu harus dibuat sebagai tensor 2 dimensi dengan 2 baris dan 3 kolom. Kami dapat memberikan lebih banyak argumen untuk melihat berfungsi untuk menentukan lebih banyak dimensi. Perhatikan saja bahwa:

jumlah baris dikalikan dengan jumlah kolom = jumlah item

Ketika kita memvisualisasikan tensor 2 dimensi di atas, kita akan melihat matriks berikut:

Kami akan mendefinisikan matriks identik lainnya dengan bentuk yang berbeda:

matrix_b = obor.tensor([1, 3, 5, 6, 8, 0]).lihat(3, 2)

Kami akhirnya dapat melakukan perkalian sekarang:

obor.matmul(matriks, matriks_b)

Cuplikan kode di atas akan memberi kami output berikut:

Regresi Linier dengan PyTorch

Regresi linier adalah algoritma pembelajaran mesin berdasarkan teknik pembelajaran terawasi untuk melakukan analisis regresi pada variabel independen dan dependen. Sudah bingung? Mari kita definisikan Regresi Linier dengan kata-kata sederhana.

Regresi linier adalah teknik untuk mengetahui hubungan antara dua variabel dan memprediksi seberapa besar perubahan variabel independen yang menyebabkan seberapa besar perubahan variabel dependen. Misalnya, algoritma regresi linier dapat diterapkan untuk mengetahui berapa kenaikan harga sebuah rumah ketika luasnya ditingkatkan dengan nilai tertentu. Atau, berapa banyak tenaga kuda di dalam mobil yang ada berdasarkan berat mesinnya. Contoh ke-2 mungkin terdengar aneh tetapi Anda selalu dapat mencoba hal-hal aneh dan siapa tahu bahwa Anda dapat membangun hubungan antara parameter ini dengan Regresi Linier!

Teknik regresi linier biasanya menggunakan persamaan garis untuk merepresentasikan hubungan antara variabel terikat (y) dan variabel bebas (x):

y = m * x + c

Dalam persamaan di atas:

m = kemiringan kurva
c = bias (titik yang memotong sumbu y)

Sekarang kita memiliki persamaan yang mewakili hubungan kasus penggunaan kita, kita akan mencoba mengatur beberapa data sampel bersama dengan visualisasi plot. Berikut adalah contoh data harga rumah dan ukurannya:

house_prices_array = [3, 4, 5, 6, 7, 8, 9]
rumah_harga_np = np.array(house_prices_array, dtype=np.mengapung32)
house_price_np = house_price_np.membentuk kembali (-1,1)
house_price_tensor = Variabel(obor.from_numpy(house_price_np))
ukuran_rumah = [ 7.5, 7, 6.5, 6.0, 5.5, 5.0, 4.5]
rumah_ukuran_np = np.array(ukuran_rumah, dtype=np.mengapung32)
house_size_np = ukuran_rumah_np.membentuk kembali (-1, 1)
house_size_tensor = Variabel(obor.from_numpy(house_size_np))
# mari kita visualisasikan data kita
impor matplotlib.pyplot sebagai plt
plt.pencar(house_prices_array, house_size_np)
plt.xlabel("Harga Rumah $")
plt.ylabel("Ukuran Rumah")
plt.title("Harga Rumah $VS Luas Rumah")
plt

Perhatikan bahwa kami menggunakan Matplotlib yang merupakan perpustakaan visualisasi yang sangat baik. Baca lebih lanjut tentang itu di Tutorial Matplotlib. Kita akan melihat plot grafik berikut setelah kita menjalankan potongan kode di atas:

Ketika kita membuat garis melalui titik-titik, itu mungkin tidak sempurna tetapi masih cukup untuk jenis hubungan yang dimiliki variabel variables. Sekarang setelah kami mengumpulkan dan memvisualisasikan data kami, kami ingin membuat prediksi berapa ukuran rumah jika dijual seharga $650.000.

Tujuan menerapkan regresi linier adalah untuk menemukan garis yang cocok dengan data kami dengan kesalahan minimum. Di sini adalah langkah-langkah yang akan kita lakukan untuk menerapkan algoritma regresi linier ke data kami:

Bangun kelas untuk Regresi Linier
Tentukan model dari kelas Regresi Linier ini
Hitung MSE (Mean squared error)
Lakukan Optimasi untuk mengurangi kesalahan (SGD i.e. penurunan gradien stokastik)
Lakukan Backpropagation
Terakhir, buat prediksi

Mari mulai menerapkan langkah-langkah di atas dengan impor yang benar:

impor obor
dari obor.Variabel impor autograd
impor obor.nn sebagai nn

Selanjutnya, kita dapat mendefinisikan kelas Regresi Linier yang diwarisi dari Modul jaringan saraf PyTorch:

kelas Regresi Linier(nn.Modul):
def __init__(self,input_size,output_size):
# fungsi super mewarisi dari nn.Modul sehingga kami dapat mengakses semuanya dari nn.Modul
super (Regresi Linier, diri sendiri).__init__()
# Fungsi linear
diri.linier = nn.Linier(input_dim,output_dim)
def maju(sendiri,x):
kembalikan diri.linier (x)

Sekarang kita sudah siap dengan kelasnya, mari kita definisikan model kita dengan ukuran input dan output 1:

masukan_redup = 1
keluaran_redup = 1
model = LinearRegression(input_dim, output_dim)

Kita dapat mendefinisikan MSE sebagai:

mse = nn.MSELoss()

Kami siap untuk menentukan optimasi yang dapat dilakukan pada prediksi model untuk kinerja terbaik:

# Optimalisasi (temukan parameter yang meminimalkan kesalahan)
learning_rate = 0.02
pengoptimal = obor.optimal.SGD (model).parameter(), lr=learning_rate)

Kami akhirnya dapat membuat plot untuk fungsi kerugian pada model kami:

daftar_kerugian = []
iterasi_number = 1001
untuk iterasi dalam range(iteration_number):
# lakukan optimasi dengan gradien nol
pengoptimal.nol_grad()
hasil = model(house_price_tensor)
kerugian = mse(hasil, house_size_tensor)
# hitung turunan dengan melangkah mundur
kerugian.ke belakang()
# Memperbarui parameter
pengoptimal.langkah()
# toko rugi
daftar_kerugian.tambahkan (kerugian.data)
# kehilangan cetak
if(iterasi % 50 == 0):
print('Epoch , kehilangan '.format (iterasi, kehilangan.data))
plt.plot(rentang(angka_iterasi),loss_list)
plt.xlabel("Jumlah Iterasi")
plt.ylabel("Rugi")
plt

Kami melakukan pengoptimalan beberapa kali pada fungsi kerugian dan mencoba memvisualisasikan berapa banyak kerugian yang meningkat atau menurun. Berikut adalah plot yang merupakan output:

Kami melihat bahwa karena jumlah iterasi lebih tinggi, kerugiannya cenderung nol. Ini berarti bahwa kita siap untuk membuat prediksi dan merencanakannya:

# prediksi harga mobil kita
diprediksi = model(house_price_tensor).data.mati rasa()
plt.scatter(house_prices_array, house_size, label = "data asli", warna = "merah")
plt.scatter(house_prices_array, prediksi, label = "data prediksi", warna ="biru")
plt.legenda()
plt.xlabel("Harga Rumah $")
plt.ylabel("Ukuran Rumah")
plt.title("Nilai Asli vs Prediksi")
plt.menunjukkan()

Berikut adalah plot yang akan membantu kita untuk membuat prediksi:

Kesimpulan

Dalam pelajaran ini, kita melihat paket komputasi luar biasa yang memungkinkan kita membuat prediksi yang lebih cepat dan efisien dan banyak lagi. PyTorch populer karena memungkinkan kita mengelola jaringan Neural dengan cara mendasar dengan Tensors.