Bagaimana cara mengatur program R besar?

Ketika saya melakukan proyek R dengan kompleksitas apa pun, skrip saya dengan cepat menjadi panjang dan membingungkan.

Apa saja praktik yang bisa saya adopsi sehingga kode saya akan selalu menyenangkan untuk bekerja dengannya? Saya sedang memikirkan hal-hal seperti

• Penempatan fungsi dalam file sumber
• Kapan memecahkan sesuatu ke file sumber lain
• Apa yang seharusnya ada di file master
• Menggunakan fungsi sebagai unit organisasi (apakah ini bermanfaat mengingat R membuatnya sulit untuk mengakses keadaan global)
• Indentasi / praktik pemutusan jalur.
  • Perlakukan (seperti {?
  • Letakkan hal-hal seperti)} pada 1 atau 2 baris?

Pada dasarnya, apa aturan praktis Anda untuk mengatur skrip R besar?

Jawaban standar adalah dengan menggunakan paket - lihat manual Penulisan R Extensions serta berbagai tutorial di web.

Ini memberi Anda

• cara semi-otomatis untuk mengatur kode Anda berdasarkan topik
• sangat mendorong Anda untuk menulis file bantuan, membuat Anda berpikir tentang antarmuka
• banyak cek kewarasan via R CMD check
• kesempatan untuk menambahkan tes regresi
• serta sarana untuk ruang nama.

Hanya menjalankan source()kode berfungsi untuk cuplikan yang sangat singkat. Segala sesuatu yang lain harus dalam sebuah paket - bahkan jika Anda tidak berencana untuk menerbitkannya karena Anda dapat menulis paket internal untuk repositori internal.

Adapun bagian 'cara mengedit', manual R Internals memiliki standar pengkodean R yang sangat baik di Bagian 6. Jika tidak, saya cenderung menggunakan default dalam mode ESS Emacs .

Pembaruan 2008-Agustus-13: David Smith baru saja membuat blog tentang Panduan Gaya R Google .

Saya suka menempatkan fungsi yang berbeda di file mereka sendiri.

Tapi saya tidak suka sistem paket R. Agak sulit digunakan.

Saya lebih suka alternatif yang ringan, untuk menempatkan fungsi file di dalam lingkungan (apa yang setiap bahasa lain sebut "namespace") dan melampirkannya. Sebagai contoh, saya membuat grup fungsi 'util' seperti:

util = new.env()

util$bgrep = function [...]

util$timeit = function [...]

while("util" %in% search())
  detach("util")
attach(util)

Ini semua dalam file util.R . Ketika Anda sumber itu, Anda mendapatkan lingkungan 'util' sehingga Anda dapat menelepon util$bgrep()dan semacamnya; tetapi lebih jauh lagi, attach()panggilan itu membuatnya begitu adil bgrep()dan langsung berfungsi. Jika Anda tidak meletakkan semua fungsi itu di lingkungan mereka sendiri, mereka akan mencemari namespace tingkat atas penerjemah (yang ls()menunjukkan).

Saya mencoba mensimulasikan sistem Python, di mana setiap file adalah modul. Itu akan lebih baik untuk dimiliki, tetapi ini tampaknya OK.

Ini mungkin terdengar agak jelas terutama jika Anda seorang programmer, tetapi inilah cara saya berpikir tentang unit kode logis dan fisik.

Saya tidak tahu apakah ini kasus Anda, tetapi ketika saya bekerja di R, saya jarang memulai dengan program rumit yang besar dalam pikiran. Saya biasanya mulai dalam satu skrip dan memisahkan kode menjadi unit yang dapat dipisahkan secara logis, sering menggunakan fungsi. Manipulasi data dan kode visualisasi ditempatkan dalam fungsinya sendiri, dll. Dan fungsi tersebut dikelompokkan bersama dalam satu bagian file (manipulasi data di bagian atas, kemudian visualisasi, dll). Pada akhirnya Anda ingin berpikir tentang cara membuatnya lebih mudah bagi Anda untuk mempertahankan skrip Anda dan menurunkan tingkat cacat.

Seberapa halus / kasarnya Anda membuat fungsi Anda akan bervariasi dan ada berbagai aturan praktis: misalnya 15 baris kode, atau "suatu fungsi harus bertanggung jawab untuk melakukan satu tugas yang diidentifikasi dengan namanya", dll. Jarak tempuh Anda akan bervariasi . Karena R tidak mendukung referensi panggilan-oleh, saya biasanya berbeda-beda membuat fungsi saya terlalu halus ketika melibatkan melewati frame data atau struktur serupa di sekitar. Tapi ini mungkin kelebihan kompensasi untuk beberapa kesalahan kinerja konyol ketika saya pertama kali mulai dengan R.

