Deep Learning Trading robot

"Je voulais mettre en pièce jointe le fichier source pour ceux que ça intéresse, mais apparemment, le forum refuse les fichiers .java ou .txt.
Je ne sais pas comment faire."

Une suggestion :
Stocke les fichiers que tu veux partager sur un cloud (Dropbox, Mega, GoogleDrive, OneDrive, etc...) et mets un lien sur ce fichier dans ton post. Exemple :
https://drive.google.com/open?id=0ByoULb6ZPevbOEU4N2NIaW84d2c
Ou, plus simple, tu mets simplement un lien pointant sur le répertoire qui contient tous les fichiers que tu veux partager.

Merci pour ton idée Takapoto.
Mais finalement, le code ne prend pas trop de place sur la page, même s'il est très long.
Quand mon projet commencera à devenir trop complexe (ça arrivera très vite), j'envisagerai ta suggestion.

Le problème avec les partages de fichiers, c'est qu'on a vite fait de se tromper de fichier, et d'en mettre un qui contient des données confidentielles. J'ai par exemple un programme java qui contient en dur mes identifiants et mots de passe. Il faudra que je fasse très attention.

Un premier bilan

Je viens de passer 3h hier et 3h aujourd’hui sur mon projet, soit déjà 6h en 2018 sur les 500h dont je dispose. Je n’ai pas beaucoup avancé, mais au moins, je me suis replongé au cœur du projet après 3 mois d’arrêt complet, j’ai remis des choses au propre et j’ai retrouvé de la motivation. Espérons que ça durera !

Avancement du projet :

Capture des cours : 10%
1- Connexion IG 0%
2- Abonnement streaming 0%
3- Gestion des exceptions 0%
4- Fichier log 0%
5- Démarrage automatique 100%
6- Ecriture des données 0%
7- Flush périodique des fichiers 0%
8- Interface graphique 0%
9- Portabilité 0%
10- Raffinements 0%

Projet global : 1%
1- Capture des cours 10%
2- Données 0%
3- Visualisation 0%
4- Indicateurs techniques 0%
5- Analyse des cours 0%
6- Systèmes de trading 0%
7- Passage d’ordres 0%
8- Gestion des positions 0%
9- Robot de trading 0%
10- Bonus 0%

Déjà 1% de fait donc, mais en fait ce travail avait déjà été fait avant. Ca devrait monter assez vite au début jusqu’à 10%, puis de moins en moins vite.

L’API IG

Avant d’entamer la partie 1-1 du projet sur la connexion IG, un petit mot sur l’API IG, pour ceux qui ne connaissent pas.

L’API IG permet l’accès direct au passage d’ordres et au flux des données boursières, sans passer par l’interface web d’IG.

Ceci procure plusieurs avantages :
• Un passage d’ordres un peu plus rapide (à confirmer).
• La possibilité d’importer la valeur des cours en temps réel.
• La possibilité de passer des ordres automatiquement, notamment sur des signaux calculés par un programme personnalisé qui tourne dans un langage rapide, par exemple Java.
• Le programme peut ainsi scruter les cours pour attendre la bonne occasion au bon moment.
• Il peut passer d’une valeur (indice, devise, …) à une autre instantanément.

Bref, cela donne toute la liberté possible, on peut personnaliser les choses exactement comme on le veut, mais au prix d’un effort considérable de programmation et de prise en main de toute l’API IG.

Il faut le dire aussi, ce n’est pas sans risque. On a en effet la possibilité de passer plusieurs ordres par seconde, et une boucle for mal conçue peut vite conduire à la catastrophe et réduire le capital à néant (par exemple une rafale d’ordres d’achat/clôture qui ferait perdre le spread une multitude de fois).

On dispose heureusement de plusieurs outils précieux :
• Le compte DEMO, qui permet de faire des tests grandeur nature avec un compte fictif.
• Les « compagnons » API, qui permettent de décortiquer pas à pas le fonctionnement des deux API et de faire des petits tests.

Il existe aussi un forum qui permet de régler de nombreux problèmes.

L’API IG est constituée de deux parties :
• L'API REST pour le trading : c’est par son intermédiaire que l’on passe les ordres, qu’on les annule, qu’on peut consulter les positions ouvertes, la valeur du compte, etc...
• L’API Streaming : elle permet l’accès aux cours en temps réel, et fournit aussi les notifications de passages d’ordres ou les problèmes éventuels d’ordre rejetés.

