"Managed Service for Apache Spark" is the new name for the product formerly known as "Dataproc on Compute Engine" (cluster deployment) and "Google Cloud Serverless for Apache Spark" (serverless deployment).

Google utilizza la tecnologia AI per tradurre i contenuti nella tua lingua preferita. Le traduzioni generate dall'AI potrebbero contenere errori.

Metodi Monte Carlo tramite Apache Spark

Managed Service for Apache Spark e Apache Spark forniscono l'infrastruttura e la capacità che puoi utilizzare per eseguire simulazioni Monte Carlo scritte in Java, Python o Scala.

I metodi Monte Carlo possono aiutare a rispondere a un'ampia gamma di domande in ambito aziendale, ingegneristico, scientifico, matematico e in altri campi. Utilizzando un campionamento casuale ripetuto per creare una distribuzione di probabilità per una variabile, una simulazione Monte Carlo può fornire risposte a domande che altrimenti sarebbero impossibili da rispondere. In finanza, ad esempio, la determinazione del prezzo di un'opzione azionaria richiede l'analisi delle migliaia di modi in cui il prezzo dell'azione potrebbe cambiare nel tempo. I metodi Monte Carlo forniscono un modo per simulare le variazioni del prezzo delle azioni in un'ampia gamma di risultati possibili, mantenendo il controllo sul dominio degli input possibili del problema.

In passato, l'esecuzione di migliaia di simulazioni poteva richiedere molto tempo e comportare costi elevati. Managed Service for Apache Spark consente di eseguire il provisioning della capacità on demand e di pagarla al minuto. Apache Spark ti consente di utilizzare cluster di decine, centinaia o migliaia di server per eseguire simulazioni in modo intuitivo e scalabile per soddisfare le tue esigenze. Ciò significa che puoi eseguire più simulazioni più rapidamente, il che può aiutare la tua attività a innovare più velocemente e a gestire meglio i rischi.

La sicurezza è sempre importante quando si lavora con i dati finanziari. Managed Service for Apache Spark viene eseguito su Google Cloud, il che contribuisce a mantenere i tuoi dati sicuri, protetti e privati in diversi modi. Ad esempio, tutti i dati vengono criptati durante la trasmissione e quando sono at-rest e Google Cloud sono conformi agli standard ISO 27001, SOC3 e PCI.

Obiettivi

Crea un cluster Managed Service for Apache Spark gestito con Apache Spark preinstallato.
Esegui una simulazione Monte Carlo utilizzando Python per stimare la crescita di un portafoglio di azioni nel tempo.
Esegui una simulazione Monte Carlo utilizzando Scala che simula il modo in cui un casinò guadagna denaro.

Costi

In questo documento vengono utilizzati i seguenti componenti fatturabili di Google Cloud:

Per generare una stima dei costi in base all'utilizzo previsto, utilizza il calcolatore prezzi.

I nuovi utenti di Google Cloud potrebbero avere diritto a una prova senza costi.

Al termine delle attività descritte in questo documento, puoi evitare l'addebito di ulteriori costi eliminando le risorse che hai creato. Per saperne di più, consulta Esegui la pulizia.

Prima di iniziare

Configura un progetto Google Cloud

Crea un cluster Managed Service for Apache Spark

Segui i passaggi per creare un cluster Managed Service for Apache Spark dalla console Google Cloud . Le impostazioni predefinite del cluster, che includono due nodi worker, sono sufficienti per questo tutorial.

Disabilita logging per gli avvisi

Per impostazione predefinita, Apache Spark stampa log dettagliati nella finestra della console. Ai fini di questo tutorial, modifica il livello di logging in modo da registrare solo gli errori. Segui questi passaggi:

Utilizza `ssh` per connetterti al nodo primario del cluster Managed Service for Apache Spark

Il nodo primario del cluster Managed Service for Apache Spark ha il suffisso -m nel nome della VM.

Nella console Google Cloud , vai alla pagina Istanze VM.
Vai a Istanze VM
Nell'elenco delle istanze della macchina virtuale, fai clic su SSH nella riga dell'istanza a cui vuoi connetterti.

Si apre una finestra SSH connessa al nodo principale.

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

Modificare l'impostazione di logging

Dalla home directory del nodo primario, modifica /etc/spark/conf/log4j.properties.
```
sudo nano /etc/spark/conf/log4j.properties
```

Imposta log4j.rootCategory uguale a 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

