Deep Learning Trading robot

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.

Salut !

Bravo pour ce journal !
Avez-vous envisagez l'oriented object programming ? Qu'en pensez-vous ?
cette approche me semble intéressante mais malheureusement l'auteur de cette webserie(qui m'as fait découvrir cette approche) n'a pas conclu:
https://www.youtube.com/watch?v=vB-CH1VS3zM&t=2s

programmer sans savoir où on va est super galère même avec APIs, pour la moindre fonction il faut passer de heures à programmer. n'as-tu pas envisagé de créer une première ébauche avec un logiciel élevé comme Matlab/Scilab ?

parce que se lancer dans la prog d'un NN ça peut prendre des années...Alors qu'avec Matlab c'est quelques heures

juste un conseil...