Méthodes Monte Carlo avec Cloud Dataproc et Apache Spark

Création d'un cluster Dataproc

Suivez les étapes permettant de créer un cluster Dataproc à partir de Google Cloud Console. Les paramètres de cluster par défaut prévoient deux nœuds de calcul, ce qui suffit pour ce tutoriel.

Désactiver la journalisation des avertissements

Par défaut, Apache Spark imprime une journalisation détaillée dans la fenêtre de la console. Pour les besoins de ce tutoriel, modifiez le niveau de journalisation pour ne consigner que les erreurs. Procédez comme suit :

Utiliser ssh pour se connecter au nœud principal du cluster Dataproc

Le nœud principal du cluster Dataproc comporte le suffixe -m sur son nom de VM.

1. In the Google Cloud console, go to the VM instances page.

   Go to VM instances

2. In the list of virtual machine instances, click SSH in the row of the instance that you want to connect to.

   

Une fenêtre SSH s'ouvre, connectée au nœud principal.

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

Redéfinir le paramètre de journalisation

1. Dans le répertoire d'accueil du nœud principal, modifiez le fichier /etc/spark/conf/log4j.properties.

   sudo nano /etc/spark/conf/log4j.properties
   

2. Définissez log4j.rootCategory sur 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
   

3. Enregistrez les modifications, puis quittez l'éditeur. Si vous souhaitez réactiver la journalisation détaillée, annulez la modification en rétablissant la valeur d'origine (INFO) de .rootCategory.

Langages de programmation Spark

Spark accepte les langages de programmation Python, Scala et Java pour les applications autonomes, et fournit des interpréteurs interactifs pour Python et Scala. Le choix de tel ou tel langage est une question de préférence personnelle. Dans ce tutoriel, nous utilisons les interpréteurs interactifs, car ils vous permettent de faire des tests en modifiant le code et en essayant différentes valeurs de saisie, puis en affichant les résultats.

Estimer la croissance d'un portefeuille

Dans le domaine de la finance, les méthodes de Monte-Carlo servent parfois à effectuer des simulations visant à prédire la performance d'un investissement. En produisant des échantillons aléatoires de résultats sur une plage de conditions de marché probables, une simulation Monte-Carlo peut répondre aux questions concernant la performance d'un portefeuille pour une situation moyenne ou dans le pire cas de figure.

Suivez ces étapes pour créer une simulation basée sur les méthodes de Monte-Carlo pour essayer d'estimer la rentabilité d'un investissement financier en fonction de quelques facteurs de marché courants.

1. Démarrez l'interpréteur Python à partir du nœud principal Dataproc.

   pyspark
   

   Attendez l'invite Spark >>>.

2. Saisissez le code ci-dessous. Veillez à conserver les retraits dans la définition de la fonction.

   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
   

3. Appuyez sur return jusqu'à ce que l'invite Spark réapparaisse.

   Le code qui précède définit une fonction qui modélise ce qui pourrait se produire pour un investisseur disposant d'un compte d'épargne-retraite investi en actions, sur lequel il effectue tous les ans un versement complémentaire. La fonction génère chaque année un retour sur investissement aléatoire exprimé en pourcentage pour une durée de terme spécifiée. La fonction reçoit pour paramètre une graine. Cette valeur permet de réinitialiser le générateur de nombres aléatoires, ce qui garantit que la fonction ne reçoit pas la même liste de nombres aléatoires à chaque exécution. La fonction random.normalvariate garantit que des valeurs aléatoires apparaissent dans une distribution normale pour l'écart moyen et l'écart-type spécifiés. La fonction augmente la valeur du portefeuille du montant de la croissance, qui peut être positif ou négatif, et ajoute une somme annuelle représentant un investissement supplémentaire.

   Vous définissez les constantes requises lors d'une prochaine étape.

4. Créez de nombreuses valeurs initiales pour alimenter la fonction. À l'invite Spark, saisissez le code suivant, qui génère 10 000 valeurs initiales :

   seeds = sc.parallelize([time.time() + i for i in range(10000)])
   

   Le résultat de l'opération parallelize est un ensemble de données distribué résilient (RDD, Resilient Distributed Dataset), c'est-à-dire un ensemble d'éléments optimisés pour le traitement en parallèle. Dans notre exemple, ce RDD contient des valeurs initiales basées sur l'heure système actuelle.

   Lors de la création du RDD, Spark divise les données en fonction du nombre de nœuds de calcul et de cœurs disponibles. Ici, Spark choisit d'utiliser huit tranches, soit une tranche par cœur. Cette valeur convient pour la présente simulation, qui porte sur 10 000 éléments de données. Dans des simulations plus importantes, chaque tranche pourrait dépasser la limite par défaut. Dans ce cas, spécifier un second paramètre sur la valeur parallelize permet d'augmenter le nombre de tranches, ce qui peut aider à maintenir une taille gérable pour chaque tranche, sans empêcher Spark d'exploiter les huit cœurs.

