Metode Monte Carlo yang menggunakan Dataproc dan Apache Spark

Dataproc dan Apache Spark menyediakan infrastruktur dan kapasitas yang dapat Anda gunakan untuk menjalankan simulasi Monte Carlo yang ditulis dalam Java, Python, atau Scala.

Metode Monte Carlo dapat membantu menjawab berbagai pertanyaan dalam bisnis, teknik, sains, matematika, dan bidang lainnya. Dengan menggunakan pengambilan sampel acak berulang untuk membuat distribusi probabilitas untuk variabel, simulasi Monte Carlo dapat memberikan jawaban atas pertanyaan yang mungkin tidak mungkin dijawab. Di bidang keuangan, misalnya, penetapan harga opsi ekuitas memerlukan analisis ribuan cara harga saham dapat berubah dari waktu ke waktu. Metode Monte Carlo menyediakan cara untuk menyimulasikan perubahan harga saham tersebut dalam berbagai kemungkinan hasil, sekaligus mempertahankan kontrol atas domain kemungkinan input terhadap masalah.

Dahulu, menjalankan ribuan simulasi dapat memakan waktu yang sangat lama dan menimbulkan biaya yang tinggi. Dataproc memungkinkan Anda menyediakan kapasitas sesuai permintaan dan membayarnya dengan cepat. Apache Spark memungkinkan Anda menggunakan cluster yang berisi puluhan, ratusan, atau ribuan server untuk menjalankan simulasi dengan cara yang intuitif dan dapat diskalakan untuk memenuhi kebutuhan Anda. Artinya, Anda dapat menjalankan lebih banyak simulasi dengan lebih cepat, sehingga bisnis Anda dapat berinovasi lebih cepat dan mengelola risiko dengan lebih baik.

Keamanan selalu menjadi faktor penting saat bekerja dengan data keuangan. Dataproc berjalan di Google Cloud, yang membantu menjaga data Anda tetap aman, terlindungi, dan pribadi dalam beberapa cara. Misalnya, semua data dienkripsi selama transmisi dan saat dalam penyimpanan, serta Google Cloud sesuai dengan ISO 27001, SOC3, dan PCI.

Tujuan

Buat cluster Dataproc terkelola dengan Apache Spark yang telah diinstal sebelumnya.
Menjalankan simulasi Monte Carlo menggunakan Python yang memperkirakan pertumbuhan portofolio stok dari waktu ke waktu.
Jalankan simulasi Monte Carlo menggunakan Scala yang menyimulasikan cara kasino menghasilkan uang.

Biaya

Dalam dokumen ini, Anda menggunakan komponen Google Cloud yang dapat ditagih berikut:

Untuk membuat perkiraan biaya berdasarkan proyeksi penggunaan Anda, gunakan kalkulator harga. Pengguna baru Google Cloud mungkin memenuhi syarat untuk mendapatkan uji coba gratis.

Setelah menyelesaikan tugas yang dijelaskan dalam dokumen ini, Anda dapat menghindari penagihan berkelanjutan dengan menghapus resource yang Anda buat. Untuk mengetahui informasi selengkapnya, lihat Pembersihan.

Sebelum memulai

Siapkan project Google Cloud

Membuat cluster Dataproc

Ikuti langkah-langkah untuk membuat cluster Dataproc dari Google Cloud Console. Setelan cluster default, yang mencakup node dua pekerja, sudah cukup untuk tutorial ini.

Menonaktifkan logging untuk peringatan

Secara default, Apache Spark mencetak logging panjang di jendela konsol. Untuk keperluan tutorial ini, ubah level logging untuk mencatat error saja. Ikuti langkah-langkah berikut:

Gunakan `ssh` untuk terhubung ke node utama cluster Dataproc

Node utama cluster Dataproc memiliki akhiran -m pada nama VM-nya.

Di konsol Google Cloud, buka halaman Instance VM.
Buka VM instances
Di daftar instance virtual machine, klik SSH di baris instance yang ingin Anda hubungkan.

Jendela SSH akan terbuka dan terhubung ke node utama.