Kapan mengekstraksi unit logis ke unit fisik mereka sendiri (seperti file sumber dan pengelompokan yang lebih besar seperti paket)? Saya punya dua kasus. Pertama, jika file menjadi terlalu besar dan bergulir di antara unit yang tidak berhubungan secara logis adalah gangguan. Kedua, jika saya memiliki fungsi yang dapat digunakan kembali oleh program lain. Saya biasanya memulai dengan menempatkan beberapa unit yang dikelompokkan, misalnya fungsi manipulasi data, ke dalam file terpisah. Saya kemudian dapat sumber file ini dari skrip lain.

Jika Anda akan menggunakan fungsi Anda, maka Anda harus mulai berpikir tentang paket. Saya tidak menggunakan kode R dalam produksi atau untuk digunakan kembali oleh orang lain karena berbagai alasan (secara singkat: budaya org lebih suka bahasa lain, masalah tentang kinerja, GPL, dll). Juga, saya cenderung untuk terus memperbaiki dan menambah koleksi file saya yang bersumber, dan saya lebih suka tidak berurusan dengan paket ketika saya melakukan perubahan. Jadi, Anda harus memeriksa jawaban terkait paket lainnya, seperti Dirk, untuk detail lebih lanjut di bagian depan ini.

Akhirnya, saya pikir pertanyaan Anda belum tentu khusus untuk R. Saya akan sangat merekomendasikan membaca Kode Lengkap oleh Steve McConnell yang berisi banyak kebijaksanaan tentang masalah-masalah seperti itu dan praktik pengkodean pada umumnya.

Saya setuju dengan saran Dirk! IMHO, mengatur program Anda dari skrip sederhana ke paket yang terdokumentasi adalah, untuk Pemrograman dalam R, seperti beralih dari Word ke TeX / LaTeX untuk menulis. Saya sarankan untuk melihat Paket R Membuat yang sangat berguna : Tutorial oleh Friedrich Leisch.

Jawaban singkat saya:

1. Tulis fungsi Anda dengan hati-hati, identifikasi output dan input yang cukup umum;
2. Batasi penggunaan variabel global;
3. Gunakan objek S3 dan, jika sesuai, objek S4;
4. Masukkan fungsi dalam paket, terutama ketika fungsi Anda memanggil C / Fortran.

Saya percaya R semakin banyak digunakan dalam produksi, sehingga kebutuhan untuk kode yang dapat digunakan kembali lebih besar dari sebelumnya. Saya menemukan penerjemah jauh lebih kuat dari sebelumnya. Tidak ada keraguan bahwa R adalah 100-300x lebih lambat dari C, tetapi biasanya bottleneck terkonsentrasi di sekitar beberapa baris kode, yang dapat didelegasikan ke C / C ++. Saya pikir itu akan menjadi kesalahan untuk mendelegasikan kekuatan R dalam manipulasi data dan analisis statistik ke bahasa lain. Dalam hal ini, penalti kinerja rendah, dan dalam hal apa pun sepadan dengan penghematan dalam upaya pembangunan. Jika waktu eksekusi adalah masalahnya, kita semua akan menjadi assembler menulis.

Saya bermaksud mencari tahu cara menulis paket tetapi belum menginvestasikan waktu. Untuk setiap proyek mini saya, saya menyimpan semua fungsi tingkat rendah saya di folder yang disebut 'fungsi /', dan sumber mereka ke ruang nama terpisah yang saya buat secara eksplisit.

Baris kode berikut akan membuat lingkungan bernama "fungsi saya" di jalur pencarian jika belum ada (menggunakan lampiran), dan mengisinya dengan fungsi-fungsi yang terdapat dalam file .r di direktori 'functions /' saya (menggunakan sys.source). Saya biasanya meletakkan baris-baris ini di bagian atas skrip utama saya dimaksudkan untuk "antarmuka pengguna" dari mana fungsi tingkat tinggi (memanggil fungsi tingkat rendah) disebut.

if( length(grep("^myfuncs$",search()))==0 )
  attach("myfuncs",pos=2)
for( f in list.files("functions","\\.r$",full=TRUE) )
  sys.source(f,pos.to.env(grep("^myfuncs$",search())))