Plus d’infos ici : https://labs.ig.com/

1-1 Connexion IG – Les constantes de connexion

Aujourd’hui, on reprend à la base de la base : la connexion à l’API IG.

J’ai créé plusieurs classes Java (ça ne date pas d’aujourd’hui) :

Une classe abstraite ConstantesDeConnexion :

Code : #

/** Les informations (identifiants, mot de passe,...) nécessaires pour se connecter à la plateforme.
 *  Il faudra parfois modifier certaines de ces constantes.
 *  Chaque compte possède son propre jeu de constantes. */ 

public abstract class ConstantesDeConnexion {
	/** Nom d'utilisateur */
	public String USERNAME;  
	/** Mot de passe */
	public String PASSWORD;
	/** Numéro d'identifiant du compte */
	public String ACCOUNT_ID;
	/** API key (normalement une par application) */ 
	public String API_KEY;
	/** URL de connexion à l'API REST Trading (pour le passage d'ordre et l'état du compte et des positions) */
	public String URL_DEAL;	
	/** URL de connexion à l'API streaming (pour récupérer les cours en temps réel en streaming) */
	public String URL_MARKETDATA;
	/** URL pour l'ouverture d'une position */
	public String URL_OPENPOSITION;
	/** URL pour la clôture d'une position */
	public String URL_CLOSEPOSITION;
	/** URL pour accéder à l'état des positions ouvertes */
	public String URL_OPENPOSITIONS;	
}

Deux classes concrètes ConstantesDeConnexionRéel et ConstantesDeConnexionDémo qui implémentent la classe abstraite ConstantesDeconnexion, et qui contiennent « en dur » les informations (le mot de passe notamment) :

Code : #

/** <p> Les constantes de connexion du compte REEL </p> 
 *  <p> <strong>Remarque : </strong> Il serait peut-être prudent d'afficher une fenêtre Popup pour avertir qu'on vient d'ouvrir le compte réel </p>
 */

public class ConstantesDeConnexionRéel extends ConstantesDeConnexion{	
	
	public ConstantesDeConnexionRéel(){
		USERNAME="frankenstein";  // mettre votre vrai nom d’utilisateur (réel) ici
		PASSWORD="abcdef";        // mettre votre vrai mot de passe (réel) ici
		ACCOUNT_ID="F7841";       // mettre votre vrai numéro de compte (réel) ici    
		API_KEY="fe547a8c8b347";  // mettre votre vraie API KEY (réel) ici
		URL_DEAL="https://api.ig.com/gateway/deal/session";	
		URL_MARKETDATA="https://apd.marketdatasystems.com";
		URL_OPENPOSITION="https://api.ig.com/gateway/deal/positions/otc";	
		URL_OPENPOSITIONS="https://api.ig.com/gateway/deal/positions";
	}	
}

Code : #

/** Les constantes de connexion du compte DEMO */
public class ConstantesDeConnexionDémo extends ConstantesDeConnexion{	
	
	public ConstantesDeConnexionDémo(){
		USERNAME="Trader";
		PASSWORD="azerty";
		ACCOUNT_ID="TGUILM";		
		API_KEY="53ea874fb687c";
		URL_DEAL="https://demo-api.ig.com/gateway/deal/session";	
		URL_MARKETDATA="https://demo-apd.marketdatasystems.com";
		URL_OPENPOSITION="https://demo-api.ig.com/gateway/deal/positions/otc";
		URL_OPENPOSITIONS="https://demo-api.ig.com/gateway/deal/positions";
		URL_CLOSEPOSITION=URL_OPENPOSITION;		
	}	
}

Remarque : L’API Key est une clé que l’on peut se procurer sur l’interface web d’IG, lorsqu’on est connecté avec le compte réel ou le compte démo. La clé est différente selon qu’on est en réel ou en démo.

Bonjour Dernière Chance. Sympa de partager du code aussi.

Par contre pour les paramètres de configuration, pourquoi n'utilises-tu pas les enum plutôt que des classes abstraites ? Je trouve que c'est pratique pour gérer les configurations de façon plus lisible.

J'ai converti ton code en enum :

Code : #

package com.company;

public enum ConstantesDeConnexion {
    CONNEXION_DEMO("username_demo", "password_demo"),
    CONNEXION_REELLE("username_reel", "password_reel");