Connected, host fingerprint: ssh-rsa 2048 ...
...
user@clusterName-m:~$

Mengubah setelan logging

Dari direktori home node utama, edit /etc/spark/conf/log4j.properties.
```
sudo nano /etc/spark/conf/log4j.properties
```

Tetapkan log4j.rootCategory sama dengan ERROR.

# Set only errors to be logged to the console
log4j.rootCategory=ERROR, console
log4j.appender.console=org.apache.log4j.ConsoleAppender
log4j.appender.console.target=System.err
log4j.appender.console.layout=org.apache.log4j.PatternLayout
log4j.appender.console.layout.ConversionPattern=%d{yy/MM/dd HH:mm:ss} %p %c{1}: %m%n

Simpan perubahan dan keluar dari editor. Jika Anda ingin mengaktifkan logging panjang lagi, balikkan perubahan dengan memulihkan nilai .rootCategory ke nilai aslinya (INFO).

Spark bahasa pemrograman

Spark mendukung Python, Scala, dan Java sebagai bahasa pemrograman untuk aplikasi mandiri, serta menyediakan penafsir interaktif untuk Python dan Scala. Bahasa yang Anda pilih adalah masalah preferensi pribadi. Tutorial ini menggunakan penafsir interaktif karena Anda dapat bereksperimen dengan mengubah kode, mencoba berbagai nilai input, lalu melihat hasilnya.

Memperkirakan pertumbuhan portofolio

Di bidang keuangan, metode Monte Carlo terkadang digunakan untuk menjalankan simulasi yang mencoba memprediksi kemungkinan performa suatu investasi. Dengan menghasilkan sampel hasil acak pada rentang kemungkinan kondisi pasar, simulasi Monte Carlo dapat menjawab pertanyaan tentang performa rata-rata portofolio atau dalam skenario kasus terburuk.

Ikuti langkah-langkah berikut untuk membuat simulasi yang menggunakan metode Monte Carlo untuk mencoba memperkirakan pertumbuhan investasi keuangan berdasarkan beberapa faktor pasar umum.

Mulai penafsir Python dari node utama Dataproc.
```
pyspark
```
Tunggu perintah Spark >>>.

Masukkan kode berikut. Pastikan Anda mempertahankan indentasi dalam definisi fungsi.

import random
import time
from operator import add

def grow(seed):
    random.seed(seed)
    portfolio_value = INVESTMENT_INIT
    for i in range(TERM):
        growth = random.normalvariate(MKT_AVG_RETURN, MKT_STD_DEV)
        portfolio_value += portfolio_value * growth + INVESTMENT_ANN
    return portfolio_value

Tekan return hingga Anda melihat perintah Spark lagi.

Kode sebelumnya menentukan fungsi yang memodelkan apa yang mungkin terjadi saat investor memiliki rekening pensiun yang sudah ada yang diinvestasikan di pasar saham, yang dia tambahkan uang tambahan setiap tahunnya. Fungsi tersebut menghasilkan laba atas investasi secara acak, dalam bentuk persentase, setiap tahun selama jangka waktu yang ditentukan. Fungsi ini mengambil nilai seed sebagai parameter. Nilai ini digunakan untuk melakukan reseed generator angka acak, yang memastikan bahwa fungsi tidak mendapatkan daftar angka acak yang sama setiap kali dijalankan. Fungsi random.normalvariate memastikan bahwa nilai acak terjadi di seluruh distribusi normal untuk rerata dan simpangan baku yang ditentukan. Fungsi ini meningkatkan nilai portofolio berdasarkan jumlah pertumbuhan, yang bisa positif atau negatif, dan menambahkan jumlah tahunan yang mewakili investasi lebih lanjut.

Anda akan menentukan konstanta yang diperlukan dalam langkah mendatang.
Buat banyak bibit untuk dimasukkan ke fungsi. Pada dialog Spark, masukkan kode berikut, yang menghasilkan 10.000 seed:
```
seeds = sc.parallelize([time.time() + i for i in range(10000)])
```
Hasil dari operasi parallelize adalah set data terdistribusi (RDD) tangguh, yang merupakan kumpulan elemen yang dioptimalkan untuk pemrosesan paralel. Dalam hal ini, RDD berisi seed yang didasarkan pada waktu sistem saat ini.