Saat Anda melakukan perubahan, Anda selalu dapat mengisinya kembali dengan baris yang sama, atau menggunakan sesuatu seperti

evalq(f <- function(x) x * 2, pos.to.env(grep("^myfuncs$",search())))

untuk mengevaluasi penambahan / modifikasi di lingkungan yang Anda buat.

Itu kludgey, saya tahu, tetapi menghindari harus terlalu formal tentang hal itu (tetapi jika Anda mendapatkan kesempatan saya mendorong sistem paket - mudah-mudahan saya akan bermigrasi seperti itu di masa depan).

Adapun konvensi pengkodean, ini adalah satu-satunya hal yang saya lihat mengenai estetika (saya suka mereka dan secara longgar mengikuti tapi saya tidak menggunakan terlalu banyak kurung kurawal di R):

http://www1.maths.lth.se/help/R/RCC/

Ada "konvensi" lain tentang penggunaan [, drop = FALSE] dan <- seperti yang disarankan operator penugasan dalam berbagai presentasi (biasanya keynote) di useR! konferensi, tapi saya rasa tidak ada yang ketat (meskipun [, drop = FALSE] berguna untuk program di mana Anda tidak yakin dengan input yang Anda harapkan).

Hitung saya sebagai orang lain yang mendukung paket. Saya akan mengakui bahwa saya sangat miskin dalam menulis halaman manual dan sketsa sampai jika / ketika saya harus (yaitu dibebaskan), tetapi itu membuat cara yang sangat praktis untuk meng-bundel sumber doe. Plus, jika Anda serius menjaga kode Anda, poin-poin yang diangkat oleh Dirk masuk ke dalam plya.

Saya juga setuju. Gunakan fungsi package.skeleton () untuk memulai. Bahkan jika Anda berpikir kode Anda tidak akan pernah berjalan lagi, ini dapat membantu memotivasi Anda untuk membuat kode yang lebih umum yang dapat menghemat waktu Anda nanti.

Sedangkan untuk mengakses lingkungan global, itu mudah dengan << - operator, meskipun tidak disarankan.

Karena belum belajar bagaimana menulis paket, saya selalu mengorganisasikannya dengan sumber sub skrip. Mirip dengan kelas menulis tetapi tidak terlibat. Secara pemrograman tidak elegan, tetapi saya menemukan saya membangun analisis dari waktu ke waktu. Setelah saya memiliki bagian besar yang berfungsi, saya sering memindahkannya ke skrip yang berbeda dan hanya sumber karena akan menggunakan objek ruang kerja. Mungkin saya perlu mengimpor data dari beberapa sumber, mengurutkan semuanya dan menemukan persimpangan. Saya mungkin memasukkan bagian itu ke dalam skrip tambahan. Namun, jika Anda ingin mendistribusikan "aplikasi" Anda untuk orang lain, atau menggunakan beberapa input interaktif, sebuah paket mungkin merupakan rute yang baik. Sebagai seorang peneliti, saya jarang perlu mendistribusikan kode analisis saya tetapi saya SERING perlu menambah atau menyesuaikannya.

Saya juga mencari cawan suci dari alur kerja yang tepat untuk menyusun proyek R besar. Saya menemukan tahun lalu paket ini disebut rsuite , dan, tentu saja, itu yang saya cari. Paket R ini secara eksplisit dikembangkan untuk penyebaran proyek R besar tetapi saya menemukan bahwa itu dapat digunakan untuk proyek R yang lebih kecil, ukuran sedang, dan ukuran besar. Saya akan memberikan tautan ke contoh dunia nyata dalam satu menit (di bawah), tetapi pertama-tama saya ingin menjelaskan paradigma baru dalam membangun proyek R denganrsuite .

Catatan. Saya bukan pencipta atau pengembang rsuite.

1. Kami telah melakukan semua kesalahan proyek dengan RStudio; tujuannya tidak boleh menjadi penciptaan proyek atau paket tetapi dari ruang lingkup yang lebih besar. Di rsuite, Anda membuat proyek super atau proyek master, yang menampung proyek R standar dan paket R, dalam semua kombinasi yang memungkinkan.

2. Dengan memiliki proyek super R Anda tidak perlu lagi Unix makeuntuk mengelola tingkat proyek R yang lebih rendah di bawahnya; Anda menggunakan skrip R di bagian atas. Mari ku tunjukkan. Saat Anda membuat proyek master rsuite, Anda mendapatkan struktur folder ini:

3. Folder Radalah tempat Anda meletakkan skrip manajemen proyek Anda, yang akan diganti make.