5. Transmettez les valeurs initiales contenues dans le RDD à la fonction grow.

   results = seeds.map(grow)
   

   La méthode map transmet chaque graine du RDD à la fonction grow et ajoute chaque résultat à un nouveau RDD, qui est stocké dans les résultats (results). Notez que cette opération, qui effectue une transformation, ne produit pas immédiatement ses résultats. Spark n'effectue ce travail qu'au moment où les résultats sont requis. Cette évaluation minimaliste explique pourquoi vous pouvez saisir du code sans avoir préalablement défini les constantes.

6. Spécifiez certaines valeurs pour la fonction.

   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
   

7. Appelez reduce pour agréger les valeurs du RDD. Saisissez le code suivant pour additionner les résultats stockés dans le RDD :

   sum = results.reduce(add)
   

8. Estimez et affichez le rendement moyen :

   print (sum / 10000.)
   

   Veillez à saisir le point (.) final, qui signifie que vous utilisez l'arithmétique en virgule flottante.

9. Vous allez maintenant modifier une hypothèse et découvrir comment cela influe sur les résultats. Par exemple, vous pouvez saisir une nouvelle valeur pour le rendement moyen du marché :

   MKT_AVG_RETURN = 0.07
   

10. Lancez à nouveau la simulation.

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

11. Lorsque vous avez terminé vos tests, appuyez sur CTRL+D pour quitter l'interpréteur Python.

Programmation d'une simulation Monte-Carlo en langage Scala

Comme chacun sait, Monte-Carlo est la destination de référence pour les jeux de hasard. Dans cette section, vous allez utiliser Scala afin de créer une simulation qui modélise l'avantage mathématique dont bénéficie un casino dans un jeu de hasard. La "marge maison" d'un véritable casino varie sensiblement d'un jeu à un autre. Par exemple, elle peut dépasser 20 % au Keno. Dans ce tutoriel, nous allons créer un jeu simple dans lequel la maison n'a qu'un avantage de 1 %. Voici comment ce jeu se déroule :

• Le joueur place une mise consistant en un certain nombre de jetons provenant de sa cagnotte.
• Le joueur lance un dé à 100 faces (amusant, non ?).
• Si le résultat du lancer est un nombre compris entre 1 et 49, le joueur gagne.
• En cas de résultat compris entre 50 et 100, le joueur perd sa mise.

À l'évidence, ce jeu crée un désavantage de 1 % pour le joueur : 51 des 100 résultats possibles pour chaque lancer lui font perdre sa mise.

Suivez ces étapes pour créer et exécuter le jeu :

1. Démarrez l'interpréteur Scala à partir du nœud principal Dataproc.

   spark-shell
   

2. Copiez et collez le code ci-après pour créer le jeu. Scala n'a pas les mêmes exigences que Python en matière de retrait : vous pouvez donc vous contenter de copier le code et de le coller lorsque l'invite scala> s'affiche.

   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)
   }
   

3. Appuyez sur return jusqu'à ce que l'invite scala> réapparaisse.

4. Saisissez le code suivant pour jouer 25 fois au jeu. Il s'agit de la valeur par défaut du paramètre NUMBER_OF_GAMES.

   playSession()
   

   Votre cagnotte contenait 10 unités au départ. Et maintenant, a-t-elle augmenté ou diminué ?

5. Simulez à présent 10 000 joueurs misant 100 jetons par partie. Faites 10 000 parties en une session. Cette simulation Monte-Carlo calcule la probabilité de perdre tout votre argent avant la fin de la session. Saisissez le code suivant :

   (sc.parallelize(1 to 10000, 500)
     .map(i => playSession(100000, 100, 250000))
     .map(i => if (i == 0) 1 else 0)
     .reduce(_+_)/10000.0)
   

   Notez la syntaxe .reduce(_+_) : il s'agit d'une notation abrégée en Scala pour désigner une agrégation à l'aide d'une fonction de sommation. Elle est fonctionnellement équivalente à la notation .reduce(add) que vous avez pu voir dans l'exemple Python.

   Le code ci-dessus effectue les étapes suivantes :

   • Créer un RDD contenant les résultats des parties jouées au cours de la session
   • Remplacer les résultats des joueurs ruinés par le nombre 1 et les résultats non nuls par le nombre 0
   • Calculer le nombre total de joueurs ruinés
   • Diviser ce nombre par le nombre de joueurs

   Voici le type de résultat que vous pouvez obtenir :

   0.998
   

   Ce résultat est la quasi-garantie de perdre tout votre argent, même si le casino n'avait qu'un avantage de 1 %.