Clever Geek Handbook

Bagaimana menjadi bilingual dalam Ilmu Data

Pada artikel ini, saya ingin mendemonstrasikan R Markdown - add-on yang berguna untuk memprogram proyek Anda di R dan Python, memungkinkan Anda untuk memprogram beberapa elemen proyek Anda dalam dua bahasa dan memanipulasi objek yang dibuat dalam satu bahasa menggunakan bahasa lain. Ini bisa bermanfaat karena:



  1. Memungkinkan Anda untuk menulis kode dalam bahasa yang sudah dikenal, tetapi pada saat yang sama menggunakan fungsi yang hanya ada dalam bahasa lain.
  2. Memungkinkan kolaborasi langsung dengan kolega yang membuat program dalam bahasa lain.
  3. Itu memungkinkan untuk bekerja dengan dua bahasa dan akhirnya belajar untuk menjadi fasih di dalamnya.





Apa yang kita butuhkan

Untuk bekerja, Anda membutuhkan komponen ini:



  1. R dan Python, tentu saja.
  2. IDE RStudio (Anda dapat melakukan ini di IDE lain, tetapi di RStudio lebih mudah).
  3. Manajer lingkungan Python favorit Anda (saya menggunakan conda di sini).
  4. Paket rmarkdown



    dan reticulate



    dipasang di R.


Saat menulis dokumen R Markdown, kami akan bekerja di RStudio, tetapi pada saat yang sama menavigasi antara cuplikan kode yang ditulis dalam R dan Python. Saya akan menunjukkan beberapa contoh sederhana.



Menyiapkan lingkungan Python

Jika Anda terbiasa dengan pemrograman dengan Python, maka Anda tahu bahwa pekerjaan apa pun yang dilakukan dengan Python harus mengacu pada lingkungan tertentu yang berisi semua paket yang diperlukan untuk pekerjaan tersebut. Ada banyak cara untuk mengelola paket dengan Python, dua yang paling populer adalah virtualenv dan conda. Di sini saya mengasumsikan bahwa kami menggunakan conda dan diinstal sebagai pengelola lingkungan Python.

Anda dapat menggunakan paket reticulate di R untuk mengatur lingkungan conda melalui baris perintah R jika Anda suka (menggunakan fitur seperti conda_create()



), tetapi sebagai programmer Python biasa, saya lebih suka mengatur lingkungan saya secara manual.



Misalkan kita membuat lingkungan conda bernama r_and_python



dan menginstal ke dalamnya pandas



dan statsmodels



... Jadi perintah di terminal: 



conda create -name r_and_python
conda activate r_and_python
conda install pandas
conda install statsmodels


Setelah menginstal pandas



, statsmodels



(dan paket lain yang mungkin Anda perlukan), pengaturan lingkungan selesai. Sekarang jalankan info conda di terminal dan pilih jalur ke lingkungan Anda. Anda akan membutuhkannya di langkah berikutnya.



Menyiapkan proyek R Anda untuk bekerja dengan R dan Python

Kami akan memulai proyek R di RStudio, tetapi kami ingin dapat menjalankan Python di proyek yang sama. Untuk memastikan bahwa kode Python berjalan di lingkungan yang kita inginkan, kita perlu mengatur variabel lingkungan sistem RETICULATE_PYTHON



untuk Python yang dapat dieksekusi di lingkungan itu. Ini akan menjadi jalur yang Anda pilih di bagian sebelumnya, diikuti oleh /bin/python3



.



Cara terbaik untuk memastikan bahwa variabel ini disetel secara permanen di proyek Anda adalah dengan membuat file teks bernama dalam proyek .Rprofile



dan menambahkan baris ini ke dalamnya. 



