Halaman ini diterjemahkan oleh Cloud Translation API.

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 sampling acak berulang untuk membuat distribusi probabilitas untuk variabel, simulasi Monte Carlo dapat memberikan jawaban atas pertanyaan yang mungkin tidak dapat dijawab. Dalam keuangan, misalnya, penetapan harga opsi ekuitas memerlukan analisis ribuan cara perubahan harga saham dari waktu ke waktu. Metode Monte Carlo memberikan cara untuk menyimulasikan perubahan harga saham tersebut dalam berbagai kemungkinan hasil, sekaligus mempertahankan kontrol atas domain kemungkinan input untuk masalah tersebut.

Sebelumnya, menjalankan ribuan simulasi dapat memerlukan waktu yang sangat lama dan mengakibatkan biaya yang tinggi. Dataproc memungkinkan Anda menyediakan kapasitas on demand dan membayarnya per menit. Apache Spark memungkinkan Anda menggunakan cluster puluhan, ratusan, atau ribuan server untuk menjalankan simulasi dengan cara yang intuitif dan skalabel untuk memenuhi kebutuhan Anda. Artinya, Anda dapat menjalankan simulasi lebih banyak dengan lebih cepat, yang dapat membantu bisnis Anda berinovasi lebih cepat dan mengelola risiko dengan lebih baik.

Keamanan selalu penting saat menangani data keuangan. Dataproc berjalan di Google Cloud, yang membantu menjaga data Anda aman, terlindungi, dan bersifat pribadi dengan beberapa cara. Misalnya, semua data dienkripsi selama transmisi dan saat dalam penyimpanan, dan Google Cloud mematuhi ISO 27001, SOC3, dan PCI.

Tujuan

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

Biaya

Dalam dokumen ini, Anda akan menggunakan komponen Google Cloudyang dapat ditagih berikut:

Untuk membuat perkiraan biaya berdasarkan proyeksi penggunaan Anda, gunakan kalkulator harga. Pengguna Google Cloud baru 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

Menyiapkan project Google Cloud

Membuat cluster Dataproc

Ikuti langkah-langkah untuk membuat cluster Dataproc dari konsol Google Cloud. 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 tujuan tutorial ini, ubah level logging agar hanya mencatat error. Ikuti langkah-langkah berikut:

Menggunakan `ssh` untuk terhubung ke node utama cluster Dataproc

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

In the Google Cloud console, go to the VM instances page.
Go to VM instances
In the list of virtual machine instances, click SSH in the row of the instance that you want to connect to.

Jendela SSH akan terbuka dan terhubung ke node utama.

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

Mengubah setelan logging

Dari direktori utama node, 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 untuk .rootCategory ke nilai aslinya (INFO).

Bahasa pemrograman Spark

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

Memperkirakan pertumbuhan portofolio

Dalam keuangan, metode Monte Carlo terkadang digunakan untuk menjalankan simulasi yang mencoba memprediksi performa investasi. Dengan menghasilkan sampel acak hasil dari berbagai kemungkinan kondisi pasar, simulasi Monte Carlo dapat menjawab pertanyaan tentang performa portofolio secara rata-rata atau dalam skenario 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 interpreter 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 membuat model tentang hal yang mungkin terjadi saat investor memiliki akun pensiun yang sudah ada dan diinvestasikan di pasar saham, yang mereka tambahi uang tambahan setiap tahun. Fungsi ini menghasilkan laba atas investasi acak, sebagai persentase, setiap tahun selama durasi jangka waktu yang ditentukan. Fungsi ini menggunakan nilai seed sebagai parameter. Nilai ini digunakan untuk membuat ulang 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 rataan dan simpangan baku yang ditentukan. Fungsi ini meningkatkan nilai portofolio dengan jumlah pertumbuhan, yang dapat positif atau negatif, dan menambahkan jumlah tahunan yang mewakili investasi lebih lanjut.