Saat membuat RDD, Spark mengelompokkan data berdasarkan jumlah pekerja dan core yang tersedia. Dalam hal ini, Spark memilih untuk menggunakan delapan irisan, satu irisan untuk setiap inti. Tidak masalah untuk simulasi ini, yang memiliki 10.000 item data. Untuk simulasi yang lebih besar, setiap irisan mungkin lebih besar dari batas default. Dalam hal ini, menentukan parameter kedua ke parallelize dapat meningkatkan irisan angka, sehingga ukuran setiap irisan tetap dapat dikelola, sementara Spark tetap memanfaatkan kedelapan core tersebut.
Masukkan RDD yang berisi bibit ke fungsi pertumbuhan.
```
results = seeds.map(grow)
```
Metode map meneruskan setiap seed dalam RDD ke fungsi grow dan menambahkan setiap hasil ke RDD baru, yang disimpan di results. Perlu diperhatikan bahwa operasi yang melakukan transformasi ini tidak langsung memberikan hasilnya. Spark tidak akan melakukan fungsi ini hingga hasilnya diperlukan. Evaluasi lambat ini adalah alasan Anda dapat memasukkan kode tanpa konstanta yang ditentukan.

Tentukan beberapa nilai untuk fungsi.

INVESTMENT_INIT = 100000  # starting amount
INVESTMENT_ANN = 10000  # yearly new investment
TERM = 30  # number of years
MKT_AVG_RETURN = 0.11 # percentage
MKT_STD_DEV = 0.18  # standard deviation

Panggil reduce untuk menggabungkan nilai dalam RDD. Masukkan kode berikut untuk menjumlahkan hasil dalam RDD:
```
sum = results.reduce(add)
```
Memperkirakan dan menampilkan hasil rata-rata:
```
print (sum / 10000.)
```
Pastikan untuk menyertakan karakter titik (.) di akhir. Hal ini menandakan aritmetika floating point.
Sekarang ubah asumsi dan lihat bagaimana hasilnya berubah. Misalnya, Anda dapat memasukkan nilai baru untuk laba rata-rata pasar:
```
MKT_AVG_RETURN = 0.07
```

Jalankan kembali simulasi.

print (sc.parallelize([time.time() + i for i in range(10000)]) \
        .map(grow).reduce(add)/10000.)

Setelah selesai bereksperimen, tekan CTRL+D untuk keluar dari penafsir Python.

Pemrograman simulasi Monte Carlo di Scala

Monte Carlo, tentu saja, terkenal sebagai tempat perjudian. Di bagian ini, Anda menggunakan Scala untuk membuat simulasi yang memodelkan keuntungan matematis yang dinikmati kasino dalam game untung-untungan. "Tepi rumah" di kasino yang sebenarnya sangat bervariasi dari satu game ke game lainnya; bisa lebih dari 20% di keno, misalnya. Tutorial ini membuat game sederhana ketika rumah hanya memiliki keunggulan satu persen. Berikut cara kerja game tersebut:

Pemain memasang taruhan, yang terdiri dari sejumlah chip dari dana bankroll.
Pemain melempar dadu 100 sisi (sejukkah itu?).
Jika hasil lemparan berupa angka dari 1 hingga 49, pemain menang.
Untuk hasil 50 sampai 100, pemain kalah dalam taruhan.

Anda dapat melihat bahwa game ini menciptakan kerugian satu persen bagi pemain: dalam 51 dari 100 kemungkinan hasil untuk setiap lemparan, pemain akan kalah.

Ikuti langkah-langkah berikut untuk membuat dan menjalankan game:

Mulai penafsir Scala dari node utama Dataproc.
```
spark-shell
```