Sys.setenv(RETICULATE_PYTHON=”path_to_environment/bin/python3")


Ganti jalur ke lingkungan dengan jalur yang Anda pilih di bagian sebelumnya. Simpan file .Rprofile



dan mulai ulang sesi R. Setiap kali Anda memulai ulang sesi atau proyek, itu dimulai .Rprofile



, menyiapkan lingkungan Python Anda. Jika Anda ingin menguji ini, Anda dapat menjalankan baris Sys.getenv ("RETICULATE_PYTHON").



Menulis Kode - Contoh Pertama

Sekarang Anda dapat mengatur dokumen R Markdown dalam proyek Anda .Rmd



dan menulis kode dalam dua bahasa berbeda. Pertama, Anda perlu memuat perpustakaan reticulate di bagian pertama kode Anda. 



```{r}
library(reticulate)
```


Sekarang, ketika Anda ingin menulis kode Python, Anda dapat membungkusnya dengan tanda kutip belakang normal, tetapi menandainya sebagai potongan kode Python dengan {python}



, dan ketika Anda ingin menulis dalam R, gunakan {r}



.



Untuk contoh pertama kita, misalkan Anda menjalankan model Python pada kumpulan data nilai ujian siswa. 



```{python}
import pandas as pd
import statsmodels.api as sm
import statsmodels.formula.api as smf
# obtain ugtests data
url = “http://peopleanalytics-regression-book.org/data/ugtests.csv"
ugtests = pd.read_csv(url)
# define model
model = smf.ols(formula = “Final ~ Yr3 + Yr2 + Yr1”, data = ugtests)
# fit model
fitted_model = model.fit()
# see results summary
model_summary = fitted_model.summary()
print(model_summary)
```






Ini bagus, tetapi katakanlah Anda harus keluar dari pekerjaan Anda karena sesuatu yang lebih mendesak dan menyerahkannya kepada kolega Anda, programmer R. Anda berharap dapat mendiagnosis model tersebut.



Jangan takut. Anda dapat mengakses semua objek python yang telah Anda buat dalam daftar umum yang disebut py. Jadi jika blok R dibuat di dalam dokumen R Markdown Anda, rekan kerja akan memiliki akses ke parameter model Anda: 



```{r}
py$fitted_model$params
```






atau beberapa sisa makanan pertama: 



```{r}
py$fitted_model$resid[1:5]
```






Sekarang Anda dapat dengan mudah melakukan beberapa diagnostik pada model, seperti memplot residual model kuantitatif-kuantitatif Anda: 



```{r}
qqnorm(py$fitted_model$resid)
```






Menulis kode - contoh kedua

Anda mengurai beberapa data penanggalan Python dan membuat bingkai data panda dengan semua data di dalamnya. Untuk mempermudah, mari muat data dan lihat: 



```{python}
import pandas as pd
url = “http://peopleanalytics-regression-book.org/data/speed_dating.csv"
speed_dating = pd.read_csv(url)
print(speed_dating.head())
```




Anda sekarang telah menjalankan model regresi logistik sederhana dengan Python untuk mencoba dan mengaitkan solusi des dengan beberapa variabel lain. Namun, Anda memahami bahwa data ini sebenarnya hierarkis dan individu yang sama dapat memiliki banyak kenalan.



Jadi Anda tahu bahwa Anda perlu menjalankan model regresi logistik efek campuran, tetapi Anda tidak dapat menemukan program Python yang melakukannya!



Dan sekali lagi, jangan takut, kirim proyek ke rekan kerja dan dia akan menulis solusinya di R. 



```{r}
library(lme4)
speed_dating <- py$speed_dating
iid_intercept_model <- lme4:::glmer(dec ~ agediff + samerace + attr + intel + prob + (1 | iid),
 data = speed_dating,
 family = “binomial”)
coefficients <- coef(iid_intercept_model)$iid
```


Sekarang Anda bisa mendapatkan kodenya dan melihat peluangnya. Dimungkinkan juga untuk mengakses objek Python R di dalam objek r generik. 



```{python}
coefs = r.coefficients
print(coefs.head())
```




Kedua contoh ini menunjukkan bagaimana Anda dapat dengan mulus menavigasi antara R dan Python dalam dokumen R Markdown yang sama. Jadi lain kali Anda berpikir tentang mengerjakan proyek lintas bahasa, pikirkan tentang menjalankan semua langkah dalam R Markdown. Hal ini dapat menghemat banyak kerumitan untuk beralih antara dua bahasa dan membantu menyimpan semua pekerjaan Anda di satu tempat sebagai narasi berkelanjutan.



Anda dapat melihat dokumen R Markdown selesai dibangun di sekitar integrasi bahasa - dengan potongan R dan Python dan objek bergerak di antara mereka - diposting di sini . Repositori Github dengan kode sumber ada di sini .



Contoh data dalam dokumen ini dari my Referensi Pemodelan Regresi Analisis Orang .



gambar




Profesi dan kursus lainnya
PROFESI







KURSUS







More articles:


All Articles