4. Folder packagesadalah folder tempat rsuitemenyimpan semua paket yang menyusun proyek-super. Anda juga dapat menyalin rekatkan paket yang tidak dapat diakses dari internet, dan rsuite juga akan membuatnya.

5. folder deploymentadalah tempat rsuiteakan menulis semua binari paket yang ditunjukkan dalam DESCRIPTIONfile paket . Jadi, ini membuat, dengan sendirinya, Anda memproyeksikan waktu akros yang sepenuhnya dapat direproduksi.

6. rsuitedilengkapi dengan klien untuk semua sistem operasi. Saya sudah menguji semuanya. Tetapi Anda juga dapat menginstalnya sebagai addinuntuk RStudio.

7. rsuitejuga memungkinkan Anda membangun condainstalasi yang terisolasi di foldernya sendiri conda. Ini bukan lingkungan tetapi instalasi Python fisik yang berasal dari Anaconda di mesin Anda. Ini bekerja bersama-sama dengan R's SystemRequirements, dari mana Anda dapat menginstal semua paket Python yang Anda inginkan, dari saluran conda yang Anda inginkan.

8. Anda juga dapat membuat repositori lokal untuk menarik paket R saat Anda offline, atau ingin membuat semuanya lebih cepat.

9. Jika mau, Anda juga dapat membangun proyek R sebagai file zip dan membaginya dengan kolega. Ini akan berjalan, asalkan kolega Anda memiliki versi R yang sama diinstal.

10. Pilihan lain adalah membangun wadah seluruh proyek di Ubuntu, Debian, atau CentOS. Jadi, alih-alih berbagi file zip dengan build proyek Anda, Anda membagikan seluruh Dockerkontainer dengan proyek Anda yang siap dijalankan.

Saya telah banyak bereksperimen dengan rsuitemencari reproduktifitas penuh, dan menghindari tergantung pada paket yang diinstal di lingkungan global. Ini salah karena segera setelah Anda menginstal pembaruan paket, proyek, lebih sering daripada tidak, berhenti bekerja, khususnya paket-paket dengan panggilan yang sangat spesifik ke suatu fungsi dengan parameter tertentu.

Hal pertama yang saya mulai coba adalah dengan bookdownebooks. Saya tidak pernah cukup beruntung memiliki bookdown untuk bertahan dalam ujian waktu lebih dari enam bulan. Jadi, apa yang saya lakukan adalah mengonversi proyek bookdown asli untuk mengikuti rsuitekerangka kerja. Sekarang, saya tidak perlu khawatir tentang memperbarui lingkungan R global saya, karena proyek ini memiliki paket sendiri dalam deploymentfolder tersebut.

Hal berikutnya yang saya lakukan adalah membuat proyek pembelajaran mesin tetapi di rsuitejalan. Master, mengatur proyek di atas, dan semua sub proyek dan paket berada di bawah kendali master. Ini benar-benar mengubah cara Anda berkode dengan R, membuat Anda lebih produktif.

Setelah itu saya mulai bekerja di paket baru saya yang disebut rTorch. Ini mungkin, sebagian besar, karena rsuite; itu membuat Anda berpikir dan menjadi besar.

Salah satu nasihat. Belajar rsuiteitu tidak mudah. Karena menghadirkan cara baru untuk membuat proyek R, rasanya sulit. Jangan kecewa pada upaya pertama, terus mendaki lereng sampai Anda berhasil. Ini membutuhkan pengetahuan lanjutan tentang sistem operasi Anda dan sistem file Anda.

Saya berharap bahwa suatu hari RStudiomemungkinkan kita untuk menghasilkan proyek rsuitepengaturan seperti halnya dari menu. Itu akan luar biasa.

Tautan:

Repo RSuite GitHUb

Bookdown r4ds

tutorial keras dan mengkilap

moderndive-book-rsuite

interpretable_ml-rsuite

IntroMachineLearningWithR-rsuite

clark-intro_ml-rsuite

hyndman-bookdown-rsuite

Statistical_rethinking-rsuite

fread-benchmarks-rsuite

dataviz-rsuite

retail-segmentation-h2o-tutorial

telco-customer-churn-tutorial

sclerotinia_rsuite

R OK untuk penggunaan interaktif dan skrip kecil, tapi saya tidak akan menggunakannya untuk program besar. Saya akan menggunakan bahasa umum untuk sebagian besar pemrograman dan membungkusnya dalam antarmuka R.