Syntaxes et définitions#

Définitions#

Définition D1 : bruit blanc

Une suite de variables aléatoires réelles $\pa{\epsilon_i}_{1 \infegal i \infegal N}$ est un bruit blanc :

$\exists \sigma > 0$ , $\forall i \in \intervalle{1}{N}, \; \epsilon_i \sim \loinormale{0}{\sigma}$
$\forall \pa{i,j} \in \intervalle{1}{N}^2, \; i \neq j \Longrightarrow \epsilon_i \independant \epsilon_j$

entrée originale

Définition D1 : classe

Une classe est un ensemble incluant des variables ou attributs et des fonctions ou méthodes. Les attributs sont des variables accessibles depuis toute méthode de la classe où elles sont définies. En python, les classes sont des types modifiables.

entrée originale

Définition D1 : point d’entrée du programme

Le point d’entrée d’un programme est la première instruction exécutée par l’ordinateur lors de l’exécution de ce programme.

entrée originale

Définition D1 : test

Les tests permettent d’exécuter des instructions différentes selon la valeur d’une condition logique.

entrée originale

Définition D1 : variable

Une variable est caractérisée par :

un identificateur : il peut contenir des lettres, des chiffres, des blancs soulignés mais il ne peut commencer par un chiffre. Minuscules et majuscules sont différenciées. Il est aussi unique.
un type : c’est une information sur le contenu de la variable qui indique à l’interpréteur python, la manière de manipuler cette information.

entrée originale

Définition D10 : frozenset

Un set est un ensemble de valeurs uniques. Ajouter une valeur déjà dans la liste n’a donc aucun impact. On s’en sert beaucoup pour récupérer une liste d’éléments uniques. Ce type est dit immutable car il est impossible d’ajouter des valeurs. En contrepartie, on peut s’en servir comme clé dans un dictionnaire ou comme valeur dans un set ou frozenset.

entrée originale

Définition D2 : constante

Les constantes sont le contraire des variables, ce sont toutes les valeurs numériques, chaînes de caractères, …, tout ce qui n’est pas désigné par un nom. Les constantes possèdent un type mais pas d’identificateur.

entrée originale

Définition D2 : fonction

Une fonction est une partie d’un programme - ou sous-programme - qui fonctionne indépendamment du reste du programme. Elle reçoit une liste de paramètres et retourne un résultat. Le corps de la fonction désigne toute instruction du programme qui est exécutée si la fonction est appelée.

entrée originale

Définition D2 : instantiaion

Une instance d’une classe C désigne une variable de type C. Le terme instance ne s’applique qu’aux variables dont le type est une classe.

entrée originale

Définition D3 : fonction récursive

Une fonction récursive est une fonction qui s’appelle elle-même.

entrée originale

Définition D3 : méthode

Les méthodes sont des fonctions qui sont associées de manière explicite à une classe. Elles ont comme particularité un accès privilégié aux données de la classe elle-même.

entrée originale

Définition D3 : type immuable (ou immutable)

Une variable de type immuable ne peut être modifiée. Une opération sur une variable de ce type entraîne nécessairement la création d’une autre variable du même type, même si cette dernière est temporaire.

entrée originale

Définition D4 : attribut

Les attributs sont des variables qui sont associées de manière explicite à une classe. Les attributs de la classe se comportent comme des variables globales pour toutes les méthodes de cette classe.

entrée originale

Définition D4 : chaîne de caractères

Le terme « chaîne de caractères » ou string en anglais signifie une suite finie de caractères, autrement dit, du texte.

entrée originale

Définition D4 : portée d’un variable

La portée d’une variable associée à un identificateur recouvre la portion du programme à l’intérieur de laquelle ce même identificateur la désigne. Ceci implique que, dans cette portion de code, aucune autre variable, aucune autre fonction, aucune autre classe, ne peut porter le même identificateur.

entrée originale

Définition D5 : méthode statique

Les méthodes statiques sont des méthodes qui peuvent être appelées même si aucune instance de la classe où elles sont définies n’a été créée.

entrée originale

Définition D5 : tuple

Les tuple sont un tableau d’objets qui peuvent être de tout type. Ils ne sont pas modifiables (les tuple sont immuables ou immutable).

entrée originale

Définition D5 : variable locale

Une variable locale est une variable dont la portée est réduite à une fonction.

entrée originale

Définition D6 : attribut statique

Les attributs statiques sont des attributs qui peuvent être utilisés même si aucune instance de la classe où ils sont définis n’a été créée. Ces attributs sont partagés par toutes les instances.

entrée originale

