Analyser les risques de portefeuille à l'aide de HTCondor et de Compute Engine

Ce tutoriel vous explique comment utiliser les services Google Cloud pour exécuter des simulations de Monte-Carlo et analyser les ensembles de données obtenus. Utilisez HTCondor pour planifier des tâches sur un cluster de machines virtuelles Compute Engine qui exécutent les simulations. Stockez ensuite les résultats de simulation agrégés à l'aide de BigQuery et analysez et visualisez ces résultats à l'aide de Datalab.

Pour suivre ce tutoriel, vous devez remplir les conditions ci-dessous :

Vous avez lu la présentation des clusters de calcul.
Vous avez une certaine expérience de Google Cloud.
Vous connaissez les outils de ligne de commande Linux.

Utiliser les simulations de Monte-Carlo dans le secteur financier

Les chercheurs et les data scientists ont souvent recours aux simulations de Monte-Carlo pour résoudre des problèmes physiques ou mathématiques compliqués à résoudre d'une autre manière. La méthode de Monte-Carlo utilise un échantillonnage aléatoire répété pour obtenir des résultats numériques. Ces simulations sont généralement exécutées sous forme de calculs indépendants, sur de nombreux ordinateurs. Ce type de calcul haute performance est souvent appelé à haut débit, par opposition au calcul parallèle étroitement couplé. Les charges de travail parallèles à haut débit sont composées de nombreux calculs plus petits pouvant s'exécuter indépendamment les uns des autres sur plusieurs hôtes. Les tâches individuelles peuvent être arrêtées et redémarrées sans affecter les autres opérations de la simulation plus large.

Le secteur des services financiers s'appuie sur les simulations de Monte-Carlo pour analyser les portefeuilles d'investissement et prévoir les pertes éventuelles découlant de risques tels que le risque de crédit, le risque de liquidité et le risque de marché. En vertu des accords de Bâle III, toutes les grandes institutions bancaires internationales requièrent une modélisation formalisée des risques. Grâce à une infrastructure informatique adéquate, les simulations peuvent être automatisées.

La modélisation des risques comprend diverses techniques, y compris le risque de marché, la valeur à risque (VaR), la simulation historique (HS) ou la théorie des valeurs extrêmes (EVT). Ce tutoriel décrit la mise en œuvre d'un calcul de la VaR d'un portefeuille d'actions hypothétique composé d'une sélection de l'indice boursier Standard & Poor's 500 (S&P 500).

Il existe deux grandes étapes dans le processus :

l'acquisition de données et la cotation des risques ;
le rapport et l'analyse de données.

Dans un premier temps, vous obtenez et traitez les positions actuelles et historiques des actions. En règle générale, les positions, les scénarios et les données de marché ne nécessitent que quelques Go de données.

La deuxième étape du processus simule le mouvement du marché en utilisant un processus stochastique, puis analyse les résultats probables. Vous pouvez utiliser une simulation de Monte-Carlo pour examiner l'évolution potentielle du prix des actifs dans le temps, en supposant que les rendements journaliers suivent une distribution normale. Ce type d'évolution des prix est connu sous le nom de marche aléatoire. La simulation de Monte-Carlo évalue le niveau de rendement attendu et la volatilité de chaque action du portefeuille. Ces données peuvent être estimées à partir des prix historiques par le biais de méthodes simples qui supposent que les niveaux de rendement et de volatilité moyens passés vont se maintenir. D'autres méthodes plus sophistiquées sont généralement utilisées, mais ce tutoriel utilise des méthodes plus simples par souci de concision.

Une simulation du marché peut être réalisée à grande échelle et parallèlement à des milliers, voire des centaines de milliers de simulations, sur des milliers d'entités d'actions. Les données obtenues peuvent être facilement regroupées en téraoctets et peuvent être difficiles à gérer.