    private String username;
    private String password;

    private ConstantesDeConnexion(String myUsername, String myPassword) {
        username = myUsername;
        password = myPassword;
    }

    public String getUsername() {
        return username;
    }

    public String getPassword() {
        return password;
    }
}

Et maintenant tu peux l'utiliser comme ça :

Code : #

package com.company;

public class Main {

    public static void main(String[] args) {
        System.out.println(ConstantesDeConnexion.CONNEXION_DEMO.getUsername());
    }
}

Bon après peut-être n'est-ce qu'une question de préférence

Merci beaucoup pour ta remarque BearIsDead!
J'étais en train de me demander s'il était vraiment utile que je poste du code, mais apparemment oui! Il y a des connaisseurs de Java ici, donc je vais continuer à montrer mon code.

J'utilise beaucoup les enum dans le reste du programme (pour les indices, les devises, etc), et c'est vrai que j'aurais dû en utiliser ici. Ca éviterait d'avoir le bout de code peu élégant ci-dessous (un extrait de ce que je posterai ce soir) :

Code : #

public Login(TypeDeCompte typeDeCompte){
		if (typeDeCompte==TypeDeCompte.REEL)
			constantesDeConnexion=new ConstantesDeConnexionRéel();
		else
			constantesDeConnexion=new ConstantesDeConnexionDémo();

Effectivement ça sera sans doute un peu plus lisible avec une enum.

Sinon pour le REST tu utilises Spring ?

Bon tu me diras utiliser le framework Spring juste pour la fonctionnalité REST c'est un peu se compliquer la vie. Il y a des librairies toutes simples pour ça je crois.

Par contre si tu attaques une base de données, ça vaut peut-être le coup d'introduire Spring. Cependant, si tu ne connais pas ce framework, il y a un petit temps d'apprentissage.

Bonjour,

C'est à partir du chapitre 4 où les choses deviendront également pour moi plus excitantes.
Bon courage pour ces phases préparatoires de l'environnement

Spoiler:

Salut, juste pour ajouter un détail mineur sur la lisibilité, hier je ne suis pas allé au bout du raisonnement: tu peux ajouter une variable dans l'enum

Code : #

private static ConstantesDeConnexion connexionActuelle = CONNEXION_DEMO;

(et son getter) pour pouvoir switcher facilement la config directement en changeant cette même ligne.

Ensuite tu utilises simplement quelque chose du style:

Code : #

System.out.println(ConstantesDeConnexion.getConnexionActuelle().getUsername());

Code : #

package com.company;

public enum ConstantesDeConnexion {
    CONNEXION_DEMO("username_demo", "password_demo"),
    CONNEXION_REELLE("username_reel", "password_reel");

    private static ConstantesDeConnexion connexionActuelle = CONNEXION_DEMO;
    private String username;
    private String password;

    private ConstantesDeConnexion(String myUsername, String myPassword) {
        username = myUsername;
        password = myPassword;
    }

    public String getUsername() {
        return username;
    }

    public String getPassword() {
        return password;
    }

    public static ConstantesDeConnexion getConnexionActuelle() {
        return connexionActuelle;
    }
}

Sinon, pour continuer avec ma publicité sur Spring , ce framework propose des solutions bien pratiques pour switcher les envionnements (fichiers .properties et profiles)

J'ai utilisé des enum, mais peut-être pas comme il le fallait. Le code perd en lisibilité je trouve, car on ne voit plus du premier coup d'œil à quel paramètre (mot de passe, username, etc...) chaque chaîne de caractère se rapporte.

Pour ce qui est de Spring, je ne sais que très vaguement ce que c'est. Ca fait partie des choses que je voudrais apprendre prochainement, mais je n'ai pas le temps en ce moment. Je suis encore dans l'étude de JavaFX.

@Euraed,

Moi aussi j'attends avec impatience la partie 4 et surtout la 5
mais il va bien falloir attendre encore deux mois.
D'ici là, il faut bosser sur les trois premières parties barbantes au possible, mais fondamentales pour la suite. Vivement que j'en sois débarrassé!

1-1 Connexion IG

Voilà cette partie à peu près terminée, disons à 80%. En tout cas elle fonctionne.
Il restera à améliorer le code de la classe Http : c’est un code que je maîtrise assez mal, en grande partie inspiré des exemples données par IG Labs. Et comme je l’ai écrit il y a deux ans, j’ai un peu oublié les détails de son fonctionnement. Du coup, je n’ose pas trop y toucher de peur de casser quelque chose.

J’ai modifié le fonctionnement de la classe ConstantesDeConnexion, donc je reposte le tout.

On a maintenant la connexion qui s’effectue au démarrage, avec la réponse du serveur qui s’affiche dans la fenêtre.

Spoiler:

Code : #

/** Les informations (identifiants, mot de passe,...) nécessaires pour se connecter à la plateforme.
 *  Il faudra parfois modifier certaines de ces constantes.
 *  Chaque compte possède son propre jeu de constantes. */ 

public class ConstantesDeConnexion {
	/** Nom d'utilisateur */
	public String USERNAME;  
	/** Mot de passe */
	public String PASSWORD;
	/** Numéro d'identifiant du compte */
	public String ACCOUNT_ID;
	/** API key (normalement une par application) */ 
	public String API_KEY;
	/** URL de connexion à l'API REST Trading (pour le passage d'ordre et l'état du compte et des positions) */
	public String URL_DEAL;	
	/** URL de connexion à l'API streaming (pour récupérer les cours en temps réel en streaming) */
	public String URL_MARKETDATA;
	/** URL pour l'ouverture ou la clôture d'une position */
	public String URL_OPENPOSITION;
	/** URL pour accéder à l'état des positions ouvertes */
	public String URL_OPENPOSITIONS;	
	
	public ConstantesDeConnexion(String username,String password,String account_id,String api_key,String url_deal,
			String url_marketdata, String url_openposition, String url_openpositions) {
		USERNAME=username;
		PASSWORD=password;
		ACCOUNT_ID=account_id;
		API_KEY=api_key;
		URL_DEAL=url_deal;
		URL_MARKETDATA=url_marketdata;
		URL_OPENPOSITION=url_openposition;		
		URL_OPENPOSITIONS=url_openpositions;				
	}
}

Code : #

/** Enumère les différents types de compte IG */
public enum TypeDeCompte {
	DEMO(new ConstantesDeConnexion("Babar",
								   "abcd",
								   "DERFT",													   "4ea36788c8bb",
								   "https://demo-api.ig.com/gateway/deal/session",	
								   "https://demo-apd.marketdatasystems.com",
								   "https://demo-api.ig.com/gateway/deal/positions/otc",
								   "https://demo-api.ig.com/gateway/deal/positions")),
	REEL(new ConstantesDeConnexion("ouioui",
								   "monsupermotdepase",
								   "EDRES2",
								   "d4e8796f6cba",
								   "https://api.ig.com/gateway/deal/session",
								   "https://apd.marketdatasystems.com",
								   "https://api.ig.com/gateway/deal/positions/otc",	
								   "https://api.ig.com/gateway/deal/positions"));
	
	ConstantesDeConnexion constantesDeConnexion;
	
	private TypeDeCompte(ConstantesDeConnexion constantesDeConnexion) {
		this.constantesDeConnexion=constantesDeConnexion;
	}
}

Code : #

/** Représente la connexion initiale (le login) à l'API IG, permettant par la suite de passer des ordres.
 * Contient notamment deux "tokens" obtenus lors de la connexion, et qui doivent être transmis pour tout accès ultérieur.*/
public class Login{
	private String cstToken;
	private String securityToken;		
	private ConstantesDeConnexion constantesDeConnexion;
	private String réponse;
	
	/** Constructeur qui initialise et crée la connexion initiale (login) à IG
	 * @param typeDeCompte le type de compte auquel on souhaite se connecter (réel ou démo). */
	public Login(TypeDeCompte typeDeCompte){		
		constantesDeConnexion=typeDeCompte.constantesDeConnexion;
		réponse=Http.executePost(constantesDeConnexion.URL_DEAL," ",constantesDeConnexion,this,true);			
	}	
	
	public String getCstToken(){
		return cstToken;
	}
	
	public void setCstToken(String chaîne){
		cstToken=chaîne;
	}
	
	public String getSecurityToken(){
		return securityToken;
	}
	
	public void setSecurityToken(String chaîne){
		securityToken=chaîne;
	}
	
	public ConstantesDeConnexion getConstantes(){
		return constantesDeConnexion;
	}
	
	public String getRéponse(){
		return réponse;
	}
	
	public static void main(String[] args){
		Login login=new Login(TypeDeCompte.REEL);
		System.out.println(login.getRéponse());
	}	
}

Code : #

import java.io.*;
import java.net.*;
import java.nio.charset.Charset;

// CODE A RETRAVAILLER, notamment exceptions à gérer

/** Classe qui contient des méthodes utilitaires statiques permettant d'effectuer des requêtes http. */
public class Http {
	private Http(){}  // la classe ne peut pas être instanciée
	
	// la procédure est différente selon que c'est le premier appel ou non
	// le premier appel sert à obtenir les tokens
	public static String executePost(String targetURL,String urlParameters,ConstantesDeConnexion constantesDeConnexion,
			Login login, boolean firstCall){ 
		HttpURLConnection connection=createConnection(targetURL,urlParameters,constantesDeConnexion);	
		if (connection!=null)
			sendRequest(connection,constantesDeConnexion);		
		String réponse=getHttpResponse(connection);    // exceptions à gérer !!!
		if (firstCall) {
			login.setSecurityToken(connection.getHeaderField("X-SECURITY-TOKEN"));
			login.setCstToken(connection.getHeaderField("CST"));
		}
		if(connection!=null){ 
		      connection.disconnect();		      	     
		 }
		return réponse;			
	}	
	
	private static HttpURLConnection createConnection(String targetURL,String urlParameters,ConstantesDeConnexion constantesDeConnexion){
		HttpURLConnection connection=null;
		try{
			URL url=new URL(targetURL);
			connection=(HttpURLConnection)url.openConnection();				
			connection.setRequestMethod("POST");
			setCommonHttpProperties(connection);		
			connection.setRequestProperty("X-IG-API-KEY",constantesDeConnexion.API_KEY); 	
			connection.setRequestProperty("Content-Length",Integer.toString(urlParameters.getBytes().length)); 
		}
		catch(MalformedURLException e){
			System.out.println("Exception : URL mal formée");
		}
		catch(ProtocolException e){
			System.out.println("Exception : Protocole incorrect");
		}
		catch(IOException e){
			System.out.println("Exception : Problème IO pour créer la connexion");
		}			
		return connection;
	}
	
	public static void sendRequest(HttpURLConnection connection,ConstantesDeConnexion constantes){
		String params="{\"identifier\":\""+constantes.USERNAME+"\",\"password\":\""+constantes.PASSWORD+"\"} ";
		try{
			DataOutputStream wr=new DataOutputStream(connection.getOutputStream());
			wr.writeBytes(params);
			wr.close();
		}
		catch(IOException e){
			System.out.println("Exception : Erreur d'envoi de la requête. Probable coupure d'internet");
		}
	}	
	
	/** Fixe les propriétés communes pour la connexion HTTP. L'objectif est seulement d'éviter la duplication de code.
	 * @param c La connexion HTTP concernée.
	 */
	private static void setCommonHttpProperties(HttpURLConnection c){
		   c.setRequestProperty("Content-Type","application/json; charset=UTF-8");
		   c.setRequestProperty("Accept","application/json; charset=UTF-8");		   	   
		   c.setRequestProperty("Content-Language","en-US");  
		   c.setUseCaches(false);
		   c.setDoOutput(true);			
	}
	
	public static String getHttpResponse(HttpURLConnection c){	
		StringBuilder réponse=new StringBuilder(); 
		try{
			InputStream is=c.getInputStream();
			BufferedReader rd=new BufferedReader(new InputStreamReader(is));			
			String line;
			while((line=rd.readLine())!=null) {			
				réponse.append(line);
			    réponse.append('\n');		       
			}
			rd.close();	
		}
		catch(IOException ex){
			String message="Erreur dans getHttpResponse";
			System.out.println(message);
			return message;
		}
		return new String(réponse.toString().getBytes(),Charset.forName("UTF-8"));		
	}	
}

Code : #

import javafx.application.Application;
import javafx.beans.property.SimpleStringProperty;
import javafx.beans.property.StringProperty;
import javafx.scene.Group;
import javafx.scene.Scene;
import javafx.scene.control.TextArea;
import javafx.stage.Stage;


public class CaptureFX extends Application{	
	Login login;
	StringProperty message;
	
	public static void main(String[] args) {
		Application.launch(args);
	}
	
	public void start(Stage stage) {
		message=new SimpleStringProperty("");
		login=new Login(TypeDeCompte.DEMO);	
		String réponse=message.getValue()+login.getRéponse();
		message.setValue(réponse);
		stage.setTitle("Capture FX");		
		TextArea textArea=new TextArea();
		textArea.setWrapText(true);
		textArea.textProperty().bind(message);
		textArea.setEditable(false);				
		Group root=new Group();
		root.getChildren().add(textArea);
		Scene scene=new Scene(root,500,400);
		stage.setScene(scene);
		stage.show();		
	}
}

Avancement du projet Capture des cours : 18%

Avancement global du projet global : 1,8%

Ben pour les enum, tu as du code du style

Spoiler:

Code : #

if (ConstantesDeConnexion.getConnexionActuelle().getUsername() == ConstantesDeConnexion.CONNEXION_DEMO.getUsername()) {
            //faire quelque chose si c'est la démo
        }

Ok perds peut-être pas trop ton temps sur Spring alors, comme tu ne connais pas. C'est un peu long à apprendre au départ. (enfin si tu utilises, entre autres, une base de données et que tu galères par exemple pour intégrer Hibernate voire si tu en as marre d'utiliser JDBC, essaies Spring. Je pourrais t'aider un peu si besoin, peut-être sur une autre file pour pas polluer celle-ci).

Bonne chance pour ton projet. J essaie aussi de faire ,la meme chose mais l instant ca me sert plus a tester des technos qu a gagner de l argent.

Si ca peut te faire gagner un peu de temps voici quelques choix apres pas mal de tests.
Utilisation de java pour le chargement de donnees
Utilisation de python pour l analyse avec anaconda et jupyter notebook
Passage au web plutot que java fx pour l interface
Utilisation de highstock pour les graphes que ce soit au niveau web ou python
Machine chez scaleway (ou aileurs) pour quelques euros plutot qu a la maison.

Cote trading ben pour l intant je demontre que le marche est parfait, ie pas trouvé de systeme vraiment efficace mais j ai passe enormement de temps sur la recuperation des donnees.

Je vais suivre d un peu plus pres tes progres

Jeff

Hello,

Bravo, je pense que je ne suis pas le seul ici, mais j'ai déjà réalisé tes 10 étapes (et plus car la phase backtest est fondamentale et la plus délicate avec des réseaux de neurone cela pique un peu) avec mise en prod pendant quelques mois. Le tout piloté sur de la reconnaissance de forme. J'ai également tester beaucoup de configuration neuronale puis j'ai aggloméré également 2 cerveaux l'un sur la forme, l'autre sur l'amplitude.

C'est beaucoup de travail. Je ne veux pas te décourager car peut être que tu auras peut être une très bonne idée. Mais il faut savoir que j'ai fait tourner cela dans tous les sens, de mon côté cela n'a rien donné et j'ai perdu de l'argent et du temps que j'aurais pu consacré à des choses plus "rentables".

Comme l'indique Benoist dans l'une de ces dernières vidéos, il faut faire attention à ne pas vouloir créer un système universel et utopique mais prendre en compte le poul du marché par exemple avec le vix.

Bon courage

+1 Alex
Dans ce genre d'entreprise, le vrai but est le chemin et pas l'arrivée, sinon nul besoin de se compliquer autant la vie. Enfin en tout cas, c'est mon point de vue. Quoi qu'il en soit, je suivrai ta progression avec intérêt et optimisme.

Alex,

Les résultats dépendent de tellement de paramètres: tels que vecteurs d'entrée, structure des réseaux, algo de descente de gradient etc, qu'il me paraît difficile de tirer une conclusion définitive sur le sujet.

Oui il ne faut rien conclure car j'ai peut être manqué beaucoup de trucs, une autre personne peut parfaitement faire mieux mais je préfère mettre en garde sur le boulot qu'il y a à réaliser tout cela pour ne rien avoir au final. J'ai tenté et j'avais encore pas mal d'idées mais à un moment à force de tester/prod/test/prod.... et cela pendant des mois je me suis dis soit j'y passe tout mon temps ou bien je passe à autre chose. Quand je suis chercheur d'or, je viens de creuser 10 mètres dans le sol mais il n'y a toujours pas de filon, soit je continue en me disant peut être encore 10 mètres, soit je cherche un autre filon. Je trouve plus sage la seconde option.