Définition D6 : type modifiable (ou mutable)

Une variable de type modifiable peut être modifiée, elle conserve le même type et le même identificateur. C’est uniquement son contenu qui évolue.

entrée originale

Définition D6 : variable globale

Une variable globale est une variable dont la portée est l’ensemble du programme.

entrée originale

Définition D7 : héritage

On dit qu’une classe $B$ hérite d’une autre classe $A$ si la déclaration de $B$ inclut les attributs et les méthodes de la classe $A$.

entrée originale

Définition D7 : liste

Les listes sont des collections d’objets qui peuvent être de tout type. Elles sont modifiables.

entrée originale

Définition D8 : dictionnaire

Les dictionnaires sont des listes de couples. Chaque couple contient une clé et une valeur. Chaque valeur est indicée par sa clé. La valeur peut-être de tout type, la clé doit être de type immuable, ce ne peut donc être ni une liste, ni un dictionnaire. Chaque clé comme chaque valeur peut avoir un type différent des autres clés ou valeurs.

entrée originale

Définition D8 : surcharge

Lorsqu’une classe B hérite de la classe A et redéfinit une méthode de la classe A portant le même nom, on dit qu’elle surcharge cette méthode. S’il n’est pas explicitement précisé qu’on fait appel à une méthode d’une classe donnée, c’est toujours la méthode surchargée qui est exécutée.

entrée originale

Définition D9 : set

Un set est un ensemble de valeurs uniques. Ajouter une valeur déjà dans la liste n’a donc aucun impact. On s’en sert beaucoup pour récupérer une liste d’éléments uniques. Ce type est dit mutable car il est possible d’ajouter des valeurs. Comme pour les dictionnaires, les valeurs stockées dans un ensemble doivent être immutables. Sans cela, le langage ne pourrait garantir l’unicité.

entrée originale

Figures#

Figure F1 : Open-High-Low-Close-Volume

_images/ohlc.png

Graphe Open-High-Low-Close-Volume d’une série financière. Les histogrammes représentant les les volumes, vert pour journée positive, rouge pour une journée négative. Chaque barre verticale relie les prix Low et High d’une même journée, les barres horizontales sont les prix Open à gauche et Close à droite.

entrée originale

Figure F10 : 4 actions françaises

BNP	Société Générale


Crédit Agricole	Danone

Quatre actions, trois banquaires (BNP, Société Générale, Crédit Agricole) et une société issue de l’alimentaire Danone.

entrée originale

Figure F11 : Rendement pour 4 actions françaises

BNP	Société Générale


Crédit Agricole	Danone

La stratégie Trend Following est appliquée aux quatre séries avec des résultats mitigés. Elle réagit bien sur la BNP et la Société Générale, elle donne de mauvais résultats sur le Crédit Agricole. Sur Danone, la stratégie conserve une position acheteuse puis perd tout ce qu’elle avait gagné par la suite alors que la série n’a plus de trend aussi évident et que sa volatilité est élevée. La série du Crédit Agricole est plus longue de deux ans mais cela n’explique pas ses mauvais résultats, la stratégie prend une série de mauvaises décisions ce qui tend à montrer qu’elle n’est pas suffisamment robuste.}

entrée originale

Figure F12 : Deal

_images/posdeal.png

Les deals sont construits à partir de la position de la stratégie. Chaque flèche à double sens désigne un deal Lorsqu’un ordre d’achat est passé alors que la position est déjà positive, on décompose en deal dont les temps de vie se superposent.

entrée originale

Figure F13 : Deal en image

_images/bouchaud.png

_images/stratdd.png

_images/stratddu.png

La première image est celle de la distribution théorique des gains calculée par Bouchaud et Potters dans leur article [Potters2005]. La distribution empirique n’est pas toujours facile à construire sur des historiques qui ne sont pas assez longs : dans le cas de notre stratégie Trend Following, il n’existe que cinq deals. Il faut donc assembler les deals de la même stratégie sur plusieurs séries. Le résultat correspond assez bien à la distribution théorique. Le troisème graphe représente la distribution des durées des deals exprimées en jours (axe des abscisses). Les deals négatifs sont nombreux et de courtes durées.

entrée originale

Figure F14 : Deal positifs, négatifs, logns, courts

_images/stratd.png

Dans ce graphe, pour un deal positif, plus il est proche de la diagonale, plus la décision de coupure de la position a été proche du maximum envisageable. Dans ce graphe, on voit que la stratégie est meilleure lorsqu’elle coupe une position vendeuse plutôt qu’acheteuse. Il faudrait sans doute pour l’améliorer tenir compte du signe de la position avant de couper même si cette conclusion est osée étant donné le peu de deals short positifs.