Cette mise en œuvre peut être encore simplifiée en utilisant les cours des actions de fin de journée des 252 derniers jours (nombre de jours de négociation d'une année type). Dans un scénario réel, le nombre de points de prix pris en compte serait beaucoup plus important, à raison d'un par seconde, voire en tick par tick. Un tick est un changement enregistré dans la valeur d'une action. Une action, telle que GOOG, peut générer 10 à 20 ticks par seconde.

Enfin, une partie intégrante du calcul de la VaR dans la méthode de Monte-Carlo consiste à simuler les rendements de chaque titre du portefeuille, puis à agréger ces rendements sur l'ensemble du portefeuille afin d'établir leur distribution. Ce tutoriel résume simplement les positions et ne tient pas compte des facteurs de risque spécifiques à une action, tels que les dépôts publics, les politiques gouvernementales, etc., qui pourraient avoir influencé les rendements historiques. Cette méthode suppose naïvement que tous les rendements historiques sont des rendements non factoriels.

Ces simplifications rendent le tutoriel plus facile à suivre. Cependant, l'architecture globale reste la même et vous pouvez la modifier en ajoutant des données ou en choisissant des modèles et des techniques plus sophistiqués.

Architecture Google Cloud

La figure suivante illustre l'architecture d'une mise en œuvre Google Cloud permettant de collecter des données de marché, d'effectuer des simulations et d'analyser les résultats.

Architecture de la mise en œuvre Google Cloud pour la collecte et l'analyse des données de marché

Voici l'enchaînement du schéma :

Vous obtenez les données de marché brutes et les valeurs de portefeuille à partir de sources de données externes ou de systèmes financiers internes et les stockez dans Cloud Storage.
Vous utilisez Cloud Deployment Manager pour provisionner un cluster de calcul hautes performances (HPC), puis les commandes de soumission de tâches HTCondor pour soumettre les tâches de simulation de Monte-Carlo au cluster de nœuds de calcul. Chaque tâche simule une action en fonction de ses mouvements historiques.
Les prévisions des cours sont automatiquement importées dans un bucket Cloud Storage.
Une fois toutes les tâches terminées, vous ingérez les données dans BigQuery pour analyse.
À ce stade, vous pouvez analyser ou traiter plus en détail les résultats agrégés pour une application en machine learning ou en veille stratégique. Dans ce tutoriel, vous analysez et visualisez les données à l'aide de Datalab. Vous pouvez également utiliser d'autres outils, tels que Data Studio, AI Platform ou d'autres outils d'analyse de données.

Objectifs

Exécuter des analyses financières courantes en utilisant HPC sur Compute Engine.
Optimiser les modèles HTCondor pour améliorer le délai d'approvisionnement.
Automatiser le chargement des données dans BigQuery et créer des visualisations à l'aide de Datalab ou de Data Studio.

Coûts

Ce tutoriel utilise les composants facturables suivants de Google Cloud :

Compute Engine pour exécuter les simulations. Pour en savoir plus, consultez la page des tarifs de Compute Engine.
BigQuery pour stocker et analyser les résultats agrégés des simulations. Pour en savoir plus, consultez la page des tarifs de BigQuery.
Cloud Storage pour stocker des données de marché et de portefeuille. Pour en savoir plus, consultez la page des tarifs de Cloud Storage.
Compute Engine pour exécuter Datalab. Pour en savoir plus, consultez la page des tarifs de Datalab.

Obtenez une estimation des coûts en fonction de votre utilisation prévue à l'aide du simulateur de coût. Les nouveaux utilisateurs de Google Cloud peuvent bénéficier d'un essai gratuit.

Avant de commencer

Connectez-vous à votre compte Google Cloud. Si vous débutez sur Google Cloud, créez un compte pour évaluer les performances de nos produits en conditions réelles. Les nouveaux clients bénéficient également de 300 $ de crédits gratuits pour exécuter, tester et déployer des charges de travail.

Dans Google Cloud Console, sur la page de sélection du projet, sélectionnez ou créez un projet Google Cloud.

Accéder au sélecteur de projet

Assurez-vous que la facturation est activée pour votre projet Cloud. Découvrez comment vérifier si la facturation est activée sur un projet.

Dans Google Cloud Console, sur la page de sélection du projet, sélectionnez ou créez un projet Google Cloud.

Accéder au sélecteur de projet

Assurez-vous que la facturation est activée pour votre projet Cloud. Découvrez comment vérifier si la facturation est activée sur un projet.

Si vous n'avez pas installé Google Cloud CLI, vous pouvez utiliser Cloud Shell pour ce tutoriel. Cloud Shell fournit un environnement shell dans lequel Google Cloud CLI est préinstallé. Dans la suite de ce tutoriel, Cloud Shell est utilisé. Si vous préférez utiliser Google Cloud CLI, vous pouvez exécuter des commandes dans la fenêtre de terminal de votre ordinateur local, sauf indication contraire.

Dans la console, ouvrez Cloud Shell.
Ouvrir Cloud Shell

Une fois que vous avez terminé ce tutoriel, vous pouvez éviter de continuer à payer des frais en supprimant les ressources que vous avez créées. Pour en savoir plus, consultez la section Effectuer un nettoyage.

Obtenir l'ensemble de données et le code

L'exemple de code de ce tutoriel est disponible dans GitHub. Il comprend des scripts permettant d'obtenir des données de marché, des modèles Deployment Manager permettant de créer le cluster de calcul HTCondor, ainsi qu'un modèle de Monte-Carlo simple.

Obtenir les outils

Pour exécuter ce tutoriel, vous avez besoin d'outils disponibles dans un dépôt GitHub, y compris un fichier makefile, des scripts et des fichiers de configuration.

Dans Cloud Shell, clonez le dépôt GitHub qui contient l'exemple de code et modifiez les répertoires dans le dossier vers lequel le dépôt a été cloné :
```
git clone https://github.com/GoogleCloudPlatform/hpc-monte-carlo.git;
cd hpc-monte-carlo
```

L'exemple de code contient un fichier makefile qui pilote la plupart des commandes que vous exécutez. Les commandes du fichier makefile sont principalement des wrappers de commandes gcloud. L'exemple de code contient des répertoires pour les éléments suivants :

data/ contient les données de portefeuille, y compris les actions S&P 500. Dans ce tutoriel, vous analysez uniquement un petit sous-ensemble, à savoir les actions FANG (Facebook, Amazon, Netflix et Google).
deploymentmanager/ contient les modèles Deployment Manager permettant de créer et de lancer le cluster de calcul HTCondor.
model/ contient le modèle de Monte-Carlo qui calcule les futurs changements des actions sur la base d'une marche aléatoire.
startup-scripts/ contient des scripts supplémentaires pour créer les images système nécessaires au cluster de calcul.

Obtenir les données historiques

Les données historiques des cours de clôture des actions qui alimentent la simulation de Monte-Carlo proviennent de Quandl. Pour obtenir l'ensemble de données, procédez comme suit :

Dans un navigateur, accédez à la page de connexion Quandl.
Créez un compte personnel. Après votre inscription, Quandl vous fournit une clé API personnalisée pour accéder aux ensembles de données publics. Conservez une copie de la clé dans un endroit sûr.
Dans Cloud Shell, téléchargez les données. Remplacez [API_KEY] par la clé que vous avez téléchargée depuis Quandl.
```
make download apikey=[API_KEY]
```
Ce fichier makefile contient une série de commandes permettant de télécharger les données. L'ensemble de données est enregistré dans le fichier data/WIKI_PRICES_2018-01-01.csv.

Si vous préférez obtenir les données directement :

Créez un compte Quandl et obtenez une clé API comme décrit dans les étapes précédentes.
Accédez à l'URL suivante en remplaçant votre clé API par [API_KEY] :
```
https://www.quandl.com/api/v3/datatables/WIKI/PRICES?qopts.export=true&api_key=$[API_KEY]&date.gt=2018-01-01
```
Quandl crée un fichier CSV contenant un ensemble de données avec les cours de clôture des actions à compter du 1er janvier 2018, crée un package de ce fichier CSV dans un fichier .zip et télécharge ce dernier sur votre ordinateur.
Décompressez le fichier.
Renommez le fichier CSV WIKI_PRICES_2018-01-01.csv et placez-le dans le sous-répertoire data.

Importer les données historiques et le code de simulation sur Cloud Storage

Une fois le code de simulation et les données historiques obtenus, rendez-les disponibles dans Google Cloud pour un traitement ultérieur.

Dans Cloud Shell, créez un bucket Cloud Storage et copiez les données et le code dans le bucket. Remplacez [YOUR_BUCKET_NAME] par un nom unique pour votre bucket Cloud Storage.
```
make upload bucketname=[YOUR_BUCKET_NAME]
```
Cette commande importe les données et les scripts de tâche HTCondor dans le bucket Cloud Storage spécifié.

Vous pouvez également créer manuellement le bucket et y copier les données à l'aide des commandes gcloud :

gsutil mb gs://[YOUR_BUCKET_NAME]
gsutil cp data/WIKI_PRICES_2018-01-01.csv gs://[YOUR_BUCKET_NAME]/data/
gsutil cp data/companies.csv gs://[YOUR_BUCKET_NAME]/data/
gsutil cp model/* gs://[YOUR_BUCKET_NAME]/model/
gsutil cp htcondor/* gs://[YOUR_BUCKET_NAME]/htcondor/

Créer un cluster HTCondor à l'aide de modèles Deployment Manager

Les exemples de Deployment Manager du dépôt GitHub fournissent un modèle à utiliser pour les clusters HTCondor. Dans ce tutoriel, vous utilisez un modèle Deployment Manager modifié qui se trouve dans le sous-répertoire deploymentmanager/.

Le modèle modifié contient les modifications suivantes :

Le modèle intègre la prise en charge des machines virtuelles (VM) préemptives en plus des VM classiques. Les VM préemptives réduisent le coût des instances Compute Engine jusqu'à 80 %, mais peuvent être récupérées sans préavis. Pour ce type d'utilisation, cela ne pose pas problème. Si une VM préemptive est récupérée, le planificateur HTCondor traite les nœuds récupérés comme des nœuds défaillants et replanifie des tâches sur d'autres nœuds.

Pour que les tâches restent en mouvement, le modèle crée deux ensembles de groupes d'instances : l'un pour les VM préemptives et l'autre pour les VM classiques. Pour différents scénarios, vous pouvez modifier le taux des types de nœuds selon vos besoins.
Les nœuds de cluster sont configurés sans accès Internet public. En informatique financière, vous devez minimiser le risque de compromission des nœuds. Les modèles HTCondor d'origine utilisent une image générique du système d'exploitation de base et téléchargent le logiciel requis lors du premier démarrage du nœud. Cette configuration nécessite que chaque nœud du cluster dispose d'une connexion Internet pour pouvoir contacter le dépôt public du logiciel HTCondor. Les modèles modifiés contiennent un ensemble d'images personnalisées sur lesquelles le logiciel requis est préinstallé pour le cluster de calcul. Les nœuds n'ont donc pas besoin de connexion Internet.
Les nœuds doivent avoir accès à Cloud Storage, afin que le réseau soit configuré pour vous donner un accès privé aux API Google.

La configuration du cluster est définie à l'aide du fichier deploymentmanager/condor-cluster.yaml du dépôt cloné. Les valeurs par défaut de ce fichier de configuration suffisent pour ce tutoriel. Cependant, vous pouvez modifier la configuration du cluster selon vos besoins. Le code sous-jacent est disponible et vous pouvez l'adapter pour prendre en charge d'autres configurations, telles que des GPU ou des packages logiciels supplémentaires.

Par exemple, vous pouvez modifier les valeurs suivantes :

la taille minimale du cœur, qui correspond au nombre de cœurs fournis par le cluster ;
le type d'instance, qui correspond au type d'instance de nœud à provisionner.

Avant de pouvoir créer le cluster, vous devez créer les images personnalisées avec tous les logiciels requis préinstallés.

Dans Cloud Shell, créez les images personnalisées :
```
make createimages
```
Cette commande crée trois images personnalisées dans votre projet : condor-master, condor-submit et condor-compute.

Vous pouvez également utiliser les commandes suivantes pour créer chaque image :
```
gcloud compute instances create condor-master-template \
    --zone=us-east1-b \
    --machine-type=n1-standard-1 \
    --image=debian-9-stretch-v20181210 \
    --image-project=debian-cloud \
    --boot-disk-size=10GB \
    --metadata-from-file \
         startup-script=startup-scripts/condor-master.sh
sleep 300
gcloud compute instances stop \
    --zone=us-east1-b condor-master-template
gcloud compute images create condor-master  \
    --source-disk condor-master-template   \
    --source-disk-zone us-east1-b   \
    --family htcondor-debian
gcloud compute instances delete \
    --quiet \
    --zone=us-east1-b condor-master-template
```
Ces commandes effectuent les tâches suivantes :
- Créer un modèle de VM pour condor-master qui utilise un script de démarrage afin de télécharger et configurer HTCondor.
- Arrêter la VM et créer un instantané pour l'image.
- Supprimer le modèle de VM.
Cette opération peut prendre plus de 30 minutes.

Si vous exécutez des commandes individuelles gcloud, exécutez l'ensemble de commandes trois fois, une fois pour chaque hôte condor-master, condor-compute et condor-submit. Modifiez le nom dans les commandes pour qu'il corresponde à l'hôte que vous configurez, par exemple condor-compute-template, condor-submit-template.
Modifiez les paramètres du cluster HTCondor dans le fichier deploymentmanager/condor-cluster.yaml. Définissez notamment la taille du cluster. Pour les tests à petite échelle, assurez-vous que les valeurs count et pvmcount sont toutes deux définies sur 2. Ces paramètres provisionnent un cluster à quatre nœuds, ce qui est suffisant pour ce tutoriel.
Déployez un cluster HTCondor dans votre projet :
```
make createcluster
```
Vous pouvez également exécuter la commande suivante :
```
gcloud deployment-manager deployments create condor-cluster \
    --config deploymentmanager/condor-cluster.yaml
```
La création du déploiement et le provisionnement des nœuds peuvent prendre quelques minutes.
Une fois le processus terminé, utilisez ssh pour vous connecter à l'hôte condor-submit :
```
gcloud compute ssh condor-submit
```
Sur la ligne de commande de l'hôte, déterminez le nombre de cœurs disponibles dans le cluster :
```
condor_status
```
Le résultat ressemble à ce qui suit :
```
     Total Owner Claimed Unclaimed Matched Preempting Backfill Drain
X86_64  16     0       0        16       0          0        0     0
Total   16     0       0        16       0          0        0     0
```
La sortie indique qu'un total de 16 cœurs est disponible, car vous avez créé 4 nœuds comportant chacun 4 cœurs. Les applications peuvent demander des cœurs uniques ou multiples pour les tâches au fur et à mesure qu'elles sont soumises au planificateur.

Lancer les simulations de Monte-Carlo

Maintenant que les hôtes sont déployés, vous pouvez utiliser la commande de soumission HTCondor pour soumettre des tâches au planificateur.

Mais avant tout, vous devez copier les fichiers de l'application depuis le répertoire de travail Cloud Shell vers l'hôte de soumission.

Déconnectez-vous de l'hôte condor-submit.

Dans Cloud Shell, copiez les données d'application et le code sur l'hôte htcondor-submit :

make ssh bucketname=[YOUR_BUCKET_NAME]

gcloud compute scp htcondor/* data/* model/* condor-submit:

Utilisez ssh pour vous connecter à nouveau à l'hôte condor-submit afin de soumettre les simulations de Monte-Carlo :
```
gcloud compute ssh condor-submit
```
La spécification de tâche HTCondor se trouve dans le fichier montecarlo-submit-job :
```
# htcondor submit script for runrandom
executable              = run_montecarlo.sh
arguments               = $(Process)
transfer_input_files    = randomwalk.py,companies.csv,WIKI_PRICES_2018-01-01.csv
should_transfer_files   = IF_NEEDED
Transfer_Output_Files   = ""
when_to_transfer_output = ON_EXIT
log                     = run.$(Process).log
Error                   = err.$(Process)
Output                  = out.$(Process)
queue 4
```
Ce fichier définit la tâche que le planificateur doit planifier sur les nœuds de calcul.
- L'exécutable est le fichier run_montecarlo.sh. Il s'agit d'un script bash qui exécute une simulation de Monte-Carlo.
- Le fichier transfer_input_files spécifie l'ensemble des fichiers de données que le planificateur copie dans les nœuds de calcul lors de la planification de la tâche. Vous transférez le modèle de Monte-Carlo, le portefeuille et la tarification historique.
- Le fichier transfer_output_files est nul, car le script bash copie la sortie dans le bucket Cloud Storage.
- Les fichiers Error et Output spécifient la convention de dénomination des fichiers stderr et stdout. Ajoutez la variable $(Process) dans les noms pour éviter la collision de noms.
- La dernière ligne soumet 4 tâches correspondant aux 4 premières actions du portefeuille d'actions.

Chaque simulation de Monte-Carlo est démarrée à l'aide du fichier de script shell run_montecarlo.sh :

#! /bin/bash
# script that initiates the random walk.
# takes one argument which is the index into the sp500.csv to
# identify which stock to simulate.
#
index=$(($1 + 2))
stockfile=companies.csv
stock=$(awk "NR == ${index} {print; exit}" ${stockfile} | cut -d, -f1)
export HOME=`pwd`

./randomwalk.py -c ${stock} --from-csv WIKI_PRICES_2018-01-01.csv > ${stock}.csv
CLOUDSDK_PYTHON=/usr/bin/python gsutil -m cp ${stock}.csv gs://[YOUR_BUCKET_NAME]/output/${stock}.csv

Ce processus identifie un symbole boursier particulier à partir du fichier companies.csv, puis exécute la simulation de Monte-Carlo en utilisant les données de tarification historiques dans WIKI_PRICES_2018-01-01.csv.

Une fois le processus terminé, le script importe les données de sortie dans le bucket Cloud Storage que vous avez créé.

Modifiez le script shell run_montecarlo.sh et remplacez [YOUR_BUCKET_NAME] par le nom du bucket Cloud Storage que vous avez créé précédemment dans la ligne gs://[YOUR_BUCKET_NAME]/output/${stock}.csv.
Soumettez la tâche au planificateur Condor :
```
condor_submit montecarlo-submit-job
```
La commande renvoie un ID de tâche.
Pour voir la progression des tâches, exécutez les commandes Condor suivantes :
1. Utilisez la commande condor_q pour afficher les tâches en file d'attente, mais non encore exécutées.
2. Utilisez la commande condor_history pour afficher les tâches déjà terminées. Remplacez [JOB_ID] par l'ID de tâche récupérée à l'étape précédente.
```
condor_history [JOB_ID]
```
Une fois les simulations terminées, vous pouvez annuler la gestion du cluster.
Déconnectez-vous de l'hôte condor-submit.

Dans Cloud Shell, annulez la gestion du cluster.

make destroycluster

gcloud deployment-manager deployments delete condor-cluster

Importer des sorties dans BigQuery

L'étape suivante consiste à charger les données depuis Cloud Storage vers BigQuery.

Dans Cloud Shell, chargez les données depuis Cloud Storage dans une nouvelle table vers BigQuery. Remplacez [YOUR_BUCKET_NAME] par le nom du bucket Cloud Storage que vous avez créé précédemment.

Si vous utilisez makefile :
```
make bq bucketname=[YOUR_BUCKET_NAME]
```

ou les commandes de gcloud CLI :

bq mk montecarlo_outputs
bq load --autodetect --source_format=CSV montecarlo_outputs.vartable
gs://[YOUR_BUCKET_NAME]/output/*.csv
cat bq-aggregate.sql | bq query --destination_table montecarlo_outputs.portfolio

Analyser les données de simulation à l'aide de Datalab

Pour analyser les données actuellement stockées dans BigQuery, vous pouvez utiliser directement BigQuery et créer des instructions SQL pour générer les données qui vous intéressent. Vous pouvez également utiliser Data Studio pour créer un tableau de bord mis à jour quotidiennement.

gcloud components install datalab

Dans ce tutoriel, vous utilisez Datalab pour analyser les données à l'aide de Python et des bibliothèques de science des données les plus utilisées telles que Pandas. Datalab vous fournit un notebook Jupyter géré qui peut effectuer les agrégations et les visualisations.

Le notebook est disponible dans le dépôt GitHub à titre de référence, mais nous vous recommandons d'en examiner vous-même les détails.

Pour analyser les données dans BigQuery :

Dans Cloud Shell, créez une instance Datalab nommée montecarlo :
```
datalab create montecarlo
```
Configurez Cloud Shell pour accéder aux notebooks Datalab.
Dans Datalab, cliquez sur + Notebook pour créer un notebook, puis ajoutez le code suivant afin de charger les bibliothèques BigQuery Python dans le notebook. Pour en savoir plus, consultez la section sur l'utilisation de Datalab avec BigQuery.
```
%load_ext google.cloud.bigquery
```
Connectez-vous à la table de sortie Monte-Carlo et chargez les données dans un objet DataFrame Pandas :
```
%%bigquery df
SELECT*
FROM `montecarlo_outputs.portfolio`
```
Visualisez la croissance de votre portefeuille :
```
matplotlib inline
df.T.plot(legend=False)
```
Les résultats sont semblables au graphique suivant :

Chaque ligne du graphique représente la valeur du portefeuille ; dans ce cas, la somme des actions FANG, sur 252 jours de négociation, sur la base des valeurs historiques de chaque action. Le graphique montre la dispersion extraordinaire des valeurs possibles.

Au lieu de tracer chacune des 1 000 simulations, vous pouvez examiner la moyenne des valeurs du portefeuille avec les intervalles de confiance correspondants. Exemple :
```
import matplotlib.pyplot as plt

mean = df.mean().reset_index().iloc[:,-1]
std  = df.std().reset_index().iloc[:,-1]
plt.errorbar(mean.index, mean, xerr=0.5, yerr=2*std, linestyle='-')
plt.show()
```
Pour obtenir un meilleur aperçu, vous pouvez créer un histogramme des valeurs à une date donnée :
```
df.iloc[:,-1].hist(bins=100)
```
Le graphique obtenu montre un histogramme des valeurs au jour 252.

Obtenez des statistiques descriptives pour cette journée :

df.T[252].describe()

count     1000.000000
mean     27958.274051
std       9295.381959
min       9446.052887
25%      21106.335794
50%      26438.180608
75%      33112.044098
max      74756.152636
Name: f251_, dtype: float64

Le résultat affiche les statistiques descriptives pour cette journée, avec une moyenne d'environ 30 000 et un écart type de 9 000.

Nettoyer

Pour éviter que les ressources utilisées lors de ce tutoriel soient facturées sur votre compte Google Cloud, supprimez le projet contenant les ressources, ou conservez le projet et supprimez les ressources individuelles.

Supprimer le projet

Dans la console, accédez à la page Gérer les ressources.
Accéder à la page Gérer les ressources
Dans la liste des projets, sélectionnez le projet que vous souhaitez supprimer, puis cliquez sur Supprimer.
Dans la boîte de dialogue, saisissez l'ID du projet, puis cliquez sur Arrêter pour supprimer le projet.

Supprimer les ressources individuelles

Si vous ne pouvez pas supprimer le projet, vous pouvez supprimer les différentes ressources manuellement :

Supprimez le cluster HTCondor.
Supprimez les modèles d'instances et les images.
Supprimez le bucket Cloud Storage.
Supprimez le notebook Datalab.
Supprimez les tables BigQuery.

Étape suivante

Explorez des architectures de référence, des schémas, des tutoriels et des bonnes pratiques concernant Google Cloud. Consultez notre Centre d'architecture cloud.