Salva le modifiche ed esci dall'editor. Se vuoi attivare di nuovo il logging dettagliato, annulla la modifica ripristinando il valore originale (INFO) per .rootCategory.

Linguaggi di programmazione Spark

Spark supporta Python, Scala e Java come linguaggi di programmazione per applicazioni autonome e fornisce interpreti interattivi per Python e Scala. La scelta del linguaggio è una questione di preferenze personali. Questo tutorial utilizza gli interpreti interattivi perché puoi sperimentare modificando il codice, provando valori di input diversi e visualizzando i risultati.

Stima la crescita del portafoglio

In finanza, i metodi Monte Carlo vengono talvolta utilizzati per eseguire simulazioni che tentano di prevedere il rendimento di un investimento. Generando campioni casuali di risultati in un intervallo di probabili condizioni di mercato, una simulazione Monte Carlo può rispondere a domande su come un portafoglio potrebbe comportarsi in media o negli scenari peggiori.

Segui questi passaggi per creare una simulazione che utilizza i metodi Monte Carlo per provare a stimare la crescita di un investimento finanziario in base ad alcuni fattori di mercato comuni.

Avvia l'interprete Python dal nodo primario di Managed Service for Apache Spark.
```
pyspark
```
Attendi il prompt di Spark >>>.

Inserisci il seguente codice. Assicurati di mantenere il rientro nella definizione della funzione.

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

Premi return finché non vedi di nuovo il prompt di Spark.

Il codice precedente definisce una funzione che modella ciò che potrebbe accadere quando un investitore ha un conto pensionistico esistente investito nel mercato azionario, a cui aggiunge denaro ogni anno. La funzione genera un ritorno sull'investimento casuale, sotto forma di percentuale, ogni anno per la durata di un periodo specificato. La funzione accetta un valore seed come parametro. Questo valore viene utilizzato per reinizializzare il generatore di numeri casuali, il che garantisce che la funzione non ottenga lo stesso elenco di numeri casuali ogni volta che viene eseguita. La funzione random.normalvariate garantisce che i valori casuali si verifichino in una distribuzione normale per la media e la deviazione standard specificate. La funzione aumenta il valore del portafoglio dell'importo della crescita, che potrebbe essere positivo o negativo, e aggiunge una somma annuale che rappresenta un ulteriore investimento.

Definisci le costanti richieste in un passaggio successivo.
Crea molti seed da fornire alla funzione. Al prompt di Spark, inserisci il seguente codice, che genera 10.000 seed:
```
seeds = sc.parallelize([time.time() + i for i in range(10000)])
```
Il risultato dell'operazione parallelize è un resilient distributed dataset (RDD), ovvero una raccolta di elementi ottimizzati per l'elaborazione parallela. In questo caso, l'RDD contiene seed basati sull'ora di sistema corrente.

Durante la creazione dell'RDD, Spark suddivide i dati in base al numero di worker e core disponibili. In questo caso, Spark sceglie di utilizzare otto sezioni, una per ogni core. Questo va bene per questa simulazione, che contiene 10.000 elementi di dati. Per le simulazioni più grandi, ogni slice potrebbe essere più grande del limite predefinito. In questo caso, specificare un secondo parametro per parallelize può aumentare il numero di segmenti, il che può contribuire a mantenere gestibile la dimensione di ogni segmento, mentre Spark continua a sfruttare tutti gli otto core.
Inserisci l'RDD che contiene i seed nella funzione di crescita.
```
results = seeds.map(grow)
```
Il metodo map passa ogni seed nell'RDD alla funzione grow e aggiunge ogni risultato a un nuovo RDD, che viene archiviato in results. Tieni presente che questa operazione, che esegue una trasformazione, non produce risultati immediati. Spark non eseguirà questa operazione finché non saranno necessari i risultati. Questa valutazione lazy è il motivo per cui puoi inserire il codice senza che le costanti siano definite.

Specifica alcuni valori per la funzione.

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

Chiama reduce per aggregare i valori nell'RDD. Inserisci il seguente codice per sommare i risultati nell'RDD:
```
sum = results.reduce(add)
```
Stima e visualizza il rendimento medio:
```
print (sum / 10000.)
```
Assicurati di includere il carattere punto (.) alla fine. Indica l'aritmetica in virgola mobile.
Ora modifica un presupposto e vedi come cambiano i risultati. Ad esempio, puoi inserire un nuovo valore per il rendimento medio del mercato:
```
MKT_AVG_RETURN = 0.07
```