entrée originale

Figure F2 : OHLC Intraday

_images/intraday.png

Graphe Open-High-Low-Close-Volume d’une série financière intraday. Les volumes représentés ici sont ceux d’une série européenne, il y a une première vague avant midi, juste avant la pause déjeuner, il y a une seconde vague qui correspond à l’ouverture des marchés américains. Certaines statistiques américaines tombe parfois à 13h30 heure française et ont un fort impact très localisé dans le temps sur les séries financières les plus traitées.}

entrée originale

Figure F3 : Exemple de carnet d’ordres, tous les ordres ne sont pas représentés.

_images/carnet.png

entrée originale

Figure F4 : Action BNP et Trend Following

_images/trend.png

Cours de l’action textit{BNP} accompagné par sa moyenne mobile 50 et ses bandes de Bollinger. Une stratégie simple de trend following consiste à acheter lorsque le cours dépasse sa bande supérieure de Bollinger (point A) et à revendre lorsque le cours passe sa bande inférieure (point B). Le gain est alors la différence des cours d’achat et de vente. Lorsque la tendance est baissière, il suffit de vendre d’abord puis d’acheter ensuite.

entrée originale

Figure F5 : Action BNP et Mean Reversing

_images/meanr.png

Cours de l’action textit{BNP} accompagné par sa moyenne mobile 50 et ses bandes de Bollinger. Une stratégie simple de mean reversing consiste à acheter lorsque le cours dépasse sa bande inférieure de Bollinger (point A) et à revendre lorsque le cours revient vers sa borne supérieure (point B). Le gain est alors la différence des cours d’achat et de vente.

entrée originale

Figure F6 : Action BNP et pair trading

_images/pair.png

Rapport entre l’action Société Générale et l’action BNP. On observe une croissance supérieure pour la Société Générale jusqu’en août 2007 date du début de la crise des subprimes puis une nette dégradation depuis l’affaire Kerviel en janvier 2008. Auparavant, la série du rapport paraît plus stable et il semble plus judicieux de faire du mean reversing.

entrée originale

Figure F7 : Le cours de la BNP entre début 2003 et mi 2008

_images/bnpf.png

entrée originale

Figure F8 : NAV

_images/navstrat.png

_images/navstratp.png

NAV de la stratégie Trend Following décrite au paragraphe Analyse d’une stratégie. Le second graphe représente la position de la stratégie, une position positive signifie une position acheteuse (long), une position négative signife une position vendeuse (short). C’est un graphe qui ne représente pas la position mais la quantité d’actions achetées ou vendues pour une position proche de un euros. Ceci explique que cette seconde courbe présente des paliers de hauteurs différentes, il s’agit de l’inverse du prix observé lors de l’ouverture d’une position.}

entrée originale

Figure F9 : NAV d’une stratégie


$\alpha$	$\beta$	$d$

Variations selon les trois paramètres $\alpha$ , $\beta$ , $d$ . Le pic obtenu pour la valeur $\alpha\sim 1.2$ est très localisé autour de cette valeur, il faut s’attendre à ce que la stratégie obtienne des résultats très différents sur des séries similaires. La courbe pour $beta$ est stable, on choisira une valeur dans cette zone. Les rendements passent du simple au double en fonction de la largeur des bandes de Bollinger. Ces graphes ne montrent que l’évolution des rendements et de la volatilité, ils pourraient aussi montrer l’évolution des drawdowns ou du ratio de Sharpe.

entrée originale

Problèmes#

Problème P1 : Régression

Soient deux variables aléatoires $X$ et $Y$ , l’objectif est d’approximer la fonction $\esp\pa{Y | X} = f\pa{X}$ . Les données du problème sont un échantillon de points $\acc{ \pa{ X_{i},Y_{i} } | 1 \infegal i \infegal N }$ et un modèle paramétré avec $\theta$ :

$\forall i \in \intervalle{1}{N}, \; Y_{i} = f \pa{\theta,X_{i}} + \epsilon_{i}$

avec $n \in \N$ , $\pa{\epsilon_{i}}_{1 \infegal i \infegal N}$ bruit blanc, $f$ est une fonction de paramètre $\theta$ .

entrée originale

Problème P1 : optimisation d’un portefeuille

Version 1 : minimisation du risque sous contrainte de rendement