Salin dan tempel kode berikut untuk membuat game. Scala tidak memiliki persyaratan yang sama dengan Python dalam hal indentasi, sehingga Anda cukup menyalin dan menempelkan kode ini pada perintah scala>.

val STARTING_FUND = 10
val STAKE = 1   // the amount of the bet
val NUMBER_OF_GAMES = 25

def rollDie: Int = {
    val r = scala.util.Random
    r.nextInt(99) + 1
}

def playGame(stake: Int): (Int) = {
    val faceValue = rollDie
    if (faceValue < 50)
        (2*stake)
    else
        (0)
}

// Function to play the game multiple times
// Returns the final fund amount
def playSession(
   startingFund: Int = STARTING_FUND,
   stake: Int = STAKE,
   numberOfGames: Int = NUMBER_OF_GAMES):
   (Int) = {

    // Initialize values
    var (currentFund, currentStake, currentGame) = (startingFund, 0, 1)

    // Keep playing until number of games is reached or funds run out
    while (currentGame <= numberOfGames && currentFund > 0) {

        // Set the current bet and deduct it from the fund
        currentStake = math.min(stake, currentFund)
        currentFund -= currentStake

        // Play the game
        val (winnings) = playGame(currentStake)

        // Add any winnings
        currentFund += winnings

        // Increment the loop counter
        currentGame += 1
    }
    (currentFund)
}

Tekan return hingga Anda melihat perintah scala>.
Masukkan kode berikut untuk memainkan game 25 kali, yang merupakan nilai default untuk NUMBER_OF_GAMES.
```
playSession()
```
Bankroll Anda dimulai dengan nilai 10 unit. Apakah sekarang lebih tinggi atau lebih rendah?
Sekarang simulasikan 10.000 pemain bertaruh 100 chip per game. Mainkan 10.000 game dalam satu sesi. Simulasi Monte Carlo ini menghitung kemungkinan kehilangan semua uang Anda sebelum akhir sesi. Masukkan kode berikut:
```
(sc.parallelize(1 to 10000, 500)
  .map(i => playSession(100000, 100, 250000))
  .map(i => if (i == 0) 1 else 0)
  .reduce(_+_)/10000.0)
```
Perhatikan bahwa sintaksis .reduce(_+_) adalah singkatan dalam Scala untuk digabungkan menggunakan fungsi penjumlahan. Secara fungsional, fungsi ini setara dengan sintaksis .reduce(add) yang Anda lihat di contoh Python.

Kode sebelumnya melakukan langkah-langkah berikut:
- Membuat RDD dengan hasil dari pemutaran sesi.
- Mengganti hasil pemain yang bangkrut dengan angka 1 dan hasil bukan nol dengan angka 0.
- Menjumlahkan jumlah pemain yang bangkrut.
- Membagi hitungan dengan jumlah pemain.
Hasil biasanya adalah:
```
0.998
```
Yang mewakili jaminan yang hampir pasti akan kehilangan semua uang Anda, meskipun kasino hanya memiliki keunggulan satu persen.

Pembersihan

Menghapus project

Di konsol Google Cloud, buka halaman Manage resource.
Buka Manage resource
Pada daftar project, pilih project yang ingin Anda hapus, lalu klik Delete.
Pada dialog, ketik project ID, lalu klik Shut down untuk menghapus project.

Langkah selanjutnya

Untuk mengetahui informasi selengkapnya tentang mengirimkan tugas Spark ke Dataproc tanpa harus menggunakan ssh untuk terhubung ke cluster, baca Dataproc—Mengirim tugas

Metode Monte Carlo yang menggunakan Dataproc dan Apache Spark

Tujuan

Biaya

Sebelum memulai

Membuat cluster Dataproc

Menonaktifkan logging untuk peringatan

Gunakan ssh untuk terhubung ke node utama cluster Dataproc

Mengubah setelan logging

Spark bahasa pemrograman

Memperkirakan pertumbuhan portofolio

Pemrograman simulasi Monte Carlo di Scala

Pembersihan

Menghapus project

Langkah selanjutnya

Gunakan `ssh` untuk terhubung ke node utama cluster Dataproc