Esegui di nuovo la simulazione.

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

Quando hai finito di sperimentare, premi CTRL+D per uscire dall'interprete Python.

Programmare una simulazione Monte Carlo in Scala

Monte Carlo è famosa per essere una meta per il gioco d'azzardo. In questa sezione, utilizzerai Scala per creare una simulazione che modelli il vantaggio matematico di cui gode un casinò in un gioco d'azzardo. Il "margine della casa" in un casinò reale varia notevolmente da gioco a gioco; ad esempio, può superare il 20% nel keno. Questo tutorial crea un gioco semplice in cui il banco ha un vantaggio di solo l'1%. Ecco come funziona il gioco:

Il giocatore piazza una scommessa, composta da un numero di fiches provenienti da un bankroll.
Il giocatore tira un dado a 100 facce (che figata sarebbe?).
Se il risultato del tiro è un numero compreso tra 1 e 49, il giocatore vince.
Per i risultati da 50 a 100, il giocatore perde la scommessa.

Puoi notare che questo gioco crea uno svantaggio dell'1% per il giocatore: in 51 dei 100 risultati possibili per ogni tiro, il giocatore perde.

Per creare ed eseguire il gioco:

Avvia l'interprete Scala dal nodo primario di Managed Service for Apache Spark.
```
spark-shell
```

Copia e incolla il seguente codice per creare il gioco. Scala non ha gli stessi requisiti di Python per quanto riguarda l'indentazione, quindi puoi semplicemente copiare e incollare questo codice al prompt 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)
}

Premi return finché non vedi il prompt scala>.
Inserisci il seguente codice per giocare 25 volte, che è il valore predefinito per NUMBER_OF_GAMES.
```
playSession()
```
Il tuo bankroll è iniziato con un valore di 10 unità. È più alto o più basso ora?
Ora simula 10.000 giocatori che scommettono 100 chip a partita. Gioca 10.000 partite in una sessione. Questa simulazione Monte Carlo calcola la probabilità di perdere tutti i tuoi soldi prima della fine della sessione. Inserisci il seguente codice:
```
(sc.parallelize(1 to 10000, 500)
  .map(i => playSession(100000, 100, 250000))
  .map(i => if (i == 0) 1 else 0)
  .reduce(_+_)/10000.0)
```
Tieni presente che la sintassi .reduce(_+_) è un'abbreviazione in Scala per l'aggregazione utilizzando una funzione di somma. È funzionalmente equivalente alla sintassi .reduce(add) che hai visto nell'esempio di Python.

Il codice precedente esegue i seguenti passaggi:
- Crea un RDD con i risultati della riproduzione della sessione.
- Sostituisce i risultati dei giocatori in bancarotta con il numero 1 e i risultati diversi da zero con il numero 0.
- Somma il conteggio dei giocatori in bancarotta.
- Divide il conteggio per il numero di giocatori.
Un risultato tipico potrebbe essere:
```
0.998
```
che rappresenta una garanzia quasi certa di perdere tutti i tuoi soldi, anche se il casinò aveva solo un vantaggio dell'1%.

Esegui la pulizia

Elimina il progetto

Nella console Google Cloud , vai alla pagina Gestisci risorse.
Vai a Gestisci risorse
Nell'elenco dei progetti, seleziona il progetto che vuoi eliminare, quindi fai clic su Elimina.
Nella finestra di dialogo, digita l'ID progetto, quindi fai clic su Chiudi per eliminare il progetto.

Passaggi successivi

Per saperne di più sull'invio di job Spark a Managed Service for Apache Spark senza dover utilizzare ssh per connettersi al cluster, leggi Managed Service for Apache Spark - Submit a job

Metodi Monte Carlo tramite Apache Spark Mantieni tutto organizzato con le raccolte Salva e classifica i contenuti in base alle tue preferenze.

Obiettivi

Costi

Prima di iniziare

Crea un cluster Managed Service for Apache Spark

Disabilita logging per gli avvisi

Utilizza ssh per connetterti al nodo primario del cluster Managed Service for Apache Spark

Modificare l'impostazione di logging

Linguaggi di programmazione Spark

Stima la crescita del portafoglio

Programmare una simulazione Monte Carlo in Scala

Esegui la pulizia

Elimina il progetto

Passaggi successivi

Metodi Monte Carlo tramite Apache Spark

Utilizza `ssh` per connetterti al nodo primario del cluster Managed Service for Apache Spark