$\begin{array}{|ll} & \underset{\vecteur{\alpha_1}{\alpha_n}}{\min} \sigma\vecteur{\alpha_1}{\alpha_N} \\ \\ \text{avec} & R\vecteur{\alpha_1}{\alpha_N} \supegal R_{min} \\ & \sum_{i=1}^{N} \alpha_i = 1 \\ & \forall i, \; 0 \infegal \alpha_i \infegal 1 \end{array}$

Version 2 : maximisation du rendement sous contraine de risque

$\begin{array}{|ll} & \underset{\vecteur{\alpha_1}{\alpha_n}}{\max} R\vecteur{\alpha_1}{\alpha_N} \\ \\ \text{avec} & \sigma\vecteur{\alpha_1}{\alpha_N} \infegal \sigma_{max} \\ & \sum_{i=1}^{N} \alpha_i = 1 \\ & \forall i, \; 0 \infegal \alpha_i \infegal 1 \end{array}$

entrée originale

Problème P2 : Classification binaire

Soient deux variables aléatoires $X$ et $Y \in \N$ , l’objectif est d’approximer la fonction $\esp\pa{Y | X} = f\pa{X}$ . Les données du problème sont un échantillon de points $\acc{ \pa{ X_{i},Y_{i} } | 1 \infegal i \infegal N }$ et un modèle paramétré avec $\theta$ :