Anda akan menentukan konstanta yang diperlukan di langkah berikutnya.
Buat banyak seed untuk dimasukkan ke dalam fungsi. Pada perintah Spark, masukkan kode berikut, yang menghasilkan 10.000 seed:
```
seeds = sc.parallelize([time.time() + i for i in range(10000)])
```
Hasil operasi parallelize adalah set data terdistribusi yang tangguh (RDD), 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 memotong data berdasarkan jumlah pekerja dan core yang tersedia. Dalam hal ini, Spark memilih untuk menggunakan delapan slice, satu slice untuk setiap core. Hal ini tidak masalah untuk simulasi ini, yang memiliki 10.000 item data. Untuk simulasi yang lebih besar, setiap slice mungkin lebih besar dari batas default. Dalam hal ini, menentukan parameter kedua ke parallelize dapat meningkatkan jumlah slice, yang dapat membantu menjaga ukuran setiap slice tetap dapat dikelola, sementara Spark masih memanfaatkan delapan core.
Masukkan RDD yang berisi seed ke fungsi pertumbuhan.
```
results = seeds.map(grow)
```
Metode map meneruskan setiap seed di RDD ke fungsi grow dan menambahkan setiap hasil ke RDD baru, yang disimpan di results. Perhatikan bahwa operasi ini, yang melakukan transformasi, tidak langsung menghasilkan hasilnya. Spark tidak akan melakukan pekerjaan 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 di RDD:
```
sum = results.reduce(add)
```
Perkiraan dan tampilkan pengembalian rata-rata:
```
print (sum / 10000.)
```
Pastikan untuk menyertakan karakter titik (.) di bagian akhir. Ini menandakan aritmetika floating point.
Sekarang ubah asumsi dan lihat bagaimana hasilnya berubah. Misalnya, Anda dapat memasukkan nilai baru untuk pengembalian rata-rata pasar:
```
MKT_AVG_RETURN = 0.07
```

Jalankan simulasi lagi.

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.

Memprogram simulasi Monte Carlo di Scala

Monte Carlo, tentu saja, terkenal sebagai tujuan perjudian. Di bagian ini, Anda akan menggunakan Scala untuk membuat simulasi yang membuat model keunggulan matematika yang dimiliki kasino dalam permainan peluang. "Keuntungan rumah" di kasino sungguhan bervariasi secara luas dari game ke game; misalnya, bisa lebih dari 20% di keno. Tutorial ini membuat game sederhana dengan rumah hanya memiliki keunggulan satu persen. Berikut cara kerja game ini:

Pemain memasang taruhan, yang terdiri dari sejumlah chip dari dana bankroll.
Pemain melempar dadu 100 sisi (keren, bukan?).
Jika hasil lemparan dadu adalah angka dari 1 hingga 49, pemain akan menang.
Untuk hasil 50 hingga 100, pemain akan kalah taruhan.

Anda dapat melihat bahwa game ini menciptakan kerugian satu persen bagi pemain: dalam 51 dari 100 kemungkinan hasil untuk setiap lemparan, pemain 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 dapat dengan mudah menyalin dan menempelkan kode ini di 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()
```
Saldo Anda dimulai dengan nilai 10 unit. Apakah sekarang lebih tinggi atau lebih rendah?
Sekarang simulasikan 10.000 pemain yang bertaruh 100 chip per game. Mainkan 10.000 game dalam sesi. Simulasi Monte Carlo ini menghitung probabilitas 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 menggabungkan menggunakan fungsi penjumlahan. Secara fungsional, tindakan ini setara dengan sintaksis .reduce(add) yang Anda lihat dalam contoh Python.

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

Pembersihan

Menghapus project

In the Google Cloud console, go to the Manage resources page.
Go to Manage resources
In the project list, select the project that you want to delete, and then click Delete.
In the dialog, type the project ID, and then click Shut down to delete the project.

Langkah selanjutnya

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

Metode Monte Carlo yang menggunakan Dataproc dan Apache Spark

Tujuan

Biaya

Sebelum memulai

Membuat cluster Dataproc

Menonaktifkan logging untuk peringatan

Menggunakan ssh untuk terhubung ke node utama cluster Dataproc

Mengubah setelan logging

Bahasa pemrograman Spark

Memperkirakan pertumbuhan portofolio

Memprogram simulasi Monte Carlo di Scala

Pembersihan

Menghapus project

Langkah selanjutnya

Menggunakan `ssh` untuk terhubung ke node utama cluster Dataproc