Mengoptimalkan Kode Python dengan Alat Profil
Menyiapkan Google Colab agar berfungsi untuk mengoptimalkan kode Python dengan alat pembuatan profil, kita mulai dengan menyiapkan lingkungan Google Colab. Jika kita baru mengenal Colab, ini adalah platform berbasis cloud yang penting dan kuat yang menyediakan akses ke notebook Jupyter dan berbagai pustaka Python. Kami mengakses Colab dengan mengunjungi (https://colab.research.google.com/) dan membuat notebook Python baru.
Impor Perpustakaan Profil
Pengoptimalan kami bergantung pada penggunaan perpustakaan profil yang mahir. Dua perpustakaan penting dalam konteks ini adalah cProfile dan line_profiler.
impor cProfil
impor line_profiler
Pustaka “cProfile” adalah alat Python bawaan untuk membuat profil kode, sedangkan “line_profiler” adalah paket eksternal yang memungkinkan kita menggali lebih dalam lagi, menganalisis kode baris demi baris.
Pada langkah ini, kita membuat contoh skrip Python untuk menghitung deret Fibonacci menggunakan fungsi rekursif. Mari kita analisis proses ini secara lebih mendalam. Deret Fibonacci adalah sekumpulan angka yang setiap angka berurutannya merupakan jumlah dari dua angka sebelumnya. Biasanya dimulai dengan 0 dan 1, sehingga urutannya terlihat seperti 0, 1, 1, 2, 3, 5, 8, 13, 21, dan seterusnya. Ini adalah barisan matematika yang biasa digunakan sebagai contoh dalam pemrograman karena sifatnya yang rekursif.
Kami mendefinisikan fungsi Python yang disebut “Fibonacci” dalam fungsi Fibonacci rekursif. Fungsi ini menggunakan bilangan bulat “n” sebagai argumennya, yang mewakili posisi dalam deret Fibonacci yang ingin kita hitung. Kita ingin mencari angka kelima dalam deret Fibonacci, misalnya jika “n” sama dengan 5.
def fibonacci ( N ) :
Selanjutnya, kita membuat kasus dasar. Kasus dasar dalam rekursi adalah skenario yang menghentikan panggilan dan mengembalikan nilai yang telah ditentukan. Pada deret Fibonacci, jika “n” bernilai 0 atau 1, kita sudah mengetahui hasilnya. Angka Fibonacci ke-0 dan ke-1 masing-masing adalah 0 dan 1.
jika N <= 1 :kembali N
Pernyataan “jika” ini menentukan apakah “n” kurang dari atau sama dengan 1. Jika ya, kita akan mengembalikan “n” itu sendiri, karena tidak diperlukan rekursi lebih lanjut.
Perhitungan Rekursif
Jika “n” melebihi 1, kita melanjutkan dengan perhitungan rekursif. Dalam hal ini, kita perlu mencari bilangan Fibonacci ke- “n” dengan menjumlahkan bilangan Fibonacci ke- “(n-1)” dan “(n-2)”. Kami mencapai ini dengan membuat dua panggilan rekursif dalam fungsi tersebut.
kalau tidak :kembali fibonacci ( N - 1 ) + fibonacci ( N - 2 )
Di sini, “fibonacci(n – 1)” menghitung bilangan Fibonacci ke “(n-1)”, dan “fibonacci(n – 2)” menghitung bilangan Fibonacci ke “(n-2)”. Kami menambahkan dua nilai ini untuk mendapatkan angka Fibonacci yang diinginkan pada posisi “n”.
Singkatnya, fungsi “fibonacci” ini menghitung angka Fibonacci secara rekursif dengan memecah soal menjadi sub-soal yang lebih kecil. Itu membuat panggilan rekursif hingga mencapai kasus dasar (0 atau 1), mengembalikan nilai yang diketahui. Untuk “n” lainnya, ia menghitung bilangan Fibonacci dengan menjumlahkan hasil dari dua panggilan rekursif untuk “(n-1)” dan “(n-2)”.
Meskipun penerapan ini mudah untuk menghitung angka Fibonacci, ini bukanlah yang paling efisien. Pada langkah selanjutnya, kami akan menggunakan alat pembuatan profil untuk mengidentifikasi dan mengoptimalkan batasan kinerjanya untuk waktu eksekusi yang lebih baik.
Membuat Profil Kode dengan CProfile
Sekarang, kita membuat profil fungsi 'fibonacci' dengan menggunakan 'cProfile'. Latihan pembuatan profil ini memberikan wawasan tentang waktu yang digunakan oleh setiap pemanggilan fungsi.
cprofiler = cProfil. Profil ( )cprofiler. memungkinkan ( )
hasil = fibonacci ( 30 )
cprofiler. cacat ( )
cprofiler. print_stats ( menyortir = 'kumulatif' )
Di segmen ini, kami menginisialisasi objek “cProfile”, mengaktifkan pembuatan profil, meminta fungsi “fibonacci” dengan “n=30”, menonaktifkan pembuatan profil, dan menampilkan statistik yang diurutkan berdasarkan waktu kumulatif. Pembuatan profil awal ini memberi kita gambaran tingkat tinggi tentang fungsi mana yang paling banyak menghabiskan waktu.
! pip instal line_profilerimpor cProfil
impor line_profiler
def fibonacci ( N ) :
jika N <= 1 :
kembali N
kalau tidak :
kembali fibonacci ( N - 1 ) + fibonacci ( N - 2 )
cprofiler = cProfil. Profil ( )
cprofiler. memungkinkan ( )
hasil = fibonacci ( 30 )
cprofiler. cacat ( )
cprofiler. print_stats ( menyortir = 'kumulatif' )
Untuk membuat profil kode baris demi baris dengan line_profiler untuk analisis yang lebih detail, kami menggunakan “line_profiler” untuk mengelompokkan kode baris demi baris. Sebelum menggunakan “line_profiler”, kita harus menginstal paket di repositori Colab.
! pip instal line_profilerSekarang kita telah menyiapkan “line_profiler”, kita dapat menerapkannya ke fungsi “fibonacci” kita:
%load_ext baris_profilerdef fibonacci ( N ) :
jika N <= 1 :
kembali N
kalau tidak :
kembali fibonacci ( N - 1 ) + fibonacci ( N - 2 )
%lprun -f fibonacci fibonacci ( 30 )
Cuplikan ini dimulai dengan memuat ekstensi “line_profiler”, mendefinisikan fungsi “fibonacci”, dan terakhir menggunakan “%lprun” untuk membuat profil fungsi “fibonacci” dengan “n=30”. Ini menawarkan segmentasi waktu eksekusi baris demi baris, dengan tepat menjelaskan di mana kode kita menghabiskan sumber dayanya.
Setelah menjalankan alat pembuatan profil untuk menganalisis hasilnya, serangkaian statistik akan disajikan yang menunjukkan karakteristik kinerja kode kita. Statistik ini melibatkan total waktu yang dihabiskan dalam setiap fungsi dan durasi setiap baris kode. Misalnya, kita dapat membedakan bahwa fungsi Fibonacci menginvestasikan lebih banyak waktu untuk menghitung ulang nilai yang sama beberapa kali. Ini adalah komputasi redundan dan merupakan area yang jelas di mana optimasi dapat diterapkan, baik melalui memoisasi atau dengan menggunakan algoritma berulang.
Sekarang, kami melakukan pengoptimalan di mana kami mengidentifikasi potensi pengoptimalan dalam fungsi Fibonacci kami. Kami memperhatikan bahwa fungsi tersebut menghitung ulang angka Fibonacci yang sama beberapa kali, sehingga menghasilkan redundansi yang tidak perlu dan waktu eksekusi lebih lambat.
Untuk mengoptimalkannya, kami menerapkan memoisasi. Memoisasi adalah teknik pengoptimalan yang melibatkan penyimpanan hasil penghitungan sebelumnya (dalam hal ini, angka Fibonacci) dan menggunakannya kembali saat diperlukan alih-alih menghitung ulang. Hal ini mengurangi komputasi yang berlebihan dan meningkatkan kinerja, terutama untuk fungsi rekursif seperti deret Fibonacci.
Untuk mengimplementasikan memoisasi dalam fungsi Fibonacci, kami menulis kode berikut:
# Kamus untuk menyimpan angka Fibonacci yang dihitungfib_cache = { }
def fibonacci ( N ) :
jika N <= 1 :
kembali N
# Periksa apakah hasilnya sudah di-cache
jika N di dalam fib_cache:
kembali fib_cache [ N ]
kalau tidak :
# Hitung dan simpan hasilnya
fib_cache [ N ] = fibonacci ( N - 1 ) + fibonacci ( N - 2 )
kembali fib_cache [ N ] ,
Dalam versi fungsi “fibonacci” yang dimodifikasi ini, kami memperkenalkan kamus “fib_cache” untuk menyimpan angka Fibonacci yang dihitung sebelumnya. Sebelum menghitung angka Fibonacci, kami memeriksa apakah angka tersebut sudah ada di cache. Jika ya, kami mengembalikan hasil cache. Dalam kasus lain, kami menghitungnya, menyimpannya di cache, dan kemudian mengembalikannya.
Mengulangi Profiling dan Optimasi
Setelah menerapkan pengoptimalan (dalam kasus kami, memoisasi), penting untuk mengulangi proses pembuatan profil untuk mengetahui dampak perubahan kami dan memastikan bahwa kami meningkatkan kinerja kode.
Pembuatan Profil Setelah Optimasi
Kita dapat menggunakan alat pembuatan profil yang sama, “cProfile” dan “line_profiler”, untuk membuat profil fungsi Fibonacci yang dioptimalkan. Dengan membandingkan hasil pembuatan profil baru dengan hasil sebelumnya, kami dapat mengukur efektivitas pengoptimalan kami.
Inilah cara kita membuat profil fungsi “fibonacci” yang dioptimalkan menggunakan “cProfile”:
cprofiler = cProfil. Profil ( )cprofiler. memungkinkan ( )
hasil = fibonacci ( 30 )
cprofiler. cacat ( )
cprofiler. print_stats ( menyortir = 'kumulatif' )
Dengan menggunakan “line_profiler”, kami membuat profilnya baris demi baris:
%lprun -f fibonacci fibonacci ( 30 )Kode:
# Kamus untuk menyimpan angka Fibonacci yang dihitungfib_cache = { }
def fibonacci ( N ) :
jika N <= 1 :
kembali N
# Periksa apakah hasilnya sudah di-cache
jika N di dalam fib_cache:
kembali fib_cache [ N ]
kalau tidak :
# Hitung dan simpan hasilnya
fib_cache [ N ] = fibonacci ( N - 1 ) + fibonacci ( N - 2 )
kembali fib_cache [ N ]
cprofiler = cProfil. Profil ( )
cprofiler. memungkinkan ( )
hasil = fibonacci ( 30 )
cprofiler. cacat ( )
cprofiler. print_stats ( menyortir = 'kumulatif' )
%lprun -f fibonacci fibonacci ( 30 )
Untuk menganalisis hasil pembuatan profil pasca pengoptimalan, waktu eksekusi akan berkurang secara signifikan, terutama untuk nilai “n” yang besar. Karena memoisasi, kami mengamati bahwa fungsi tersebut sekarang menghabiskan lebih sedikit waktu untuk menghitung ulang angka Fibonacci.
Langkah-langkah ini penting dalam proses optimasi. Pengoptimalan melibatkan pembuatan perubahan yang terinformasi pada kode kami berdasarkan pengamatan yang diperoleh dari pembuatan profil, sementara pembuatan profil berulang memastikan bahwa pengoptimalan kami menghasilkan peningkatan kinerja yang diharapkan. Dengan pembuatan profil berulang, pengoptimalan, dan validasi, kami dapat menyempurnakan kode Python kami untuk memberikan kinerja yang lebih baik dan meningkatkan pengalaman pengguna aplikasi kami.
Kesimpulan
Dalam artikel ini, kami membahas contoh saat kami mengoptimalkan kode Python menggunakan alat pembuatan profil dalam lingkungan Google Colab. Kami menginisialisasi contoh dengan penyiapan, mengimpor pustaka pembuatan profil penting, menulis kode sampel, membuat profil menggunakan “cProfile” dan “line_profiler”, menghitung hasilnya, menerapkan pengoptimalan, dan menyempurnakan kinerja kode secara berulang.