$\forall i \in \intervalle{1}{N}, \; Y_{i} = \left\{ \begin{array}{l} 1 \text{ si } f \pa{\theta, X_{i}} + \epsilon_i > 0 \\ 0 \text{ sinon } \end{array}\right.$

avec $n \in \N$ , $\pa{\epsilon_{i}}_{1 \infegal i \infegal N}$ une variable aléatoire, $f$ est une fonction de paramètre $\theta$ .

entrée originale

Syntaxe#

Syntaxe S1 : Attraper une exception

try:
    # ... instructions à protéger
except type_exception_1:
    # ... que faire en cas d'erreur de type type_exception_1
except (type_exception_i, type_exception_j):
    # ... que faire en cas d'erreur de type type_exception_i ou type_exception_j
except type_exception_n:
    # ... que faire en cas d'erreur de type type_exception_n
except:
    # ... que faire en cas d'erreur d'un type différent de tous
    #     les précédents types
else:
    # ... que faire lorsque une erreur aucune erreur n'est apparue

entrée originale

Syntaxe S1 : Déclaration d’une classe

class nom_classe :
    # corps de la classe
    # ...

entrée originale

Syntaxe S1 : Tests

if condition1 :
   instruction1
   instruction2
   ...
else :
   instruction3
   instruction4
   ...

entrée originale

Syntaxe S1 : importer un module (1)

import importlib
import module_exemple
module_exemple.exemple_variable = 10
importlib.reload(module_exemple)
print(module_exemple.exemple_variable)      # affiche 3

entrée originale

Syntaxe S10 : Déclaration d’un attribut statique

class nom_class :
    attribut_statique = valeur
    def nom_methode (self,params, ...):
        nom_class.attribut_statique2 = valeur2
    @staticmethod
    def nom_methode_st (params, ...) :
        nom_class.attribut_statique3 = valeur3

entrée originale

Syntaxe S11 : Déclaration d’une propriété

class nom_classe :
    nom_propriete = property (fget, fset, fdel, doc)

entrée originale

Syntaxe S12 : Déclaration d’une propriété (2)

class nom_classe :

    @property
    def fget_variable(self):
        return self.variable

    @variable.setter
    def fset_variable(self, v):
        self.variable = v

entrée originale

Syntaxe S13 : Déclaration de l’opérateur __copy__

class nom_classe :
    def __copy__ () :
        copie = nom_classe(...)
        # ...
        return copie

entrée originale

Syntaxe S14 : Déclaration d’attributs figés

class nom_classe (object) :
    __slots__ = "attribut_1", ..., "attribut_n"

entrée originale

Syntaxe S15 : Héritage

class nom_classe (nom_ancetre) :
    # corps de la classe
    # ...

entrée originale

Syntaxe S16 : Surcharge de méthodes héritées

class nom_classe (nom_ancetre) :
    def nom_autre_methode (self, ...) :
        # ...
    def nom_methode (self, ...) :
        nom_ancetre.nom_methode (self, ...)
            # appel de la méthode définie chez l'ancêtre
        nom_ancetre.nom_autre_methode (self, ...)
            # appel d'une autre méthode définie chez l'ancêtre
        self.nom_autre_methode (...)
            # appel d'une méthode surchargée

entrée originale

Syntaxe S2 : Instanciation d’une classe

cl = nom_classe()

entrée originale

Syntaxe S2 : Instruction pass

signe = 0
x = 0
if x < 0: signe = -1
elif x == 0:
   pass          # signe est déjà égal à 0
else :
    signe = 1

entrée originale

Syntaxe S2 : Lever une exception

raise exception_type(message)

Cette instruction lance l’exception exception_type associée au message message. Le message est facultatif, lorsqu’il n’y en a pas, la syntaxe se résume à raise exception_type.

entrée originale

Syntaxe S2 : importer un module (2)

import module_exemple as alias

c = alias.exemple_classe()
print(c)
print(alias.exemple_fonction())

entrée originale

Syntaxe S3 : Boucle while

while cond :
    instruction 1
    ...
    instruction n

entrée originale

Syntaxe S3 : Déclaration d’une méthode

class nom_classe :
    def nom_methode(self, param_1, ..., param_n):
        # corps de la méthode...

entrée originale

Syntaxe S3 : importer un module (3)

from module_exemple import *  # décommmandé
from module_exemple import exemple_classe, exemple_fonction

c = exemple_classe()
print(c)
print(exemple_fonction())

entrée originale

Syntaxe S4 : Appel d’une méthode

cl = nom_classe()    # variable de type nom_classe
t  = cl.nom_methode (valeur_1, ..., valeur_n)

entrée originale

Syntaxe S4 : Boucle for

for x in ensemble:
    instruction 1
    ...
    instruction n

entrée originale

Syntaxe S5 : Déclaration d’un attribut

class nom_classe :
    def nom_methode (self, param_1, ..., param_n) :
        self.nom_attribut = valeur

entrée originale

Syntaxe S5 : Liste en extension

[ expression for x in ensemble ]

entrée originale

Syntaxe S6 : Déclaration d’un constructeur

class nom_classe :
    def __init__(self, param_1, ..., param_n):
        # code du constructeur

entrée originale

Syntaxe S6 : Déclaration d’une fonction

def fonction_nom (par_1, ..., par_n) :
    instruction_1
    ...
    instruction_n
    return res_1, ..., res_n

entrée originale

Syntaxe S7 : Appel d’un constructeur

x = nom_classe (valeur_1,...,valeur_n)

entrée originale

Syntaxe S7 : Appel d’une fonction

x_1, ..., x_n = fonction_nom (valeur_1, valeur_2, ..., valeur_n)

entrée originale

Syntaxe S8 : Déclaration de l’opérateur __str__

class nom_class :
    def __str__ (self) :
        # corps de l'opérateur
        return...

entrée originale

Syntaxe S8 : Valeurs par défaut

def fonction_nom (param_1, param_2 = valeur_2, ..., param_n = valeur_n):
    ...

entrée originale

Syntaxe S9 : Déclaration d’une méthode statique

class nom_class :
    @staticmethod
    def nom_methode(params, ...) :
        # corps de la méthode
        ...

entrée originale

Syntaxe S9 : Nombre indéfini de paramètres

def fonction (param_1, ..., param_n, *liste, **dictionnaire) :

entrée originale

Tables#

Table T1 : Implantation des Hedge Funds en 2007

Implantation des Hedge Funds de par le monde et répartition selon les différentes stratégies de trading. Source Lipper Mars 2007, extrait de [Jacquillat2008].

Lieu	Répartition
Iles Cayman	34 %
USA	20 %
British Virgin Islands	14 %
Bermudes	5 %
Luxembourg	5 %
France	4 %
Irlande	3 %
Bahamas	3 %
Guernsey	2 %
Antilles Néerlandaises	2 %

Stratégie	Répartition
Multi=stratégie	31%
Long / Short Equity	23%
Event Driven	13%
Commodity Trading Advisor (CTA)	6%
Fixed Income Arbitrage	5%
Emerging Markets	4%
Global Macro	4%
Equity Market Neutral	4%

entrée originale

Table T2 : Indicateurs BNP, Crédit Agricole, Danone, Société Générale


BNP	1,00	0,75	0,67	0,44
SG	0,75	1,00	0,63	0,42
CA	0,67	0,63	1,00	0,35
Danone	0,44	0,42	0,35	1,00

Matrice des autocorrélations pour les rendements quotidiens des quatre actions BNP, Société Générale, Crédit Agricole et Danone. Les corrélations sont moins fortes entre Danone et une banque qu’entre banques. Bien que les données quotidiennes soient beaucoup plus propres que des données intraday, il faut quand même vérifier que les séries sont homogènes et contiennent les mêmes dates avant de calculer les corrélations sur les rendements.

entrée originale